No OneTemporary
Actions

Size

383 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/program/include/bc.php b/program/include/bc.php
	index 8a3d4f918..4c8f8a4cf 100644
	--- a/program/include/bc.php
	+++ b/program/include/bc.php
	@@ -1,399 +1,400 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/bc.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Provide deprecated functions aliases for backward compatibility \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Roundcube Webmail deprecated functions
	*
	* @package Core
	* @author Thomas Bruederli <roundcube@gmail.com>
	*/

	// constants for input reading
	define('RCUBE_INPUT_GET', rcube_utils::INPUT_GET);
	define('RCUBE_INPUT_POST', rcube_utils::INPUT_POST);
	define('RCUBE_INPUT_GPC', rcube_utils::INPUT_GPC);

	define('JS_OBJECT_NAME', rcmail::JS_OBJECT_NAME);
	+define('RCMAIL_CHARSET', RCUBE_CHARSET);

	function get_table_name($table)
	{
	return rcmail::get_instance()->db->table_name($table);
	}

	function rcube_label($p, $domain=null)
	{
	return rcmail::get_instance()->gettext($p, $domain);
	}

	function rcube_label_exists($name, $domain=null, &$ref_domain = null)
	{
	return rcmail::get_instance()->text_exists($name, $domain, $ref_domain);
	}

	function rcmail_overwrite_action($action)
	{
	rcmail::get_instance()->overwrite_action($action);
	}

	function rcmail_url($action, $p=array(), $task=null)
	{
	return rcmail::get_instance()->url((array)$p + array('_action' => $action, 'task' => $task));
	}

	function rcmail_temp_gc()
	{
	$rcmail = rcmail::get_instance()->temp_gc();
	}

	function rcube_charset_convert($str, $from, $to=NULL)
	{
	return rcube_charset::convert($str, $from, $to);
	}

	function rc_detect_encoding($string, $failover='')
	{
	return rcube_charset::detect($string, $failover);
	}

	function rc_utf8_clean($input)
	{
	return rcube_charset::clean($input);
	}

	function json_serialize($input)
	{
	return rcube_output::json_serialize($input);
	}

	function rep_specialchars_output($str, $enctype='', $mode='', $newlines=TRUE)
	{
	return rcube_utils::rep_specialchars_output($str, $enctype, $mode, $newlines);
	}

	function Q($str, $mode='strict', $newlines=TRUE)
	{
	return rcmail::Q($str, $mode, $newlines);
	}

	function JQ($str)
	{
	return rcmail::JQ($str);
	}

	function get_input_value($fname, $source, $allow_html=FALSE, $charset=NULL)
	{
	return rcube_utils::get_input_value($fname, $source, $allow_html, $charset);
	}

	function parse_input_value($value, $allow_html=FALSE, $charset=NULL)
	{
	return rcube_utils::parse_input_value($value, $allow_html, $charset);
	}

	function request2param($mode = RCUBE_INPUT_GPC, $ignore = 'task\|action')
	{
	return rcube_utils::request2param($mode, $ignore);
	}

	function html_identifier($str, $encode=false)
	{
	return rcube_utils::html_identifier($str, $encode);
	}

	function rcube_table_output($attrib, $table_data, $a_show_cols, $id_col)
	{
	return rcmail::get_instance()->table_output($attrib, $table_data, $a_show_cols, $id_col);
	}

	function rcmail_get_edit_field($col, $value, $attrib, $type='text')
	{
	return rcube_utils::get_edit_field($col, $value, $attrib, $type);
	}

	function rcmail_mod_css_styles($source, $container_id, $allow_remote=false)
	{
	return rcube_utils::mod_css_styles($source, $container_id, $allow_remote);
	}

	function rcmail_xss_entity_decode($content)
	{
	return rcube_utils::xss_entity_decode($content);
	}

	function create_attrib_string($attrib, $allowed_attribs=array('id', 'class', 'style'))
	{
	return html::attrib_string($attrib, $allowed_attribs);
	}

	function parse_attrib_string($str)
	{
	return html::parse_attrib_string($str);
	}

	function format_date($date, $format=NULL, $convert=true)
	{
	return rcmail::get_instance()->format_date($date, $format, $convert);
	}

	function rcmail_mailbox_list($attrib)
	{
	return rcmail::get_instance()->folder_list($attrib);
	}

	function rcmail_mailbox_select($attrib = array())
	{
	return rcmail::get_instance()->folder_selector($attrib);
	}

	function rcmail_render_folder_tree_html(&$arrFolders, &$mbox_name, &$jslist, $attrib, $nestLevel = 0)
	{
	return rcmail::get_instance()->render_folder_tree_html($arrFolders, $mbox_name, $jslist, $attrib, $nestLevel);
	}

	function rcmail_render_folder_tree_select(&$arrFolders, &$mbox_name, $maxlength, &$select, $realnames = false, $nestLevel = 0, $opts = array())
	{
	return rcmail::get_instance()->render_folder_tree_select($arrFolders, $mbox_name, $maxlength, $select, $realnames, $nestLevel, $opts);
	}

	function rcmail_build_folder_tree(&$arrFolders, $folder, $delm = '/', $path = '')
	{
	return rcmail::get_instance()->build_folder_tree($arrFolders, $folder, $delm, $path);
	}

	function rcmail_folder_classname($folder_id)
	{
	return rcmail::get_instance()->folder_classname($folder_id);
	}

	function rcmail_localize_foldername($name)
	{
	return rcmail::get_instance()->localize_foldername($name);
	}

	function rcmail_localize_folderpath($path)
	{
	return rcmail::get_instance()->localize_folderpath($path);
	}

	function rcmail_quota_display($attrib)
	{
	return rcmail::get_instance()->quota_display($attrib);
	}

	function rcmail_quota_content($attrib = null)
	{
	return rcmail::get_instance()->quota_content($attrib);
	}

	function rcmail_display_server_error($fallback=null, $fallback_args=null)
	{
	rcmail::get_instance()->display_server_error($fallback, $fallback_args);
	}

	function rcmail_filetype2classname($mimetype, $filename)
	{
	return rcube_utils::file2class($mimetype, $filename);
	}

	function rcube_html_editor($mode='')
	{
	rcmail::get_instance()->html_editor($mode);
	}

	function rcmail_replace_emoticons($html)
	{
	return rcmail::get_instance()->replace_emoticons($html);
	}

	function rcmail_deliver_message(&$message, $from, $mailto, &$smtp_error, &$body_file=null, $smtp_opts=null)
	{
	return rcmail::get_instance()->deliver_message($message, $from, $mailto, $smtp_error, $body_file, $smtp_opts);
	}

	function rcmail_gen_message_id()
	{
	return rcmail::get_instance()->gen_message_id();
	}

	function rcmail_user_date()
	{
	return rcmail::get_instance()->user_date();
	}

	function rcmail_mem_check($need)
	{
	return rcube_utils::mem_check($need);
	}

	function rcube_https_check($port=null, $use_https=true)
	{
	return rcube_utils::https_check($port, $use_https);
	}

	function rcube_sess_unset($var_name=null)
	{
	rcmail::get_instance()->session->remove($var_name);
	}

	function rcube_parse_host($name, $host='')
	{
	return rcube_utils::parse_host($name, $host);
	}

	function check_email($email, $dns_check=true)
	{
	return rcube_utils::check_email($email, $dns_check);
	}

	function console()
	{
	call_user_func_array(array('rcmail', 'console'), func_get_args());
	}

	function write_log($name, $line)
	{
	return rcmail::write_log($name, $line);
	}

	function rcmail_log_login()
	{
	return rcmail::get_instance()->log_login();
	}

	function rcmail_remote_ip()
	{
	return rcube_utils::remote_ip();
	}

	function rcube_check_referer()
	{
	return rcmail::check_referer();
	}

	function rcube_timer()
	{
	return rcmail::timer();
	}

	function rcube_print_time($timer, $label='Timer', $dest='console')
	{
	rcmail::print_timer($timer, $label, $dest);
	}

	function raise_error($arg=array(), $log=false, $terminate=false)
	{
	rcmail::raise_error($arg, $log, $terminate);
	}

	function rcube_log_bug($arg_arr)
	{
	rcmail::log_bug($arg_arr);
	}

	function rcube_upload_progress()
	{
	rcmail::get_instance()->upload_progress();
	}

	function rcube_upload_init()
	{
	return rcmail::get_instance()->upload_init();
	}

	function rcube_autocomplete_init()
	{
	rcmail::get_instance()->autocomplete_init();
	}

	function rcube_fontdefs($font = null)
	{
	return rcmail::font_defs($font);
	}

	function send_nocacheing_headers()
	{
	return rcmail::get_instance()->output->nocacheing_headers();
	}

	function show_bytes($bytes)
	{
	return rcmail::get_instance()->show_bytes($bytes);
	}

	function rc_wordwrap($string, $width=75, $break="\n", $cut=false, $charset=null)
	{
	return rcube_mime::wordwrap($string, $width, $break, $cut, $charset);
	}

	function rc_request_header($name)
	{
	return rcube_utils::request_header($name);
	}

	function rcube_explode_quoted_string($delimiter, $string)
	{
	return rcube_utils::explode_quoted_string($delimiter, $string);
	}

	function rc_mime_content_type($path, $name, $failover = 'application/octet-stream', $is_stream=false)
	{
	return rcube_mime::file_content_type($path, $name, $failover, $is_stream);
	}

	function rc_image_content_type($data)
	{
	return rcube_mime::image_content_type($data);
	}

	function rcube_strtotime($date)
	{
	return rcube_utils::strtotime($date);
	}

	function rcube_idn_to_ascii($str)
	{
	return rcube_utils::idn_to_ascii($str);
	}

	function rcube_idn_to_utf8($str)
	{
	return rcube_utils::idn_to_utf8($str);
	}

	function send_future_expire_header($offset = 2600000)
	{
	return rcmail::get_instance()->output->future_expire_header($offset);
	}

	function get_opt($aliases = array())
	{
	return rcube_utils::get_opt($aliases);
	}

	function prompt_silent($prompt = 'Password:')
	{
	return rcube_utils::prompt_silent($prompt);
	}

	function get_boolean($str)
	{
	return rcube_utils::get_boolean($str);
	}
	diff --git a/program/include/rcmail.php b/program/include/rcmail.php
	index 72c2fd944..cdafc5e7b 100644
	--- a/program/include/rcmail.php
	+++ b/program/include/rcmail.php
	@@ -1,2127 +1,2127 @@
	<?php

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

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


	const JS_OBJECT_NAME = 'rcmail';

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


	/**
	* This implements the 'singleton' design pattern
	*
	* @return rcmail The one and only instance
	*/
	static function get_instance()
	{
	if (!self::$instance \|\| !is_a(self::$instance, 'rcmail')) {
	self::$instance = new rcmail();
	self::$instance->startup(); // init AFTER object was linked with self::$instance
	}

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

	// 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') {
	if ($this->session && $_SESSION['task'] != $this->task)
	$this->session->remove('page');
	// set current task to session
	$_SESSION['task'] = $this->task;
	}

	// init output class
	if (!empty($_REQUEST['_remote']))
	$GLOBALS['OUTPUT'] = $this->json_init();
	else
	$GLOBALS['OUTPUT'] = $this->load_gui(!empty($_REQUEST['_framed']));

	// load plugins
	$this->plugins->init($this, $this->task);
	$this->plugins->load_plugins((array)$this->config->get('plugins', array()), array('filesystem_attachments', 'jqueryui'));
	}


	/**
	* Setter for application task
	*
	* @param string Task to set
	*/
	public function set_task($task)
	{
	$task = asciiwords($task);

	if ($this->user && $this->user->ID)
	$task = !$task ? 'mail' : $task;
	else
	$task = 'login';

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

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


	/**
	* Setter for system user object
	*
	* @param rcube_user Current user instance
	*/
	public function set_user($user)
	{
	if (is_object($user)) {
	$this->user = $user;

	// overwrite config with user preferences
	$this->config->set_user_prefs((array)$this->user->get_prefs());
	}

	$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
	if (in_array($lang, array('tr_TR', 'ku', 'az_AZ'))) {
	setlocale(LC_CTYPE, 'en_US.utf8', 'en_US.UTF-8');
	}
	}


	/**
	* Return instance of the internal address book class
	*
	* @param string Address book identifier (-1 for default addressbook)
	* @param boolean 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]) {
	$contacts = new rcube_ldap($ldap_config[$id], $this->config->get('ldap_debug'), $this->config->mail_domain($_SESSION['storage_host']));
	}
	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) {
	self::raise_error(array(
	'code' => 700, 'type' => 'php',
	'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 address books list
	*
	* @param boolean True if the address book needs to be writeable
	* @param boolean True if the address book needs to be not hidden
	*
	* @return array Address books array
	*/
	public function get_address_sources($writeable = false, $skip_hidden = false)
	{
	$abook_type = strtolower($this->config->get('address_book_type'));
	$ldap_config = $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 ($abook_type != 'ldap' && $abook_type != '') {
	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,
	'autocomplete' => in_array('sql', $autocomplete),
	'undelete' => $this->address_books['0']->undelete && $this->config->get('undo_timeout'),
	);
	}

	if ($ldap_config) {
	$ldap_config = (array) $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' => is_array($prop['groups']),
	'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;
	}


	/**
	* Init output object for GUI and add common scripts.
	* This will instantiate a rcube_output_html object and set
	* environment vars according to the current session and configuration
	*
	* @param boolean True if this request is loaded in a (i)frame
	* @return rcube_output_html Reference to HTML output object
	*/
	public function load_gui($framed = false)
	{
	// init output page
	if (!($this->output instanceof rcube_output_html))
	$this->output = new rcube_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(RCMAIL_CHARSET);
	+ $this->output->set_charset(RCUBE_CHARSET);

	// add some basic labels to client
	$this->output->add_label('loading', 'servererror', 'requesttimedout', 'refreshing');

	return $this->output;
	}


	/**
	* Create an output object for JSON responses
	*
	* @return rcube_output_json Reference to JSON output object
	*/
	public function json_init()
	{
	if (!($this->output instanceof rcube_output_json))
	$this->output = new rcube_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;

	// restore skin selection after logout
	if ($_SESSION['temp'] && !empty($_SESSION['skin']))
	$this->config->set('skin', $_SESSION['skin']);
	}


	/**
	* Perfom 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 Mail storage (IMAP) user name
	* @param string Mail storage (IMAP) password
	* @param string Mail storage (IMAP) host
	* @param bool Enables cookie check
	*
	* @return boolean True on success, False on failure
	*/
	function login($username, $pass, $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;
	}

	$config = $this->config->all();

	if (!$host)
	$host = $config['default_host'];

	// Validate that selected host is in the list of configured hosts
	if (is_array($config['default_host'])) {
	$allowed = false;
	foreach ($config['default_host'] as $key => $host_allowed) {
	if (!is_numeric($key))
	$host_allowed = $key;
	if ($host == $host_allowed) {
	$allowed = true;
	break;
	}
	}
	if (!$allowed) {
	$host = null;
	}
	}
	else if (!empty($config['default_host']) && $host != rcube_utils::parse_host($config['default_host'])) {
	$host = null;
	}

	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' && (!$config['default_port'] \|\| $config['default_port'] == 143))
	$port = 993;
	}

	if (!$port) {
	$port = $config['default_port'];
	}

	/* Modify username with domain if required
	Inspired by Marco <P0L0_notspam_binware.org>
	*/
	// Check if we need to add domain
	if (!empty($config['username_domain']) && strpos($username, '@') === false) {
	if (is_array($config['username_domain']) && isset($config['username_domain'][$host]))
	$username .= '@'.rcube_utils::parse_host($config['username_domain'][$host], $host);
	else if (is_string($config['username_domain']))
	$username .= '@'.rcube_utils::parse_host($config['username_domain'], $host);
	}

	if (!isset($config['login_lc'])) {
	$config['login_lc'] = 2; // default
	}

	// Convert username to lowercase. If storage backend
	// is case-insensitive we need to store always the same username (#1487113)
	if ($config['login_lc']) {
	if ($config['login_lc'] == 2 \|\| $config['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);
	$username = rcube_utils::idn_to_ascii($username);

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

	$storage = $this->get_storage();

	// try to log in
	if (!$storage->connect($host, $username, $pass, $port, $ssl)) {
	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 ($config['auto_create_user']) {
	if ($created = rcube_user::create($username, $host)) {
	$user = $created;
	}
	else {
	self::raise_error(array(
	'code' => 620, 'type' => 'php',
	'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, 'type' => 'php',
	'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();

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

	// create default folders on first login
	if ($config['create_default_folders'] && (!empty($created) \|\| empty($user->data['last_login']))) {
	$storage->create_default_folders();
	}

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

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

	// force reloading complete list of subscribed mailboxes
	$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($user, $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)) {
	list($key, $val) = each($default_host);
	$host = is_numeric($key) ? $val : $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, 'skin' => $this->config->get('skin'));
	$this->user->reset();
	}


	/**
	* Do server side actions on logout
	*/
	public function logout_actions()
	{
	$config = $this->config->all();
	$storage = $this->get_storage();

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

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

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


	/**
	* Generate a unique token to be used in a form request
	*
	* @return string The request token
	*/
	public function get_request_token()
	{
	$sess_id = $_COOKIE[ini_get('session.name')];
	if (!$sess_id) $sess_id = session_id();

	$plugin = $this->plugins->exec_hook('request_token', array(
	'value' => md5('RT' . $this->get_user_id() . $this->config->get('des_key') . $sess_id)));

	return $plugin['value'];
	}


	/**
	* Check if the current request contains a valid token
	*
	* @param int Request method
	* @return boolean True if request token is valid false if not
	*/
	public function check_request($mode = rcube_utils::INPUT_POST)
	{
	$token = rcube_utils::get_input_value('_token', $mode);
	$sess_id = $_COOKIE[ini_get('session.name')];
	return !empty($sess_id) && $token == $this->get_request_token();
	}


	/**
	* Create unique authorization hash
	*
	* @param string Session ID
	* @param int Timestamp
	* @return string The generated auth hash
	*/
	private function get_auth_hash($sess_id, $ts)
	{
	$auth_string = sprintf('rcmailsess%sR%sChk:%s;%s',
	$sess_id,
	$ts,
	$this->config->get('ip_check') ? $_SERVER['REMOTE_ADDR'] : '*...*',
	$_SERVER['HTTP_USER_AGENT']);

	if (function_exists('sha1'))
	return sha1($auth_string);
	else
	return md5($auth_string);
	}


	/**
	* Build a valid URL to this instance of Roundcube
	*
	* @param mixed Either a string with the action or url parameters as key-value pairs
	*
	* @return string Valid application URL
	*/
	public function url($p)
	{
	if (!is_array($p)) {
	if (strpos($p, 'http') === 0)
	return $p;

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

	$task = $p['_task'] ? $p['_task'] : ($p['task'] ? $p['task'] : $this->task);
	$p['_task'] = $task;
	unset($p['task']);

	$url = './';
	$delm = '?';
	foreach (array_reverse($p) as $key => $val) {
	if ($val !== '' && $val !== null) {
	$par = $key[0] == '_' ? $key : '_'.$key;
	$url .= $delm.urlencode($par).'='.urlencode($val);
	$delm = '&';
	}
	}
	return $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();
	}

	// before closing the database connection, write session data
	if ($_SERVER['REMOTE_ADDR'] && is_object($this->session)) {
	session_write_close();
	}

	// write performance stats to logs/console
	if ($this->config->get('devel_mode')) {
	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);
	}
	}


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

	$prefs = $this->config->all();
	if (!empty($prefs['namespace_fixed']))
	return;

	// 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 = $prefs[$opt]) {
	if ($value != 'INBOX' && !preg_match($regexp, $value)) {
	$prefs[$opt] = $prefix.$value;
	}
	}
	}

	if (!empty($prefs['default_folders'])) {
	foreach ($prefs['default_folders'] as $idx => $name) {
	if ($name != 'INBOX' && !preg_match($regexp, $name)) {
	$prefs['default_folders'][$idx] = $prefix.$name;
	}
	}
	}

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

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

	if (!empty($prefs['collapsed_folders'])) {
	$folders = explode('&&', $prefs['collapsed_folders']);
	$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 New action value
	*/
	public function overwrite_action($action)
	{
	$this->action = $action;
	$this->output->set_env('action', $action);
	}


	/**
	* Send the given message using the configured method.
	*
	* @param object $message Reference to Mail_MIME object
	* @param string $from Sender address string
	* @param array $mailto Array of recipient address strings
	* @param array $smtp_error SMTP error array (reference)
	* @param string $body_file Location of file with saved message body (reference),
	* used when delay_file_io is enabled
	* @param array $smtp_opts SMTP options (e.g. DSN request)
	*
	* @return boolean Send status.
	*/
	public function deliver_message(&$message, $from, $mailto, &$smtp_error, &$body_file = null, $smtp_opts = null)
	{
	$headers = $message->headers();

	// send thru SMTP server using custom SMTP library
	if ($this->config->get('smtp_server')) {
	// generate list of recipients
	$a_recipients = array($mailto);

	if (strlen($headers['Cc']))
	$a_recipients[] = $headers['Cc'];
	if (strlen($headers['Bcc']))
	$a_recipients[] = $headers['Bcc'];

	// clean Bcc from header for recipients
	$send_headers = $headers;
	unset($send_headers['Bcc']);
	// here too, it because txtHeaders() below use $message->_headers not only $send_headers
	unset($message->_headers['Bcc']);

	$smtp_headers = $message->txtHeaders($send_headers, true);

	if ($message->getParam('delay_file_io')) {
	// use common temp dir
	$temp_dir = $this->config->get('temp_dir');
	$body_file = tempnam($temp_dir, 'rcmMsg');
	if (PEAR::isError($mime_result = $message->saveMessageBody($body_file))) {
	self::raise_error(array('code' => 650, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Could not create message: ".$mime_result->getMessage()),
	TRUE, FALSE);
	return false;
	}
	$msg_body = fopen($body_file, 'r');
	}
	else {
	$msg_body = $message->get();
	}

	// send message
	if (!is_object($this->smtp)) {
	$this->smtp_init(true);
	}

	$sent = $this->smtp->send_mail($from, $a_recipients, $smtp_headers, $msg_body, $smtp_opts);
	$smtp_response = $this->smtp->get_response();
	$smtp_error = $this->smtp->get_error();

	// log error
	if (!$sent) {
	self::raise_error(array('code' => 800, 'type' => 'smtp',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => "SMTP error: ".join("\n", $smtp_response)), TRUE, FALSE);
	}
	}
	// send mail using PHP's mail() function
	else {
	// unset some headers because they will be added by the mail() function
	$headers_enc = $message->headers($headers);
	$headers_php = $message->_headers;
	unset($headers_php['To'], $headers_php['Subject']);

	// reset stored headers and overwrite
	$message->_headers = array();
	$header_str = $message->txtHeaders($headers_php);

	// #1485779
	if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
	if (preg_match_all('/<([^@]+@[^>]+)>/', $headers_enc['To'], $m)) {
	$headers_enc['To'] = implode(', ', $m[1]);
	}
	}

	$msg_body = $message->get();

	if (PEAR::isError($msg_body)) {
	self::raise_error(array('code' => 650, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Could not create message: ".$msg_body->getMessage()),
	TRUE, FALSE);
	}
	else {
	$delim = $this->config->header_delimiter();
	$to = $headers_enc['To'];
	$subject = $headers_enc['Subject'];
	$header_str = rtrim($header_str);

	if ($delim != "\r\n") {
	$header_str = str_replace("\r\n", $delim, $header_str);
	$msg_body = str_replace("\r\n", $delim, $msg_body);
	$to = str_replace("\r\n", $delim, $to);
	$subject = str_replace("\r\n", $delim, $subject);
	}

	if (ini_get('safe_mode'))
	$sent = mail($to, $subject, $msg_body, $header_str);
	else
	$sent = mail($to, $subject, $msg_body, $header_str, "-f$from");
	}
	}

	if ($sent) {
	$this->plugins->exec_hook('message_sent', array('headers' => $headers, 'body' => $msg_body));

	// remove MDN headers after sending
	unset($headers['Return-Receipt-To'], $headers['Disposition-Notification-To']);

	// get all recipients
	if ($headers['Cc'])
	$mailto .= $headers['Cc'];
	if ($headers['Bcc'])
	$mailto .= $headers['Bcc'];
	if (preg_match_all('/<([^@]+@[^>]+)>/', $mailto, $m))
	$mailto = implode(', ', array_unique($m[1]));

	if ($this->config->get('smtp_log')) {
	self::write_log('sendmail', sprintf("User %s [%s]; Message for %s; %s",
	$this->user->get_username(),
	$_SERVER['REMOTE_ADDR'],
	$mailto,
	!empty($smtp_response) ? join('; ', $smtp_response) : ''));
	}
	}

	if (is_resource($msg_body)) {
	fclose($msg_body);
	}

	$message->_headers = array();
	$message->headers($headers);

	return $sent;
	}


	/**
	* Unique Message-ID generator.
	*
	* @return string Message-ID
	*/
	public function gen_message_id()
	{
	$local_part = md5(uniqid('rcmail'.mt_rand(),true));
	$domain_part = $this->user->get_username('domain');

	// Try to find FQDN, some spamfilters doesn't like 'localhost' (#1486924)
	if (!preg_match('/\.[a-z]+$/i', $domain_part)) {
	foreach (array($_SERVER['HTTP_HOST'], $_SERVER['SERVER_NAME']) as $host) {
	$host = preg_replace('/:[0-9]+$/', '', $host);
	if ($host && preg_match('/\.[a-z]+$/i', $host)) {
	$domain_part = $host;
	}
	}
	}

	return sprintf('<%s@%s>', $local_part, $domain_part);
	}


	/**
	* 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()
	{
	if (!$this->config->get('log_logins')) {
	return;
	}

	$user_name = $this->get_user_name();
	$user_id = $this->get_user_id();

	if (!$user_id) {
	return;
	}

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


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

	// add table header
	if (!$attrib['noheader']) {
	foreach ($a_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 ($a_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'] : '';
	$rowid = 'rcmrow' . rcube_utils::html_identifier($row_data[$id_col]);

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

	// format each col
	foreach ($a_show_cols as $col) {
	$table->add($col, $this->Q(is_array($row_data[$col]) ? $row_data[$col][0] : $row_data[$col]));
	}
	}
	}

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


	/**
	* Convert the given date to a human readable form
	* This uses the date formatting properties from config
	*
	* @param mixed Date representation (string, timestamp or DateTime object)
	* @param string Date format to use
	* @param bool Enables date convertion 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)');

	$rcmail = rcmail::get_instance();
	$storage = $rcmail->get_storage();

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

	$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
	$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) {
	$rcmail->build_folder_tree($a_mailboxes, $folder, $delimiter);
	}
	}

	// allow plugins to alter the folder tree or to localize folder names
	$hook = $rcmail->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($rcmail->gettext($attrib['noselection'])), '');
	}

	$rcmail->render_folder_tree_select($a_mailboxes, $mbox_name, $attrib['maxlength'], $select, $attrib['realnames']);
	$out = $select->show($attrib['default']);
	}
	else {
	$js_mailboxlist = array();
	$out = html::tag('ul', $attrib, $rcmail->render_folder_tree_html($a_mailboxes, $mbox_name, $js_mailboxlist, $attrib), html::$common_attrib);

	$rcmail->output->add_gui_object('mailboxlist', $attrib['id']);
	$rcmail->output->set_env('mailboxes', $js_mailboxlist);
	$rcmail->output->set_env('unreadwrap', $attrib['unreadwrap']);
	$rcmail->output->set_env('collapsed_folders', (string)$rcmail->config->get('collapsed_folders'));
	}

	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())
	{
	$p += array('maxlength' => 100, 'realnames' => false, '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();

	foreach ($list as $folder) {
	if (empty($p['exceptions']) \|\| !in_array($folder, $p['exceptions'])) {
	$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');

	$out = '';
	foreach ($arrFolders as $key => $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)", rcmail::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) .
	(!empty($folder['folders']) ? html::div(array(
	'class' => ($is_collapsed ? 'collapsed' : 'expanded'),
	'style' => "position:absolute",
	'onclick' => sprintf("%s.command('collapse-folder', '%s')", rcmail::JS_OBJECT_NAME, $js_name)
	), ' ') : ''));

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

	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 $key => $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('\\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
	*
	* @return string Localized folder name in UTF-8 encoding
	*/
	public function localize_foldername($name)
	{
	if ($folder_class = $this->folder_classname($name)) {
	return $this->gettext($folder_class);
	}
	else {
	return rcube_charset::convert($name, 'UTF7-IMAP');
	}
	}


	public function localize_folderpath($path)
	{
	$protect_folders = $this->config->get('protect_default_folders');
	$default_folders = (array) $this->config->get('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 && in_array($directory, $default_folders)) {
	unset($result);
	$result[] = $this->localize_foldername($directory);
	}
	else {
	$result[] = rcube_charset::convert($dir, 'UTF7-IMAP');
	}
	}

	return implode($delimiter, $result);
	}


	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, '');
	}


	public function quota_content($attrib = null)
	{
	$quota = $this->storage->get_quota();
	$quota = $this->plugins->exec_hook('quota', $quota);

	$quota_result = (array) $quota;
	$quota_result['type'] = isset($_SESSION['quota_display']) ? $_SESSION['quota_display'] : '';

	if (!$quota['total'] && $this->config->get('quota_zero_as_unlimited')) {
	$quota_result['title'] = $this->gettext('unlimited');
	$quota_result['percent'] = 0;
	}
	else if ($quota['total']) {
	if (!isset($quota['percent'])) {
	$quota_result['percent'] = min(100, round(($quota['used']/max(1,$quota['total']))*100));
	}

	$title = 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'];
	}
	}
	else {
	$quota_result['title'] = $this->gettext('unknown');
	$quota_result['percent'] = 0;
	}

	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
	*/
	public function display_server_error($fallback = null, $fallback_args = null)
	{
	$err_code = $this->storage->get_error_code();
	$res_code = $this->storage->get_response_code();

	if ($res_code == rcube_storage::NOPERM) {
	$this->output->show_message('errornoperm', 'error');
	}
	else if ($res_code == rcube_storage::READONLY) {
	$this->output->show_message('errorreadonly', 'error');
	}
	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) {
	$this->output->show_message('errornoperm', 'error');
	}
	else {
	$this->output->show_message('servererrormsg', 'error', array('msg' => $err_str));
	}
	}
	else if ($err_code < 0) {
	$this->output->show_message('storageerror', 'error');
	}
	else if ($fallback) {
	$this->output->show_message($fallback, 'error', $fallback_args);
	}
	}


	/**
	* Output HTML editor scripts
	*
	* @param string $mode Editor mode
	*/
	public function html_editor($mode = '')
	{
	$hook = $this->plugins->exec_hook('html_editor', array('mode' => $mode));

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

	$lang = strtolower($_SESSION['language']);

	// TinyMCE uses two-letter lang codes, with exception of Chinese
	if (strpos($lang, 'zh_') === 0) {
	$lang = str_replace('_', '-', $lang);
	}
	else {
	$lang = substr($lang, 0, 2);
	}

	if (!file_exists(INSTALL_PATH . 'program/js/tiny_mce/langs/'.$lang.'.js')) {
	$lang = 'en';
	}

	$script = json_encode(array(
	'mode' => $mode,
	'lang' => $lang,
	'skin_path' => $this->output->get_skin_path(),
	'spellcheck' => intval($this->config->get('enable_spellcheck')),
	'spelldict' => intval($this->config->get('spellcheck_dictionary'))
	));

	$this->output->include_script('tiny_mce/tiny_mce.js');
	$this->output->include_script('editor.js');
	$this->output->add_script("rcmail_editor_init($script)", 'docready');
	}


	/**
	* Replaces TinyMCE's emoticon images with plain-text representation
	*
	* @param string $html HTML content
	*
	* @return string HTML content
	*/
	public static function replace_emoticons($html)
	{
	$emoticons = array(
	'8-)' => 'smiley-cool',
	':-#' => 'smiley-foot-in-mouth',
	':-*' => 'smiley-kiss',
	':-X' => 'smiley-sealed',
	':-P' => 'smiley-tongue-out',
	':-@' => 'smiley-yell',
	":'(" => 'smiley-cry',
	':-(' => 'smiley-frown',
	':-D' => 'smiley-laughing',
	':-)' => 'smiley-smile',
	':-S' => 'smiley-undecided',
	':-$' => 'smiley-embarassed',
	'O:-)' => 'smiley-innocent',
	':-\|' => 'smiley-money-mouth',
	':-O' => 'smiley-surprised',
	';-)' => 'smiley-wink',
	);

	foreach ($emoticons as $idx => $file) {
	// <img title="Cry" src="http://.../program/js/tiny_mce/plugins/emotions/img/smiley-cry.gif" border="0" alt="Cry" />
	$search[] = '/<img title="[a-z ]+" src="https?:\/\/[a-z0-9_.\/-]+\/tiny_mce\/plugins\/emotions\/img\/'.$file.'.gif"[^>]+\/>/i';
	$replace[] = $idx;
	}

	return preg_replace($search, $replace, $html);
	}


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

	if (function_exists('apc_fetch')) {
	$status = apc_fetch($prefix . $params['name']);

	if (!empty($status)) {
	$status['percent'] = round($status['current']/$status['total']*100);
	$params = array_merge($status, $params);
	}
	}

	if (isset($params['percent']))
	$params['text'] = $this->gettext(array('name' => 'uploadprogress', 'vars' => array(
	'percent' => $params['percent'] . '%',
	'current' => $this->show_bytes($params['current']),
	'total' => $this->show_bytes($params['total'])
	)));

	$this->output->command('upload_progress_update', $params);
	$this->output->send();
	}


	/**
	* Initializes file uploading interface.
	*/
	public function upload_init()
	{
	// Enable upload progress bar
	if (($seconds = $this->config->get('upload_progress')) && ini_get('apc.rfc1867')) {
	if ($field_name = ini_get('apc.rfc1867_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 = parse_bytes(ini_get('upload_max_filesize'));
	$max_postsize = parse_bytes(ini_get('post_max_size'));
	if ($max_postsize && $max_postsize < $max_filesize) {
	$max_filesize = $max_postsize;
	}

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

	return $max_filesize;
	}


	/**
	* 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 Number of bytes
	*
	* @return string Byte string
	*/
	public function show_bytes($bytes)
	{
	if ($bytes >= 1073741824) {
	$gb = $bytes/1073741824;
	$str = sprintf($gb>=10 ? "%d " : "%.1f ", $gb) . $this->gettext('GB');
	}
	else if ($bytes >= 1048576) {
	$mb = $bytes/1048576;
	$str = sprintf($mb>=10 ? "%d " : "%.1f ", $mb) . $this->gettext('MB');
	}
	else if ($bytes >= 1024) {
	$str = sprintf("%d ", round($bytes/1024)) . $this->gettext('KB');
	}
	else {
	$str = sprintf('%d ', $bytes) . $this->gettext('B');
	}

	return $str;
	}


	/**
	* Quote a given string.
	* Shortcut function for rcube_utils::rep_specialchars_output()
	*
	* @return string HTML-quoted string
	*/
	public static function Q($str, $mode = 'strict', $newlines = true)
	{
	return rcube_utils::rep_specialchars_output($str, 'html', $mode, $newlines);
	}


	/**
	* Quote a given string for javascript output.
	* Shortcut function for rcube_utils::rep_specialchars_output()
	*
	* @return string JS-quoted string
	*/
	public static function JQ($str)
	{
	return rcube_utils::rep_specialchars_output($str, 'js');
	}


	/**
	* Returns real size (calculated) of the message part
	*
	* @param rcube_message_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 ($part->encoding == 'base64') {
	$size = $size / 1.33;
	}

	$size = '~' . $this->show_bytes($size);
	}

	return $size;
	}


	/************************************************************************
	******* Deprecated methods (to be removed) *******
	***********************************************************************/

	public static function setcookie($name, $value, $exp = 0)
	{
	rcube_utils::setcookie($name, $value, $exp);
	}

	public function imap_connect()
	{
	return $this->storage_connect();
	}

	public function imap_init()
	{
	return $this->storage_init();
	}

	/**
	* 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/lib/Roundcube/bootstrap.php b/program/lib/Roundcube/bootstrap.php
	index 47020c1ab..eed7db8c1 100644
	--- a/program/lib/Roundcube/bootstrap.php
	+++ b/program/lib/Roundcube/bootstrap.php
	@@ -1,493 +1,493 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/bootstrap.php \|
	\| \|
	\| This file is part of the Roundcube PHP suite \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| CONTENTS: \|
	\| Roundcube Framework Initialization \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Roundcube Framework Initialization
	*
	* @package Framework
	* @subpackage Core
	*/

	$config = array(
	'error_reporting' => E_ALL &~ (E_NOTICE \| E_STRICT),
	// Some users are not using Installer, so we'll check some
	// critical PHP settings here. Only these, which doesn't provide
	// an error/warning in the logs later. See (#1486307).
	'mbstring.func_overload' => 0,
	'suhosin.session.encrypt' => 0,
	'session.auto_start' => 0,
	'file_uploads' => 1,
	'magic_quotes_runtime' => 0,
	'magic_quotes_sybase' => 0, // #1488506
	);
	foreach ($config as $optname => $optval) {
	if ($optval != ini_get($optname) && @ini_set($optname, $optval) === false) {
	die("ERROR: Wrong '$optname' option value and it wasn't possible to set it to required value ($optval).\n"
	."Check your PHP configuration (including php_admin_flag).");
	}
	}

	// framework constants
	define('RCUBE_VERSION', '0.9-git');
	-define('RCMAIL_CHARSET', 'UTF-8');
	+define('RCUBE_CHARSET', 'UTF-8');

	if (!defined('RCUBE_LIB_DIR')) {
	define('RCUBE_LIB_DIR', dirname(__FILE__).'/');
	}

	if (!defined('RCUBE_INSTALL_PATH')) {
	define('RCUBE_INSTALL_PATH', RCUBE_LIB_DIR);
	}

	if (!defined('RCUBE_CONFIG_DIR')) {
	define('RCUBE_CONFIG_DIR', RCUBE_INSTALL_PATH . 'config/');
	}

	if (!defined('RCUBE_PLUGINS_DIR')) {
	define('RCUBE_PLUGINS_DIR', RCUBE_INSTALL_PATH . 'plugins/');
	}

	if (!defined('RCUBE_LOCALIZATION_DIR')) {
	define('RCUBE_LOCALIZATION_DIR', RCUBE_INSTALL_PATH . 'localization/');
	}

	// set internal encoding for mbstring extension
	if (extension_loaded('mbstring')) {
	- mb_internal_encoding(RCMAIL_CHARSET);
	- @mb_regex_encoding(RCMAIL_CHARSET);
	+ mb_internal_encoding(RCUBE_CHARSET);
	+ @mb_regex_encoding(RCUBE_CHARSET);
	}

	// Register autoloader
	spl_autoload_register('rcube_autoload');

	// set PEAR error handling (will also load the PEAR main class)
	PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, 'rcube_pear_error');



	/**
	* Similar function as in_array() but case-insensitive
	*
	* @param string $needle Needle value
	* @param array $heystack Array to search in
	*
	* @return boolean True if found, False if not
	*/
	function in_array_nocase($needle, $haystack)
	{
	$needle = mb_strtolower($needle);
	foreach ((array)$haystack as $value) {
	if ($needle === mb_strtolower($value)) {
	return true;
	}
	}

	return false;
	}


	/**
	* Parse a human readable string for a number of bytes.
	*
	* @param string $str Input string
	*
	* @return float Number of bytes
	*/
	function parse_bytes($str)
	{
	if (is_numeric($str)) {
	return floatval($str);
	}

	if (preg_match('/([0-9\.]+)\s([a-z])/i', $str, $regs)) {
	$bytes = floatval($regs[1]);
	switch (strtolower($regs[2])) {
	case 'g':
	case 'gb':
	$bytes *= 1073741824;
	break;
	case 'm':
	case 'mb':
	$bytes *= 1048576;
	break;
	case 'k':
	case 'kb':
	$bytes *= 1024;
	break;
	}
	}

	return floatval($bytes);
	}


	/**
	* Make sure the string ends with a slash
	*/
	function slashify($str)
	{
	return unslashify($str).'/';
	}


	/**
	* Remove slashes at the end of the string
	*/
	function unslashify($str)
	{
	return preg_replace('/\/+$/', '', $str);
	}


	/**
	* Returns number of seconds for a specified offset string.
	*
	* @param string $str String representation of the offset (e.g. 20min, 5h, 2days, 1week)
	*
	* @return int Number of seconds
	*/
	function get_offset_sec($str)
	{
	if (preg_match('/^([0-9]+)\s*([smhdw])/i', $str, $regs)) {
	$amount = (int) $regs[1];
	$unit = strtolower($regs[2]);
	}
	else {
	$amount = (int) $str;
	$unit = 's';
	}

	switch ($unit) {
	case 'w':
	$amount *= 7;
	case 'd':
	$amount *= 24;
	case 'h':
	$amount *= 60;
	case 'm':
	$amount *= 60;
	}

	return $amount;
	}


	/**
	* Create a unix timestamp with a specified offset from now.
	*
	* @param string $offset_str String representation of the offset (e.g. 20min, 5h, 2days)
	* @param int $factor Factor to multiply with the offset
	*
	* @return int Unix timestamp
	*/
	function get_offset_time($offset_str, $factor=1)
	{
	return time() + get_offset_sec($offset_str) * $factor;
	}


	/**
	* Truncate string if it is longer than the allowed length.
	* Replace the middle or the ending part of a string with a placeholder.
	*
	* @param string $str Input string
	* @param int $maxlength Max. length
	* @param string $placeholder Replace removed chars with this
	* @param bool $ending Set to True if string should be truncated from the end
	*
	* @return string Abbreviated string
	*/
	function abbreviate_string($str, $maxlength, $placeholder='...', $ending=false)
	{
	$length = mb_strlen($str);

	if ($length > $maxlength) {
	if ($ending) {
	return mb_substr($str, 0, $maxlength) . $placeholder;
	}

	$placeholder_length = mb_strlen($placeholder);
	$first_part_length = floor(($maxlength - $placeholder_length)/2);
	$second_starting_location = $length - $maxlength + $first_part_length + $placeholder_length;

	$str = mb_substr($str, 0, $first_part_length) . $placeholder . mb_substr($str, $second_starting_location);
	}

	return $str;
	}


	/**
	* Get all keys from array (recursive).
	*
	* @param array $array Input array
	*
	* @return array List of array keys
	*/
	function array_keys_recursive($array)
	{
	$keys = array();

	if (!empty($array) && is_array($array)) {
	foreach ($array as $key => $child) {
	$keys[] = $key;
	foreach (array_keys_recursive($child) as $val) {
	$keys[] = $val;
	}
	}
	}

	return $keys;
	}


	/**
	* Remove all non-ascii and non-word chars except ., -, _
	*/
	function asciiwords($str, $css_id = false, $replace_with = '')
	{
	$allowed = 'a-z0-9\_\-' . (!$css_id ? '\.' : '');
	return preg_replace("/[^$allowed]/i", $replace_with, $str);
	}


	/**
	* Check if a string contains only ascii characters
	*
	* @param string $str String to check
	* @param bool $control_chars Includes control characters
	*
	* @return bool
	*/
	function is_ascii($str, $control_chars = true)
	{
	$regexp = $control_chars ? '/[^\x00-\x7F]/' : '/[^\x20-\x7E]/';
	return preg_match($regexp, $str) ? false : true;
	}


	/**
	* Remove single and double quotes from a given string
	*
	* @param string Input value
	*
	* @return string Dequoted string
	*/
	function strip_quotes($str)
	{
	return str_replace(array("'", '"'), '', $str);
	}


	/**
	* Remove new lines characters from given string
	*
	* @param string $str Input value
	*
	* @return string Stripped string
	*/
	function strip_newlines($str)
	{
	return preg_replace('/[\r\n]/', '', $str);
	}


	/**
	* Compose a valid representation of name and e-mail address
	*
	* @param string $email E-mail address
	* @param string $name Person name
	*
	* @return string Formatted string
	*/
	function format_email_recipient($email, $name = '')
	{
	$email = trim($email);

	if ($name && $name != $email) {
	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	if (preg_match('/[\<\>\\\.\[\]@,;:"]/', $name)) {
	$name = '"'.addcslashes($name, '"').'"';
	}

	return "$name <$email>";
	}

	return $email;
	}


	/**
	* Format e-mail address
	*
	* @param string $email E-mail address
	*
	* @return string Formatted e-mail address
	*/
	function format_email($email)
	{
	$email = trim($email);
	$parts = explode('@', $email);
	$count = count($parts);

	if ($count > 1) {
	$parts[$count-1] = mb_strtolower($parts[$count-1]);

	$email = implode('@', $parts);
	}

	return $email;
	}


	/**
	* mbstring replacement functions
	*/
	if (!extension_loaded('mbstring'))
	{
	function mb_strlen($str)
	{
	return strlen($str);
	}

	function mb_strtolower($str)
	{
	return strtolower($str);
	}

	function mb_strtoupper($str)
	{
	return strtoupper($str);
	}

	function mb_substr($str, $start, $len=null)
	{
	return substr($str, $start, $len);
	}

	function mb_strpos($haystack, $needle, $offset=0)
	{
	return strpos($haystack, $needle, $offset);
	}

	function mb_strrpos($haystack, $needle, $offset=0)
	{
	return strrpos($haystack, $needle, $offset);
	}
	}

	/**
	* intl replacement functions
	*/

	if (!function_exists('idn_to_utf8'))
	{
	function idn_to_utf8($domain, $flags=null)
	{
	static $idn, $loaded;

	if (!$loaded) {
	$idn = new Net_IDNA2();
	$loaded = true;
	}

	if ($idn && $domain && preg_match('/(^\|\.)xn--/i', $domain)) {
	try {
	$domain = $idn->decode($domain);
	}
	catch (Exception $e) {
	}
	}
	return $domain;
	}
	}

	if (!function_exists('idn_to_ascii'))
	{
	function idn_to_ascii($domain, $flags=null)
	{
	static $idn, $loaded;

	if (!$loaded) {
	$idn = new Net_IDNA2();
	$loaded = true;
	}

	if ($idn && $domain && preg_match('/[^\x20-\x7E]/', $domain)) {
	try {
	$domain = $idn->encode($domain);
	}
	catch (Exception $e) {
	}
	}
	return $domain;
	}
	}

	/**
	* Use PHP5 autoload for dynamic class loading
	*
	* @todo Make Zend, PEAR etc play with this
	* @todo Make our classes conform to a more straight forward CS.
	*/
	function rcube_autoload($classname)
	{
	$filename = preg_replace(
	array(
	'/Mail_(.+)/',
	'/Net_(.+)/',
	'/Auth_(.+)/',
	'/^html_.+/',
	'/^rcube(.*)/',
	'/^utf8$/',
	),
	array(
	'Mail/\\1',
	'Net/\\1',
	'Auth/\\1',
	'Roundcube/html',
	'Roundcube/rcube\\1',
	'utf8.class',
	),
	$classname
	);

	if ($fp = @fopen("$filename.php", 'r', true)) {
	fclose($fp);
	include_once "$filename.php";
	return true;
	}

	return false;
	}

	/**
	* Local callback function for PEAR errors
	*/
	function rcube_pear_error($err)
	{
	error_log(sprintf("%s (%s): %s",
	$err->getMessage(),
	$err->getCode(),
	$err->getUserinfo()), 0);
	}
	diff --git a/program/lib/Roundcube/html.php b/program/lib/Roundcube/html.php
	index 8ff685a84..5fb574b97 100644
	--- a/program/lib/Roundcube/html.php
	+++ b/program/lib/Roundcube/html.php
	@@ -1,849 +1,849 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/html.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2011, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Helper class to create valid XHTML code \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Class for HTML code creation
	*
	* @package Framework
	* @subpackage HTML
	*/
	class html
	{
	protected $tagname;
	protected $attrib = array();
	protected $allowed = array();
	protected $content;

	public static $doctype = 'xhtml';
	public static $lc_tags = true;
	public static $common_attrib = array('id','class','style','title','align');
	public static $containers = array('iframe','div','span','p','h1','h2','h3','form','textarea','table','thead','tbody','tr','th','td','style','script');

	/**
	* Constructor
	*
	* @param array $attrib Hash array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}
	}

	/**
	* Return the tag code
	*
	* @return string The finally composed HTML tag
	*/
	public function show()
	{
	return self::tag($this->tagname, $this->attrib, $this->content, array_merge(self::$common_attrib, $this->allowed));
	}

	/**** STATIC METHODS *****/

	/**
	* Generic method to create a HTML tag
	*
	* @param string $tagname Tag name
	* @param array $attrib Tag attributes as key/value pairs
	* @param string $content Optinal Tag content (creates a container tag)
	* @param array $allowed_attrib List with allowed attributes, omit to allow all
	* @return string The XHTML tag
	*/
	public static function tag($tagname, $attrib = array(), $content = null, $allowed_attrib = null)
	{
	if (is_string($attrib))
	$attrib = array('class' => $attrib);

	$inline_tags = array('a','span','img');
	$suffix = $attrib['nl'] \|\| ($content && $attrib['nl'] !== false && !in_array($tagname, $inline_tags)) ? "\n" : '';

	$tagname = self::$lc_tags ? strtolower($tagname) : $tagname;
	if (isset($content) \|\| in_array($tagname, self::$containers)) {
	$suffix = $attrib['noclose'] ? $suffix : '</' . $tagname . '>' . $suffix;
	unset($attrib['noclose'], $attrib['nl']);
	return '<' . $tagname . self::attrib_string($attrib, $allowed_attrib) . '>' . $content . $suffix;
	}
	else {
	return '<' . $tagname . self::attrib_string($attrib, $allowed_attrib) . '>' . $suffix;
	}
	}

	/**
	*
	*/
	public static function doctype($type)
	{
	$doctypes = array(
	'html5' => '<!DOCTYPE html>',
	'xhtml' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-trans' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-strict' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
	);

	if ($doctypes[$type]) {
	self::$doctype = preg_replace('/-\w+$/', '', $type);
	return $doctypes[$type];
	}

	return '';
	}

	/**
	* Derrived method for <div> containers
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Div content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function div($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('div', $attr, $cont, array_merge(self::$common_attrib, array('onclick')));
	}

	/**
	* Derrived method for <p> blocks
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Paragraph content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function p($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('p', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method to create <img />
	*
	* @param mixed $attr Hash array with tag attributes or string with image source (src)
	* @return string HTML code
	* @see html::tag()
	*/
	public static function img($attr = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	return self::tag('img', $attr + array('alt' => ''), null, array_merge(self::$common_attrib,
	array('src','alt','width','height','border','usemap','onclick')));
	}

	/**
	* Derrived method for link tags
	*
	* @param mixed $attr Hash array with tag attributes or string with link location (href)
	* @param string $cont Link content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function a($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('href' => $attr);
	}
	return self::tag('a', $attr, $cont, array_merge(self::$common_attrib,
	array('href','target','name','rel','onclick','onmouseover','onmouseout','onmousedown','onmouseup')));
	}

	/**
	* Derrived method for inline span tags
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function span($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('span', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method for form element labels
	*
	* @param mixed $attr Hash array with tag attributes or string with 'for' attrib
	* @param string $cont Tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function label($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('for' => $attr);
	}
	return self::tag('label', $attr, $cont, array_merge(self::$common_attrib, array('for')));
	}

	/**
	* Derrived method to create <iframe></iframe>
	*
	* @param mixed $attr Hash array with tag attributes or string with frame source (src)
	* @return string HTML code
	* @see html::tag()
	*/
	public static function iframe($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	return self::tag('iframe', $attr, $cont, array_merge(self::$common_attrib,
	array('src','name','width','height','border','frameborder')));
	}

	/**
	* Derrived method to create <script> tags
	*
	* @param mixed $attr Hash array with tag attributes or string with script source (src)
	* @param string $cont Javascript code to be placed as tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function script($attr, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	if ($cont) {
	if (self::$doctype == 'xhtml')
	$cont = "\n/* <![CDATA[ /\n" . $cont . "\n/ ]]> */\n";
	else
	$cont = "\n" . $cont . "\n";
	}

	return self::tag('script', $attr + array('type' => 'text/javascript', 'nl' => true),
	$cont, array_merge(self::$common_attrib, array('src','type','charset')));
	}

	/**
	* Derrived method for line breaks
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function br($attrib = array())
	{
	return self::tag('br', $attrib);
	}

	/**
	* Create string with attributes
	*
	* @param array $attrib Associative arry with tag attributes
	* @param array $allowed List of allowed attributes
	* @return string Valid attribute string
	*/
	public static function attrib_string($attrib = array(), $allowed = null)
	{
	if (empty($attrib)) {
	return '';
	}

	$allowed_f = array_flip((array)$allowed);
	$attrib_arr = array();
	foreach ($attrib as $key => $value) {
	// skip size if not numeric
	if ($key == 'size' && !is_numeric($value)) {
	continue;
	}

	// ignore "internal" or not allowed attributes
	if ($key == 'nl' \|\| ($allowed && !isset($allowed_f[$key])) \|\| $value === null) {
	continue;
	}

	// skip empty eventhandlers
	if (preg_match('/^on[a-z]+/', $key) && !$value) {
	continue;
	}

	// attributes with no value
	if (in_array($key, array('checked', 'multiple', 'disabled', 'selected'))) {
	if ($value) {
	$attrib_arr[] = $key . '="' . $key . '"';
	}
	}
	else {
	$attrib_arr[] = $key . '="' . self::quote($value) . '"';
	}
	}

	return count($attrib_arr) ? ' '.implode(' ', $attrib_arr) : '';
	}

	/**
	* Convert a HTML attribute string attributes to an associative array (name => value)
	*
	* @param string Input string
	* @return array Key-value pairs of parsed attributes
	*/
	public static function parse_attrib_string($str)
	{
	$attrib = array();
	$regexp = '/\s([-_a-z]+)=(["\'])??(?(2)([^\2])\2\|(\S+?))/Ui';

	preg_match_all($regexp, stripslashes($str), $regs, PREG_SET_ORDER);

	// convert attributes to an associative array (name => value)
	if ($regs) {
	foreach ($regs as $attr) {
	$attrib[strtolower($attr[1])] = html_entity_decode($attr[3] . $attr[4]);
	}
	}

	return $attrib;
	}

	/**
	* Replacing specials characters in html attribute value
	*
	* @param string $str Input string
	*
	* @return string The quoted string
	*/
	public static function quote($str)
	{
	- return @htmlspecialchars($str, ENT_COMPAT, RCMAIL_CHARSET);
	+ return @htmlspecialchars($str, ENT_COMPAT, RCUBE_CHARSET);
	}
	}


	/**
	* Class to create an HTML input field
	*
	* @package HTML
	*/
	class html_inputfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'text';
	protected $allowed = array(
	'type','name','value','size','tabindex','autocapitalize',
	'autocomplete','checked','onchange','onclick','disabled','readonly',
	'spellcheck','results','maxlength','src','multiple','placeholder',
	);

	/**
	* Object constructor
	*
	* @param array $attrib Associative array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}

	if ($attrib['type']) {
	$this->type = $attrib['type'];
	}
	}

	/**
	* Compose input tag
	*
	* @param string $value Field value
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = null, $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	if ($value !== null) {
	$this->attrib['value'] = $value;
	}
	// set type
	$this->attrib['type'] = $this->type;
	return parent::show();
	}
	}

	/**
	* Class to create an HTML password field
	*
	* @package HTML
	*/
	class html_passwordfield extends html_inputfield
	{
	protected $type = 'password';
	}

	/**
	* Class to create an hidden HTML input field
	*
	* @package HTML
	*/

	class html_hiddenfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'hidden';
	protected $fields_arr = array();
	protected $allowed = array('type','name','value','onchange','disabled','readonly');

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = null)
	{
	if (is_array($attrib)) {
	$this->add($attrib);
	}
	}

	/**
	* Add a hidden field to this instance
	*
	* @param array $attrib Named tag attributes
	*/
	public function add($attrib)
	{
	$this->fields_arr[] = $attrib;
	}

	/**
	* Create HTML code for the hidden fields
	*
	* @return string Final HTML code
	*/
	public function show()
	{
	$out = '';
	foreach ($this->fields_arr as $attrib) {
	$out .= self::tag($this->tagname, array('type' => $this->type) + $attrib);
	}
	return $out;
	}
	}

	/**
	* Class to create HTML radio buttons
	*
	* @package HTML
	*/
	class html_radiobutton extends html_inputfield
	{
	protected $type = 'radio';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create HTML checkboxes
	*
	* @package HTML
	*/
	class html_checkbox extends html_inputfield
	{
	protected $type = 'checkbox';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create an HTML textarea
	*
	* @package HTML
	*/
	class html_textarea extends html
	{
	protected $tagname = 'textarea';
	protected $allowed = array('name','rows','cols','wrap','tabindex',
	'onchange','disabled','readonly','spellcheck');

	/**
	* Get HTML code for this object
	*
	* @param string $value Textbox value
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// take value attribute as content
	if (empty($value) && !empty($this->attrib['value'])) {
	$value = $this->attrib['value'];
	}

	// make shure we don't print the value attribute
	if (isset($this->attrib['value'])) {
	unset($this->attrib['value']);
	}

	if (!empty($value) && empty($this->attrib['is_escaped'])) {
	$value = self::quote($value);
	}

	return self::tag($this->tagname, $this->attrib, $value,
	array_merge(self::$common_attrib, $this->allowed));
	}
	}

	/**
	* Builder for HTML drop-down menus
	* Syntax:<pre>
	* // create instance. arguments are used to set attributes of select-tag
	* $select = new html_select(array('name' => 'fieldname'));
	*
	* // add one option
	* $select->add('Switzerland', 'CH');
	*
	* // add multiple options
	* $select->add(array('Switzerland','Germany'), array('CH','DE'));
	*
	* // generate pulldown with selection 'Switzerland' and return html-code
	* // as second argument the same attributes available to instanciate can be used
	* print $select->show('CH');
	* </pre>
	*
	* @package HTML
	*/
	class html_select extends html
	{
	protected $tagname = 'select';
	protected $options = array();
	protected $allowed = array('name','size','tabindex','autocomplete',
	'multiple','onchange','disabled','rel');

	/**
	* Add a new option to this drop-down
	*
	* @param mixed $names Option name or array with option names
	* @param mixed $values Option value or array with option values
	*/
	public function add($names, $values = null)
	{
	if (is_array($names)) {
	foreach ($names as $i => $text) {
	$this->options[] = array('text' => $text, 'value' => $values[$i]);
	}
	}
	else {
	$this->options[] = array('text' => $names, 'value' => $values);
	}
	}

	/**
	* Get HTML code for this object
	*
	* @param string $select Value of the selection option
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($select = array(), $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	$this->content = "\n";
	$select = (array)$select;
	foreach ($this->options as $option) {
	$attr = array(
	'value' => $option['value'],
	'selected' => (in_array($option['value'], $select, true) \|\|
	in_array($option['text'], $select, true)) ? 1 : null);

	$option_content = $option['text'];
	if (empty($this->attrib['is_escaped'])) {
	$option_content = self::quote($option_content);
	}

	$this->content .= self::tag('option', $attr, $option_content);
	}

	return parent::show();
	}
	}


	/**
	* Class to build an HTML table
	*
	* @package HTML
	*/
	class html_table extends html
	{
	protected $tagname = 'table';
	protected $allowed = array('id','class','style','width','summary',
	'cellpadding','cellspacing','border');

	private $header = array();
	private $rows = array();
	private $rowindex = 0;
	private $colindex = 0;

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = array())
	{
	$default_attrib = self::$doctype == 'xhtml' ? array('summary' => '', 'border' => 0) : array();
	$this->attrib = array_merge($attrib, $default_attrib);
	}

	/**
	* Add a table cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	$cell->attrib = $attr;
	$cell->content = $cont;

	$this->rows[$this->rowindex]->cells[$this->colindex] = $cell;
	$this->colindex += max(1, intval($attr['colspan']));

	if ($this->attrib['cols'] && $this->colindex >= $this->attrib['cols']) {
	$this->add_row();
	}
	}

	/**
	* Add a table header cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add_header($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	$cell->attrib = $attr;
	$cell->content = $cont;
	$this->header[] = $cell;
	}

	/**
	* Remove a column from a table
	* Useful for plugins making alterations
	*
	* @param string $class
	*/
	public function remove_column($class)
	{
	// Remove the header
	foreach ($this->header as $index=>$header){
	if ($header->attrib['class'] == $class){
	unset($this->header[$index]);
	break;
	}
	}

	// Remove cells from rows
	foreach ($this->rows as $i=>$row){
	foreach ($row->cells as $j=>$cell){
	if ($cell->attrib['class'] == $class){
	unset($this->rows[$i]->cells[$j]);
	break;
	}
	}
	}
	}

	/**
	* Jump to next row
	*
	* @param array $attr Row attributes
	*/
	public function add_row($attr = array())
	{
	$this->rowindex++;
	$this->colindex = 0;
	$this->rows[$this->rowindex] = new stdClass;
	$this->rows[$this->rowindex]->attrib = $attr;
	$this->rows[$this->rowindex]->cells = array();
	}

	/**
	* Set row attributes
	*
	* @param array $attr Row attributes
	* @param int $index Optional row index (default current row index)
	*/
	public function set_row_attribs($attr = array(), $index = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	if ($index === null) {
	$index = $this->rowindex;
	}

	$this->rows[$index]->attrib = $attr;
	}

	/**
	* Get row attributes
	*
	* @param int $index Row index
	*
	* @return array Row attributes
	*/
	public function get_row_attribs($index = null)
	{
	if ($index === null) {
	$index = $this->rowindex;
	}

	return $this->rows[$index] ? $this->rows[$index]->attrib : null;
	}

	/**
	* Build HTML output of the table data
	*
	* @param array $attrib Table attributes
	* @return string The final table HTML code
	*/
	public function show($attrib = null)
	{
	if (is_array($attrib))
	$this->attrib = array_merge($this->attrib, $attrib);

	$thead = $tbody = "";

	// include <thead>
	if (!empty($this->header)) {
	$rowcontent = '';
	foreach ($this->header as $c => $col) {
	$rowcontent .= self::tag('td', $col->attrib, $col->content);
	}
	$thead = self::tag('thead', null, self::tag('tr', null, $rowcontent, parent::$common_attrib));
	}

	foreach ($this->rows as $r => $row) {
	$rowcontent = '';
	foreach ($row->cells as $c => $col) {
	$rowcontent .= self::tag('td', $col->attrib, $col->content);
	}

	if ($r < $this->rowindex \|\| count($row->cells)) {
	$tbody .= self::tag('tr', $row->attrib, $rowcontent, parent::$common_attrib);
	}
	}

	if ($this->attrib['rowsonly']) {
	return $tbody;
	}

	// add <tbody>
	$this->content = $thead . self::tag('tbody', null, $tbody);

	unset($this->attrib['cols'], $this->attrib['rowsonly']);
	return parent::show();
	}

	/**
	* Count number of rows
	*
	* @return The number of rows
	*/
	public function size()
	{
	return count($this->rows);
	}

	/**
	* Remove table body (all rows)
	*/
	public function remove_body()
	{
	$this->rows = array();
	$this->rowindex = 0;
	}

	}
	diff --git a/program/lib/Roundcube/rcube.php b/program/lib/Roundcube/rcube.php
	index c798465ed..1ce6241c8 100644
	--- a/program/lib/Roundcube/rcube.php
	+++ b/program/lib/Roundcube/rcube.php
	@@ -1,1257 +1,1257 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2008-2012, The Roundcube Dev Team \|
	\| Copyright (C) 2011-2012, 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: \|
	\| Framework base class providing core functions and holding \|
	\| instances of all 'global' objects like db- and storage-connections \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Base class of the Roundcube Framework
	* implemented as singleton
	*
	* @package Framework
	* @subpackage Core
	*/
	class rcube
	{
	const INIT_WITH_DB = 1;
	const INIT_WITH_PLUGINS = 2;

	/**
	* Singleton instace of rcube
	*
	* @var rcmail
	*/
	static protected $instance;

	/**
	* Stores instance of rcube_config.
	*
	* @var rcube_config
	*/
	public $config;

	/**
	* Instace of database class.
	*
	* @var rcube_db
	*/
	public $db;

	/**
	* Instace of Memcache class.
	*
	* @var Memcache
	*/
	public $memcache;

	/**
	* Instace of rcube_session class.
	*
	* @var rcube_session
	*/
	public $session;

	/**
	* Instance of rcube_smtp class.
	*
	* @var rcube_smtp
	*/
	public $smtp;

	/**
	* Instance of rcube_storage class.
	*
	* @var rcube_storage
	*/
	public $storage;

	/**
	* Instance of rcube_output class.
	*
	* @var rcube_output
	*/
	public $output;

	/**
	* Instance of rcube_plugin_api.
	*
	* @var rcube_plugin_api
	*/
	public $plugins;


	/* private/protected vars */
	protected $texts;
	protected $caches = array();
	protected $shutdown_functions = array();
	protected $expunge_cache = false;


	/**
	* This implements the 'singleton' design pattern
	*
	* @param integer Options to initialize with this instance. See rcube::INIT_WITH_* constants
	*
	* @return rcube The one and only instance
	*/
	static function get_instance($mode = 0)
	{
	if (!self::$instance) {
	self::$instance = new rcube();
	self::$instance->init($mode);
	}

	return self::$instance;
	}


	/**
	* Private constructor
	*/
	protected function __construct()
	{
	// load configuration
	$this->config = new rcube_config;
	$this->plugins = new rcube_dummy_plugin_api;

	register_shutdown_function(array($this, 'shutdown'));
	}


	/**
	* Initial startup function
	*/
	protected function init($mode = 0)
	{
	// initialize syslog
	if ($this->config->get('log_driver') == 'syslog') {
	$syslog_id = $this->config->get('syslog_id', 'roundcube');
	$syslog_facility = $this->config->get('syslog_facility', LOG_USER);
	openlog($syslog_id, LOG_ODELAY, $syslog_facility);
	}

	// connect to database
	if ($mode & self::INIT_WITH_DB) {
	$this->get_dbh();
	}

	// create plugin API and load plugins
	if ($mode & self::INIT_WITH_PLUGINS) {
	$this->plugins = rcube_plugin_api::get_instance();
	}
	}


	/**
	* Get the current database connection
	*
	* @return rcube_db Database object
	*/
	public function get_dbh()
	{
	if (!$this->db) {
	$config_all = $this->config->all();
	$this->db = rcube_db::factory($config_all['db_dsnw'], $config_all['db_dsnr'], $config_all['db_persistent']);
	$this->db->set_debug((bool)$config_all['sql_debug']);
	}

	return $this->db;
	}


	/**
	* Get global handle for memcache access
	*
	* @return object Memcache
	*/
	public function get_memcache()
	{
	if (!isset($this->memcache)) {
	// no memcache support in PHP
	if (!class_exists('Memcache')) {
	$this->memcache = false;
	return false;
	}

	$this->memcache = new Memcache;
	$this->mc_available = 0;

	// add all configured hosts to pool
	$pconnect = $this->config->get('memcache_pconnect', true);
	foreach ($this->config->get('memcache_hosts', array()) as $host) {
	if (substr($host, 0, 7) != 'unix://') {
	list($host, $port) = explode(':', $host);
	if (!$port) $port = 11211;
	}
	else {
	$port = 0;
	}

	$this->mc_available += intval($this->memcache->addServer(
	$host, $port, $pconnect, 1, 1, 15, false, array($this, 'memcache_failure')));
	}

	// test connection and failover (will result in $this->mc_available == 0 on complete failure)
	$this->memcache->increment('__CONNECTIONTEST__', 1); // NOP if key doesn't exist

	if (!$this->mc_available) {
	$this->memcache = false;
	}
	}

	return $this->memcache;
	}


	/**
	* Callback for memcache failure
	*/
	public function memcache_failure($host, $port)
	{
	static $seen = array();

	// only report once
	if (!$seen["$host:$port"]++) {
	$this->mc_available--;
	self::raise_error(array(
	'code' => 604, 'type' => 'db',
	'line' => __LINE__, 'file' => __FILE__,
	'message' => "Memcache failure on host $host:$port"),
	true, false);
	}
	}


	/**
	* Initialize and get cache object
	*
	* @param string $name Cache identifier
	* @param string $type Cache type ('db', 'apc' or 'memcache')
	* @param string $ttl Expiration time for cache items
	* @param bool $packed Enables/disables data serialization
	*
	* @return rcube_cache Cache object
	*/
	public function get_cache($name, $type='db', $ttl=0, $packed=true)
	{
	if (!isset($this->caches[$name]) && ($userid = $this->get_user_id())) {
	$this->caches[$name] = new rcube_cache($type, $userid, $name, $ttl, $packed);
	}

	return $this->caches[$name];
	}


	/**
	* Create SMTP object and connect to server
	*
	* @param boolean True if connection should be established
	*/
	public function smtp_init($connect = false)
	{
	$this->smtp = new rcube_smtp();

	if ($connect) {
	$this->smtp->connect();
	}
	}


	/**
	* Initialize and get storage object
	*
	* @return rcube_storage Storage object
	*/
	public function get_storage()
	{
	// already initialized
	if (!is_object($this->storage)) {
	$this->storage_init();
	}

	return $this->storage;
	}


	/**
	* Initialize storage object
	*/
	public function storage_init()
	{
	// already initialized
	if (is_object($this->storage)) {
	return;
	}

	$driver = $this->config->get('storage_driver', 'imap');
	$driver_class = "rcube_{$driver}";

	if (!class_exists($driver_class)) {
	self::raise_error(array(
	'code' => 700, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Storage driver class ($driver) not found!"),
	true, true);
	}

	// Initialize storage object
	$this->storage = new $driver_class;

	// for backward compat. (deprecated, will be removed)
	$this->imap = $this->storage;

	// enable caching of mail data
	$storage_cache = $this->config->get("{$driver}_cache");
	$messages_cache = $this->config->get('messages_cache');
	// for backward compatybility
	if ($storage_cache === null && $messages_cache === null && $this->config->get('enable_caching')) {
	$storage_cache = 'db';
	$messages_cache = true;
	}

	if ($storage_cache) {
	$this->storage->set_caching($storage_cache);
	}
	if ($messages_cache) {
	$this->storage->set_messages_caching(true);
	}

	// set pagesize from config
	$pagesize = $this->config->get('mail_pagesize');
	if (!$pagesize) {
	$pagesize = $this->config->get('pagesize', 50);
	}
	$this->storage->set_pagesize($pagesize);

	// set class options
	$options = array(
	'auth_type' => $this->config->get("{$driver}_auth_type", 'check'),
	'auth_cid' => $this->config->get("{$driver}_auth_cid"),
	'auth_pw' => $this->config->get("{$driver}_auth_pw"),
	'debug' => (bool) $this->config->get("{$driver}_debug"),
	'force_caps' => (bool) $this->config->get("{$driver}_force_caps"),
	'timeout' => (int) $this->config->get("{$driver}_timeout"),
	'skip_deleted' => (bool) $this->config->get('skip_deleted'),
	'driver' => $driver,
	);

	if (!empty($_SESSION['storage_host'])) {
	$options['host'] = $_SESSION['storage_host'];
	$options['user'] = $_SESSION['username'];
	$options['port'] = $_SESSION['storage_port'];
	$options['ssl'] = $_SESSION['storage_ssl'];
	$options['password'] = $this->decrypt($_SESSION['password']);
	$_SESSION[$driver.'_host'] = $_SESSION['storage_host'];
	}

	$options = $this->plugins->exec_hook("storage_init", $options);

	// for backward compat. (deprecated, to be removed)
	$options = $this->plugins->exec_hook("imap_init", $options);

	$this->storage->set_options($options);
	$this->set_storage_prop();
	}


	/**
	* Set storage parameters.
	* This must be done AFTER connecting to the server!
	*/
	protected function set_storage_prop()
	{
	$storage = $this->get_storage();

	- $storage->set_charset($this->config->get('default_charset', RCMAIL_CHARSET));
	+ $storage->set_charset($this->config->get('default_charset', RCUBE_CHARSET));

	if ($default_folders = $this->config->get('default_folders')) {
	$storage->set_default_folders($default_folders);
	}
	if (isset($_SESSION['mbox'])) {
	$storage->set_folder($_SESSION['mbox']);
	}
	if (isset($_SESSION['page'])) {
	$storage->set_page($_SESSION['page']);
	}
	}


	/**
	* Create session object and start the session.
	*/
	public function session_init()
	{
	// session started (Installer?)
	if (session_id()) {
	return;
	}

	$sess_name = $this->config->get('session_name');
	$sess_domain = $this->config->get('session_domain');
	$sess_path = $this->config->get('session_path');
	$lifetime = $this->config->get('session_lifetime', 0) * 60;

	// set session domain
	if ($sess_domain) {
	ini_set('session.cookie_domain', $sess_domain);
	}
	// set session path
	if ($sess_path) {
	ini_set('session.cookie_path', $sess_path);
	}
	// set session garbage collecting time according to session_lifetime
	if ($lifetime) {
	ini_set('session.gc_maxlifetime', $lifetime * 2);
	}

	ini_set('session.cookie_secure', rcube_utils::https_check());
	ini_set('session.name', $sess_name ? $sess_name : 'roundcube_sessid');
	ini_set('session.use_cookies', 1);
	ini_set('session.use_only_cookies', 1);
	ini_set('session.serialize_handler', 'php');
	ini_set('session.cookie_httponly', 1);

	// use database for storing session data
	$this->session = new rcube_session($this->get_dbh(), $this->config);

	$this->session->register_gc_handler(array($this, 'temp_gc'));
	$this->session->register_gc_handler(array($this, 'cache_gc'));

	$this->session->set_secret($this->config->get('des_key') . dirname($_SERVER['SCRIPT_NAME']));
	$this->session->set_ip_check($this->config->get('ip_check'));

	// start PHP session (if not in CLI mode)
	if ($_SERVER['REMOTE_ADDR']) {
	session_start();
	}
	}


	/**
	* Garbage collector function for temp files.
	* Remove temp files older than two days
	*/
	public function temp_gc()
	{
	$tmp = unslashify($this->config->get('temp_dir'));
	$expire = time() - 172800; // expire in 48 hours

	if ($tmp && ($dir = opendir($tmp))) {
	while (($fname = readdir($dir)) !== false) {
	if ($fname{0} == '.') {
	continue;
	}

	if (filemtime($tmp.'/'.$fname) < $expire) {
	@unlink($tmp.'/'.$fname);
	}
	}

	closedir($dir);
	}
	}


	/**
	* Garbage collector for cache entries.
	* Set flag to expunge caches on shutdown
	*/
	public function cache_gc()
	{
	// because this gc function is called before storage is initialized,
	// we just set a flag to expunge storage cache on shutdown.
	$this->expunge_cache = true;
	}


	/**
	* Get localized text in the desired language
	*
	* @param mixed $attrib Named parameters array or label name
	* @param string $domain Label domain (plugin) name
	*
	* @return string Localized text
	*/
	public function gettext($attrib, $domain=null)
	{
	// load localization files if not done yet
	if (empty($this->texts)) {
	$this->load_language();
	}

	// extract attributes
	if (is_string($attrib)) {
	$attrib = array('name' => $attrib);
	}

	$name = $attrib['name'] ? $attrib['name'] : '';

	// attrib contain text values: use them from now
	if (($setval = $attrib[strtolower($_SESSION['language'])]) \|\| ($setval = $attrib['en_us'])) {
	$this->texts[$name] = $setval;
	}

	// check for text with domain
	if ($domain && ($text = $this->texts[$domain.'.'.$name])) {
	}
	// text does not exist
	else if (!($text = $this->texts[$name])) {
	return "[$name]";
	}

	// replace vars in text
	if (is_array($attrib['vars'])) {
	foreach ($attrib['vars'] as $var_key => $var_value) {
	$text = str_replace($var_key[0]!='$' ? '$'.$var_key : $var_key, $var_value, $text);
	}
	}

	// format output
	if (($attrib['uppercase'] && strtolower($attrib['uppercase'] == 'first')) \|\| $attrib['ucfirst']) {
	return ucfirst($text);
	}
	else if ($attrib['uppercase']) {
	return mb_strtoupper($text);
	}
	else if ($attrib['lowercase']) {
	return mb_strtolower($text);
	}

	return strtr($text, array('\n' => "\n"));
	}


	/**
	* Check if the given text label exists
	*
	* @param string $name Label name
	* @param string $domain Label domain (plugin) name or '*' for all domains
	* @param string $ref_domain Sets domain name if label is found
	*
	* @return boolean True if text exists (either in the current language or in en_US)
	*/
	public function text_exists($name, $domain = null, &$ref_domain = null)
	{
	// load localization files if not done yet
	if (empty($this->texts)) {
	$this->load_language();
	}

	if (isset($this->texts[$name])) {
	$ref_domain = '';
	return true;
	}

	// any of loaded domains (plugins)
	if ($domain == '*') {
	foreach ($this->plugins->loaded_plugins() as $domain) {
	if (isset($this->texts[$domain.'.'.$name])) {
	$ref_domain = $domain;
	return true;
	}
	}
	}
	// specified domain
	else if ($domain) {
	$ref_domain = $domain;
	return isset($this->texts[$domain.'.'.$name]);
	}

	return false;
	}


	/**
	* Load a localization package
	*
	* @param string Language ID
	* @param array Additional text labels/messages
	*/
	public function load_language($lang = null, $add = array())
	{
	$lang = $this->language_prop(($lang ? $lang : $_SESSION['language']));

	// load localized texts
	if (empty($this->texts) \|\| $lang != $_SESSION['language']) {
	$this->texts = array();

	// handle empty lines after closing PHP tag in localization files
	ob_start();

	// get english labels (these should be complete)
	@include(RCUBE_LOCALIZATION_DIR . 'en_US/labels.inc');
	@include(RCUBE_LOCALIZATION_DIR . 'en_US/messages.inc');

	if (is_array($labels))
	$this->texts = $labels;
	if (is_array($messages))
	$this->texts = array_merge($this->texts, $messages);

	// include user language files
	if ($lang != 'en' && $lang != 'en_US' && is_dir(RCUBE_LOCALIZATION_DIR . $lang)) {
	include_once(RCUBE_LOCALIZATION_DIR . $lang . '/labels.inc');
	include_once(RCUBE_LOCALIZATION_DIR . $lang . '/messages.inc');

	if (is_array($labels))
	$this->texts = array_merge($this->texts, $labels);
	if (is_array($messages))
	$this->texts = array_merge($this->texts, $messages);
	}

	ob_end_clean();

	$_SESSION['language'] = $lang;
	}

	// append additional texts (from plugin)
	if (is_array($add) && !empty($add)) {
	$this->texts += $add;
	}
	}


	/**
	* Check the given string and return a valid language code
	*
	* @param string Language code
	*
	* @return string Valid language code
	*/
	protected function language_prop($lang)
	{
	static $rcube_languages, $rcube_language_aliases;

	// user HTTP_ACCEPT_LANGUAGE if no language is specified
	if (empty($lang) \|\| $lang == 'auto') {
	$accept_langs = explode(',', $_SERVER['HTTP_ACCEPT_LANGUAGE']);
	$lang = str_replace('-', '_', $accept_langs[0]);
	}

	if (empty($rcube_languages)) {
	@include(RCUBE_LOCALIZATION_DIR . 'index.inc');
	}

	// check if we have an alias for that language
	if (!isset($rcube_languages[$lang]) && isset($rcube_language_aliases[$lang])) {
	$lang = $rcube_language_aliases[$lang];
	}
	// try the first two chars
	else if (!isset($rcube_languages[$lang])) {
	$short = substr($lang, 0, 2);

	// check if we have an alias for the short language code
	if (!isset($rcube_languages[$short]) && isset($rcube_language_aliases[$short])) {
	$lang = $rcube_language_aliases[$short];
	}
	// expand 'nn' to 'nn_NN'
	else if (!isset($rcube_languages[$short])) {
	$lang = $short.'_'.strtoupper($short);
	}
	}

	if (!isset($rcube_languages[$lang]) \|\| !is_dir(RCUBE_LOCALIZATION_DIR . $lang)) {
	$lang = 'en_US';
	}

	return $lang;
	}


	/**
	* Read directory program/localization and return a list of available languages
	*
	* @return array List of available localizations
	*/
	public function list_languages()
	{
	static $sa_languages = array();

	if (!sizeof($sa_languages)) {
	@include(RCUBE_LOCALIZATION_DIR . 'index.inc');

	if ($dh = @opendir(RCUBE_LOCALIZATION_DIR)) {
	while (($name = readdir($dh)) !== false) {
	if ($name[0] == '.' \|\| !is_dir(RCUBE_LOCALIZATION_DIR . $name)) {
	continue;
	}

	if ($label = $rcube_languages[$name]) {
	$sa_languages[$name] = $label;
	}
	}
	closedir($dh);
	}
	}

	return $sa_languages;
	}


	/**
	* Encrypt using 3DES
	*
	* @param string $clear clear text input
	* @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
	* @param boolean $base64 whether or not to base64_encode() the result before returning
	*
	* @return string encrypted text
	*/
	public function encrypt($clear, $key = 'des_key', $base64 = true)
	{
	if (!$clear) {
	return '';
	}

	/*-
	* Add a single canary byte to the end of the clear text, which
	* will help find out how much of padding will need to be removed
	* upon decryption; see http://php.net/mcrypt_generic#68082
	*/
	$clear = pack("a*H2", $clear, "80");

	if (function_exists('mcrypt_module_open') &&
	($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, ""))
	) {
	$iv = $this->create_iv(mcrypt_enc_get_iv_size($td));
	mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
	$cipher = $iv . mcrypt_generic($td, $clear);
	mcrypt_generic_deinit($td);
	mcrypt_module_close($td);
	}
	else {
	@include_once 'des.inc';

	if (function_exists('des')) {
	$des_iv_size = 8;
	$iv = $this->create_iv($des_iv_size);
	$cipher = $iv . des($this->config->get_crypto_key($key), $clear, 1, 1, $iv);
	}
	else {
	self::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Could not perform encryption; make sure Mcrypt is installed or lib/des.inc is available"
	), true, true);
	}
	}

	return $base64 ? base64_encode($cipher) : $cipher;
	}


	/**
	* Decrypt 3DES-encrypted string
	*
	* @param string $cipher encrypted text
	* @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
	* @param boolean $base64 whether or not input is base64-encoded
	*
	* @return string decrypted text
	*/
	public function decrypt($cipher, $key = 'des_key', $base64 = true)
	{
	if (!$cipher) {
	return '';
	}

	$cipher = $base64 ? base64_decode($cipher) : $cipher;

	if (function_exists('mcrypt_module_open') &&
	($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, ""))
	) {
	$iv_size = mcrypt_enc_get_iv_size($td);
	$iv = substr($cipher, 0, $iv_size);

	// session corruption? (#1485970)
	if (strlen($iv) < $iv_size) {
	return '';
	}

	$cipher = substr($cipher, $iv_size);
	mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
	$clear = mdecrypt_generic($td, $cipher);
	mcrypt_generic_deinit($td);
	mcrypt_module_close($td);
	}
	else {
	@include_once 'des.inc';

	if (function_exists('des')) {
	$des_iv_size = 8;
	$iv = substr($cipher, 0, $des_iv_size);
	$cipher = substr($cipher, $des_iv_size);
	$clear = des($this->config->get_crypto_key($key), $cipher, 0, 1, $iv);
	}
	else {
	self::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Could not perform decryption; make sure Mcrypt is installed or lib/des.inc is available"
	), true, true);
	}
	}

	/*-
	* Trim PHP's padding and the canary byte; see note in
	* rcube::encrypt() and http://php.net/mcrypt_generic#68082
	*/
	$clear = substr(rtrim($clear, "\0"), 0, -1);

	return $clear;
	}


	/**
	* Generates encryption initialization vector (IV)
	*
	* @param int Vector size
	*
	* @return string Vector string
	*/
	private function create_iv($size)
	{
	// mcrypt_create_iv() can be slow when system lacks entrophy
	// we'll generate IV vector manually
	$iv = '';
	for ($i = 0; $i < $size; $i++) {
	$iv .= chr(mt_rand(0, 255));
	}

	return $iv;
	}


	/**
	* Build a valid URL to this instance of Roundcube
	*
	* @param mixed Either a string with the action or url parameters as key-value pairs
	* @return string Valid application URL
	*/
	public function url($p)
	{
	// STUB: should be overloaded by the application
	return '';
	}


	/**
	* Function to be executed in script shutdown
	* Registered with register_shutdown_function()
	*/
	public function shutdown()
	{
	foreach ($this->shutdown_functions as $function) {
	call_user_func($function);
	}

	if (is_object($this->smtp)) {
	$this->smtp->disconnect();
	}

	foreach ($this->caches as $cache) {
	if (is_object($cache)) {
	$cache->close();
	}
	}

	if (is_object($this->storage)) {
	if ($this->expunge_cache) {
	$this->storage->expunge_cache();
	}
	$this->storage->close();
	}
	}


	/**
	* Registers shutdown function to be executed on shutdown.
	* The functions will be executed before destroying any
	* objects like smtp, imap, session, etc.
	*
	* @param callback Function callback
	*/
	public function add_shutdown_function($function)
	{
	$this->shutdown_functions[] = $function;
	}


	/**
	* Construct shell command, execute it and return output as string.
	* Keywords {keyword} are replaced with arguments
	*
	* @param $cmd Format string with {keywords} to be replaced
	* @param $values (zero, one or more arrays can be passed)
	*
	* @return output of command. shell errors not detectable
	*/
	public static function exec(/* $cmd, $values1 = array(), ... */)
	{
	$args = func_get_args();
	$cmd = array_shift($args);
	$values = $replacements = array();

	// merge values into one array
	foreach ($args as $arg) {
	$values += (array)$arg;
	}

	preg_match_all('/({(-?)([a-z]\w*)})/', $cmd, $matches, PREG_SET_ORDER);
	foreach ($matches as $tags) {
	list(, $tag, $option, $key) = $tags;
	$parts = array();

	if ($option) {
	foreach ((array)$values["-$key"] as $key => $value) {
	if ($value === true \|\| $value === false \|\| $value === null) {
	$parts[] = $value ? $key : "";
	}
	else {
	foreach ((array)$value as $val) {
	$parts[] = "$key " . escapeshellarg($val);
	}
	}
	}
	}
	else {
	foreach ((array)$values[$key] as $value) {
	$parts[] = escapeshellarg($value);
	}
	}

	$replacements[$tag] = join(" ", $parts);
	}

	// use strtr behaviour of going through source string once
	$cmd = strtr($cmd, $replacements);

	return (string)shell_exec($cmd);
	}


	/**
	* Print or write debug messages
	*
	* @param mixed Debug message or data
	*/
	public static function console()
	{
	$args = func_get_args();

	if (class_exists('rcube', false)) {
	$rcube = self::get_instance();
	$plugin = $rcube->plugins->exec_hook('console', array('args' => $args));
	if ($plugin['abort']) {
	return;
	}
	$args = $plugin['args'];
	}

	$msg = array();
	foreach ($args as $arg) {
	$msg[] = !is_string($arg) ? var_export($arg, true) : $arg;
	}

	self::write_log('console', join(";\n", $msg));
	}


	/**
	* Append a line to a logfile in the logs directory.
	* Date will be added automatically to the line.
	*
	* @param $name name of log file
	* @param line Line to append
	*/
	public static function write_log($name, $line)
	{
	if (!is_string($line)) {
	$line = var_export($line, true);
	}

	$date_format = self::$instance ? self::$instance->config->get('log_date_format') : null;
	$log_driver = self::$instance ? self::$instance->config->get('log_driver') : null;

	if (empty($date_format)) {
	$date_format = 'd-M-Y H:i:s O';
	}

	$date = date($date_format);

	// trigger logging hook
	if (is_object(self::$instance) && is_object(self::$instance->plugins)) {
	$log = self::$instance->plugins->exec_hook('write_log', array('name' => $name, 'date' => $date, 'line' => $line));
	$name = $log['name'];
	$line = $log['line'];
	$date = $log['date'];
	if ($log['abort'])
	return true;
	}

	if ($log_driver == 'syslog') {
	$prio = $name == 'errors' ? LOG_ERR : LOG_INFO;
	syslog($prio, $line);
	return true;
	}

	// log_driver == 'file' is assumed here

	$line = sprintf("[%s]: %s\n", $date, $line);
	$log_dir = self::$instance ? self::$instance->config->get('log_dir') : null;

	if (empty($log_dir)) {
	$log_dir = RCUBE_INSTALL_PATH . 'logs';
	}

	// try to open specific log file for writing
	$logfile = $log_dir.'/'.$name;

	if ($fp = @fopen($logfile, 'a')) {
	fwrite($fp, $line);
	fflush($fp);
	fclose($fp);
	return true;
	}

	trigger_error("Error writing to log file $logfile; Please check permissions", E_USER_WARNING);
	return false;
	}


	/**
	* Throw system error (and show error page).
	*
	* @param array Named parameters
	* - code: Error code (required)
	* - type: Error type [php\|db\|imap\|javascript] (required)
	* - message: Error message
	* - file: File where error occured
	* - line: Line where error occured
	* @param boolean True to log the error
	* @param boolean Terminate script execution
	*/
	public static function raise_error($arg = array(), $log = false, $terminate = false)
	{
	// handle PHP exceptions
	if (is_object($arg) && is_a($arg, 'Exception')) {
	$err = array(
	'type' => 'php',
	'code' => $arg->getCode(),
	'line' => $arg->getLine(),
	'file' => $arg->getFile(),
	'message' => $arg->getMessage(),
	);
	$arg = $err;
	}

	// installer
	if (class_exists('rcube_install', false)) {
	$rci = rcube_install::get_instance();
	$rci->raise_error($arg);
	return;
	}

	if (($log \|\| $terminate) && $arg['type'] && $arg['message']) {
	$arg['fatal'] = $terminate;
	self::log_bug($arg);
	}

	// display error page and terminate script
	if ($terminate && is_object(self::$instance->output)) {
	self::$instance->output->raise_error($arg['code'], $arg['message']);
	}
	}


	/**
	* Report error according to configured debug_level
	*
	* @param array Named parameters
	* @see self::raise_error()
	*/
	public static function log_bug($arg_arr)
	{
	$program = strtoupper($arg_arr['type']);
	$level = self::get_instance()->config->get('debug_level');

	// disable errors for ajax requests, write to log instead (#1487831)
	if (($level & 4) && !empty($_REQUEST['_remote'])) {
	$level = ($level ^ 4) \| 1;
	}

	// write error to local log file
	if (($level & 1) \|\| !empty($arg_arr['fatal'])) {
	if ($_SERVER['REQUEST_METHOD'] == 'POST') {
	$post_query = '?_task='.urlencode($_POST['_task']).'&_action='.urlencode($_POST['_action']);
	}
	else {
	$post_query = '';
	}

	$log_entry = sprintf("%s Error: %s%s (%s %s)",
	$program,
	$arg_arr['message'],
	$arg_arr['file'] ? sprintf(' in %s on line %d', $arg_arr['file'], $arg_arr['line']) : '',
	$_SERVER['REQUEST_METHOD'],
	$_SERVER['REQUEST_URI'] . $post_query);

	if (!self::write_log('errors', $log_entry)) {
	// send error to PHPs error handler if write_log didn't succeed
	trigger_error($arg_arr['message']);
	}
	}

	// report the bug to the global bug reporting system
	if ($level & 2) {
	// TODO: Send error via HTTP
	}

	// show error if debug_mode is on
	if ($level & 4) {
	print "<b>$program Error";

	if (!empty($arg_arr['file']) && !empty($arg_arr['line'])) {
	print " in $arg_arr[file] ($arg_arr[line])";
	}

	print ':</b> ';
	print nl2br($arg_arr['message']);
	print '<br />';
	flush();
	}
	}


	/**
	* Returns current time (with microseconds).
	*
	* @return float Current time in seconds since the Unix
	*/
	public static function timer()
	{
	return microtime(true);
	}


	/**
	* Logs time difference according to provided timer
	*
	* @param float $timer Timer (self::timer() result)
	* @param string $label Log line prefix
	* @param string $dest Log file name
	*
	* @see self::timer()
	*/
	public static function print_timer($timer, $label = 'Timer', $dest = 'console')
	{
	static $print_count = 0;

	$print_count++;
	$now = self::timer();
	$diff = $now - $timer;

	if (empty($label)) {
	$label = 'Timer '.$print_count;
	}

	self::write_log($dest, sprintf("%s: %0.4f sec", $label, $diff));
	}


	/**
	* Getter for logged user ID.
	*
	* @return mixed User identifier
	*/
	public function get_user_id()
	{
	if (is_object($this->user)) {
	return $this->user->ID;
	}
	else if (isset($_SESSION['user_id'])) {
	return $_SESSION['user_id'];
	}

	return null;
	}


	/**
	* Getter for logged user name.
	*
	* @return string User name
	*/
	public function get_user_name()
	{
	if (is_object($this->user)) {
	return $this->user->get_username();
	}
	else if (isset($_SESSION['username'])) {
	return $_SESSION['username'];
	}
	}


	/**
	* Getter for logged user email (derived from user name not identity).
	*
	* @return string User email address
	*/
	public function get_user_email()
	{
	if (is_object($this->user)) {
	return $this->user->get_username('mail');
	}
	}


	/**
	* Getter for logged user password.
	*
	* @return string User password
	*/
	public function get_user_password()
	{
	if ($this->password) {
	return $this->password;
	}
	else if ($_SESSION['password']) {
	return $this->decrypt($_SESSION['password']);
	}
	}
	}


	/**
	* Lightweight plugin API class serving as a dummy if plugins are not enabled
	*
	* @package Core
	*/
	class rcube_dummy_plugin_api
	{
	/**
	* Triggers a plugin hook.
	* @see rcube_plugin_api::exec_hook()
	*/
	public function exec_hook($hook, $args = array())
	{
	return $args;
	}
	}
	diff --git a/program/lib/Roundcube/rcube_charset.php b/program/lib/Roundcube/rcube_charset.php
	index e8cce00e3..6135a5711 100644
	--- a/program/lib/Roundcube/rcube_charset.php
	+++ b/program/lib/Roundcube/rcube_charset.php
	@@ -1,791 +1,791 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_charset.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| Copyright (C) 2011-2012, Kolab Systems AG \|
	\| Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org> \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Provide charset conversion functionality \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Character sets conversion functionality
	*
	* @package Framework
	* @subpackage Core
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @author Aleksander Machniak <alec@alec.pl>
	* @author Edmund Grimley Evans <edmundo@rano.org>
	*/
	class rcube_charset
	{
	// Aliases: some of them from HTML5 spec.
	static public $aliases = array(
	'USASCII' => 'WINDOWS-1252',
	'ANSIX31101983' => 'WINDOWS-1252',
	'ANSIX341968' => 'WINDOWS-1252',
	'UNKNOWN8BIT' => 'ISO-8859-15',
	'UNKNOWN' => 'ISO-8859-15',
	'USERDEFINED' => 'ISO-8859-15',
	'KSC56011987' => 'EUC-KR',
	'GB2312' => 'GBK',
	'GB231280' => 'GBK',
	'UNICODE' => 'UTF-8',
	'UTF7IMAP' => 'UTF7-IMAP',
	'TIS620' => 'WINDOWS-874',
	'ISO88599' => 'WINDOWS-1254',
	'ISO885911' => 'WINDOWS-874',
	'MACROMAN' => 'MACINTOSH',
	'77' => 'MAC',
	'128' => 'SHIFT-JIS',
	'129' => 'CP949',
	'130' => 'CP1361',
	'134' => 'GBK',
	'136' => 'BIG5',
	'161' => 'WINDOWS-1253',
	'162' => 'WINDOWS-1254',
	'163' => 'WINDOWS-1258',
	'177' => 'WINDOWS-1255',
	'178' => 'WINDOWS-1256',
	'186' => 'WINDOWS-1257',
	'204' => 'WINDOWS-1251',
	'222' => 'WINDOWS-874',
	'238' => 'WINDOWS-1250',
	'MS950' => 'CP950',
	'WINDOWS949' => 'UHC',
	);


	/**
	* Catch an error and throw an exception.
	*
	* @param int Level of the error
	* @param string Error message
	*/
	public static function error_handler($errno, $errstr)
	{
	throw new ErrorException($errstr, 0, $errno);
	}


	/**
	* Parse and validate charset name string (see #1485758).
	* Sometimes charset string is malformed, there are also charset aliases
	* but we need strict names for charset conversion (specially utf8 class)
	*
	* @param string $input Input charset name
	*
	* @return string The validated charset name
	*/
	public static function parse_charset($input)
	{
	static $charsets = array();
	$charset = strtoupper($input);

	if (isset($charsets[$input])) {
	return $charsets[$input];
	}

	$charset = preg_replace(array(
	'/^[^0-9A-Z]+/', // e.g. _ISO-8859-JP$SIO
	'/\$.*$/', // e.g. _ISO-8859-JP$SIO
	'/UNICODE-1-1-*/', // RFC1641/1642
	'/^X-/', // X- prefix (e.g. X-ROMAN8 => ROMAN8)
	), '', $charset);

	if ($charset == 'BINARY') {
	return $charsets[$input] = null;
	}

	// allow A-Z and 0-9 only
	$str = preg_replace('/[^A-Z0-9]/', '', $charset);

	if (isset(self::$aliases[$str])) {
	$result = self::$aliases[$str];
	}
	// UTF
	else if (preg_match('/U[A-Z][A-Z](7\|8\|16\|32)(BE\|LE)*/', $str, $m)) {
	$result = 'UTF-' . $m[1] . $m[2];
	}
	// ISO-8859
	else if (preg_match('/ISO8859([0-9]{0,2})/', $str, $m)) {
	$iso = 'ISO-8859-' . ($m[1] ? $m[1] : 1);
	// some clients sends windows-1252 text as latin1,
	// it is safe to use windows-1252 for all latin1
	$result = $iso == 'ISO-8859-1' ? 'WINDOWS-1252' : $iso;
	}
	// handle broken charset names e.g. WINDOWS-1250HTTP-EQUIVCONTENT-TYPE
	else if (preg_match('/(WIN\|WINDOWS)([0-9]+)/', $str, $m)) {
	$result = 'WINDOWS-' . $m[2];
	}
	// LATIN
	else if (preg_match('/LATIN(.*)/', $str, $m)) {
	$aliases = array('2' => 2, '3' => 3, '4' => 4, '5' => 9, '6' => 10,
	'7' => 13, '8' => 14, '9' => 15, '10' => 16,
	'ARABIC' => 6, 'CYRILLIC' => 5, 'GREEK' => 7, 'GREEK1' => 7, 'HEBREW' => 8
	);

	// some clients sends windows-1252 text as latin1,
	// it is safe to use windows-1252 for all latin1
	if ($m[1] == 1) {
	$result = 'WINDOWS-1252';
	}
	// if iconv is not supported we need ISO labels, it's also safe for iconv
	else if (!empty($aliases[$m[1]])) {
	$result = 'ISO-8859-'.$aliases[$m[1]];
	}
	// iconv requires convertion of e.g. LATIN-1 to LATIN1
	else {
	$result = $str;
	}
	}
	else {
	$result = $charset;
	}

	$charsets[$input] = $result;

	return $result;
	}


	/**
	* Convert a string from one charset to another.
	* Uses mbstring and iconv functions if possible
	*
	* @param string Input string
	* @param string Suspected charset of the input string
	- * @param string Target charset to convert to; defaults to RCMAIL_CHARSET
	+ * @param string Target charset to convert to; defaults to RCUBE_CHARSET
	*
	* @return string Converted string
	*/
	public static function convert($str, $from, $to = null)
	{
	static $iconv_options = null;
	static $mbstring_list = null;
	static $mbstring_sch = null;
	static $conv = null;

	- $to = empty($to) ? RCMAIL_CHARSET : $to;
	+ $to = empty($to) ? RCUBE_CHARSET : $to;
	$from = self::parse_charset($from);

	// It is a common case when UTF-16 charset is used with US-ASCII content (#1488654)
	// In that case we can just skip the conversion (use UTF-8)
	if ($from == 'UTF-16' && !preg_match('/[^\x00-\x7F]/', $str)) {
	$from = 'UTF-8';
	}

	if ($from == $to \|\| empty($str) \|\| empty($from)) {
	return $str;
	}

	if ($iconv_options === null) {
	if (function_exists('iconv')) {
	// ignore characters not available in output charset
	$iconv_options = '//IGNORE';
	if (iconv('', $iconv_options, '') === false) {
	// iconv implementation does not support options
	$iconv_options = '';
	}
	}
	}

	// convert charset using iconv module
	if ($iconv_options !== null && $from != 'UTF7-IMAP' && $to != 'UTF7-IMAP') {
	// throw an exception if iconv reports an illegal character in input
	// it means that input string has been truncated
	set_error_handler(array('rcube_charset', 'error_handler'), E_NOTICE);
	try {
	$_iconv = iconv($from, $to . $iconv_options, $str);
	} catch (ErrorException $e) {
	$_iconv = false;
	}
	restore_error_handler();

	if ($_iconv !== false) {
	return $_iconv;
	}
	}

	if ($mbstring_list === null) {
	if (extension_loaded('mbstring')) {
	$mbstring_sch = mb_substitute_character();
	$mbstring_list = mb_list_encodings();
	$mbstring_list = array_map('strtoupper', $mbstring_list);
	}
	}

	// convert charset using mbstring module
	if ($mbstring_list !== null) {
	$aliases['WINDOWS-1257'] = 'ISO-8859-13';
	// it happens that mbstring supports ASCII but not US-ASCII
	if (($from == 'US-ASCII' \|\| $to == 'US-ASCII') && !in_array('US-ASCII', $mbstring_list)) {
	$aliases['US-ASCII'] = 'ASCII';
	}

	$mb_from = $aliases[$from] ? $aliases[$from] : $from;
	$mb_to = $aliases[$to] ? $aliases[$to] : $to;

	// return if encoding found, string matches encoding and convert succeeded
	if (in_array($mb_from, $mbstring_list) && in_array($mb_to, $mbstring_list)) {
	if (mb_check_encoding($str, $mb_from)) {
	// Do the same as //IGNORE with iconv
	mb_substitute_character('none');
	$out = mb_convert_encoding($str, $mb_to, $mb_from);
	mb_substitute_character($mbstring_sch);

	if ($out !== false) {
	return $out;
	}
	}
	}
	}

	// convert charset using bundled classes/functions
	if ($to == 'UTF-8') {
	if ($from == 'UTF7-IMAP') {
	if ($_str = self::utf7imap_to_utf8($str)) {
	return $_str;
	}
	}
	else if ($from == 'UTF-7') {
	if ($_str = self::utf7_to_utf8($str)) {
	return $_str;
	}
	}
	else if ($from == 'ISO-8859-1' && function_exists('utf8_encode')) {
	return utf8_encode($str);
	}
	else if (class_exists('utf8')) {
	if (!$conv) {
	$conv = new utf8($from);
	}
	else {
	$conv->loadCharset($from);
	}

	if ($_str = $conv->strToUtf8($str)) {
	return $_str;
	}
	}
	}

	// encode string for output
	if ($from == 'UTF-8') {
	// @TODO: we need a function for UTF-7 (RFC2152) conversion
	if ($to == 'UTF7-IMAP' \|\| $to == 'UTF-7') {
	if ($_str = self::utf8_to_utf7imap($str)) {
	return $_str;
	}
	}
	else if ($to == 'ISO-8859-1' && function_exists('utf8_decode')) {
	return utf8_decode($str);
	}
	else if (class_exists('utf8')) {
	if (!$conv) {
	$conv = new utf8($to);
	}
	else {
	$conv->loadCharset($from);
	}

	if ($_str = $conv->strToUtf8($str)) {
	return $_str;
	}
	}
	}

	// return original string
	return $str;
	}


	/**
	* Converts string from standard UTF-7 (RFC 2152) to UTF-8.
	*
	* @param string Input string (UTF-7)
	*
	* @return string Converted string (UTF-8)
	*/
	public static function utf7_to_utf8($str)
	{
	$Index_64 = array(
	0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
	0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
	0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0,
	1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0,
	0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
	1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
	0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
	1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
	);

	$u7len = strlen($str);
	$str = strval($str);
	$res = '';

	for ($i=0; $u7len > 0; $i++, $u7len--) {
	$u7 = $str[$i];
	if ($u7 == '+') {
	$i++;
	$u7len--;
	$ch = '';

	for (; $u7len > 0; $i++, $u7len--) {
	$u7 = $str[$i];

	if (!$Index_64[ord($u7)]) {
	break;
	}

	$ch .= $u7;
	}

	if ($ch == '') {
	if ($u7 == '-') {
	$res .= '+';
	}

	continue;
	}

	$res .= self::utf16_to_utf8(base64_decode($ch));
	}
	else {
	$res .= $u7;
	}
	}

	return $res;
	}


	/**
	* Converts string from UTF-16 to UTF-8 (helper for utf-7 to utf-8 conversion)
	*
	* @param string Input string
	*
	* @return string The converted string
	*/
	public static function utf16_to_utf8($str)
	{
	$len = strlen($str);
	$dec = '';

	for ($i = 0; $i < $len; $i += 2) {
	$c = ord($str[$i]) << 8 \| ord($str[$i + 1]);
	if ($c >= 0x0001 && $c <= 0x007F) {
	$dec .= chr($c);
	}
	else if ($c > 0x07FF) {
	$dec .= chr(0xE0 \| (($c >> 12) & 0x0F));
	$dec .= chr(0x80 \| (($c >> 6) & 0x3F));
	$dec .= chr(0x80 \| (($c >> 0) & 0x3F));
	}
	else {
	$dec .= chr(0xC0 \| (($c >> 6) & 0x1F));
	$dec .= chr(0x80 \| (($c >> 0) & 0x3F));
	}
	}

	return $dec;
	}


	/**
	* Convert the data ($str) from RFC 2060's UTF-7 to UTF-8.
	* If input data is invalid, return the original input string.
	* RFC 2060 obviously intends the encoding to be unique (see
	* point 5 in section 5.1.3), so we reject any non-canonical
	* form, such as &ACY- (instead of &-) or &AMA-&AMA- (instead
	* of &AMAAwA-).
	*
	* Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com>
	*
	* @param string $str Input string (UTF7-IMAP)
	*
	* @return string Output string (UTF-8)
	*/
	public static function utf7imap_to_utf8($str)
	{
	$Index_64 = array(
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, 63,-1,-1,-1,
	52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
	15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
	-1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
	41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
	);

	$u7len = strlen($str);
	$str = strval($str);
	$p = '';
	$err = '';

	for ($i=0; $u7len > 0; $i++, $u7len--) {
	$u7 = $str[$i];
	if ($u7 == '&') {
	$i++;
	$u7len--;
	$u7 = $str[$i];

	if ($u7len && $u7 == '-') {
	$p .= '&';
	continue;
	}

	$ch = 0;
	$k = 10;
	for (; $u7len > 0; $i++, $u7len--) {
	$u7 = $str[$i];

	if ((ord($u7) & 0x80) \|\| ($b = $Index_64[ord($u7)]) == -1) {
	break;
	}

	if ($k > 0) {
	$ch \|= $b << $k;
	$k -= 6;
	}
	else {
	$ch \|= $b >> (-$k);
	if ($ch < 0x80) {
	// Printable US-ASCII
	if (0x20 <= $ch && $ch < 0x7f) {
	return $err;
	}
	$p .= chr($ch);
	}
	else if ($ch < 0x800) {
	$p .= chr(0xc0 \| ($ch >> 6));
	$p .= chr(0x80 \| ($ch & 0x3f));
	}
	else {
	$p .= chr(0xe0 \| ($ch >> 12));
	$p .= chr(0x80 \| (($ch >> 6) & 0x3f));
	$p .= chr(0x80 \| ($ch & 0x3f));
	}

	$ch = ($b << (16 + $k)) & 0xffff;
	$k += 10;
	}
	}

	// Non-zero or too many extra bits
	if ($ch \|\| $k < 6) {
	return $err;
	}

	// BASE64 not properly terminated
	if (!$u7len \|\| $u7 != '-') {
	return $err;
	}

	// Adjacent BASE64 sections
	if ($u7len > 2 && $str[$i+1] == '&' && $str[$i+2] != '-') {
	return $err;
	}
	}
	// Not printable US-ASCII
	else if (ord($u7) < 0x20 \|\| ord($u7) >= 0x7f) {
	return $err;
	}
	else {
	$p .= $u7;
	}
	}

	return $p;
	}


	/**
	* Convert the data ($str) from UTF-8 to RFC 2060's UTF-7.
	* Unicode characters above U+FFFF are replaced by U+FFFE.
	* If input data is invalid, return an empty string.
	*
	* Translated from C to PHP by Thomas Bruederli <roundcube@gmail.com>
	*
	* @param string $str Input string (UTF-8)
	*
	* @return string Output string (UTF7-IMAP)
	*/
	public static function utf8_to_utf7imap($str)
	{
	$B64Chars = array(
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
	'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
	'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
	't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
	'8', '9', '+', ','
	);

	$u8len = strlen($str);
	$base64 = 0;
	$i = 0;
	$p = '';
	$err = '';

	while ($u8len) {
	$u8 = $str[$i];
	$c = ord($u8);

	if ($c < 0x80) {
	$ch = $c;
	$n = 0;
	}
	else if ($c < 0xc2) {
	return $err;
	}
	else if ($c < 0xe0) {
	$ch = $c & 0x1f;
	$n = 1;
	}
	else if ($c < 0xf0) {
	$ch = $c & 0x0f;
	$n = 2;
	}
	else if ($c < 0xf8) {
	$ch = $c & 0x07;
	$n = 3;
	}
	else if ($c < 0xfc) {
	$ch = $c & 0x03;
	$n = 4;
	}
	else if ($c < 0xfe) {
	$ch = $c & 0x01;
	$n = 5;
	}
	else {
	return $err;
	}

	$i++;
	$u8len--;

	if ($n > $u8len) {
	return $err;
	}

	for ($j=0; $j < $n; $j++) {
	$o = ord($str[$i+$j]);
	if (($o & 0xc0) != 0x80) {
	return $err;
	}
	$ch = ($ch << 6) \| ($o & 0x3f);
	}

	if ($n > 1 && !($ch >> ($n * 5 + 1))) {
	return $err;
	}

	$i += $n;
	$u8len -= $n;

	if ($ch < 0x20 \|\| $ch >= 0x7f) {
	if (!$base64) {
	$p .= '&';
	$base64 = 1;
	$b = 0;
	$k = 10;
	}
	if ($ch & ~0xffff) {
	$ch = 0xfffe;
	}

	$p .= $B64Chars[($b \| $ch >> $k)];
	$k -= 6;
	for (; $k >= 0; $k -= 6) {
	$p .= $B64Chars[(($ch >> $k) & 0x3f)];
	}

	$b = ($ch << (-$k)) & 0x3f;
	$k += 16;
	}
	else {
	if ($base64) {
	if ($k > 10) {
	$p .= $B64Chars[$b];
	}
	$p .= '-';
	$base64 = 0;
	}

	$p .= chr($ch);
	if (chr($ch) == '&') {
	$p .= '-';
	}
	}
	}

	if ($base64) {
	if ($k > 10) {
	$p .= $B64Chars[$b];
	}
	$p .= '-';
	}

	return $p;
	}


	/**
	* A method to guess character set of a string.
	*
	* @param string $string String.
	* @param string $failover Default result for failover.
	*
	* @return string Charset name
	*/
	public static function detect($string, $failover='')
	{
	if (substr($string, 0, 4) == "\0\0\xFE\xFF") return 'UTF-32BE'; // Big Endian
	if (substr($string, 0, 4) == "\xFF\xFE\0\0") return 'UTF-32LE'; // Little Endian
	if (substr($string, 0, 2) == "\xFE\xFF") return 'UTF-16BE'; // Big Endian
	if (substr($string, 0, 2) == "\xFF\xFE") return 'UTF-16LE'; // Little Endian
	if (substr($string, 0, 3) == "\xEF\xBB\xBF") return 'UTF-8';

	// heuristics
	if ($string[0] == "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-32BE';
	if ($string[0] != "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] == "\0") return 'UTF-32LE';
	if ($string[0] == "\0" && $string[1] != "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-16BE';
	if ($string[0] != "\0" && $string[1] == "\0" && $string[2] != "\0" && $string[3] == "\0") return 'UTF-16LE';

	if (function_exists('mb_detect_encoding')) {
	// FIXME: the order is important, because sometimes
	// iso string is detected as euc-jp and etc.
	$enc = array(
	'UTF-8', 'SJIS', 'GB2312',
	'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
	'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9',
	'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16',
	'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R', 'BIG5',
	'ISO-2022-KR', 'ISO-2022-JP',
	);

	$result = mb_detect_encoding($string, join(',', $enc));
	}
	else {
	// No match, check for UTF-8
	// from http://w3.org/International/questions/qa-forms-utf-8.html
	if (preg_match('/\A(
	[\x09\x0A\x0D\x20-\x7E]
	\| [\xC2-\xDF][\x80-\xBF]
	\| \xE0[\xA0-\xBF][\x80-\xBF]
	\| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}
	\| \xED[\x80-\x9F][\x80-\xBF]
	\| \xF0[\x90-\xBF][\x80-\xBF]{2}
	\| [\xF1-\xF3][\x80-\xBF]{3}
	\| \xF4[\x80-\x8F][\x80-\xBF]{2}
	)*\z/xs', substr($string, 0, 2048))
	) {
	return 'UTF-8';
	}
	}

	return $result ? $result : $failover;
	}


	/**
	* Removes non-unicode characters from input.
	*
	* @param mixed $input String or array.
	*
	* @return mixed String or array
	*/
	public static function clean($input)
	{
	// handle input of type array
	if (is_array($input)) {
	foreach ($input as $idx => $val) {
	$input[$idx] = self::clean($val);
	}
	return $input;
	}

	if (!is_string($input) \|\| $input == '') {
	return $input;
	}

	// iconv/mbstring are much faster (especially with long strings)
	if (function_exists('mb_convert_encoding')) {
	if (($res = mb_convert_encoding($input, 'UTF-8', 'UTF-8')) !== false) {
	return $res;
	}
	}

	if (function_exists('iconv')) {
	if (($res = @iconv('UTF-8', 'UTF-8//IGNORE', $input)) !== false) {
	return $res;
	}
	}

	$seq = '';
	$out = '';
	$regexp = '/^('.
	// '[\x00-\x7F]'. // UTF8-1
	'\|[\xC2-\xDF][\x80-\xBF]'. // UTF8-2
	'\|\xE0[\xA0-\xBF][\x80-\xBF]'. // UTF8-3
	'\|[\xE1-\xEC][\x80-\xBF][\x80-\xBF]'. // UTF8-3
	'\|\xED[\x80-\x9F][\x80-\xBF]'. // UTF8-3
	'\|[\xEE-\xEF][\x80-\xBF][\x80-\xBF]'. // UTF8-3
	'\|\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF]'. // UTF8-4
	'\|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]'.// UTF8-4
	'\|\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF]'. // UTF8-4
	')$/';

	for ($i = 0, $len = strlen($input); $i < $len; $i++) {
	$chr = $input[$i];
	$ord = ord($chr);

	// 1-byte character
	if ($ord <= 0x7F) {
	if ($seq) {
	$out .= preg_match($regexp, $seq) ? $seq : '';
	}
	$seq = '';
	$out .= $chr;
	// first (or second) byte of multibyte sequence
	}
	else if ($ord >= 0xC0) {
	if (strlen($seq) > 1) {
	$out .= preg_match($regexp, $seq) ? $seq : '';
	$seq = '';
	}
	else if ($seq && ord($seq) < 0xC0) {
	$seq = '';
	}
	$seq .= $chr;
	// next byte of multibyte sequence
	}
	else if ($seq) {
	$seq .= $chr;
	}
	}

	if ($seq) {
	$out .= preg_match($regexp, $seq) ? $seq : '';
	}

	return $out;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_config.php b/program/lib/Roundcube/rcube_config.php
	index 8112d2ece..615faf3ad 100644
	--- a/program/lib/Roundcube/rcube_config.php
	+++ b/program/lib/Roundcube/rcube_config.php
	@@ -1,441 +1,441 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_config.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2008-2012, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Class to read configuration settings \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Configuration class for Roundcube
	*
	* @package Framework
	* @subpackage Core
	*/
	class rcube_config
	{
	const DEFAULT_SKIN = 'larry';

	private $prop = array();
	private $errors = array();
	private $userprefs = array();

	/**
	* Renamed options
	*
	* @var array
	*/
	private $legacy_props = array(
	// new name => old name
	'default_folders' => 'default_imap_folders',
	'mail_pagesize' => 'pagesize',
	'addressbook_pagesize' => 'pagesize',
	'reply_mode' => 'top_posting',
	'refresh_interval' => 'keep_alive',
	'min_refresh_interval' => 'min_keep_alive',
	);


	/**
	* Object constructor
	*/
	public function __construct()
	{
	$this->load();

	// Defaults, that we do not require you to configure,
	// but contain information that is used in various
	// locations in the code:
	$this->set('contactlist_fields', array('name', 'firstname', 'surname', 'email'));
	}


	/**
	* Load config from local config file
	*
	* @todo Remove global $CONFIG
	*/
	private function load()
	{
	// load main config file
	if (!$this->load_from_file(RCUBE_CONFIG_DIR . 'main.inc.php'))
	$this->errors[] = 'main.inc.php was not found.';

	// load database config
	if (!$this->load_from_file(RCUBE_CONFIG_DIR . 'db.inc.php'))
	$this->errors[] = 'db.inc.php was not found.';

	// load host-specific configuration
	$this->load_host_config();

	// set skin (with fallback to old 'skin_path' property)
	if (empty($this->prop['skin'])) {
	if (!empty($this->prop['skin_path'])) {
	$this->prop['skin'] = str_replace('skins/', '', unslashify($this->prop['skin_path']));
	}
	else {
	$this->prop['skin'] = self::DEFAULT_SKIN;
	}
	}

	// larry is the new default skin :-)
	if ($this->prop['skin'] == 'default')
	$this->prop['skin'] = self::DEFAULT_SKIN;

	// fix paths
	$this->prop['log_dir'] = $this->prop['log_dir'] ? realpath(unslashify($this->prop['log_dir'])) : RCUBE_INSTALL_PATH . 'logs';
	$this->prop['temp_dir'] = $this->prop['temp_dir'] ? realpath(unslashify($this->prop['temp_dir'])) : RCUBE_INSTALL_PATH . 'temp';

	// fix default imap folders encoding
	foreach (array('drafts_mbox', 'junk_mbox', 'sent_mbox', 'trash_mbox') as $folder)
	- $this->prop[$folder] = rcube_charset::convert($this->prop[$folder], RCMAIL_CHARSET, 'UTF7-IMAP');
	+ $this->prop[$folder] = rcube_charset::convert($this->prop[$folder], RCUBE_CHARSET, 'UTF7-IMAP');

	if (!empty($this->prop['default_folders']))
	foreach ($this->prop['default_folders'] as $n => $folder)
	- $this->prop['default_folders'][$n] = rcube_charset::convert($folder, RCMAIL_CHARSET, 'UTF7-IMAP');
	+ $this->prop['default_folders'][$n] = rcube_charset::convert($folder, RCUBE_CHARSET, 'UTF7-IMAP');

	// set PHP error logging according to config
	if ($this->prop['debug_level'] & 1) {
	ini_set('log_errors', 1);

	if ($this->prop['log_driver'] == 'syslog') {
	ini_set('error_log', 'syslog');
	}
	else {
	ini_set('error_log', $this->prop['log_dir'].'/errors');
	}
	}

	// enable display_errors in 'show' level, but not for ajax requests
	ini_set('display_errors', intval(empty($_REQUEST['_remote']) && ($this->prop['debug_level'] & 4)));

	// set timezone auto settings values
	if ($this->prop['timezone'] == 'auto') {
	$this->prop['_timezone_value'] = $this->client_timezone();
	}
	else if (is_numeric($this->prop['timezone']) && ($tz = timezone_name_from_abbr("", $this->prop['timezone'] * 3600, 0))) {
	$this->prop['timezone'] = $tz;
	}
	else if (empty($this->prop['timezone'])) {
	$this->prop['timezone'] = 'UTC';
	}

	// remove deprecated properties
	unset($this->prop['dst_active']);

	// export config data
	$GLOBALS['CONFIG'] = &$this->prop;
	}

	/**
	* Load a host-specific config file if configured
	* This will merge the host specific configuration with the given one
	*/
	private function load_host_config()
	{
	$fname = null;

	if (is_array($this->prop['include_host_config'])) {
	$fname = $this->prop['include_host_config'][$_SERVER['HTTP_HOST']];
	}
	else if (!empty($this->prop['include_host_config'])) {
	$fname = preg_replace('/[^a-z0-9\.\-_]/i', '', $_SERVER['HTTP_HOST']) . '.inc.php';
	}

	if ($fname) {
	$this->load_from_file(RCUBE_CONFIG_DIR . $fname);
	}
	}


	/**
	* Read configuration from a file
	* and merge with the already stored config values
	*
	* @param string $fpath Full path to the config file to be loaded
	* @return booelan True on success, false on failure
	*/
	public function load_from_file($fpath)
	{
	if (is_file($fpath) && is_readable($fpath)) {
	// use output buffering, we don't need any output here
	ob_start();
	include($fpath);
	ob_end_clean();

	if (is_array($rcmail_config)) {
	$this->prop = array_merge($this->prop, $rcmail_config, $this->userprefs);
	return true;
	}
	}

	return false;
	}


	/**
	* Getter for a specific config parameter
	*
	* @param string $name Parameter name
	* @param mixed $def Default value if not set
	* @return mixed The requested config value
	*/
	public function get($name, $def = null)
	{
	if (isset($this->prop[$name])) {
	$result = $this->prop[$name];
	}
	else if (isset($this->legacy_props[$name])) {
	return $this->get($this->legacy_props[$name], $def);
	}
	else {
	$result = $def;
	}

	$rcube = rcube::get_instance();

	if ($name == 'timezone' && isset($this->prop['_timezone_value'])) {
	$result = $this->prop['_timezone_value'];
	}
	else if ($name == 'client_mimetypes') {
	if ($result == null && $def == null)
	$result = 'text/plain,text/html,text/xml,image/jpeg,image/gif,image/png,image/bmp,image/tiff,application/x-javascript,application/pdf,application/x-shockwave-flash';
	if ($result && is_string($result))
	$result = explode(',', $result);
	}

	$plugin = $rcube->plugins->exec_hook('config_get', array(
	'name' => $name, 'default' => $def, 'result' => $result));

	return $plugin['result'];
	}


	/**
	* Setter for a config parameter
	*
	* @param string $name Parameter name
	* @param mixed $value Parameter value
	*/
	public function set($name, $value)
	{
	$this->prop[$name] = $value;
	}


	/**
	* Override config options with the given values (eg. user prefs)
	*
	* @param array $prefs Hash array with config props to merge over
	*/
	public function merge($prefs)
	{
	$this->prop = array_merge($this->prop, $prefs, $this->userprefs);
	}


	/**
	* Merge the given prefs over the current config
	* and make sure that they survive further merging.
	*
	* @param array $prefs Hash array with user prefs
	*/
	public function set_user_prefs($prefs)
	{
	// Honor the dont_override setting for any existing user preferences
	$dont_override = $this->get('dont_override');
	if (is_array($dont_override) && !empty($dont_override)) {
	foreach ($dont_override as $key) {
	unset($prefs[$key]);
	}
	}

	// convert user's timezone into the new format
	if (is_numeric($prefs['timezone']) && ($tz = timezone_name_from_abbr('', $prefs['timezone'] * 3600, 0))) {
	$prefs['timezone'] = $tz;
	}

	// larry is the new default skin :-)
	if ($prefs['skin'] == 'default') {
	$prefs['skin'] = self::DEFAULT_SKIN;
	}

	$this->userprefs = $prefs;
	$this->prop = array_merge($this->prop, $prefs);

	// override timezone settings with client values
	if ($this->prop['timezone'] == 'auto') {
	$this->prop['_timezone_value'] = isset($_SESSION['timezone']) ? $this->client_timezone() : $this->prop['_timezone_value'];
	}
	else if (isset($this->prop['_timezone_value']))
	unset($this->prop['_timezone_value']);
	}


	/**
	* Getter for all config options
	*
	* @return array Hash array containg all config properties
	*/
	public function all()
	{
	return $this->prop;
	}

	/**
	* Special getter for user's timezone offset including DST
	*
	* @return float Timezone offset (in hours)
	* @deprecated
	*/
	public function get_timezone()
	{
	if ($tz = $this->get('timezone')) {
	try {
	$tz = new DateTimeZone($tz);
	return $tz->getOffset(new DateTime('now')) / 3600;
	}
	catch (Exception $e) {
	}
	}

	return 0;
	}

	/**
	* Return requested DES crypto key.
	*
	* @param string $key Crypto key name
	* @return string Crypto key
	*/
	public function get_crypto_key($key)
	{
	// Bomb out if the requested key does not exist
	if (!array_key_exists($key, $this->prop)) {
	rcube::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Request for unconfigured crypto key \"$key\""
	), true, true);
	}

	$key = $this->prop[$key];

	// Bomb out if the configured key is not exactly 24 bytes long
	if (strlen($key) != 24) {
	rcube::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Configured crypto key '$key' is not exactly 24 bytes long"
	), true, true);
	}

	return $key;
	}


	/**
	* Try to autodetect operating system and find the correct line endings
	*
	* @return string The appropriate mail header delimiter
	*/
	public function header_delimiter()
	{
	// use the configured delimiter for headers
	if (!empty($this->prop['mail_header_delimiter'])) {
	$delim = $this->prop['mail_header_delimiter'];
	if ($delim == "\n" \|\| $delim == "\r\n")
	return $delim;
	else
	rcube::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Invalid mail_header_delimiter setting"
	), true, false);
	}

	$php_os = strtolower(substr(PHP_OS, 0, 3));

	if ($php_os == 'win')
	return "\r\n";

	if ($php_os == 'mac')
	return "\r\n";

	return "\n";
	}


	/**
	* Return the mail domain configured for the given host
	*
	* @param string $host IMAP host
	* @param boolean $encode If true, domain name will be converted to IDN ASCII
	* @return string Resolved SMTP host
	*/
	public function mail_domain($host, $encode=true)
	{
	$domain = $host;

	if (is_array($this->prop['mail_domain'])) {
	if (isset($this->prop['mail_domain'][$host]))
	$domain = $this->prop['mail_domain'][$host];
	}
	else if (!empty($this->prop['mail_domain'])) {
	$domain = rcube_utils::parse_host($this->prop['mail_domain']);
	}

	if ($encode) {
	$domain = rcube_utils::idn_to_ascii($domain);
	}

	return $domain;
	}


	/**
	* Getter for error state
	*
	* @return mixed Error message on error, False if no errors
	*/
	public function get_error()
	{
	return empty($this->errors) ? false : join("\n", $this->errors);
	}


	/**
	* Internal getter for client's (browser) timezone identifier
	*/
	private function client_timezone()
	{
	if (isset($_SESSION['timezone']) && is_numeric($_SESSION['timezone'])
	&& ($ctz = timezone_name_from_abbr("", $_SESSION['timezone'] * 3600, 0))) {
	return $ctz;
	}
	else if (!empty($_SESSION['timezone'])) {
	try {
	$tz = timezone_open($_SESSION['timezone']);
	return $tz->getName();
	}
	catch (Exception $e) { /* gracefully ignore */ }
	}

	// fallback to server's timezone
	return date_default_timezone_get();
	}

	}
	diff --git a/program/lib/Roundcube/rcube_contacts.php b/program/lib/Roundcube/rcube_contacts.php
	index e4500c744..5b4292a4c 100644
	--- a/program/lib/Roundcube/rcube_contacts.php
	+++ b/program/lib/Roundcube/rcube_contacts.php
	@@ -1,1002 +1,1002 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_contacts.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2006-2012, 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: \|
	\| Interface to the local address book database \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Model class for the local address book database
	*
	* @package Framework
	* @subpackage Addressbook
	*/
	class rcube_contacts extends rcube_addressbook
	{
	// protected for backward compat. with some plugins
	protected $db_name = 'contacts';
	protected $db_groups = 'contactgroups';
	protected $db_groupmembers = 'contactgroupmembers';
	protected $vcard_fieldmap = array();

	/**
	* Store database connection.
	*
	* @var rcube_db
	*/
	private $db = null;
	private $user_id = 0;
	private $filter = null;
	private $result = null;
	private $cache;
	private $table_cols = array('name', 'email', 'firstname', 'surname');
	private $fulltext_cols = array('name', 'firstname', 'surname', 'middlename', 'nickname',
	'jobtitle', 'organization', 'department', 'maidenname', 'email', 'phone',
	'address', 'street', 'locality', 'zipcode', 'region', 'country', 'website', 'im', 'notes');

	// public properties
	public $primary_key = 'contact_id';
	public $name;
	public $readonly = false;
	public $groups = true;
	public $undelete = true;
	public $list_page = 1;
	public $page_size = 10;
	public $group_id = 0;
	public $ready = false;
	public $coltypes = array('name', 'firstname', 'surname', 'middlename', 'prefix', 'suffix', 'nickname',
	'jobtitle', 'organization', 'department', 'assistant', 'manager',
	'gender', 'maidenname', 'spouse', 'email', 'phone', 'address',
	'birthday', 'anniversary', 'website', 'im', 'notes', 'photo');

	const SEPARATOR = ',';


	/**
	* Object constructor
	*
	* @param object Instance of the rcube_db class
	* @param integer User-ID
	*/
	function __construct($dbconn, $user)
	{
	$this->db = $dbconn;
	$this->user_id = $user;
	$this->ready = $this->db && !$this->db->is_error();
	}


	/**
	* Returns addressbook name
	*/
	function get_name()
	{
	return $this->name;
	}


	/**
	* Save a search string for future listings
	*
	* @param string SQL params to use in listing method
	*/
	function set_search_set($filter)
	{
	$this->filter = $filter;
	$this->cache = null;
	}


	/**
	* Getter for saved search properties
	*
	* @return mixed Search properties used by this class
	*/
	function get_search_set()
	{
	return $this->filter;
	}


	/**
	* Setter for the current group
	* (empty, has to be re-implemented by extending class)
	*/
	function set_group($gid)
	{
	$this->group_id = $gid;
	$this->cache = null;
	}


	/**
	* Reset all saved results and search parameters
	*/
	function reset()
	{
	$this->result = null;
	$this->filter = null;
	$this->cache = null;
	}


	/**
	* List all active contact groups of this source
	*
	* @param string Search string to match group name
	* @return array Indexed list of contact groups, each a hash array
	*/
	function list_groups($search = null)
	{
	$results = array();

	if (!$this->groups)
	return $results;

	$sql_filter = $search ? " AND " . $this->db->ilike('name', '%'.$search.'%') : '';

	$sql_result = $this->db->query(
	"SELECT * FROM ".$this->db->table_name($this->db_groups).
	" WHERE del<>1".
	" AND user_id=?".
	$sql_filter.
	" ORDER BY name",
	$this->user_id);

	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$sql_arr['ID'] = $sql_arr['contactgroup_id'];
	$results[] = $sql_arr;
	}

	return $results;
	}


	/**
	* Get group properties such as name and email address(es)
	*
	* @param string Group identifier
	* @return array Group properties as hash array
	*/
	function get_group($group_id)
	{
	$sql_result = $this->db->query(
	"SELECT * FROM ".$this->db->table_name($this->db_groups).
	" WHERE del<>1".
	" AND contactgroup_id=?".
	" AND user_id=?",
	$group_id, $this->user_id);

	if ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$sql_arr['ID'] = $sql_arr['contactgroup_id'];
	return $sql_arr;
	}

	return null;
	}

	/**
	* List the current set of contact records
	*
	* @param array List of cols to show, Null means all
	* @param int Only return this number of records, use negative values for tail
	* @param boolean True to skip the count query (select only)
	* @return array Indexed list of contact records, each a hash array
	*/
	function list_records($cols=null, $subset=0, $nocount=false)
	{
	if ($nocount \|\| $this->list_page <= 1) {
	// create dummy result, we don't need a count now
	$this->result = new rcube_result_set();
	} else {
	// count all records
	$this->result = $this->count();
	}

	$start_row = $subset < 0 ? $this->result->first + $this->page_size + $subset : $this->result->first;
	$length = $subset != 0 ? abs($subset) : $this->page_size;

	if ($this->group_id)
	$join = " LEFT JOIN ".$this->db->table_name($this->db_groupmembers)." AS m".
	" ON (m.contact_id = c.".$this->primary_key.")";

	$order_col = (in_array($this->sort_col, $this->table_cols) ? $this->sort_col : 'name');
	$order_cols = array('c.'.$order_col);
	if ($order_col == 'firstname')
	$order_cols[] = 'c.surname';
	else if ($order_col == 'surname')
	$order_cols[] = 'c.firstname';
	if ($order_col != 'name')
	$order_cols[] = 'c.name';
	$order_cols[] = 'c.email';

	$sql_result = $this->db->limitquery(
	"SELECT * FROM ".$this->db->table_name($this->db_name)." AS c" .
	$join .
	" WHERE c.del<>1" .
	" AND c.user_id=?" .
	($this->group_id ? " AND m.contactgroup_id=?" : "").
	($this->filter ? " AND (".$this->filter.")" : "") .
	" ORDER BY ". $this->db->concat($order_cols) .
	" " . $this->sort_order,
	$start_row,
	$length,
	$this->user_id,
	$this->group_id);

	// determine whether we have to parse the vcard or if only db cols are requested
	$read_vcard = !$cols \|\| count(array_intersect($cols, $this->table_cols)) < count($cols);

	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$sql_arr['ID'] = $sql_arr[$this->primary_key];

	if ($read_vcard)
	$sql_arr = $this->convert_db_data($sql_arr);
	else {
	$sql_arr['email'] = explode(self::SEPARATOR, $sql_arr['email']);
	$sql_arr['email'] = array_map('trim', $sql_arr['email']);
	}

	$this->result->add($sql_arr);
	}

	$cnt = count($this->result->records);

	// update counter
	if ($nocount)
	$this->result->count = $cnt;
	else if ($this->list_page <= 1) {
	if ($cnt < $this->page_size && $subset == 0)
	$this->result->count = $cnt;
	else if (isset($this->cache['count']))
	$this->result->count = $this->cache['count'];
	else
	$this->result->count = $this->_count();
	}

	return $this->result;
	}


	/**
	* Search contacts
	*
	* @param mixed $fields The field name of array of field names to search in
	* @param mixed $value Search value (or array of values when $fields is array)
	* @param int $mode Matching mode:
	* 0 - partial (abc),
	* 1 - strict (=),
	* 2 - prefix (abc*)
	* @param boolean $select True if results are requested, False if count only
	* @param boolean $nocount True to skip the count query (select only)
	* @param array $required List of fields that cannot be empty
	*
	* @return object rcube_result_set Contact records and 'count' value
	*/
	function search($fields, $value, $mode=0, $select=true, $nocount=false, $required=array())
	{
	if (!is_array($fields))
	$fields = array($fields);
	if (!is_array($required) && !empty($required))
	$required = array($required);

	$where = $and_where = array();
	$mode = intval($mode);
	$WS = ' ';
	$AS = self::SEPARATOR;

	foreach ($fields as $idx => $col) {
	// direct ID search
	if ($col == 'ID' \|\| $col == $this->primary_key) {
	$ids = !is_array($value) ? explode(self::SEPARATOR, $value) : $value;
	$ids = $this->db->array2list($ids, 'integer');
	$where[] = 'c.' . $this->primary_key.' IN ('.$ids.')';
	continue;
	}
	// fulltext search in all fields
	else if ($col == '*') {
	$words = array();
	foreach (explode($WS, rcube_utils::normalize_string($value)) as $word) {
	switch ($mode) {
	case 1: // strict
	$words[] = '(' . $this->db->ilike('words', $word . '%')
	. ' OR ' . $this->db->ilike('words', '%' . $WS . $word . $WS . '%')
	. ' OR ' . $this->db->ilike('words', '%' . $WS . $word) . ')';
	break;
	case 2: // prefix
	$words[] = '(' . $this->db->ilike('words', $word . '%')
	. ' OR ' . $this->db->ilike('words', '%' . $WS . $word . '%') . ')';
	break;
	default: // partial
	$words[] = $this->db->ilike('words', '%' . $word . '%');
	}
	}
	$where[] = '(' . join(' AND ', $words) . ')';
	}
	else {
	$val = is_array($value) ? $value[$idx] : $value;
	// table column
	if (in_array($col, $this->table_cols)) {
	switch ($mode) {
	case 1: // strict
	$where[] = '(' . $this->db->quoteIdentifier($col) . ' = ' . $this->db->quote($val)
	. ' OR ' . $this->db->ilike($col, $val . $AS . '%')
	. ' OR ' . $this->db->ilike($col, '%' . $AS . $val . $AS . '%')
	. ' OR ' . $this->db->ilike($col, '%' . $AS . $val) . ')';
	break;
	case 2: // prefix
	$where[] = '(' . $this->db->ilike($col, $val . '%')
	. ' OR ' . $this->db->ilike($col, $AS . $val . '%') . ')';
	break;
	default: // partial
	$where[] = $this->db->ilike($col, '%' . $val . '%');
	}
	}
	// vCard field
	else {
	if (in_array($col, $this->fulltext_cols)) {
	foreach (rcube_utils::normalize_string($val, true) as $word) {
	switch ($mode) {
	case 1: // strict
	$words[] = '(' . $this->db->ilike('words', $word . $WS . '%')
	. ' OR ' . $this->db->ilike('words', '%' . $AS . $word . $WS .'%')
	. ' OR ' . $this->db->ilike('words', '%' . $AS . $word) . ')';
	break;
	case 2: // prefix
	$words[] = '(' . $this->db->ilike('words', $word . '%')
	. ' OR ' . $this->db->ilike('words', $AS . $word . '%') . ')';
	break;
	default: // partial
	$words[] = $this->db->ilike('words', '%' . $word . '%');
	}
	}
	$where[] = '(' . join(' AND ', $words) . ')';
	}
	if (is_array($value))
	$post_search[$col] = mb_strtolower($val);
	}
	}
	}

	foreach (array_intersect($required, $this->table_cols) as $col) {
	$and_where[] = $this->db->quoteIdentifier($col).' <> '.$this->db->quote('');
	}

	if (!empty($where)) {
	// use AND operator for advanced searches
	$where = join(is_array($value) ? ' AND ' : ' OR ', $where);
	}

	if (!empty($and_where))
	$where = ($where ? "($where) AND " : '') . join(' AND ', $and_where);

	// Post-searching in vCard data fields
	// we will search in all records and then build a where clause for their IDs
	if (!empty($post_search)) {
	$ids = array(0);
	// build key name regexp
	$regexp = '/^(' . implode(array_keys($post_search), '\|') . ')(?:.*)$/';
	// use initial WHERE clause, to limit records number if possible
	if (!empty($where))
	$this->set_search_set($where);

	// count result pages
	$cnt = $this->count();
	$pages = ceil($cnt / $this->page_size);
	$scnt = count($post_search);

	// get (paged) result
	for ($i=0; $i<$pages; $i++) {
	$this->list_records(null, $i, true);
	while ($row = $this->result->next()) {
	$id = $row[$this->primary_key];
	$found = array();
	foreach (preg_grep($regexp, array_keys($row)) as $col) {
	$pos = strpos($col, ':');
	$colname = $pos ? substr($col, 0, $pos) : $col;
	$search = $post_search[$colname];
	foreach ((array)$row[$col] as $value) {
	// composite field, e.g. address
	foreach ((array)$value as $val) {
	$val = mb_strtolower($val);
	switch ($mode) {
	case 1:
	$got = ($val == $search);
	break;
	case 2:
	$got = ($search == substr($val, 0, strlen($search)));
	break;
	default:
	$got = (strpos($val, $search) !== false);
	break;
	}

	if ($got) {
	$found[$colname] = true;
	break 2;
	}
	}
	}
	}
	// all fields match
	if (count($found) >= $scnt) {
	$ids[] = $id;
	}
	}
	}

	// build WHERE clause
	$ids = $this->db->array2list($ids, 'integer');
	$where = 'c.' . $this->primary_key.' IN ('.$ids.')';
	// reset counter
	unset($this->cache['count']);

	// when we know we have an empty result
	if ($ids == '0') {
	$this->set_search_set($where);
	return ($this->result = new rcube_result_set(0, 0));
	}
	}

	if (!empty($where)) {
	$this->set_search_set($where);
	if ($select)
	$this->list_records(null, 0, $nocount);
	else
	$this->result = $this->count();
	}

	return $this->result;
	}


	/**
	* Count number of available contacts in database
	*
	* @return rcube_result_set Result object
	*/
	function count()
	{
	$count = isset($this->cache['count']) ? $this->cache['count'] : $this->_count();

	return new rcube_result_set($count, ($this->list_page-1) * $this->page_size);
	}


	/**
	* Count number of available contacts in database
	*
	* @return int Contacts count
	*/
	private function _count()
	{
	if ($this->group_id)
	$join = " LEFT JOIN ".$this->db->table_name($this->db_groupmembers)." AS m".
	" ON (m.contact_id=c.".$this->primary_key.")";

	// count contacts for this user
	$sql_result = $this->db->query(
	"SELECT COUNT(c.contact_id) AS rows".
	" FROM ".$this->db->table_name($this->db_name)." AS c".
	$join.
	" WHERE c.del<>1".
	" AND c.user_id=?".
	($this->group_id ? " AND m.contactgroup_id=?" : "").
	($this->filter ? " AND (".$this->filter.")" : ""),
	$this->user_id,
	$this->group_id
	);

	$sql_arr = $this->db->fetch_assoc($sql_result);

	$this->cache['count'] = (int) $sql_arr['rows'];

	return $this->cache['count'];
	}


	/**
	* Return the last result set
	*
	* @return mixed Result array or NULL if nothing selected yet
	*/
	function get_result()
	{
	return $this->result;
	}


	/**
	* Get a specific contact record
	*
	* @param mixed record identifier(s)
	* @return mixed Result object with all record fields or False if not found
	*/
	function get_record($id, $assoc=false)
	{
	// return cached result
	if ($this->result && ($first = $this->result->first()) && $first[$this->primary_key] == $id)
	return $assoc ? $first : $this->result;

	$this->db->query(
	"SELECT * FROM ".$this->db->table_name($this->db_name).
	" WHERE contact_id=?".
	" AND user_id=?".
	" AND del<>1",
	$id,
	$this->user_id
	);

	if ($sql_arr = $this->db->fetch_assoc()) {
	$record = $this->convert_db_data($sql_arr);
	$this->result = new rcube_result_set(1);
	$this->result->add($record);
	}

	return $assoc && $record ? $record : $this->result;
	}


	/**
	* Get group assignments of a specific contact record
	*
	* @param mixed Record identifier
	* @return array List of assigned groups as ID=>Name pairs
	*/
	function get_record_groups($id)
	{
	$results = array();

	if (!$this->groups)
	return $results;

	$sql_result = $this->db->query(
	"SELECT cgm.contactgroup_id, cg.name FROM " . $this->db->table_name($this->db_groupmembers) . " AS cgm" .
	" LEFT JOIN " . $this->db->table_name($this->db_groups) . " AS cg ON (cgm.contactgroup_id = cg.contactgroup_id AND cg.del<>1)" .
	" WHERE cgm.contact_id=?",
	$id
	);
	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$results[$sql_arr['contactgroup_id']] = $sql_arr['name'];
	}

	return $results;
	}


	/**
	* Check the given data before saving.
	* If input not valid, the message to display can be fetched using get_error()
	*
	* @param array Assoziative array with data to save
	* @param boolean Try to fix/complete record automatically
	* @return boolean True if input is valid, False if not.
	*/
	public function validate(&$save_data, $autofix = false)
	{
	// validate e-mail addresses
	$valid = parent::validate($save_data, $autofix);

	// require at least one e-mail address (syntax check is already done)
	if ($valid && !array_filter($this->get_col_values('email', $save_data, true))) {
	$this->set_error(self::ERROR_VALIDATE, 'noemailwarning');
	$valid = false;
	}

	return $valid;
	}


	/**
	* Create a new contact record
	*
	* @param array Associative array with save data
	* @return integer\|boolean The created record ID on success, False on error
	*/
	function insert($save_data, $check=false)
	{
	if (!is_array($save_data))
	return false;

	$insert_id = $existing = false;

	if ($check) {
	foreach ($save_data as $col => $values) {
	if (strpos($col, 'email') === 0) {
	foreach ((array)$values as $email) {
	if ($existing = $this->search('email', $email, false, false))
	break 2;
	}
	}
	}
	}

	$save_data = $this->convert_save_data($save_data);
	$a_insert_cols = $a_insert_values = array();

	foreach ($save_data as $col => $value) {
	$a_insert_cols[] = $this->db->quoteIdentifier($col);
	$a_insert_values[] = $this->db->quote($value);
	}

	if (!$existing->count && !empty($a_insert_cols)) {
	$this->db->query(
	"INSERT INTO ".$this->db->table_name($this->db_name).
	" (user_id, changed, del, ".join(', ', $a_insert_cols).")".
	" VALUES (".intval($this->user_id).", ".$this->db->now().", 0, ".join(', ', $a_insert_values).")"
	);

	$insert_id = $this->db->insert_id($this->db_name);
	}

	// also add the newly created contact to the active group
	if ($insert_id && $this->group_id)
	$this->add_to_group($this->group_id, $insert_id);

	$this->cache = null;

	return $insert_id;
	}


	/**
	* Update a specific contact record
	*
	* @param mixed Record identifier
	* @param array Assoziative array with save data
	* @return boolean True on success, False on error
	*/
	function update($id, $save_cols)
	{
	$updated = false;
	$write_sql = array();
	$record = $this->get_record($id, true);
	$save_cols = $this->convert_save_data($save_cols, $record);

	foreach ($save_cols as $col => $value) {
	$write_sql[] = sprintf("%s=%s", $this->db->quoteIdentifier($col), $this->db->quote($value));
	}

	if (!empty($write_sql)) {
	$this->db->query(
	"UPDATE ".$this->db->table_name($this->db_name).
	" SET changed=".$this->db->now().", ".join(', ', $write_sql).
	" WHERE contact_id=?".
	" AND user_id=?".
	" AND del<>1",
	$id,
	$this->user_id
	);

	$updated = $this->db->affected_rows();
	$this->result = null; // clear current result (from get_record())
	}

	return $updated;
	}


	private function convert_db_data($sql_arr)
	{
	$record = array();
	$record['ID'] = $sql_arr[$this->primary_key];

	if ($sql_arr['vcard']) {
	unset($sql_arr['email']);
	- $vcard = new rcube_vcard($sql_arr['vcard'], RCMAIL_CHARSET, false, $this->vcard_fieldmap);
	+ $vcard = new rcube_vcard($sql_arr['vcard'], RCUBE_CHARSET, false, $this->vcard_fieldmap);
	$record += $vcard->get_assoc() + $sql_arr;
	}
	else {
	$record += $sql_arr;
	$record['email'] = explode(self::SEPARATOR, $record['email']);
	$record['email'] = array_map('trim', $record['email']);
	}

	return $record;
	}


	private function convert_save_data($save_data, $record = array())
	{
	$out = array();
	$words = '';

	// copy values into vcard object
	- $vcard = new rcube_vcard($record['vcard'] ? $record['vcard'] : $save_data['vcard'], RCMAIL_CHARSET, false, $this->vcard_fieldmap);
	+ $vcard = new rcube_vcard($record['vcard'] ? $record['vcard'] : $save_data['vcard'], RCUBE_CHARSET, false, $this->vcard_fieldmap);
	$vcard->reset();
	foreach ($save_data as $key => $values) {
	list($field, $section) = explode(':', $key);
	$fulltext = in_array($field, $this->fulltext_cols);
	foreach ((array)$values as $value) {
	if (isset($value))
	$vcard->set($field, $value, $section);
	if ($fulltext && is_array($value))
	$words .= ' ' . rcube_utils::normalize_string(join(" ", $value));
	else if ($fulltext && strlen($value) >= 3)
	$words .= ' ' . rcube_utils::normalize_string($value);
	}
	}
	$out['vcard'] = $vcard->export(false);

	foreach ($this->table_cols as $col) {
	$key = $col;
	if (!isset($save_data[$key]))
	$key .= ':home';
	if (isset($save_data[$key])) {
	if (is_array($save_data[$key]))
	$out[$col] = join(self::SEPARATOR, $save_data[$key]);
	else
	$out[$col] = $save_data[$key];
	}
	}

	// save all e-mails in database column
	$out['email'] = join(self::SEPARATOR, $vcard->email);

	// join words for fulltext search
	$out['words'] = join(" ", array_unique(explode(" ", $words)));

	return $out;
	}


	/**
	* Mark one or more contact records as deleted
	*
	* @param array Record identifiers
	* @param boolean Remove record(s) irreversible (unsupported)
	*/
	function delete($ids, $force=true)
	{
	if (!is_array($ids))
	$ids = explode(self::SEPARATOR, $ids);

	$ids = $this->db->array2list($ids, 'integer');

	// flag record as deleted (always)
	$this->db->query(
	"UPDATE ".$this->db->table_name($this->db_name).
	" SET del=1, changed=".$this->db->now().
	" WHERE user_id=?".
	" AND contact_id IN ($ids)",
	$this->user_id
	);

	$this->cache = null;

	return $this->db->affected_rows();
	}


	/**
	* Undelete one or more contact records
	*
	* @param array Record identifiers
	*/
	function undelete($ids)
	{
	if (!is_array($ids))
	$ids = explode(self::SEPARATOR, $ids);

	$ids = $this->db->array2list($ids, 'integer');

	// clear deleted flag
	$this->db->query(
	"UPDATE ".$this->db->table_name($this->db_name).
	" SET del=0, changed=".$this->db->now().
	" WHERE user_id=?".
	" AND contact_id IN ($ids)",
	$this->user_id
	);

	$this->cache = null;

	return $this->db->affected_rows();
	}


	/**
	* Remove all records from the database
	*/
	function delete_all()
	{
	$this->cache = null;

	$this->db->query("UPDATE ".$this->db->table_name($this->db_name).
	" SET del=1, changed=".$this->db->now().
	" WHERE user_id = ?", $this->user_id);

	return $this->db->affected_rows();
	}


	/**
	* Create a contact group with the given name
	*
	* @param string The group name
	* @return mixed False on error, array with record props in success
	*/
	function create_group($name)
	{
	$result = false;

	// make sure we have a unique name
	$name = $this->unique_groupname($name);

	$this->db->query(
	"INSERT INTO ".$this->db->table_name($this->db_groups).
	" (user_id, changed, name)".
	" VALUES (".intval($this->user_id).", ".$this->db->now().", ".$this->db->quote($name).")"
	);

	if ($insert_id = $this->db->insert_id($this->db_groups))
	$result = array('id' => $insert_id, 'name' => $name);

	return $result;
	}


	/**
	* Delete the given group (and all linked group members)
	*
	* @param string Group identifier
	* @return boolean True on success, false if no data was changed
	*/
	function delete_group($gid)
	{
	// flag group record as deleted
	$sql_result = $this->db->query(
	"UPDATE ".$this->db->table_name($this->db_groups).
	" SET del=1, changed=".$this->db->now().
	" WHERE contactgroup_id=?".
	" AND user_id=?",
	$gid, $this->user_id
	);

	$this->cache = null;

	return $this->db->affected_rows();
	}


	/**
	* Rename a specific contact group
	*
	* @param string Group identifier
	* @param string New name to set for this group
	* @return boolean New name on success, false if no data was changed
	*/
	function rename_group($gid, $newname, &$new_gid)
	{
	// make sure we have a unique name
	$name = $this->unique_groupname($newname);

	$sql_result = $this->db->query(
	"UPDATE ".$this->db->table_name($this->db_groups).
	" SET name=?, changed=".$this->db->now().
	" WHERE contactgroup_id=?".
	" AND user_id=?",
	$name, $gid, $this->user_id
	);

	return $this->db->affected_rows() ? $name : false;
	}


	/**
	* Add the given contact records the a certain group
	*
	* @param string Group identifier
	* @param array List of contact identifiers to be added
	* @return int Number of contacts added
	*/
	function add_to_group($group_id, $ids)
	{
	if (!is_array($ids))
	$ids = explode(self::SEPARATOR, $ids);

	$added = 0;
	$exists = array();

	// get existing assignments ...
	$sql_result = $this->db->query(
	"SELECT contact_id FROM ".$this->db->table_name($this->db_groupmembers).
	" WHERE contactgroup_id=?".
	" AND contact_id IN (".$this->db->array2list($ids, 'integer').")",
	$group_id
	);
	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$exists[] = $sql_arr['contact_id'];
	}
	// ... and remove them from the list
	$ids = array_diff($ids, $exists);

	foreach ($ids as $contact_id) {
	$this->db->query(
	"INSERT INTO ".$this->db->table_name($this->db_groupmembers).
	" (contactgroup_id, contact_id, created)".
	" VALUES (?, ?, ".$this->db->now().")",
	$group_id,
	$contact_id
	);

	if ($error = $this->db->is_error())
	$this->set_error(self::ERROR_SAVING, $error);
	else
	$added++;
	}

	return $added;
	}


	/**
	* Remove the given contact records from a certain group
	*
	* @param string Group identifier
	* @param array List of contact identifiers to be removed
	* @return int Number of deleted group members
	*/
	function remove_from_group($group_id, $ids)
	{
	if (!is_array($ids))
	$ids = explode(self::SEPARATOR, $ids);

	$ids = $this->db->array2list($ids, 'integer');

	$sql_result = $this->db->query(
	"DELETE FROM ".$this->db->table_name($this->db_groupmembers).
	" WHERE contactgroup_id=?".
	" AND contact_id IN ($ids)",
	$group_id
	);

	return $this->db->affected_rows();
	}


	/**
	* Check for existing groups with the same name
	*
	* @param string Name to check
	* @return string A group name which is unique for the current use
	*/
	private function unique_groupname($name)
	{
	$checkname = $name;
	$num = 2; $hit = false;

	do {
	$sql_result = $this->db->query(
	"SELECT 1 FROM ".$this->db->table_name($this->db_groups).
	" WHERE del<>1".
	" AND user_id=?".
	" AND name=?",
	$this->user_id,
	$checkname);

	// append number to make name unique
	if ($hit = $this->db->fetch_array($sql_result)) {
	$checkname = $name . ' ' . $num++;
	}
	} while ($hit);

	return $checkname;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_csv2vcard.php b/program/lib/Roundcube/rcube_csv2vcard.php
	index ec7a3ab41..850c0c4c3 100644
	--- a/program/lib/Roundcube/rcube_csv2vcard.php
	+++ b/program/lib/Roundcube/rcube_csv2vcard.php
	@@ -1,382 +1,382 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_csv2vcard.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2008-2012, 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: \|
	\| CSV to vCard data conversion \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* CSV to vCard data converter
	*
	* @package Framework
	* @subpackage Addressbook
	* @author Aleksander Machniak <alec@alec.pl>
	*/
	class rcube_csv2vcard
	{
	/**
	* CSV to vCard fields mapping
	*
	* @var array
	*/
	protected $csv2vcard_map = array(
	// MS Outlook 2010
	'anniversary' => 'anniversary',
	'assistants_name' => 'assistant',
	'assistants_phone' => 'phone:assistant',
	'birthday' => 'birthday',
	'business_city' => 'locality:work',
	'business_countryregion' => 'country:work',
	'business_fax' => 'phone:work,fax',
	'business_phone' => 'phone:work',
	'business_phone_2' => 'phone:work2',
	'business_postal_code' => 'zipcode:work',
	'business_state' => 'region:work',
	'business_street' => 'street:work',
	//'business_street_2' => '',
	//'business_street_3' => '',
	'car_phone' => 'phone:car',
	'categories' => 'categories',
	//'children' => '',
	'company' => 'organization',
	//'company_main_phone' => '',
	'department' => 'department',
	//'email_2_address' => '', //@TODO
	//'email_2_type' => '',
	//'email_3_address' => '', //@TODO
	//'email_3_type' => '',
	'email_address' => 'email:main',
	//'email_type' => '',
	'first_name' => 'firstname',
	'gender' => 'gender',
	'home_city' => 'locality:home',
	'home_countryregion' => 'country:home',
	'home_fax' => 'phone:home,fax',
	'home_phone' => 'phone:home',
	'home_phone_2' => 'phone:home2',
	'home_postal_code' => 'zipcode:home',
	'home_state' => 'region:home',
	'home_street' => 'street:home',
	//'home_street_2' => '',
	//'home_street_3' => '',
	//'initials' => '',
	//'isdn' => '',
	'job_title' => 'jobtitle',
	//'keywords' => '',
	//'language' => '',
	'last_name' => 'surname',
	//'location' => '',
	'managers_name' => 'manager',
	'middle_name' => 'middlename',
	//'mileage' => '',
	'mobile_phone' => 'phone:cell',
	'notes' => 'notes',
	//'office_location' => '',
	'other_city' => 'locality:other',
	'other_countryregion' => 'country:other',
	'other_fax' => 'phone:other,fax',
	'other_phone' => 'phone:other',
	'other_postal_code' => 'zipcode:other',
	'other_state' => 'region:other',
	'other_street' => 'street:other',
	//'other_street_2' => '',
	//'other_street_3' => '',
	'pager' => 'phone:pager',
	'primary_phone' => 'phone:pref',
	//'profession' => '',
	//'radio_phone' => '',
	'spouse' => 'spouse',
	'suffix' => 'suffix',
	'title' => 'title',
	'web_page' => 'website:homepage',

	// Thunderbird
	'birth_day' => 'birthday-d',
	'birth_month' => 'birthday-m',
	'birth_year' => 'birthday-y',
	'display_name' => 'displayname',
	'fax_number' => 'phone:fax',
	'home_address' => 'street:home',
	//'home_address_2' => '',
	'home_country' => 'country:home',
	'home_zipcode' => 'zipcode:home',
	'mobile_number' => 'phone:cell',
	'nickname' => 'nickname',
	'organization' => 'organization',
	'pager_number' => 'phone:pager',
	'primary_email' => 'email:pref',
	'secondary_email' => 'email:other',
	'web_page_1' => 'website:homepage',
	'web_page_2' => 'website:other',
	'work_phone' => 'phone:work',
	'work_address' => 'street:work',
	//'work_address_2' => '',
	'work_country' => 'country:work',
	'work_zipcode' => 'zipcode:work',
	);

	/**
	* CSV label to text mapping for English
	*
	* @var array
	*/
	protected $label_map = array(
	// MS Outlook 2010
	'anniversary' => "Anniversary",
	'assistants_name' => "Assistant's Name",
	'assistants_phone' => "Assistant's Phone",
	'birthday' => "Birthday",
	'business_city' => "Business City",
	'business_countryregion' => "Business Country/Region",
	'business_fax' => "Business Fax",
	'business_phone' => "Business Phone",
	'business_phone_2' => "Business Phone 2",
	'business_postal_code' => "Business Postal Code",
	'business_state' => "Business State",
	'business_street' => "Business Street",
	//'business_street_2' => "Business Street 2",
	//'business_street_3' => "Business Street 3",
	'car_phone' => "Car Phone",
	'categories' => "Categories",
	//'children' => "Children",
	'company' => "Company",
	//'company_main_phone' => "Company Main Phone",
	'department' => "Department",
	//'directory_server' => "Directory Server",
	//'email_2_address' => "E-mail 2 Address",
	//'email_2_type' => "E-mail 2 Type",
	//'email_3_address' => "E-mail 3 Address",
	//'email_3_type' => "E-mail 3 Type",
	'email_address' => "E-mail Address",
	//'email_type' => "E-mail Type",
	'first_name' => "First Name",
	'gender' => "Gender",
	'home_city' => "Home City",
	'home_countryregion' => "Home Country/Region",
	'home_fax' => "Home Fax",
	'home_phone' => "Home Phone",
	'home_phone_2' => "Home Phone 2",
	'home_postal_code' => "Home Postal Code",
	'home_state' => "Home State",
	'home_street' => "Home Street",
	//'home_street_2' => "Home Street 2",
	//'home_street_3' => "Home Street 3",
	//'initials' => "Initials",
	//'isdn' => "ISDN",
	'job_title' => "Job Title",
	//'keywords' => "Keywords",
	//'language' => "Language",
	'last_name' => "Last Name",
	//'location' => "Location",
	'managers_name' => "Manager's Name",
	'middle_name' => "Middle Name",
	//'mileage' => "Mileage",
	'mobile_phone' => "Mobile Phone",
	'notes' => "Notes",
	//'office_location' => "Office Location",
	'other_city' => "Other City",
	'other_countryregion' => "Other Country/Region",
	'other_fax' => "Other Fax",
	'other_phone' => "Other Phone",
	'other_postal_code' => "Other Postal Code",
	'other_state' => "Other State",
	'other_street' => "Other Street",
	//'other_street_2' => "Other Street 2",
	//'other_street_3' => "Other Street 3",
	'pager' => "Pager",
	'primary_phone' => "Primary Phone",
	//'profession' => "Profession",
	//'radio_phone' => "Radio Phone",
	'spouse' => "Spouse",
	'suffix' => "Suffix",
	'title' => "Title",
	'web_page' => "Web Page",

	// Thunderbird
	'birth_day' => "Birth Day",
	'birth_month' => "Birth Month",
	'birth_year' => "Birth Year",
	'display_name' => "Display Name",
	'fax_number' => "Fax Number",
	'home_address' => "Home Address",
	//'home_address_2' => "Home Address 2",
	'home_country' => "Home Country",
	'home_zipcode' => "Home ZipCode",
	'mobile_number' => "Mobile Number",
	'nickname' => "Nickname",
	'organization' => "Organization",
	'pager_number' => "Pager Namber",
	'primary_email' => "Primary Email",
	'secondary_email' => "Secondary Email",
	'web_page_1' => "Web Page 1",
	'web_page_2' => "Web Page 2",
	'work_phone' => "Work Phone",
	'work_address' => "Work Address",
	//'work_address_2' => "Work Address 2",
	'work_country' => "Work Country",
	'work_zipcode' => "Work ZipCode",
	);

	protected $local_label_map = array();
	protected $vcards = array();
	protected $map = array();


	/**
	* Class constructor
	*
	* @param string $lang File language
	*/
	public function __construct($lang = 'en_US')
	{
	// Localize fields map
	if ($lang && $lang != 'en_US') {
	if (file_exists(RCUBE_LOCALIZATION_DIR . "$lang/csv2vcard.inc")) {
	include RCUBE_LOCALIZATION_DIR . "$lang/csv2vcard.inc";
	}

	if (!empty($map)) {
	$this->local_label_map = array_merge($this->label_map, $map);
	}
	}

	$this->label_map = array_flip($this->label_map);
	$this->local_label_map = array_flip($this->local_label_map);
	}

	/**
	*
	*/
	public function import($csv)
	{
	// convert to UTF-8
	$head = substr($csv, 0, 4096);
	$fallback = rcube::get_instance()->config->get('default_charset', 'ISO-8859-1'); // fallback to Latin-1?
	- $charset = rcube_charset::detect($head, RCMAIL_CHARSET);
	+ $charset = rcube_charset::detect($head, RCUBE_CHARSET);
	$csv = rcube_charset::convert($csv, $charset);
	$head = '';

	$this->map = array();

	// Parse file
	foreach (preg_split("/[\r\n]+/", $csv) as $i => $line) {
	$line = trim($line);
	if (empty($line)) {
	continue;
	}

	$elements = rcube_utils::explode_quoted_string(',', $line);

	if (empty($elements)) {
	continue;
	}

	// Parse header
	if (empty($this->map)) {
	$this->parse_header($elements);
	if (empty($this->map)) {
	break;
	}
	}
	// Parse data row
	else {
	$this->csv_to_vcard($elements);
	}
	}
	}

	/**
	* @return array rcube_vcard List of vcards
	*/
	public function export()
	{
	return $this->vcards;
	}

	/**
	* Parse CSV header line, detect fields mapping
	*/
	protected function parse_header($elements)
	{
	$map1 = array();
	$map2 = array();
	$size = count($elements);

	// check English labels
	for ($i = 0; $i < $size; $i++) {
	$label = $this->label_map[$elements[$i]];
	if ($label && !empty($this->csv2vcard_map[$label])) {
	$map1[$i] = $this->csv2vcard_map[$label];
	}
	}
	// check localized labels
	if (!empty($this->local_label_map)) {
	for ($i = 0; $i < $size; $i++) {
	$label = $this->local_label_map[$elements[$i]];
	if ($label && !empty($this->csv2vcard_map[$label])) {
	$map2[$i] = $this->csv2vcard_map[$label];
	}
	}
	}

	$this->map = count($map1) >= count($map2) ? $map1 : $map2;
	}

	/**
	* Convert CSV data row to vCard
	*/
	protected function csv_to_vcard($data)
	{
	$contact = array();
	foreach ($this->map as $idx => $name) {
	$value = $data[$idx];
	if ($value !== null && $value !== '') {
	$contact[$name] = $value;
	}
	}

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

	// Handle special values
	if (!empty($contact['birthday-d']) && !empty($contact['birthday-m']) && !empty($contact['birthday-y'])) {
	$contact['birthday'] = $contact['birthday-y'] .'-' .$contact['birthday-m'] . '-' . $contact['birthday-d'];
	}

	foreach (array('birthday', 'anniversary') as $key) {
	if (!empty($contact[$key]) && $contact[$key] == '0/0/00') { // @TODO: localization?
	unset($contact[$key]);
	}
	}

	if (!empty($contact['gender']) && ($gender = strtolower($contact['gender']))) {
	if (!in_array($gender, array('male', 'female'))) {
	unset($contact['gender']);
	}
	}

	// Create vcard object
	$vcard = new rcube_vcard();
	foreach ($contact as $name => $value) {
	$name = explode(':', $name);
	$vcard->set($name[0], $value, $name[1]);
	}

	// add to the list
	$this->vcards[] = $vcard;
	}
	}
	diff --git a/program/lib/Roundcube/rcube_mime.php b/program/lib/Roundcube/rcube_mime.php
	index 25ee31d64..98761c503 100644
	--- a/program/lib/Roundcube/rcube_mime.php
	+++ b/program/lib/Roundcube/rcube_mime.php
	@@ -1,713 +1,715 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_mime.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| Copyright (C) 2011-2012, 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: \|
	\| MIME message parsing utilities \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Class for parsing MIME messages
	*
	* @package Framework
	* @subpackage Storage
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @author Aleksander Machniak <alec@alec.pl>
	*/
	class rcube_mime
	{
	private static $default_charset;


	/**
	* Object constructor.
	*/
	function __construct($default_charset = null)
	{
	self::$default_charset = $default_charset;
	}


	/**
	* Returns message/object character set name
	*
	* @return string Characted set name
	*/
	public static function get_charset()
	{
	if (self::$default_charset) {
	return self::$default_charset;
	}

	if ($charset = rcube::get_instance()->config->get('default_charset')) {
	return $charset;
	}

	- return RCMAIL_CHARSET;
	+ return RCUBE_CHARSET;
	}


	/**
	* Parse the given raw message source and return a structure
	* of rcube_message_part objects.
	*
	* It makes use of the PEAR:Mail_mimeDecode library
	*
	* @param string The message source
	* @return object rcube_message_part The message structure
	*/
	public static function parse_message($raw_body)
	{
	$mime = new Mail_mimeDecode($raw_body);
	$struct = $mime->decode(array('include_bodies' => true, 'decode_bodies' => true));
	return self::structure_part($struct);
	}


	/**
	* Recursive method to convert a Mail_mimeDecode part into a rcube_message_part object
	*
	* @param object A message part struct
	* @param int Part count
	* @param string Parent MIME ID
	*
	* @return object rcube_message_part
	*/
	private static function structure_part($part, $count=0, $parent='')
	{
	$struct = new rcube_message_part;
	$struct->mime_id = $part->mime_id ? $part->mime_id : (empty($parent) ? (string)$count : "$parent.$count");
	$struct->headers = $part->headers;
	$struct->ctype_primary = $part->ctype_primary;
	$struct->ctype_secondary = $part->ctype_secondary;
	$struct->mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
	$struct->ctype_parameters = $part->ctype_parameters;

	if ($part->headers['content-transfer-encoding'])
	$struct->encoding = $part->headers['content-transfer-encoding'];
	if ($part->ctype_parameters['charset'])
	$struct->charset = $part->ctype_parameters['charset'];

	$part_charset = $struct->charset ? $struct->charset : self::get_charset();

	// determine filename
	if (($filename = $part->d_parameters['filename']) \|\| ($filename = $part->ctype_parameters['name'])) {
	$struct->filename = rcube_mime::decode_mime_string($filename, $part_charset);
	}

	// copy part body and convert it to UTF-8 if necessary
	$struct->body = $part->ctype_primary == 'text' \|\| !$part->ctype_parameters['charset'] ? rcube_charset::convert($part->body, $part_charset) : $part->body;
	$struct->size = strlen($part->body);
	$struct->disposition = $part->disposition;

	foreach ((array)$part->parts as $child_part) {
	$struct->parts[] = self::structure_part($child_part, ++$count, $struct->mime_id);
	}

	return $struct;
	}


	/**
	* Split an address list into a structured array list
	*
	* @param string $input Input string
	* @param int $max List only this number of addresses
	* @param boolean $decode Decode address strings
	* @param string $fallback Fallback charset if none specified
	*
	* @return array Indexed list of addresses
	*/
	static function decode_address_list($input, $max = null, $decode = true, $fallback = null)
	{
	$a = self::parse_address_list($input, $decode, $fallback);
	$out = array();
	$j = 0;

	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	$special_chars = '[\<\>\\\.\[\]@,;:"]';

	if (!is_array($a))
	return $out;

	foreach ($a as $val) {
	$j++;
	$address = trim($val['address']);
	$name = trim($val['name']);

	if ($name && $address && $name != $address)
	$string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address);
	else if ($address)
	$string = $address;
	else if ($name)
	$string = $name;

	$out[$j] = array(
	'name' => $name,
	'mailto' => $address,
	'string' => $string
	);

	if ($max && $j==$max)
	break;
	}

	return $out;
	}


	/**
	* Decode a message header value
	*
	* @param string $input Header value
	* @param string $fallback Fallback charset if none specified
	*
	* @return string Decoded string
	*/
	public static function decode_header($input, $fallback = null)
	{
	$str = self::decode_mime_string((string)$input, $fallback);

	return $str;
	}


	/**
	* Decode a mime-encoded string to internal charset
	*
	* @param string $input Header value
	* @param string $fallback Fallback charset if none specified
	*
	* @return string Decoded string
	*/
	public static function decode_mime_string($input, $fallback = null)
	{
	$default_charset = !empty($fallback) ? $fallback : self::get_charset();

	// rfc: all line breaks or other characters not found
	// in the Base64 Alphabet must be ignored by decoding software
	// delete all blanks between MIME-lines, differently we can
	// receive unnecessary blanks and broken utf-8 symbols
	$input = preg_replace("/\?=\s+=\?/", '?==?', $input);

	// encoded-word regexp
	$re = '/=\?([^?]+)\?([BbQq])\?([^\n]*?)\?=/';

	// Find all RFC2047's encoded words
	if (preg_match_all($re, $input, $matches, PREG_OFFSET_CAPTURE \| PREG_SET_ORDER)) {
	// Initialize variables
	$tmp = array();
	$out = '';
	$start = 0;

	foreach ($matches as $idx => $m) {
	$pos = $m[0][1];
	$charset = $m[1][0];
	$encoding = $m[2][0];
	$text = $m[3][0];
	$length = strlen($m[0][0]);

	// Append everything that is before the text to be decoded
	if ($start != $pos) {
	$substr = substr($input, $start, $pos-$start);
	$out .= rcube_charset::convert($substr, $default_charset);
	$start = $pos;
	}
	$start += $length;

	// Per RFC2047, each string part "MUST represent an integral number
	// of characters . A multi-octet character may not be split across
	// adjacent encoded-words." However, some mailers break this, so we
	// try to handle characters spanned across parts anyway by iterating
	// through and aggregating sequential encoded parts with the same
	// character set and encoding, then perform the decoding on the
	// aggregation as a whole.

	$tmp[] = $text;
	if ($next_match = $matches[$idx+1]) {
	if ($next_match[0][1] == $start
	&& $next_match[1][0] == $charset
	&& $next_match[2][0] == $encoding
	) {
	continue;
	}
	}

	$count = count($tmp);
	$text = '';

	// Decode and join encoded-word's chunks
	if ($encoding == 'B' \|\| $encoding == 'b') {
	// base64 must be decoded a segment at a time
	for ($i=0; $i<$count; $i++)
	$text .= base64_decode($tmp[$i]);
	}
	else { //if ($encoding == 'Q' \|\| $encoding == 'q') {
	// quoted printable can be combined and processed at once
	for ($i=0; $i<$count; $i++)
	$text .= $tmp[$i];

	$text = str_replace('_', ' ', $text);
	$text = quoted_printable_decode($text);
	}

	$out .= rcube_charset::convert($text, $charset);
	$tmp = array();
	}

	// add the last part of the input string
	if ($start != strlen($input)) {
	$out .= rcube_charset::convert(substr($input, $start), $default_charset);
	}

	// return the results
	return $out;
	}

	// no encoding information, use fallback
	return rcube_charset::convert($input, $default_charset);
	}


	/**
	* Decode a mime part
	*
	* @param string $input Input string
	* @param string $encoding Part encoding
	* @return string Decoded string
	*/
	public static function decode($input, $encoding = '7bit')
	{
	switch (strtolower($encoding)) {
	case 'quoted-printable':
	return quoted_printable_decode($input);
	case 'base64':
	return base64_decode($input);
	case 'x-uuencode':
	case 'x-uue':
	case 'uue':
	case 'uuencode':
	return convert_uudecode($input);
	case '7bit':
	default:
	return $input;
	}
	}


	/**
	* Split RFC822 header string into an associative array
	* @access private
	*/
	public static function parse_headers($headers)
	{
	$a_headers = array();
	$headers = preg_replace('/\r?\n(\t\| )+/', ' ', $headers);
	$lines = explode("\n", $headers);
	$c = count($lines);

	for ($i=0; $i<$c; $i++) {
	if ($p = strpos($lines[$i], ': ')) {
	$field = strtolower(substr($lines[$i], 0, $p));
	$value = trim(substr($lines[$i], $p+1));
	if (!empty($value))
	$a_headers[$field] = $value;
	}
	}

	return $a_headers;
	}


	/**
	* @access private
	*/
	private static function parse_address_list($str, $decode = true, $fallback = null)
	{
	// remove any newlines and carriage returns before
	$str = preg_replace('/\r?\n(\s\|\t)?/', ' ', $str);

	// extract list items, remove comments
	$str = self::explode_header_string(',;', $str, true);
	$result = array();

	// simplified regexp, supporting quoted local part
	$email_rx = '(\S+\|("\s(?:[^"\f\n\r\t\v\b\s]+\s)+"))@\S+';

	foreach ($str as $key => $val) {
	$name = '';
	$address = '';
	$val = trim($val);

	if (preg_match('/(.*)<('.$email_rx.')>$/', $val, $m)) {
	$address = $m[2];
	$name = trim($m[1]);
	}
	else if (preg_match('/^('.$email_rx.')$/', $val, $m)) {
	$address = $m[1];
	$name = '';
	}
	else {
	$name = $val;
	}

	// dequote and/or decode name
	if ($name) {
	if ($name[0] == '"' && $name[strlen($name)-1] == '"') {
	$name = substr($name, 1, -1);
	$name = stripslashes($name);
	}
	if ($decode) {
	$name = self::decode_header($name, $fallback);
	}
	}

	if (!$address && $name) {
	$address = $name;
	}

	if ($address) {
	$result[$key] = array('name' => $name, 'address' => $address);
	}
	}

	return $result;
	}


	/**
	* Explodes header (e.g. address-list) string into array of strings
	* using specified separator characters with proper handling
	* of quoted-strings and comments (RFC2822)
	*
	* @param string $separator String containing separator characters
	* @param string $str Header string
	* @param bool $remove_comments Enable to remove comments
	*
	* @return array Header items
	*/
	public static function explode_header_string($separator, $str, $remove_comments = false)
	{
	$length = strlen($str);
	$result = array();
	$quoted = false;
	$comment = 0;
	$out = '';

	for ($i=0; $i<$length; $i++) {
	// we're inside a quoted string
	if ($quoted) {
	if ($str[$i] == '"') {
	$quoted = false;
	}
	else if ($str[$i] == "\\") {
	if ($comment <= 0) {
	$out .= "\\";
	}
	$i++;
	}
	}
	// we are inside a comment string
	else if ($comment > 0) {
	if ($str[$i] == ')') {
	$comment--;
	}
	else if ($str[$i] == '(') {
	$comment++;
	}
	else if ($str[$i] == "\\") {
	$i++;
	}
	continue;
	}
	// separator, add to result array
	else if (strpos($separator, $str[$i]) !== false) {
	if ($out) {
	$result[] = $out;
	}
	$out = '';
	continue;
	}
	// start of quoted string
	else if ($str[$i] == '"') {
	$quoted = true;
	}
	// start of comment
	else if ($remove_comments && $str[$i] == '(') {
	$comment++;
	}

	if ($comment <= 0) {
	$out .= $str[$i];
	}
	}

	if ($out && $comment <= 0) {
	$result[] = $out;
	}

	return $result;
	}


	/**
	* Interpret a format=flowed message body according to RFC 2646
	*
	* @param string $text Raw body formatted as flowed text
	*
	* @return string Interpreted text with unwrapped lines and stuffed space removed
	*/
	public static function unfold_flowed($text)
	{
	$text = preg_split('/\r?\n/', $text);
	$last = -1;
	$q_level = 0;

	foreach ($text as $idx => $line) {
	if ($line[0] == '>' && preg_match('/^(>+\s*)/', $line, $regs)) {
	$q = strlen(str_replace(' ', '', $regs[0]));
	$line = substr($line, strlen($regs[0]));

	if ($q == $q_level && $line
	&& isset($text[$last])
	&& $text[$last][strlen($text[$last])-1] == ' '
	) {
	$text[$last] .= $line;
	unset($text[$idx]);
	}
	else {
	$last = $idx;
	}
	}
	else {
	$q = 0;
	if ($line == '-- ') {
	$last = $idx;
	}
	else {
	// remove space-stuffing
	$line = preg_replace('/^\s/', '', $line);

	if (isset($text[$last]) && $line
	&& $text[$last] != '-- '
	&& $text[$last][strlen($text[$last])-1] == ' '
	) {
	$text[$last] .= $line;
	unset($text[$idx]);
	}
	else {
	$text[$idx] = $line;
	$last = $idx;
	}
	}
	}
	$q_level = $q;
	}

	return implode("\r\n", $text);
	}


	/**
	* Wrap the given text to comply with RFC 2646
	*
	* @param string $text Text to wrap
	* @param int $length Length
	* @param string $charset Character encoding of $text
	*
	* @return string Wrapped text
	*/
	public static function format_flowed($text, $length = 72, $charset=null)
	{
	$text = preg_split('/\r?\n/', $text);

	foreach ($text as $idx => $line) {
	if ($line != '-- ') {
	if ($line[0] == '>' && preg_match('/^(>+ {0,1})+/', $line, $regs)) {
	$level = substr_count($regs[0], '>');
	$prefix = str_repeat('>', $level) . ' ';
	$line = rtrim(substr($line, strlen($regs[0])));
	$line = $prefix . self::wordwrap($line, $length - $level - 2, " \r\n$prefix", false, $charset);
	}
	else if ($line) {
	$line = self::wordwrap(rtrim($line), $length - 2, " \r\n", false, $charset);
	// space-stuffing
	$line = preg_replace('/(^\|\r\n)(From\| \|>)/', '\\1 \\2', $line);
	}

	$text[$idx] = $line;
	}
	}

	return implode("\r\n", $text);
	}


	/**
	* Improved wordwrap function.
	*
	* @param string $string Text to wrap
	* @param int $width Line width
	* @param string $break Line separator
	* @param bool $cut Enable to cut word
	* @param string $charset Charset of $string
	*
	* @return string Text
	*/
	public static function wordwrap($string, $width=75, $break="\n", $cut=false, $charset=null)
	{
	- if ($charset && function_exists('mb_internal_encoding'))
	+ if ($charset && function_exists('mb_internal_encoding')) {
	mb_internal_encoding($charset);
	+ }

	$para = preg_split('/\r?\n/', $string);
	$string = '';

	while (count($para)) {
	$line = array_shift($para);
	if ($line[0] == '>') {
	$string .= $line.$break;
	continue;
	}

	$list = explode(' ', $line);
	$len = 0;
	while (count($list)) {
	$line = array_shift($list);
	$l = mb_strlen($line);
	$newlen = $len + $l + ($len ? 1 : 0);

	if ($newlen <= $width) {
	$string .= ($len ? ' ' : '').$line;
	$len += (1 + $l);
	}
	else {
	if ($l > $width) {
	if ($cut) {
	$start = 0;
	while ($l) {
	$str = mb_substr($line, $start, $width);
	$strlen = mb_strlen($str);
	$string .= ($len ? $break : '').$str;
	$start += $strlen;
	$l -= $strlen;
	$len = $strlen;
	}
	}
	else {
	$string .= ($len ? $break : '').$line;
	if (count($list)) {
	$string .= $break;
	}
	$len = 0;
	}
	}
	else {
	$string .= $break.$line;
	$len = $l;
	}
	}
	}

	if (count($para)) {
	$string .= $break;
	}
	}

	- if ($charset && function_exists('mb_internal_encoding'))
	- mb_internal_encoding(RCMAIL_CHARSET);
	+ if ($charset && function_exists('mb_internal_encoding')) {
	+ mb_internal_encoding(RCUBE_CHARSET);
	+ }

	return $string;
	}


	/**
	* A method to guess the mime_type of an attachment.
	*
	* @param string $path Path to the file.
	* @param string $name File name (with suffix)
	* @param string $failover Mime type supplied for failover.
	* @param string $is_stream Set to True if $path contains file body
	*
	* @return string
	* @author Till Klampaeckel <till@php.net>
	* @see http://de2.php.net/manual/en/ref.fileinfo.php
	* @see http://de2.php.net/mime_content_type
	*/
	public static function file_content_type($path, $name, $failover = 'application/octet-stream', $is_stream = false)
	{
	$mime_type = null;
	$mime_magic = rcube::get_instance()->config->get('mime_magic');
	$mime_ext = @include RCUBE_CONFIG_DIR . '/mimetypes.php';

	// use file name suffix with hard-coded mime-type map
	if (is_array($mime_ext) && $name) {
	if ($suffix = substr($name, strrpos($name, '.')+1)) {
	$mime_type = $mime_ext[strtolower($suffix)];
	}
	}

	// try fileinfo extension if available
	if (!$mime_type && function_exists('finfo_open')) {
	if ($finfo = finfo_open(FILEINFO_MIME, $mime_magic)) {
	if ($is_stream)
	$mime_type = finfo_buffer($finfo, $path);
	else
	$mime_type = finfo_file($finfo, $path);
	finfo_close($finfo);
	}
	}

	// try PHP's mime_content_type
	if (!$mime_type && !$is_stream && function_exists('mime_content_type')) {
	$mime_type = @mime_content_type($path);
	}

	// fall back to user-submitted string
	if (!$mime_type) {
	$mime_type = $failover;
	}
	else {
	// Sometimes (PHP-5.3?) content-type contains charset definition,
	// Remove it (#1487122) also "charset=binary" is useless
	$mime_type = array_shift(preg_split('/[; ]/', $mime_type));
	}

	return $mime_type;
	}


	/**
	* Detect image type of the given binary data by checking magic numbers.
	*
	* @param string $data Binary file content
	*
	* @return string Detected mime-type or jpeg as fallback
	*/
	public static function image_content_type($data)
	{
	$type = 'jpeg';
	if (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png';
	else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif';
	else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico';
	// else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg';

	return 'image/' . $type;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_output.php b/program/lib/Roundcube/rcube_output.php
	index f7ac3002f..3f881fe06 100644
	--- a/program/lib/Roundcube/rcube_output.php
	+++ b/program/lib/Roundcube/rcube_output.php
	@@ -1,284 +1,284 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_output.php \|
	\| \|
	\| This file is part of the Roundcube PHP suite \|
	\| Copyright (C) 2005-2012 The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| CONTENTS: \|
	\| Abstract class for output generation \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class for output generation
	*
	* @package Framework
	* @subpackage View
	*/
	abstract class rcube_output
	{
	public $browser;
	public $type = 'html';
	public $ajax_call = false;
	public $framed = false;

	protected $app;
	protected $config;
	- protected $charset = RCMAIL_CHARSET;
	+ protected $charset = RCUBE_CHARSET;
	protected $env = array();
	protected $pagetitle = '';
	protected $object_handlers = array();


	/**
	* Object constructor
	*/
	public function __construct($task = null, $framed = false)
	{
	$this->app = rcube::get_instance();
	$this->config = $this->app->config;
	$this->browser = new rcube_browser();
	}


	/**
	* Magic getter
	*/
	public function __get($var)
	{
	// allow read-only access to $env
	if ($var == 'env')
	return $this->env;

	return null;
	}

	/**
	* Setter for page title
	*
	* @param string $title Page title
	*/
	public function set_pagetitle($title)
	{
	$this->pagetitle = $title;
	}


	/**
	* Setter for output charset.
	* To be specified in a meta tag and sent as http-header
	*
	* @param string $charset Charset name
	*/
	public function set_charset($charset)
	{
	$this->charset = $charset;
	}


	/**
	* Getter for output charset
	*
	* @return string Output charset name
	*/
	public function get_charset()
	{
	return $this->charset;
	}


	/**
	* Getter for the current skin path property
	*/
	public function get_skin_path()
	{
	return $this->config->get('skin_path');
	}


	/**
	* Set environment variable
	*
	* @param string $name Property name
	* @param mixed $value Property value
	*/
	public function set_env($name, $value)
	{
	$this->env[$name] = $value;
	}


	/**
	* Environment variable getter.
	*
	* @param string $name Property name
	*
	* @return mixed Property value
	*/
	public function get_env($name)
	{
	return $this->env[$name];
	}


	/**
	* Delete all stored env variables and commands
	*/
	public function reset()
	{
	$this->env = array();
	$this->object_handlers = array();
	$this->pagetitle = '';
	}


	/**
	* Call a client method
	*
	* @param string Method to call
	* @param ... Additional arguments
	*/
	abstract function command();


	/**
	* Add a localized label to the client environment
	*/
	abstract function add_label();


	/**
	* Invoke display_message command
	*
	* @param string $message Message to display
	* @param string $type Message type [notice\|confirm\|error]
	* @param array $vars Key-value pairs to be replaced in localized text
	* @param boolean $override Override last set message
	* @param int $timeout Message displaying time in seconds
	*/
	abstract function show_message($message, $type = 'notice', $vars = null, $override = true, $timeout = 0);


	/**
	* Redirect to a certain url.
	*
	* @param mixed $p Either a string with the action or url parameters as key-value pairs
	* @param int $delay Delay in seconds
	*/
	abstract function redirect($p = array(), $delay = 1);


	/**
	* Send output to the client.
	*/
	abstract function send();


	/**
	* Register a template object handler
	*
	* @param string Object name
	* @param string Function name to call
	* @return void
	*/
	public function add_handler($obj, $func)
	{
	$this->object_handlers[$obj] = $func;
	}


	/**
	* Register a list of template object handlers
	*
	* @param array Hash array with object=>handler pairs
	* @return void
	*/
	public function add_handlers($arr)
	{
	$this->object_handlers = array_merge($this->object_handlers, $arr);
	}


	/**
	* Send HTTP headers to prevent caching a page
	*/
	public function nocacheing_headers()
	{
	if (headers_sent()) {
	return;
	}

	header("Expires: ".gmdate("D, d M Y H:i:s")." GMT");
	header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");

	// Request browser to disable DNS prefetching (CVE-2010-0464)
	header("X-DNS-Prefetch-Control: off");

	// We need to set the following headers to make downloads work using IE in HTTPS mode.
	if ($this->browser->ie && rcube_utils::https_check()) {
	header('Pragma: private');
	header("Cache-Control: private, must-revalidate");
	}
	else {
	header("Cache-Control: private, no-cache, must-revalidate, post-check=0, pre-check=0");
	header("Pragma: no-cache");
	}
	}

	/**
	* Send header with expire date 30 days in future
	*
	* @param int Expiration time in seconds
	*/
	public function future_expire_header($offset = 2600000)
	{
	if (headers_sent())
	return;

	header("Expires: " . gmdate("D, d M Y H:i:s", time()+$offset) . " GMT");
	header("Cache-Control: max-age=$offset");
	header("Pragma: ");
	}


	/**
	* Show error page and terminate script execution
	*
	* @param int $code Error code
	* @param string $message Error message
	*/
	public function raise_error($code, $message)
	{
	// STUB: to be overloaded by specific output classes
	fputs(STDERR, "Error $code: $message\n");
	exit(-1);
	}


	/**
	* Convert a variable into a javascript object notation
	*
	* @param mixed Input value
	*
	* @return string Serialized JSON string
	*/
	public static function json_serialize($input)
	{
	$input = rcube_charset::clean($input);

	// sometimes even using rcube_charset::clean() the input contains invalid UTF-8 sequences
	// that's why we have @ here
	return @json_encode($input);
	}

	}
	diff --git a/program/lib/Roundcube/rcube_output_html.php b/program/lib/Roundcube/rcube_output_html.php
	index 0d51eaf06..6c9dfdd1f 100644
	--- a/program/lib/Roundcube/rcube_output_html.php
	+++ b/program/lib/Roundcube/rcube_output_html.php
	@@ -1,1775 +1,1775 @@
	<?php

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


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

	protected $message = null;
	protected $js_env = array();
	protected $js_labels = array();
	protected $js_commands = array();
	protected $skin_paths = array();
	protected $template_name;
	protected $scripts_path = '';
	protected $script_files = array();
	protected $css_files = array();
	protected $scripts = array();
	protected $default_template = "<html>\n<head><title></title></head>\n<body></body>\n</html>";
	protected $header = '';
	protected $footer = '';
	protected $body = '';
	protected $base_path = '';

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

	/**
	* Constructor
	*
	* @todo Replace $this->config with the real rcube_config object
	*/
	public function __construct($task = null, $framed = false)
	{
	parent::__construct();

	//$this->framed = $framed;
	$this->set_env('task', $task);
	$this->set_env('x_frame_options', $this->config->get('x_frame_options', 'sameorigin'));

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

	// load the correct skin (in case user-defined)
	$skin = $this->config->get('skin');
	$this->set_skin($skin);
	$this->set_env('skin', $skin);

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

	// add common javascripts
	$this->add_script('var '.rcmail::JS_OBJECT_NAME.' = new rcube_webmail();', 'head_top');

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

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

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


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


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

	return $title;
	}


	/**
	* Set skin
	*/
	public function set_skin($skin)
	{
	$valid = false;

	if (!empty($skin) && is_dir('skins/'.$skin) && is_readable('skins/'.$skin)) {
	$skin_path = 'skins/'.$skin;
	$valid = true;
	}
	else {
	$skin_path = $this->config->get('skin_path');
	if (!$skin_path) {
	$skin_path = 'skins/' . rcube_config::DEFAULT_SKIN;
	}
	$valid = !$skin;
	}

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

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

	return $valid;
	}

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

	// read meta file and check for dependecies
	$meta = @json_decode(@file_get_contents($skin_path.'/meta.json'), true);
	if ($meta['extends'] && is_dir('skins/' . $meta['extends'])) {
	$this->load_skin('skins/' . $meta['extends']);
	}
	}


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


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

	foreach ($skin_paths as $skin_path) {
	$path = realpath($skin_path . $file);
	if (is_file($path)) {
	return $skin_path . $file;
	}
	}

	return false;
	}


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


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


	/**
	* Add a localized label to the client environment
	*/
	public function add_label()
	{
	$args = func_get_args();
	if (count($args) == 1 && is_array($args[0]))
	$args = $args[0];

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


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

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


	/**
	* Delete all stored env variables and commands
	*/
	public function reset()
	{
	parent::reset();
	$this->js_env = array();
	$this->js_labels = array();
	$this->js_commands = array();
	$this->script_files = array();
	$this->scripts = array();
	$this->header = '';
	$this->footer = '';
	$this->body = '';
	}


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


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

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

	if ($exit) {
	exit;
	}
	}


	/**
	* Process template and write to stdOut
	*
	* @param string $template HTML template content
	*/
	public function write($template = '')
	{
	// unlock interface after iframe load
	$unlock = preg_replace('/[^a-z0-9]/i', '', $_REQUEST['_unlock']);
	if ($this->framed) {
	array_unshift($this->js_commands, array('set_busy', false, null, $unlock));
	}
	else if ($unlock) {
	array_unshift($this->js_commands, array('hide_message', $unlock));
	}

	if (!empty($this->script_files))
	$this->set_env('request_token', $this->app->get_request_token());

	// write all env variables to client
	$js = $this->framed ? "if(window.parent) {\n" : '';
	$js .= $this->get_js_commands() . ($this->framed ? ' }' : '');
	$this->add_script($js, 'head_top');

	// send clickjacking protection headers
	$iframe = $this->framed \|\| !empty($_REQUEST['_framed']);
	if (!headers_sent() && ($xframe = $this->app->config->get('x_frame_options', 'sameorigin')))
	header('X-Frame-Options: ' . ($iframe && $xframe == 'deny' ? 'sameorigin' : $xframe));

	// call super method
	$this->_write($template, $this->config->get('skin_path'));
	}


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

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

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

	// add fallback to default skin
	if (is_dir($this->app->plugins->dir . $plugin . '/skins/default')) {
	$skin_dir = $plugin . '/skins/default';
	$plugin_skin_paths[] = $this->app->plugins->url . $skin_dir;
	}

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

	// find skin template
	$path = false;
	foreach ($this->skin_paths as $skin_path) {
	$path = "$skin_path/templates/$name.html";

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

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

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

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

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

	// parse for specialtags
	$output = $this->parse_conditions($templ);
	$output = $this->parse_xml($output);

	// trigger generic hook where plugins can put additional content to the page
	$hook = $this->app->plugins->exec_hook("render_page", array('template' => $realname, 'content' => $output));

	// save some memory
	$output = $hook['content'];
	unset($hook['content']);

	// make sure all <form> tags have a valid request token
	$output = preg_replace_callback('/<form\s+([^>]+)>/Ui', array($this, 'alter_form_tag'), $output);
	$this->footer = preg_replace_callback('/<form\s+([^>]+)>/Ui', array($this, 'alter_form_tag'), $this->footer);

	if ($write) {
	// add debug console
	if ($realname != 'error' && ($this->config->get('debug_level') & 8)) {
	$this->add_footer('<div id="console" style="position:absolute;top:5px;left:5px;width:405px;padding:2px;background:white;z-index:9000;display:none">
	<a href="#toggle" onclick="con=$(\'#dbgconsole\');con[con.is(\':visible\')?\'hide\':\'show\']();return false">console</a>
	<textarea name="console" id="dbgconsole" rows="20" cols="40" style="display:none;width:400px;border:none;font-size:10px" spellcheck="false"></textarea></div>'
	);
	$this->add_script(
	"if (!window.console \|\| !window.console.log) {\n".
	" window.console = new rcube_console();\n".
	" $('#console').show();\n".
	"}", 'foot');
	}
	$this->write(trim($output));
	}
	else {
	return $output;
	}

	if ($exit) {
	exit;
	}
	}


	/**
	* Return executable javascript code for all registered commands
	*
	* @return string $out
	*/
	protected function get_js_commands()
	{
	$out = '';
	if (!$this->framed && !empty($this->js_env)) {
	$out .= rcmail::JS_OBJECT_NAME . '.set_env('.self::json_serialize($this->js_env).");\n";
	}
	if (!empty($this->js_labels)) {
	$this->command('add_label', $this->js_labels);
	}
	foreach ($this->js_commands as $i => $args) {
	$method = array_shift($args);
	foreach ($args as $i => $arg) {
	$args[$i] = self::json_serialize($arg);
	}
	$parent = $this->framed \|\| preg_match('/^parent\./', $method);
	$out .= sprintf(
	"%s.%s(%s);\n",
	($parent ? 'if(window.parent && parent.'.rcmail::JS_OBJECT_NAME.') parent.' : '') . rcmail::JS_OBJECT_NAME,
	preg_replace('/^parent\./', '', $method),
	implode(',', $args)
	);
	}

	return $out;
	}


	/**
	* Make URLs starting with a slash point to skin directory
	*
	* @param string Input string
	* @param boolean True if URL should be resolved using the current skin path stack
	* @return string
	*/
	public function abs_url($str, $search_path = false)
	{
	if ($str[0] == '/') {
	if ($search_path && ($file_url = $this->get_skin_file($str, $skin_path)))
	return $file_url;

	return $this->base_path . $str;
	}
	else
	return $str;
	}


	/**
	* Show error page and terminate script execution
	*
	* @param int $code Error code
	* @param string $message Error message
	*/
	public function raise_error($code, $message)
	{
	global $__page_content, $ERROR_CODE, $ERROR_MESSAGE;

	$ERROR_CODE = $code;
	$ERROR_MESSAGE = $message;

	include RCUBE_INSTALL_PATH . 'program/steps/utils/error.inc';
	exit;
	}


	/*** Template parsing methods ***/

	/**
	* Replace all strings ($varname)
	* with the content of the according global variable.
	*/
	protected function parse_with_globals($input)
	{
	$GLOBALS['__version'] = html::quote(RCMAIL_VERSION);
	$GLOBALS['__comm_path'] = html::quote($this->app->comm_path);
	$GLOBALS['__skin_path'] = html::quote($this->base_path);

	return preg_replace_callback('/\$(__[a-z0-9_\-]+)/',
	array($this, 'globals_callback'), $input);
	}


	/**
	* Callback funtion for preg_replace_callback() in parse_with_globals()
	*/
	protected function globals_callback($matches)
	{
	return $GLOBALS[$matches[1]];
	}


	/**
	* Correct absolute paths in images and other tags
	* add timestamp to .js and .css filename
	*/
	protected function fix_paths($output)
	{
	return preg_replace_callback(
	'!(src\|href\|background)=(["\']?)([a-z0-9/_.-]+)(["\'\s>])!i',
	array($this, 'file_callback'), $output);
	}


	/**
	* Callback function for preg_replace_callback in write()
	*
	* @return string Parsed string
	*/
	protected function file_callback($matches)
	{
	$file = $matches[3];

	// correct absolute paths
	if ($file[0] == '/') {
	$file = $this->base_path . $file;
	}

	// add file modification timestamp
	if (preg_match('/\.(js\|css)$/', $file)) {
	if ($fs = @filemtime($file)) {
	$file .= '?s=' . $fs;
	}
	}

	return $matches[1] . '=' . $matches[2] . $file . $matches[4];
	}


	/**
	* Public wrapper to dipp into template parsing.
	*
	* @param string $input
	* @return string
	* @uses rcube_output_html::parse_xml()
	* @since 0.1-rc1
	*/
	public function just_parse($input)
	{
	return $this->parse_xml($input);
	}


	/**
	* Parse for conditional tags
	*
	* @param string $input
	* @return string
	*/
	protected function parse_conditions($input)
	{
	$matches = preg_split('/<roundcube:(if\|elseif\|else\|endif)\s+([^>]+)>\n?/is', $input, 2, PREG_SPLIT_DELIM_CAPTURE);
	if ($matches && count($matches) == 4) {
	if (preg_match('/^(else\|endif)$/i', $matches[1])) {
	return $matches[0] . $this->parse_conditions($matches[3]);
	}
	$attrib = html::parse_attrib_string($matches[2]);
	if (isset($attrib['condition'])) {
	$condmet = $this->check_condition($attrib['condition']);
	$submatches = preg_split('/<roundcube:(elseif\|else\|endif)\s+([^>]+)>\n?/is', $matches[3], 2, PREG_SPLIT_DELIM_CAPTURE);
	if ($condmet) {
	$result = $submatches[0];
	$result.= ($submatches[1] != 'endif' ? preg_replace('/.*<roundcube:endif\s+[^>]+>\n?/Uis', '', $submatches[3], 1) : $submatches[3]);
	}
	else {
	$result = "<roundcube:$submatches[1] $submatches[2]>" . $submatches[3];
	}
	return $matches[0] . $this->parse_conditions($result);
	}
	rcube::raise_error(array(
	'code' => 500,
	'type' => 'php',
	'line' => __LINE__,
	'file' => __FILE__,
	'message' => "Unable to parse conditional tag " . $matches[2]
	), true, false);
	}
	return $input;
	}


	/**
	* Determines if a given condition is met
	*
	* @todo Get rid off eval() once I understand what this does.
	* @todo Extend this to allow real conditions, not just "set"
	* @param string Condition statement
	* @return boolean True if condition is met, False if not
	*/
	protected function check_condition($condition)
	{
	return eval("return (".$this->parse_expression($condition).");");
	}


	/**
	* Inserts hidden field with CSRF-prevention-token into POST forms
	*/
	protected function alter_form_tag($matches)
	{
	$out = $matches[0];
	$attrib = html::parse_attrib_string($matches[1]);

	if (strtolower($attrib['method']) == 'post') {
	$hidden = new html_hiddenfield(array('name' => '_token', 'value' => $this->app->get_request_token()));
	$out .= "\n" . $hidden->show();
	}

	return $out;
	}


	/**
	* Parses expression and replaces variables
	*
	* @param string Expression statement
	* @return string Expression value
	*/
	protected function parse_expression($expression)
	{
	return preg_replace(
	array(
	'/session:([a-z0-9_]+)/i',
	'/config:([a-z0-9_]+)(:([a-z0-9_]+))?/i',
	'/env:([a-z0-9_]+)/i',
	'/request:([a-z0-9_]+)/i',
	'/cookie:([a-z0-9_]+)/i',
	'/browser:([a-z0-9_]+)/i',
	'/template:name/i',
	),
	array(
	"\$_SESSION['\\1']",
	"\$this->app->config->get('\\1',rcube_utils::get_boolean('\\3'))",
	"\$this->env['\\1']",
	"rcube_utils::get_input_value('\\1', rcube_utils::INPUT_GPC)",
	"\$_COOKIE['\\1']",
	"\$this->browser->{'\\1'}",
	$this->template_name,
	),
	$expression);
	}


	/**
	* Search for special tags in input and replace them
	* with the appropriate content
	*
	* @param string Input string to parse
	* @return string Altered input string
	* @todo Use DOM-parser to traverse template HTML
	* @todo Maybe a cache.
	*/
	protected function parse_xml($input)
	{
	return preg_replace_callback('/<roundcube:([-_a-z]+)\s+((?:[^>]\|\\\\>)+)(?<!\\\\)>/Ui', array($this, 'xml_command'), $input);
	}


	/**
	* Callback function for parsing an xml command tag
	* and turn it into real html content
	*
	* @param array Matches array of preg_replace_callback
	* @return string Tag/Object content
	*/
	protected function xml_command($matches)
	{
	$command = strtolower($matches[1]);
	$attrib = html::parse_attrib_string($matches[2]);

	// empty output if required condition is not met
	if (!empty($attrib['condition']) && !$this->check_condition($attrib['condition'])) {
	return '';
	}

	// execute command
	switch ($command) {
	// return a button
	case 'button':
	if ($attrib['name'] \|\| $attrib['command']) {
	return $this->button($attrib);
	}
	break;

	// frame
	case 'frame':
	return $this->frame($attrib);
	break;

	// show a label
	case 'label':
	if ($attrib['expression'])
	$attrib['name'] = eval("return " . $this->parse_expression($attrib['expression']) .";");

	if ($attrib['name'] \|\| $attrib['command']) {
	// @FIXME: 'noshow' is useless, remove?
	if ($attrib['noshow']) {
	return '';
	}

	$vars = $attrib + array('product' => $this->config->get('product_name'));
	unset($vars['name'], $vars['command']);

	$label = $this->app->gettext($attrib + array('vars' => $vars));
	$quoting = !empty($attrib['quoting']) ? strtolower($attrib['quoting']) : (rcube_utils::get_boolean((string)$attrib['html']) ? 'no' : '');

	switch ($quoting) {
	case 'no':
	case 'raw':
	break;
	case 'javascript':
	case 'js':
	$label = rcmail::JQ($label);
	break;
	default:
	$label = html::quote($label);
	break;
	}

	return $label;
	}
	break;

	// include a file
	case 'include':
	$old_base_path = $this->base_path;
	if ($path = $this->get_skin_file($attrib['file'], $skin_path, $attrib['skinpath'])) {
	$this->base_path = preg_replace('!plugins/\w+/!', '', $skin_path); // set base_path to core skin directory (not plugin's skin)
	$path = realpath($path);
	}

	if (is_readable($path)) {
	if ($this->config->get('skin_include_php')) {
	$incl = $this->include_php($path);
	}
	else {
	$incl = file_get_contents($path);
	}
	$incl = $this->parse_conditions($incl);
	$incl = $this->parse_xml($incl);
	$incl = $this->fix_paths($incl);
	$this->base_path = $old_base_path;
	return $incl;
	}
	break;

	case 'plugin.include':
	$hook = $this->app->plugins->exec_hook("template_plugin_include", $attrib);
	return $hook['content'];

	// define a container block
	case 'container':
	if ($attrib['name'] && $attrib['id']) {
	$this->command('gui_container', $attrib['name'], $attrib['id']);
	// let plugins insert some content here
	$hook = $this->app->plugins->exec_hook("template_container", $attrib);
	return $hook['content'];
	}
	break;

	// return code for a specific application object
	case 'object':
	$object = strtolower($attrib['name']);
	$content = '';

	// we are calling a class/method
	if (($handler = $this->object_handlers[$object]) && is_array($handler)) {
	if ((is_object($handler[0]) && method_exists($handler[0], $handler[1])) \|\|
	(is_string($handler[0]) && class_exists($handler[0])))
	$content = call_user_func($handler, $attrib);
	}
	// execute object handler function
	else if (function_exists($handler)) {
	$content = call_user_func($handler, $attrib);
	}
	else if ($object == 'doctype') {
	$content = html::doctype($attrib['value']);
	}
	else if ($object == 'logo') {
	$attrib += array('alt' => $this->xml_command(array('', 'object', 'name="productname"')));
	if ($logo = $this->config->get('skin_logo'))
	$attrib['src'] = $logo;
	$content = html::img($attrib);
	}
	else if ($object == 'productname') {
	$name = $this->config->get('product_name', 'Roundcube Webmail');
	$content = html::quote($name);
	}
	else if ($object == 'version') {
	$ver = (string)RCMAIL_VERSION;
	if (is_file(RCUBE_INSTALL_PATH . '.svn/entries')) {
	if (preg_match('/Revision:\s(\d+)/', @shell_exec('svn info'), $regs))
	$ver .= ' [SVN r'.$regs[1].']';
	}
	else if (is_file(RCUBE_INSTALL_PATH . '.git/index')) {
	if (preg_match('/Date:\s+([^\n]+)/', @shell_exec('git log -1'), $regs)) {
	if ($date = date('Ymd.Hi', strtotime($regs[1]))) {
	$ver .= ' [GIT '.$date.']';
	}
	}
	}
	$content = html::quote($ver);
	}
	else if ($object == 'steptitle') {
	$content = html::quote($this->get_pagetitle());
	}
	else if ($object == 'pagetitle') {
	if ($this->config->get('devel_mode') && !empty($_SESSION['username']))
	$title = $_SESSION['username'].' :: ';
	else if ($prod_name = $this->config->get('product_name'))
	$title = $prod_name . ' :: ';
	else
	$title = '';
	$title .= $this->get_pagetitle();
	$content = html::quote($title);
	}

	// exec plugin hooks for this template object
	$hook = $this->app->plugins->exec_hook("template_object_$object", $attrib + array('content' => $content));
	return $hook['content'];

	// return code for a specified eval expression
	case 'exp':
	$value = $this->parse_expression($attrib['expression']);
	return eval("return html::quote($value);");

	// return variable
	case 'var':
	$var = explode(':', $attrib['name']);
	$name = $var[1];
	$value = '';

	switch ($var[0]) {
	case 'env':
	$value = $this->env[$name];
	break;
	case 'config':
	$value = $this->config->get($name);
	if (is_array($value) && $value[$_SESSION['storage_host']]) {
	$value = $value[$_SESSION['storage_host']];
	}
	break;
	case 'request':
	$value = rcube_utils::get_input_value($name, rcube_utils::INPUT_GPC);
	break;
	case 'session':
	$value = $_SESSION[$name];
	break;
	case 'cookie':
	$value = htmlspecialchars($_COOKIE[$name]);
	break;
	case 'browser':
	$value = $this->browser->{$name};
	break;
	}

	if (is_array($value)) {
	$value = implode(', ', $value);
	}

	return html::quote($value);
	break;
	}
	return '';
	}


	/**
	* Include a specific file and return it's contents
	*
	* @param string File path
	* @return string Contents of the processed file
	*/
	protected function include_php($file)
	{
	ob_start();
	include $file;
	$out = ob_get_contents();
	ob_end_clean();

	return $out;
	}


	/**
	* Create and register a button
	*
	* @param array Named button attributes
	* @return string HTML button
	* @todo Remove all inline JS calls and use jQuery instead.
	* @todo Remove all sprintf()'s - they are pretty, but also slow.
	*/
	public function button($attrib)
	{
	static $s_button_count = 100;

	// these commands can be called directly via url
	$a_static_commands = array('compose', 'list', 'preferences', 'folders', 'identities');

	if (!($attrib['command'] \|\| $attrib['name'])) {
	return '';
	}

	// try to find out the button type
	if ($attrib['type']) {
	$attrib['type'] = strtolower($attrib['type']);
	}
	else {
	$attrib['type'] = ($attrib['image'] \|\| $attrib['imagepas'] \|\| $attrib['imageact']) ? 'image' : 'link';
	}

	$command = $attrib['command'];

	if ($attrib['task'])
	$command = $attrib['task'] . '.' . $command;

	if (!$attrib['image']) {
	$attrib['image'] = $attrib['imagepas'] ? $attrib['imagepas'] : $attrib['imageact'];
	}

	if (!$attrib['id']) {
	$attrib['id'] = sprintf('rcmbtn%d', $s_button_count++);
	}
	// get localized text for labels and titles
	if ($attrib['title']) {
	$attrib['title'] = html::quote($this->app->gettext($attrib['title'], $attrib['domain']));
	}
	if ($attrib['label']) {
	$attrib['label'] = html::quote($this->app->gettext($attrib['label'], $attrib['domain']));
	}
	if ($attrib['alt']) {
	$attrib['alt'] = html::quote($this->app->gettext($attrib['alt'], $attrib['domain']));
	}

	// set title to alt attribute for IE browsers
	if ($this->browser->ie && !$attrib['title'] && $attrib['alt']) {
	$attrib['title'] = $attrib['alt'];
	}

	// add empty alt attribute for XHTML compatibility
	if (!isset($attrib['alt'])) {
	$attrib['alt'] = '';
	}

	// register button in the system
	if ($attrib['command']) {
	$this->add_script(sprintf(
	"%s.register_button('%s', '%s', '%s', '%s', '%s', '%s');",
	rcmail::JS_OBJECT_NAME,
	$command,
	$attrib['id'],
	$attrib['type'],
	$attrib['imageact'] ? $this->abs_url($attrib['imageact']) : $attrib['classact'],
	$attrib['imagesel'] ? $this->abs_url($attrib['imagesel']) : $attrib['classsel'],
	$attrib['imageover'] ? $this->abs_url($attrib['imageover']) : ''
	));

	// make valid href to specific buttons
	if (in_array($attrib['command'], rcmail::$main_tasks)) {
	$attrib['href'] = $this->app->url(array('task' => $attrib['command']));
	$attrib['onclick'] = sprintf("return %s.command('switch-task','%s',this,event)", rcmail::JS_OBJECT_NAME, $attrib['command']);
	}
	else if ($attrib['task'] && in_array($attrib['task'], rcmail::$main_tasks)) {
	$attrib['href'] = $this->app->url(array('action' => $attrib['command'], 'task' => $attrib['task']));
	}
	else if (in_array($attrib['command'], $a_static_commands)) {
	$attrib['href'] = $this->app->url(array('action' => $attrib['command']));
	}
	else if (($attrib['command'] == 'permaurl' \|\| $attrib['command'] == 'extwin') && !empty($this->env['permaurl'])) {
	$attrib['href'] = $this->env['permaurl'];
	}
	}

	// overwrite attributes
	if (!$attrib['href']) {
	$attrib['href'] = '#';
	}
	if ($attrib['task']) {
	if ($attrib['classact'])
	$attrib['class'] = $attrib['classact'];
	}
	else if ($command && !$attrib['onclick']) {
	$attrib['onclick'] = sprintf(
	"return %s.command('%s','%s',this,event)",
	rcmail::JS_OBJECT_NAME,
	$command,
	$attrib['prop']
	);
	}

	$out = '';

	// generate image tag
	if ($attrib['type'] == 'image') {
	$attrib_str = html::attrib_string(
	$attrib,
	array(
	'style', 'class', 'id', 'width', 'height', 'border', 'hspace',
	'vspace', 'align', 'alt', 'tabindex', 'title'
	)
	);
	$btn_content = sprintf('<img src="%s"%s />', $this->abs_url($attrib['image']), $attrib_str);
	if ($attrib['label']) {
	$btn_content .= ' '.$attrib['label'];
	}
	$link_attrib = array('href', 'onclick', 'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup', 'target');
	}
	else if ($attrib['type'] == 'link') {
	$btn_content = isset($attrib['content']) ? $attrib['content'] : ($attrib['label'] ? $attrib['label'] : $attrib['command']);
	$link_attrib = array('href', 'onclick', 'title', 'id', 'class', 'style', 'tabindex', 'target');
	if ($attrib['innerclass'])
	$btn_content = html::span($attrib['innerclass'], $btn_content);
	}
	else if ($attrib['type'] == 'input') {
	$attrib['type'] = 'button';

	if ($attrib['label']) {
	$attrib['value'] = $attrib['label'];
	}
	if ($attrib['command']) {
	$attrib['disabled'] = 'disabled';
	}

	$out = html::tag('input', $attrib, null, array('type', 'value', 'onclick', 'id', 'class', 'style', 'tabindex', 'disabled'));
	}

	// generate html code for button
	if ($btn_content) {
	$attrib_str = html::attrib_string($attrib, $link_attrib);
	$out = sprintf('<a%s>%s</a>', $attrib_str, $btn_content);
	}

	return $out;
	}


	/**
	* Link an external script file
	*
	* @param string File URL
	* @param string Target position [head\|foot]
	*/
	public function include_script($file, $position='head')
	{
	static $sa_files = array();

	if (!preg_match('\|^https?://\|i', $file) && $file[0] != '/') {
	$file = $this->scripts_path . $file;
	if ($fs = @filemtime($file)) {
	$file .= '?s=' . $fs;
	}
	}

	if (in_array($file, $sa_files)) {
	return;
	}

	$sa_files[] = $file;

	if (!is_array($this->script_files[$position])) {
	$this->script_files[$position] = array();
	}

	$this->script_files[$position][] = $file;
	}


	/**
	* Add inline javascript code
	*
	* @param string JS code snippet
	* @param string Target position [head\|head_top\|foot]
	*/
	public function add_script($script, $position='head')
	{
	if (!isset($this->scripts[$position])) {
	$this->scripts[$position] = "\n" . rtrim($script);
	}
	else {
	$this->scripts[$position] .= "\n" . rtrim($script);
	}
	}


	/**
	* Link an external css file
	*
	* @param string File URL
	*/
	public function include_css($file)
	{
	$this->css_files[] = $file;
	}


	/**
	* Add HTML code to the page header
	*
	* @param string $str HTML code
	*/
	public function add_header($str)
	{
	$this->header .= "\n" . $str;
	}


	/**
	* Add HTML code to the page footer
	* To be added right befor </body>
	*
	* @param string $str HTML code
	*/
	public function add_footer($str)
	{
	$this->footer .= "\n" . $str;
	}


	/**
	* Process template and write to stdOut
	*
	* @param string HTML template
	* @param string Base for absolute paths
	*/
	public function _write($templ = '', $base_path = '')
	{
	$output = empty($templ) ? $this->default_template : trim($templ);

	// set default page title
	if (empty($this->pagetitle)) {
	$this->pagetitle = 'Roundcube Mail';
	}

	// replace specialchars in content
	$page_title = html::quote($this->pagetitle);
	$page_header = '';
	$page_footer = '';

	// include meta tag with charset
	if (!empty($this->charset)) {
	if (!headers_sent()) {
	header('Content-Type: text/html; charset=' . $this->charset);
	}
	$page_header = '<meta http-equiv="content-type"';
	$page_header.= ' content="text/html; charset=';
	$page_header.= $this->charset . '" />'."\n";
	}

	// definition of the code to be placed in the document header and footer
	if (is_array($this->script_files['head'])) {
	foreach ($this->script_files['head'] as $file) {
	$page_header .= html::script($file);
	}
	}

	$head_script = $this->scripts['head_top'] . $this->scripts['head'];
	if (!empty($head_script)) {
	$page_header .= html::script(array(), $head_script);
	}

	if (!empty($this->header)) {
	$page_header .= $this->header;
	}

	// put docready commands into page footer
	if (!empty($this->scripts['docready'])) {
	$this->add_script('$(document).ready(function(){ ' . $this->scripts['docready'] . "\n});", 'foot');
	}

	if (is_array($this->script_files['foot'])) {
	foreach ($this->script_files['foot'] as $file) {
	$page_footer .= html::script($file);
	}
	}

	if (!empty($this->footer)) {
	$page_footer .= $this->footer . "\n";
	}

	if (!empty($this->scripts['foot'])) {
	$page_footer .= html::script(array(), $this->scripts['foot']);
	}

	// find page header
	if ($hpos = stripos($output, '</head>')) {
	$page_header .= "\n";
	}
	else {
	if (!is_numeric($hpos)) {
	$hpos = stripos($output, '<body');
	}
	if (!is_numeric($hpos) && ($hpos = stripos($output, '<html'))) {
	while ($output[$hpos] != '>') {
	$hpos++;
	}
	$hpos++;
	}
	$page_header = "<head>\n<title>$page_title</title>\n$page_header\n</head>\n";
	}

	// add page hader
	if ($hpos) {
	$output = substr_replace($output, $page_header, $hpos, 0);
	}
	else {
	$output = $page_header . $output;
	}

	// add page footer
	if (($fpos = strripos($output, '</body>')) \|\| ($fpos = strripos($output, '</html>'))) {
	$output = substr_replace($output, $page_footer."\n", $fpos, 0);
	}
	else {
	$output .= "\n".$page_footer;
	}

	// add css files in head, before scripts, for speed up with parallel downloads
	if (!empty($this->css_files) &&
	(($pos = stripos($output, '<script ')) \|\| ($pos = stripos($output, '</head>')))
	) {
	$css = '';
	foreach ($this->css_files as $file) {
	$css .= html::tag('link', array('rel' => 'stylesheet',
	'type' => 'text/css', 'href' => $file, 'nl' => true));
	}
	$output = substr_replace($output, $css, $pos, 0);
	}

	$output = $this->parse_with_globals($this->fix_paths($output));

	// trigger hook with final HTML content to be sent
	$hook = $this->app->plugins->exec_hook("send_page", array('content' => $output));
	if (!$hook['abort']) {
	- if ($this->charset != RCMAIL_CHARSET) {
	- echo rcube_charset::convert($hook['content'], RCMAIL_CHARSET, $this->charset);
	+ if ($this->charset != RCUBE_CHARSET) {
	+ echo rcube_charset::convert($hook['content'], RCUBE_CHARSET, $this->charset);
	}
	else {
	echo $hook['content'];
	}
	}
	}


	/**
	* Returns iframe object, registers some related env variables
	*
	* @param array $attrib HTML attributes
	* @param boolean $is_contentframe Register this iframe as the 'contentframe' gui object
	* @return string IFRAME element
	*/
	public function frame($attrib, $is_contentframe = false)
	{
	static $idcount = 0;

	if (!$attrib['id']) {
	$attrib['id'] = 'rcmframe' . ++$idcount;
	}

	$attrib['name'] = $attrib['id'];
	$attrib['src'] = $attrib['src'] ? $this->abs_url($attrib['src'], true) : 'program/resources/blank.gif';

	// register as 'contentframe' object
	if ($is_contentframe \|\| $attrib['contentframe']) {
	$this->set_env('contentframe', $attrib['contentframe'] ? $attrib['contentframe'] : $attrib['name']);
	$this->set_env('blankpage', $attrib['src']);
	}

	return html::iframe($attrib);
	}


	/* *********** common functions delivering gui objects ************ */


	/**
	* Create a form tag with the necessary hidden fields
	*
	* @param array Named tag parameters
	* @return string HTML code for the form
	*/
	public function form_tag($attrib, $content = null)
	{
	if ($this->framed \|\| !empty($_REQUEST['_framed'])) {
	$hiddenfield = new html_hiddenfield(array('name' => '_framed', 'value' => '1'));
	$hidden = $hiddenfield->show();
	}
	if ($this->env['extwin']) {
	$hiddenfield = new html_hiddenfield(array('name' => '_extwin', 'value' => '1'));
	$hidden = $hiddenfield->show();
	}

	if (!$content)
	$attrib['noclose'] = true;

	return html::tag('form',
	$attrib + array('action' => "./", 'method' => "get"),
	$hidden . $content,
	array('id','class','style','name','method','action','enctype','onsubmit'));
	}


	/**
	* Build a form tag with a unique request token
	*
	* @param array Named tag parameters including 'action' and 'task' values which will be put into hidden fields
	* @param string Form content
	* @return string HTML code for the form
	*/
	public function request_form($attrib, $content = '')
	{
	$hidden = new html_hiddenfield();
	if ($attrib['task']) {
	$hidden->add(array('name' => '_task', 'value' => $attrib['task']));
	}
	if ($attrib['action']) {
	$hidden->add(array('name' => '_action', 'value' => $attrib['action']));
	}

	unset($attrib['task'], $attrib['request']);
	$attrib['action'] = './';

	// we already have a <form> tag
	if ($attrib['form']) {
	if ($this->framed \|\| !empty($_REQUEST['_framed']))
	$hidden->add(array('name' => '_framed', 'value' => '1'));
	return $hidden->show() . $content;
	}
	else
	return $this->form_tag($attrib, $hidden->show() . $content);
	}


	/**
	* GUI object 'username'
	* Showing IMAP username of the current session
	*
	* @param array Named tag parameters (currently not used)
	* @return string HTML code for the gui object
	*/
	public function current_username($attrib)
	{
	static $username;

	// alread fetched
	if (!empty($username)) {
	return $username;
	}

	// Current username is an e-mail address
	if (strpos($_SESSION['username'], '@')) {
	$username = $_SESSION['username'];
	}
	// get e-mail address from default identity
	else if ($sql_arr = $this->app->user->get_identity()) {
	$username = $sql_arr['email'];
	}
	else {
	$username = $this->app->user->get_username();
	}

	return rcube_utils::idn_to_utf8($username);
	}


	/**
	* GUI object 'loginform'
	* Returns code for the webmail login form
	*
	* @param array Named parameters
	* @return string HTML code for the gui object
	*/
	protected function login_form($attrib)
	{
	$default_host = $this->config->get('default_host');
	$autocomplete = (int) $this->config->get('login_autocomplete');

	$_SESSION['temp'] = true;

	// save original url
	$url = rcube_utils::get_input_value('_url', rcube_utils::INPUT_POST);
	if (empty($url) && !preg_match('/_(task\|action)=logout/', $_SERVER['QUERY_STRING']))
	$url = $_SERVER['QUERY_STRING'];

	// Disable autocapitalization on iPad/iPhone (#1488609)
	$attrib['autocapitalize'] = 'off';

	// set atocomplete attribute
	$user_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
	$host_attrib = $autocomplete > 0 ? array() : array('autocomplete' => 'off');
	$pass_attrib = $autocomplete > 1 ? array() : array('autocomplete' => 'off');

	$input_task = new html_hiddenfield(array('name' => '_task', 'value' => 'login'));
	$input_action = new html_hiddenfield(array('name' => '_action', 'value' => 'login'));
	$input_tzone = new html_hiddenfield(array('name' => '_timezone', 'id' => 'rcmlogintz', 'value' => '_default_'));
	$input_url = new html_hiddenfield(array('name' => '_url', 'id' => 'rcmloginurl', 'value' => $url));
	$input_user = new html_inputfield(array('name' => '_user', 'id' => 'rcmloginuser')
	+ $attrib + $user_attrib);
	$input_pass = new html_passwordfield(array('name' => '_pass', 'id' => 'rcmloginpwd')
	+ $attrib + $pass_attrib);
	$input_host = null;

	if (is_array($default_host) && count($default_host) > 1) {
	$input_host = new html_select(array('name' => '_host', 'id' => 'rcmloginhost'));

	foreach ($default_host as $key => $value) {
	if (!is_array($value)) {
	$input_host->add($value, (is_numeric($key) ? $value : $key));
	}
	else {
	$input_host = null;
	break;
	}
	}
	}
	else if (is_array($default_host) && ($host = array_pop($default_host))) {
	$hide_host = true;
	$input_host = new html_hiddenfield(array(
	'name' => '_host', 'id' => 'rcmloginhost', 'value' => $host) + $attrib);
	}
	else if (empty($default_host)) {
	$input_host = new html_inputfield(array('name' => '_host', 'id' => 'rcmloginhost')
	+ $attrib + $host_attrib);
	}

	$form_name = !empty($attrib['form']) ? $attrib['form'] : 'form';
	$this->add_gui_object('loginform', $form_name);

	// create HTML table with two cols
	$table = new html_table(array('cols' => 2));

	$table->add('title', html::label('rcmloginuser', html::quote($this->app->gettext('username'))));
	$table->add('input', $input_user->show(rcube_utils::get_input_value('_user', rcube_utils::INPUT_GPC)));

	$table->add('title', html::label('rcmloginpwd', html::quote($this->app->gettext('password'))));
	$table->add('input', $input_pass->show());

	// add host selection row
	if (is_object($input_host) && !$hide_host) {
	$table->add('title', html::label('rcmloginhost', html::quote($this->app->gettext('server'))));
	$table->add('input', $input_host->show(rcube_utils::get_input_value('_host', rcube_utils::INPUT_GPC)));
	}

	$out = $input_task->show();
	$out .= $input_action->show();
	$out .= $input_tzone->show();
	$out .= $input_url->show();
	$out .= $table->show();

	if ($hide_host) {
	$out .= $input_host->show();
	}

	// surround html output with a form tag
	if (empty($attrib['form'])) {
	$out = $this->form_tag(array('name' => $form_name, 'method' => 'post'), $out);
	}

	// include script for timezone detection
	$this->include_script('jstz.min.js');

	return $out;
	}


	/**
	* GUI object 'preloader'
	* Loads javascript code for images preloading
	*
	* @param array Named parameters
	* @return void
	*/
	protected function preloader($attrib)
	{
	$images = preg_split('/[\s\t\n,]+/', $attrib['images'], -1, PREG_SPLIT_NO_EMPTY);
	$images = array_map(array($this, 'abs_url'), $images);

	if (empty($images) \|\| $this->app->task == 'logout')
	return;

	$this->add_script('var images = ' . self::json_serialize($images) .';
	for (var i=0; i<images.length; i++) {
	img = new Image();
	img.src = images[i];
	}', 'docready');
	}


	/**
	* GUI object 'searchform'
	* Returns code for search function
	*
	* @param array Named parameters
	* @return string HTML code for the gui object
	*/
	protected function search_form($attrib)
	{
	// add some labels to client
	$this->add_label('searching');

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

	if (empty($attrib['id'])) {
	$attrib['id'] = 'rcmqsearchbox';
	}
	if ($attrib['type'] == 'search' && !$this->browser->khtml) {
	unset($attrib['type'], $attrib['results']);
	}

	$input_q = new html_inputfield($attrib);
	$out = $input_q->show();

	$this->add_gui_object('qsearchbox', $attrib['id']);

	// add form tag around text field
	if (empty($attrib['form'])) {
	$out = $this->form_tag(array(
	'name' => "rcmqsearchform",
	'onsubmit' => rcmail::JS_OBJECT_NAME . ".command('search'); return false",
	'style' => "display:inline"),
	$out);
	}

	return $out;
	}


	/**
	* Builder for GUI object 'message'
	*
	* @param array Named tag parameters
	* @return string HTML code for the gui object
	*/
	protected function message_container($attrib)
	{
	if (isset($attrib['id']) === false) {
	$attrib['id'] = 'rcmMessageContainer';
	}

	$this->add_gui_object('message', $attrib['id']);

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


	/**
	* GUI object 'charsetselector'
	*
	* @param array Named parameters for the select tag
	* @return string HTML code for the gui object
	*/
	public function charset_selector($attrib)
	{
	// pass the following attributes to the form class
	$field_attrib = array('name' => '_charset');
	foreach ($attrib as $attr => $value) {
	if (in_array($attr, array('id', 'name', 'class', 'style', 'size', 'tabindex'))) {
	$field_attrib[$attr] = $value;
	}
	}

	$charsets = array(
	'UTF-8' => 'UTF-8 ('.$this->app->gettext('unicode').')',
	'US-ASCII' => 'ASCII ('.$this->app->gettext('english').')',
	'ISO-8859-1' => 'ISO-8859-1 ('.$this->app->gettext('westerneuropean').')',
	'ISO-8859-2' => 'ISO-8859-2 ('.$this->app->gettext('easterneuropean').')',
	'ISO-8859-4' => 'ISO-8859-4 ('.$this->app->gettext('baltic').')',
	'ISO-8859-5' => 'ISO-8859-5 ('.$this->app->gettext('cyrillic').')',
	'ISO-8859-6' => 'ISO-8859-6 ('.$this->app->gettext('arabic').')',
	'ISO-8859-7' => 'ISO-8859-7 ('.$this->app->gettext('greek').')',
	'ISO-8859-8' => 'ISO-8859-8 ('.$this->app->gettext('hebrew').')',
	'ISO-8859-9' => 'ISO-8859-9 ('.$this->app->gettext('turkish').')',
	'ISO-8859-10' => 'ISO-8859-10 ('.$this->app->gettext('nordic').')',
	'ISO-8859-11' => 'ISO-8859-11 ('.$this->app->gettext('thai').')',
	'ISO-8859-13' => 'ISO-8859-13 ('.$this->app->gettext('baltic').')',
	'ISO-8859-14' => 'ISO-8859-14 ('.$this->app->gettext('celtic').')',
	'ISO-8859-15' => 'ISO-8859-15 ('.$this->app->gettext('westerneuropean').')',
	'ISO-8859-16' => 'ISO-8859-16 ('.$this->app->gettext('southeasterneuropean').')',
	'WINDOWS-1250' => 'Windows-1250 ('.$this->app->gettext('easterneuropean').')',
	'WINDOWS-1251' => 'Windows-1251 ('.$this->app->gettext('cyrillic').')',
	'WINDOWS-1252' => 'Windows-1252 ('.$this->app->gettext('westerneuropean').')',
	'WINDOWS-1253' => 'Windows-1253 ('.$this->app->gettext('greek').')',
	'WINDOWS-1254' => 'Windows-1254 ('.$this->app->gettext('turkish').')',
	'WINDOWS-1255' => 'Windows-1255 ('.$this->app->gettext('hebrew').')',
	'WINDOWS-1256' => 'Windows-1256 ('.$this->app->gettext('arabic').')',
	'WINDOWS-1257' => 'Windows-1257 ('.$this->app->gettext('baltic').')',
	'WINDOWS-1258' => 'Windows-1258 ('.$this->app->gettext('vietnamese').')',
	'ISO-2022-JP' => 'ISO-2022-JP ('.$this->app->gettext('japanese').')',
	'ISO-2022-KR' => 'ISO-2022-KR ('.$this->app->gettext('korean').')',
	'ISO-2022-CN' => 'ISO-2022-CN ('.$this->app->gettext('chinese').')',
	'EUC-JP' => 'EUC-JP ('.$this->app->gettext('japanese').')',
	'EUC-KR' => 'EUC-KR ('.$this->app->gettext('korean').')',
	'EUC-CN' => 'EUC-CN ('.$this->app->gettext('chinese').')',
	'BIG5' => 'BIG5 ('.$this->app->gettext('chinese').')',
	'GB2312' => 'GB2312 ('.$this->app->gettext('chinese').')',
	);

	if (!empty($_POST['_charset'])) {
	$set = $_POST['_charset'];
	}
	else if (!empty($attrib['selected'])) {
	$set = $attrib['selected'];
	}
	else {
	$set = $this->get_charset();
	}

	$set = strtoupper($set);
	if (!isset($charsets[$set])) {
	$charsets[$set] = $set;
	}

	$select = new html_select($field_attrib);
	$select->add(array_values($charsets), array_keys($charsets));

	return $select->show($set);
	}

	/**
	* Include content from config/about.<LANG>.html if available
	*/
	protected function about_content($attrib)
	{
	$content = '';
	$filenames = array(
	'about.' . $_SESSION['language'] . '.html',
	'about.' . substr($_SESSION['language'], 0, 2) . '.html',
	'about.html',
	);
	foreach ($filenames as $file) {
	$fn = RCUBE_CONFIG_DIR . $file;
	if (is_readable($fn)) {
	$content = file_get_contents($fn);
	$content = $this->parse_conditions($content);
	$content = $this->parse_xml($content);
	break;
	}
	}

	return $content;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_spellchecker.php b/program/lib/Roundcube/rcube_spellchecker.php
	index 30d15d721..fce2cac75 100644
	--- a/program/lib/Roundcube/rcube_spellchecker.php
	+++ b/program/lib/Roundcube/rcube_spellchecker.php
	@@ -1,621 +1,621 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_spellchecker.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2011, Kolab Systems AG \|
	\| Copyright (C) 2008-2011, 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: \|
	\| Spellchecking using different backends \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Aleksander Machniak <machniak@kolabsys.com> \|
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Helper class for spellchecking with Googielspell and PSpell support.
	*
	* @package Framework
	* @subpackage Utils
	*/
	class rcube_spellchecker
	{
	private $matches = array();
	private $engine;
	private $lang;
	private $rc;
	private $error;
	private $separator = '/[\s\r\n\t\/\[\]{}<>\\"]+\|[:;?!,\.]([^\w]\|$)/';
	private $options = array();
	private $dict;
	private $have_dict;


	// default settings
	const GOOGLE_HOST = 'ssl://www.google.com';
	const GOOGLE_PORT = 443;
	const MAX_SUGGESTIONS = 10;


	/**
	* Constructor
	*
	* @param string $lang Language code
	*/
	function __construct($lang = 'en')
	{
	$this->rc = rcube::get_instance();
	$this->engine = $this->rc->config->get('spellcheck_engine', 'googie');
	$this->lang = $lang ? $lang : 'en';

	$this->options = array(
	'ignore_syms' => $this->rc->config->get('spellcheck_ignore_syms'),
	'ignore_nums' => $this->rc->config->get('spellcheck_ignore_nums'),
	'ignore_caps' => $this->rc->config->get('spellcheck_ignore_caps'),
	'dictionary' => $this->rc->config->get('spellcheck_dictionary'),
	);
	}


	/**
	* Set content and check spelling
	*
	* @param string $text Text content for spellchecking
	* @param bool $is_html Enables HTML-to-Text conversion
	*
	* @return bool True when no mispelling found, otherwise false
	*/
	function check($text, $is_html = false)
	{
	// convert to plain text
	if ($is_html) {
	$this->content = $this->html2text($text);
	}
	else {
	$this->content = $text;
	}

	if ($this->engine == 'pspell') {
	$this->matches = $this->_pspell_check($this->content);
	}
	else {
	$this->matches = $this->_googie_check($this->content);
	}

	return $this->found() == 0;
	}


	/**
	* Number of mispellings found (after check)
	*
	* @return int Number of mispellings
	*/
	function found()
	{
	return count($this->matches);
	}


	/**
	* Returns suggestions for the specified word
	*
	* @param string $word The word
	*
	* @return array Suggestions list
	*/
	function get_suggestions($word)
	{
	if ($this->engine == 'pspell') {
	return $this->_pspell_suggestions($word);
	}

	return $this->_googie_suggestions($word);
	}


	/**
	* Returns misspelled words
	*
	* @param string $text The content for spellchecking. If empty content
	* used for check() method will be used.
	*
	* @return array List of misspelled words
	*/
	function get_words($text = null, $is_html=false)
	{
	if ($this->engine == 'pspell') {
	return $this->_pspell_words($text, $is_html);
	}

	return $this->_googie_words($text, $is_html);
	}


	/**
	* Returns checking result in XML (Googiespell) format
	*
	* @return string XML content
	*/
	function get_xml()
	{
	// send output
	- $out = '<?xml version="1.0" encoding="'.RCMAIL_CHARSET.'"?><spellresult charschecked="'.mb_strlen($this->content).'">';
	+ $out = '<?xml version="1.0" encoding="'.RCUBE_CHARSET.'"?><spellresult charschecked="'.mb_strlen($this->content).'">';

	foreach ($this->matches as $item) {
	$out .= '<c o="'.$item[1].'" l="'.$item[2].'">';
	$out .= is_array($item[4]) ? implode("\t", $item[4]) : $item[4];
	$out .= '</c>';
	}

	$out .= '</spellresult>';

	return $out;
	}


	/**
	* Returns checking result (misspelled words with suggestions)
	*
	* @return array Spellchecking result. An array indexed by word.
	*/
	function get()
	{
	$result = array();

	foreach ($this->matches as $item) {
	if ($this->engine == 'pspell') {
	$word = $item[0];
	}
	else {
	- $word = mb_substr($this->content, $item[1], $item[2], RCMAIL_CHARSET);
	+ $word = mb_substr($this->content, $item[1], $item[2], RCUBE_CHARSET);
	}
	$result[$word] = is_array($item[4]) ? implode("\t", $item[4]) : $item[4];
	}

	return $result;
	}


	/**
	* Returns error message
	*
	* @return string Error message
	*/
	function error()
	{
	return $this->error;
	}


	/**
	* Checks the text using pspell
	*
	* @param string $text Text content for spellchecking
	*/
	private function _pspell_check($text)
	{
	// init spellchecker
	$this->_pspell_init();

	if (!$this->plink) {
	return array();
	}

	// tokenize
	$text = preg_split($this->separator, $text, NULL, PREG_SPLIT_NO_EMPTY \| PREG_SPLIT_OFFSET_CAPTURE);

	$diff = 0;
	$matches = array();

	foreach ($text as $w) {
	$word = trim($w[0]);
	$pos = $w[1] - $diff;
	$len = mb_strlen($word);

	// skip exceptions
	if ($this->is_exception($word)) {
	}
	else if (!pspell_check($this->plink, $word)) {
	$suggestions = pspell_suggest($this->plink, $word);

	if (sizeof($suggestions) > self::MAX_SUGGESTIONS) {
	$suggestions = array_slice($suggestions, 0, self::MAX_SUGGESTIONS);
	}

	$matches[] = array($word, $pos, $len, null, $suggestions);
	}

	$diff += (strlen($word) - $len);
	}

	return $matches;
	}


	/**
	* Returns the misspelled words
	*/
	private function _pspell_words($text = null, $is_html=false)
	{
	$result = array();

	if ($text) {
	// init spellchecker
	$this->_pspell_init();

	if (!$this->plink) {
	return array();
	}

	// With PSpell we don't need to get suggestions to return misspelled words
	if ($is_html) {
	$text = $this->html2text($text);
	}

	$text = preg_split($this->separator, $text, NULL, PREG_SPLIT_NO_EMPTY \| PREG_SPLIT_OFFSET_CAPTURE);

	foreach ($text as $w) {
	$word = trim($w[0]);

	// skip exceptions
	if ($this->is_exception($word)) {
	continue;
	}

	if (!pspell_check($this->plink, $word)) {
	$result[] = $word;
	}
	}

	return $result;
	}

	foreach ($this->matches as $m) {
	$result[] = $m[0];
	}

	return $result;
	}


	/**
	* Returns suggestions for misspelled word
	*/
	private function _pspell_suggestions($word)
	{
	// init spellchecker
	$this->_pspell_init();

	if (!$this->plink) {
	return array();
	}

	$suggestions = pspell_suggest($this->plink, $word);

	if (sizeof($suggestions) > self::MAX_SUGGESTIONS)
	$suggestions = array_slice($suggestions, 0, self::MAX_SUGGESTIONS);

	return is_array($suggestions) ? $suggestions : array();
	}


	/**
	* Initializes PSpell dictionary
	*/
	private function _pspell_init()
	{
	if (!$this->plink) {
	if (!extension_loaded('pspell')) {
	$this->error = "Pspell extension not available";
	rcube::raise_error(array(
	'code' => 500, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => $this->error), true, false);

	return;
	}

	- $this->plink = pspell_new($this->lang, null, null, RCMAIL_CHARSET, PSPELL_FAST);
	+ $this->plink = pspell_new($this->lang, null, null, RCUBE_CHARSET, PSPELL_FAST);
	}

	if (!$this->plink) {
	$this->error = "Unable to load Pspell engine for selected language";
	}
	}


	private function _googie_check($text)
	{
	// spell check uri is configured
	$url = $this->rc->config->get('spellcheck_uri');

	if ($url) {
	$a_uri = parse_url($url);
	$ssl = ($a_uri['scheme'] == 'https' \|\| $a_uri['scheme'] == 'ssl');
	$port = $a_uri['port'] ? $a_uri['port'] : ($ssl ? 443 : 80);
	$host = ($ssl ? 'ssl://' : '') . $a_uri['host'];
	$path = $a_uri['path'] . ($a_uri['query'] ? '?'.$a_uri['query'] : '') . $this->lang;
	}
	else {
	$host = self::GOOGLE_HOST;
	$port = self::GOOGLE_PORT;
	$path = '/tbproxy/spell?lang=' . $this->lang;
	}

	// Google has some problem with spaces, use \n instead
	$gtext = str_replace(' ', "\n", $text);

	$gtext = '<?xml version="1.0" encoding="utf-8" ?>'
	.'<spellrequest textalreadyclipped="0" ignoredups="0" ignoredigits="1" ignoreallcaps="1">'
	.'<text>' . $gtext . '</text>'
	.'</spellrequest>';

	$store = '';
	if ($fp = fsockopen($host, $port, $errno, $errstr, 30)) {
	$out = "POST $path HTTP/1.0\r\n";
	$out .= "Host: " . str_replace('ssl://', '', $host) . "\r\n";
	$out .= "Content-Length: " . strlen($gtext) . "\r\n";
	$out .= "Content-Type: application/x-www-form-urlencoded\r\n";
	$out .= "Connection: Close\r\n\r\n";
	$out .= $gtext;
	fwrite($fp, $out);

	while (!feof($fp))
	$store .= fgets($fp, 128);
	fclose($fp);
	}

	if (!$store) {
	$this->error = "Empty result from spelling engine";
	}

	preg_match_all('/<c o="([^"])" l="([^"])" s="([^"])">([^<])<\/c>/', $store, $matches, PREG_SET_ORDER);

	// skip exceptions (if appropriate options are enabled)
	if (!empty($this->options['ignore_syms']) \|\| !empty($this->options['ignore_nums'])
	\|\| !empty($this->options['ignore_caps']) \|\| !empty($this->options['dictionary'])
	) {
	foreach ($matches as $idx => $m) {
	- $word = mb_substr($text, $m[1], $m[2], RCMAIL_CHARSET);
	+ $word = mb_substr($text, $m[1], $m[2], RCUBE_CHARSET);
	// skip exceptions
	if ($this->is_exception($word)) {
	unset($matches[$idx]);
	}
	}
	}

	return $matches;
	}


	private function _googie_words($text = null, $is_html=false)
	{
	if ($text) {
	if ($is_html) {
	$text = $this->html2text($text);
	}

	$matches = $this->_googie_check($text);
	}
	else {
	$matches = $this->matches;
	$text = $this->content;
	}

	$result = array();

	foreach ($matches as $m) {
	- $result[] = mb_substr($text, $m[1], $m[2], RCMAIL_CHARSET);
	+ $result[] = mb_substr($text, $m[1], $m[2], RCUBE_CHARSET);
	}

	return $result;
	}


	private function _googie_suggestions($word)
	{
	if ($word) {
	$matches = $this->_googie_check($word);
	}
	else {
	$matches = $this->matches;
	}

	if ($matches[0][4]) {
	$suggestions = explode("\t", $matches[0][4]);
	if (sizeof($suggestions) > self::MAX_SUGGESTIONS) {
	$suggestions = array_slice($suggestions, 0, MAX_SUGGESTIONS);
	}

	return $suggestions;
	}

	return array();
	}


	private function html2text($text)
	{
	$h2t = new html2text($text, false, true, 0);
	return $h2t->get_text();
	}


	/**
	* Check if the specified word is an exception accoring to
	* spellcheck options.
	*
	* @param string $word The word
	*
	* @return bool True if the word is an exception, False otherwise
	*/
	public function is_exception($word)
	{
	// Contain only symbols (e.g. "+9,0", "2:2")
	if (!$word \|\| preg_match('/^[0-9@#$%^&_+~*=:;?!,.-]+$/', $word))
	return true;

	// Contain symbols (e.g. "g@@gle"), all symbols excluding separators
	if (!empty($this->options['ignore_syms']) && preg_match('/[@#$%^&_+~*=-]/', $word))
	return true;

	// Contain numbers (e.g. "g00g13")
	if (!empty($this->options['ignore_nums']) && preg_match('/[0-9]/', $word))
	return true;

	// Blocked caps (e.g. "GOOGLE")
	if (!empty($this->options['ignore_caps']) && $word == mb_strtoupper($word))
	return true;

	// Use exceptions from dictionary
	if (!empty($this->options['dictionary'])) {
	$this->load_dict();

	// @TODO: should dictionary be case-insensitive?
	if (!empty($this->dict) && in_array($word, $this->dict))
	return true;
	}

	return false;
	}


	/**
	* Add a word to dictionary
	*
	* @param string $word The word to add
	*/
	public function add_word($word)
	{
	$this->load_dict();

	foreach (explode(' ', $word) as $word) {
	// sanity check
	if (strlen($word) < 512) {
	$this->dict[] = $word;
	$valid = true;
	}
	}

	if ($valid) {
	$this->dict = array_unique($this->dict);
	$this->update_dict();
	}
	}


	/**
	* Remove a word from dictionary
	*
	* @param string $word The word to remove
	*/
	public function remove_word($word)
	{
	$this->load_dict();

	if (($key = array_search($word, $this->dict)) !== false) {
	unset($this->dict[$key]);
	$this->update_dict();
	}
	}


	/**
	* Update dictionary row in DB
	*/
	private function update_dict()
	{
	if (strcasecmp($this->options['dictionary'], 'shared') != 0) {
	$userid = $this->rc->get_user_id();
	}

	$plugin = $this->rc->plugins->exec_hook('spell_dictionary_save', array(
	'userid' => $userid, 'language' => $this->lang, 'dictionary' => $this->dict));

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

	if ($this->have_dict) {
	if (!empty($this->dict)) {
	$this->rc->db->query(
	"UPDATE ".$this->rc->db->table_name('dictionary')
	." SET data = ?"
	." WHERE user_id " . ($plugin['userid'] ? "= ".$this->rc->db->quote($plugin['userid']) : "IS NULL")
	." AND " . $this->rc->db->quoteIdentifier('language') . " = ?",
	implode(' ', $plugin['dictionary']), $plugin['language']);
	}
	// don't store empty dict
	else {
	$this->rc->db->query(
	"DELETE FROM " . $this->rc->db->table_name('dictionary')
	." WHERE user_id " . ($plugin['userid'] ? "= ".$this->rc->db->quote($plugin['userid']) : "IS NULL")
	." AND " . $this->rc->db->quoteIdentifier('language') . " = ?",
	$plugin['language']);
	}
	}
	else if (!empty($this->dict)) {
	$this->rc->db->query(
	"INSERT INTO " .$this->rc->db->table_name('dictionary')
	." (user_id, " . $this->rc->db->quoteIdentifier('language') . ", data) VALUES (?, ?, ?)",
	$plugin['userid'], $plugin['language'], implode(' ', $plugin['dictionary']));
	}
	}


	/**
	* Get dictionary from DB
	*/
	private function load_dict()
	{
	if (is_array($this->dict)) {
	return $this->dict;
	}

	if (strcasecmp($this->options['dictionary'], 'shared') != 0) {
	$userid = $this->rc->get_user_id();
	}

	$plugin = $this->rc->plugins->exec_hook('spell_dictionary_get', array(
	'userid' => $userid, 'language' => $this->lang, 'dictionary' => array()));

	if (empty($plugin['abort'])) {
	$dict = array();
	$this->rc->db->query(
	"SELECT data FROM ".$this->rc->db->table_name('dictionary')
	." WHERE user_id ". ($plugin['userid'] ? "= ".$this->rc->db->quote($plugin['userid']) : "IS NULL")
	." AND " . $this->rc->db->quoteIdentifier('language') . " = ?",
	$plugin['language']);

	if ($sql_arr = $this->rc->db->fetch_assoc($sql_result)) {
	$this->have_dict = true;
	if (!empty($sql_arr['data'])) {
	$dict = explode(' ', $sql_arr['data']);
	}
	}

	$plugin['dictionary'] = array_merge((array)$plugin['dictionary'], $dict);
	}

	if (!empty($plugin['dictionary']) && is_array($plugin['dictionary'])) {
	$this->dict = $plugin['dictionary'];
	}
	else {
	$this->dict = array();
	}

	return $this->dict;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_vcard.php b/program/lib/Roundcube/rcube_vcard.php
	index 7b59e206d..45ee601e5 100644
	--- a/program/lib/Roundcube/rcube_vcard.php
	+++ b/program/lib/Roundcube/rcube_vcard.php
	@@ -1,793 +1,793 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_vcard.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2008-2012, 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: \|
	\| Logical representation of a vcard address record \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Logical representation of a vcard-based address record
	* Provides functions to parse and export vCard data format
	*
	* @package Framework
	* @subpackage Addressbook
	*/
	class rcube_vcard
	{
	private static $values_decoded = false;
	private $raw = array(
	'FN' => array(),
	'N' => array(array('','','','','')),
	);
	private static $fieldmap = array(
	'phone' => 'TEL',
	'birthday' => 'BDAY',
	'website' => 'URL',
	'notes' => 'NOTE',
	'email' => 'EMAIL',
	'address' => 'ADR',
	'jobtitle' => 'TITLE',
	'department' => 'X-DEPARTMENT',
	'gender' => 'X-GENDER',
	'maidenname' => 'X-MAIDENNAME',
	'anniversary' => 'X-ANNIVERSARY',
	'assistant' => 'X-ASSISTANT',
	'manager' => 'X-MANAGER',
	'spouse' => 'X-SPOUSE',
	'edit' => 'X-AB-EDIT',
	);
	private $typemap = array('IPHONE' => 'mobile', 'CELL' => 'mobile', 'WORK,FAX' => 'workfax');
	private $phonetypemap = array('HOME1' => 'HOME', 'BUSINESS1' => 'WORK', 'BUSINESS2' => 'WORK2', 'BUSINESSFAX' => 'WORK,FAX', 'MOBILE' => 'CELL');
	private $addresstypemap = array('BUSINESS' => 'WORK');
	private $immap = array('X-JABBER' => 'jabber', 'X-ICQ' => 'icq', 'X-MSN' => 'msn', 'X-AIM' => 'aim', 'X-YAHOO' => 'yahoo', 'X-SKYPE' => 'skype', 'X-SKYPE-USERNAME' => 'skype');

	public $business = false;
	public $displayname;
	public $surname;
	public $firstname;
	public $middlename;
	public $nickname;
	public $organization;
	public $email = array();

	public static $eol = "\r\n";

	/**
	* Constructor
	*/
	- public function __construct($vcard = null, $charset = RCMAIL_CHARSET, $detect = false, $fieldmap = array())
	+ public function __construct($vcard = null, $charset = RCUBE_CHARSET, $detect = false, $fieldmap = array())
	{
	if (!empty($fielmap))
	$this->extend_fieldmap($fieldmap);

	if (!empty($vcard))
	$this->load($vcard, $charset, $detect);
	}


	/**
	* Load record from (internal, unfolded) vcard 3.0 format
	*
	* @param string vCard string to parse
	* @param string Charset of string values
	* @param boolean True if loading a 'foreign' vcard and extra heuristics for charset detection is required
	*/
	- public function load($vcard, $charset = RCMAIL_CHARSET, $detect = false)
	+ public function load($vcard, $charset = RCUBE_CHARSET, $detect = false)
	{
	self::$values_decoded = false;
	$this->raw = self::vcard_decode($vcard);

	// resolve charset parameters
	if ($charset == null) {
	$this->raw = self::charset_convert($this->raw);
	}
	// vcard has encoded values and charset should be detected
	else if ($detect && self::$values_decoded &&
	- ($detected_charset = self::detect_encoding(self::vcard_encode($this->raw))) && $detected_charset != RCMAIL_CHARSET) {
	+ ($detected_charset = self::detect_encoding(self::vcard_encode($this->raw))) && $detected_charset != RCUBE_CHARSET) {
	$this->raw = self::charset_convert($this->raw, $detected_charset);
	}

	// consider FN empty if the same as the primary e-mail address
	if ($this->raw['FN'][0][0] == $this->raw['EMAIL'][0][0])
	$this->raw['FN'][0][0] = '';

	// find well-known address fields
	$this->displayname = $this->raw['FN'][0][0];
	$this->surname = $this->raw['N'][0][0];
	$this->firstname = $this->raw['N'][0][1];
	$this->middlename = $this->raw['N'][0][2];
	$this->nickname = $this->raw['NICKNAME'][0][0];
	$this->organization = $this->raw['ORG'][0][0];
	$this->business = ($this->raw['X-ABSHOWAS'][0][0] == 'COMPANY') \|\| (join('', (array)$this->raw['N'][0]) == '' && !empty($this->organization));

	foreach ((array)$this->raw['EMAIL'] as $i => $raw_email)
	$this->email[$i] = is_array($raw_email) ? $raw_email[0] : $raw_email;

	// make the pref e-mail address the first entry in $this->email
	$pref_index = $this->get_type_index('EMAIL', 'pref');
	if ($pref_index > 0) {
	$tmp = $this->email[0];
	$this->email[0] = $this->email[$pref_index];
	$this->email[$pref_index] = $tmp;
	}
	}


	/**
	* Return vCard data as associative array to be unsed in Roundcube address books
	*
	* @return array Hash array with key-value pairs
	*/
	public function get_assoc()
	{
	$out = array('name' => $this->displayname);
	$typemap = $this->typemap;

	// copy name fields to output array
	foreach (array('firstname','surname','middlename','nickname','organization') as $col) {
	if (strlen($this->$col))
	$out[$col] = $this->$col;
	}

	if ($this->raw['N'][0][3])
	$out['prefix'] = $this->raw['N'][0][3];
	if ($this->raw['N'][0][4])
	$out['suffix'] = $this->raw['N'][0][4];

	// convert from raw vcard data into associative data for Roundcube
	foreach (array_flip(self::$fieldmap) as $tag => $col) {
	foreach ((array)$this->raw[$tag] as $i => $raw) {
	if (is_array($raw)) {
	$k = -1;
	$key = $col;
	$subtype = '';

	if (!empty($raw['type'])) {
	$combined = join(',', self::array_filter((array)$raw['type'], 'internet,pref', true));
	$combined = strtoupper($combined);

	if ($typemap[$combined]) {
	$subtype = $typemap[$combined];
	}
	else if ($typemap[$raw['type'][++$k]]) {
	$subtype = $typemap[$raw['type'][$k]];
	}
	else {
	$subtype = strtolower($raw['type'][$k]);
	}

	while ($k < count($raw['type']) && ($subtype == 'internet' \|\| $subtype == 'pref'))
	$subtype = $typemap[$raw['type'][++$k]] ? $typemap[$raw['type'][$k]] : strtolower($raw['type'][$k]);
	}

	// read vcard 2.1 subtype
	if (!$subtype) {
	foreach ($raw as $k => $v) {
	if (!is_numeric($k) && $v === true && ($k = strtolower($k))
	&& !in_array($k, array('pref','internet','voice','base64'))
	) {
	$k_uc = strtoupper($k);
	$subtype = $typemap[$k_uc] ? $typemap[$k_uc] : $k;
	break;
	}
	}
	}

	// force subtype if none set
	if (!$subtype && preg_match('/^(email\|phone\|address\|website)/', $key))
	$subtype = 'other';

	if ($subtype)
	$key .= ':' . $subtype;

	// split ADR values into assoc array
	if ($tag == 'ADR') {
	list(,, $value['street'], $value['locality'], $value['region'], $value['zipcode'], $value['country']) = $raw;
	$out[$key][] = $value;
	}
	else
	$out[$key][] = $raw[0];
	}
	else {
	$out[$col][] = $raw;
	}
	}
	}

	// handle special IM fields as used by Apple
	foreach ($this->immap as $tag => $type) {
	foreach ((array)$this->raw[$tag] as $i => $raw) {
	$out['im:'.$type][] = $raw[0];
	}
	}

	// copy photo data
	if ($this->raw['PHOTO'])
	$out['photo'] = $this->raw['PHOTO'][0][0];

	return $out;
	}


	/**
	* Convert the data structure into a vcard 3.0 string
	*/
	public function export($folded = true)
	{
	$vcard = self::vcard_encode($this->raw);
	return $folded ? self::rfc2425_fold($vcard) : $vcard;
	}


	/**
	* Clear the given fields in the loaded vcard data
	*
	* @param array List of field names to be reset
	*/
	public function reset($fields = null)
	{
	if (!$fields)
	$fields = array_merge(array_values(self::$fieldmap), array_keys($this->immap), array('FN','N','ORG','NICKNAME','EMAIL','ADR','BDAY'));

	foreach ($fields as $f)
	unset($this->raw[$f]);

	if (!$this->raw['N'])
	$this->raw['N'] = array(array('','','','',''));
	if (!$this->raw['FN'])
	$this->raw['FN'] = array();

	$this->email = array();
	}


	/**
	* Setter for address record fields
	*
	* @param string Field name
	* @param string Field value
	* @param string Type/section name
	*/
	public function set($field, $value, $type = 'HOME')
	{
	$field = strtolower($field);
	$type_uc = strtoupper($type);

	switch ($field) {
	case 'name':
	case 'displayname':
	$this->raw['FN'][0][0] = $this->displayname = $value;
	break;

	case 'surname':
	$this->raw['N'][0][0] = $this->surname = $value;
	break;

	case 'firstname':
	$this->raw['N'][0][1] = $this->firstname = $value;
	break;

	case 'middlename':
	$this->raw['N'][0][2] = $this->middlename = $value;
	break;

	case 'prefix':
	$this->raw['N'][0][3] = $value;
	break;

	case 'suffix':
	$this->raw['N'][0][4] = $value;
	break;

	case 'nickname':
	$this->raw['NICKNAME'][0][0] = $this->nickname = $value;
	break;

	case 'organization':
	$this->raw['ORG'][0][0] = $this->organization = $value;
	break;

	case 'photo':
	if (strpos($value, 'http:') === 0) {
	// TODO: fetch file from URL and save it locally?
	$this->raw['PHOTO'][0] = array(0 => $value, 'url' => true);
	}
	else {
	$this->raw['PHOTO'][0] = array(0 => $value, 'base64' => (bool) preg_match('![^a-z0-9/=+-]!i', $value));
	}
	break;

	case 'email':
	$this->raw['EMAIL'][] = array(0 => $value, 'type' => array_filter(array('INTERNET', $type_uc)));
	$this->email[] = $value;
	break;

	case 'im':
	// save IM subtypes into extension fields
	$typemap = array_flip($this->immap);
	if ($field = $typemap[strtolower($type)])
	$this->raw[$field][] = array(0 => $value);
	break;

	case 'birthday':
	case 'anniversary':
	if (($val = rcube_utils::strtotime($value)) && ($fn = self::$fieldmap[$field]))
	$this->raw[$fn][] = array(0 => date('Y-m-d', $val), 'value' => array('date'));
	break;

	case 'address':
	if ($this->addresstypemap[$type_uc])
	$type = $this->addresstypemap[$type_uc];

	$value = $value[0] ? $value : array('', '', $value['street'], $value['locality'], $value['region'], $value['zipcode'], $value['country']);

	// fall through if not empty
	if (!strlen(join('', $value)))
	break;

	default:
	if ($field == 'phone' && $this->phonetypemap[$type_uc])
	$type = $this->phonetypemap[$type_uc];

	if (($tag = self::$fieldmap[$field]) && (is_array($value) \|\| strlen($value))) {
	$index = count($this->raw[$tag]);
	$this->raw[$tag][$index] = (array)$value;
	if ($type) {
	$typemap = array_flip($this->typemap);
	$this->raw[$tag][$index]['type'] = explode(',', ($typemap[$type_uc] ? $typemap[$type_uc] : $type));
	}
	}
	break;
	}
	}

	/**
	* Setter for individual vcard properties
	*
	* @param string VCard tag name
	* @param array Value-set of this vcard property
	* @param boolean Set to true if the value-set should be appended instead of replacing any existing value-set
	*/
	public function set_raw($tag, $value, $append = false)
	{
	$index = $append ? count($this->raw[$tag]) : 0;
	$this->raw[$tag][$index] = (array)$value;
	}


	/**
	* Find index with the '$type' attribute
	*
	* @param string Field name
	* @return int Field index having $type set
	*/
	private function get_type_index($field, $type = 'pref')
	{
	$result = 0;
	if ($this->raw[$field]) {
	foreach ($this->raw[$field] as $i => $data) {
	if (is_array($data['type']) && in_array_nocase('pref', $data['type']))
	$result = $i;
	}
	}

	return $result;
	}


	/**
	* Convert a whole vcard (array) to UTF-8.
	* If $force_charset is null, each member value that has a charset parameter will be converted
	*/
	private static function charset_convert($card, $force_charset = null)
	{
	foreach ($card as $key => $node) {
	foreach ($node as $i => $subnode) {
	if (is_array($subnode) && (($charset = $force_charset) \|\| ($subnode['charset'] && ($charset = $subnode['charset'][0])))) {
	foreach ($subnode as $j => $value) {
	if (is_numeric($j) && is_string($value))
	$card[$key][$i][$j] = rcube_charset::convert($value, $charset);
	}
	unset($card[$key][$i]['charset']);
	}
	}
	}

	return $card;
	}


	/**
	* Extends fieldmap definition
	*/
	public function extend_fieldmap($map)
	{
	if (is_array($map))
	self::$fieldmap = array_merge($map, self::$fieldmap);
	}


	/**
	* Factory method to import a vcard file
	*
	* @param string vCard file content
	* @return array List of rcube_vcard objects
	*/
	public static function import($data)
	{
	$out = array();

	// check if charsets are specified (usually vcard version < 3.0 but this is not reliable)
	if (preg_match('/charset=/i', substr($data, 0, 2048)))
	$charset = null;
	// detect charset and convert to utf-8
	- else if (($charset = self::detect_encoding($data)) && $charset != RCMAIL_CHARSET) {
	+ else if (($charset = self::detect_encoding($data)) && $charset != RCUBE_CHARSET) {
	$data = rcube_charset::convert($data, $charset);
	$data = preg_replace(array('/^[\xFE\xFF]{2}/', '/^\xEF\xBB\xBF/', '/^\x00+/'), '', $data); // also remove BOM
	- $charset = RCMAIL_CHARSET;
	+ $charset = RCUBE_CHARSET;
	}

	$vcard_block = '';
	$in_vcard_block = false;

	foreach (preg_split("/[\r\n]+/", $data) as $i => $line) {
	if ($in_vcard_block && !empty($line))
	$vcard_block .= $line . "\n";

	$line = trim($line);

	if (preg_match('/^END:VCARD$/i', $line)) {
	// parse vcard
	$obj = new rcube_vcard(self::cleanup($vcard_block), $charset, true, self::$fieldmap);
	if (!empty($obj->displayname) \|\| !empty($obj->email))
	$out[] = $obj;

	$in_vcard_block = false;
	}
	else if (preg_match('/^BEGIN:VCARD$/i', $line)) {
	$vcard_block = $line . "\n";
	$in_vcard_block = true;
	}
	}

	return $out;
	}


	/**
	* Normalize vcard data for better parsing
	*
	* @param string vCard block
	* @return string Cleaned vcard block
	*/
	private static function cleanup($vcard)
	{
	// Convert special types (like Skype) to normal type='skype' classes with this simple regex ;)
	$vcard = preg_replace(
	'/item(\d+)\.(TEL\|EMAIL\|URL)([^:]?):(.?)item\1.X-ABLabel:(?:_\$!<)?([\w-() ]*)(?:>!\$_)?./s',
	'\2;type=\5\3:\4',
	$vcard);

	// convert Apple X-ABRELATEDNAMES into X-* fields for better compatibility
	$vcard = preg_replace_callback(
	'/item(\d+)\.(X-ABRELATEDNAMES)([^:]?):(.?)item\1.X-ABLabel:(?:_\$!<)?([\w-() ]*)(?:>!\$_)?./s',
	array('self', 'x_abrelatednames_callback'),
	$vcard);

	// Remove cruft like item1.X-AB*, item1.ADR instead of ADR, and empty lines
	$vcard = preg_replace(array('/^item\d\.X-AB.$/m', '/^item\d*\./m', "/\n+/"), array('', '', "\n"), $vcard);

	// convert X-WAB-GENDER to X-GENDER
	if (preg_match('/X-WAB-GENDER:(\d)/', $vcard, $matches)) {
	$value = $matches[1] == '2' ? 'male' : 'female';
	$vcard = preg_replace('/X-WAB-GENDER:\d/', 'X-GENDER:' . $value, $vcard);
	}

	// if N doesn't have any semicolons, add some
	$vcard = preg_replace('/^(N:[^;\R]*)$/m', '\1;;;;', $vcard);

	return $vcard;
	}

	private static function x_abrelatednames_callback($matches)
	{
	return 'X-' . strtoupper($matches[5]) . $matches[3] . ':'. $matches[4];
	}

	private static function rfc2425_fold_callback($matches)
	{
	// chunk_split string and avoid lines breaking multibyte characters
	$c = 71;
	$out .= substr($matches[1], 0, $c);
	for ($n = $c; $c < strlen($matches[1]); $c++) {
	// break if length > 75 or mutlibyte character starts after position 71
	if ($n > 75 \|\| ($n > 71 && ord($matches[1][$c]) >> 6 == 3)) {
	$out .= "\r\n ";
	$n = 0;
	}
	$out .= $matches[1][$c];
	$n++;
	}

	return $out;
	}

	public static function rfc2425_fold($val)
	{
	return preg_replace_callback('/([^\n]{72,})/', array('self', 'rfc2425_fold_callback'), $val);
	}


	/**
	* Decodes a vcard block (vcard 3.0 format, unfolded)
	* into an array structure
	*
	* @param string vCard block to parse
	* @return array Raw data structure
	*/
	private static function vcard_decode($vcard)
	{
	// Perform RFC2425 line unfolding and split lines
	$vcard = preg_replace(array("/\r/", "/\n\s+/"), '', $vcard);
	$lines = explode("\n", $vcard);
	$data = array();

	for ($i=0; $i < count($lines); $i++) {
	if (!preg_match('/^([^:]+):(.+)$/', $lines[$i], $line))
	continue;

	if (preg_match('/^(BEGIN\|END)$/i', $line[1]))
	continue;

	// convert 2.1-style "EMAIL;internet;home:" to 3.0-style "EMAIL;TYPE=internet;TYPE=home:"
	if (($data['VERSION'][0] == "2.1") && preg_match('/^([^;]+);([^:]+)/', $line[1], $regs2) && !preg_match('/^TYPE=/i', $regs2[2])) {
	$line[1] = $regs2[1];
	foreach (explode(';', $regs2[2]) as $prop)
	$line[1] .= ';' . (strpos($prop, '=') ? $prop : 'TYPE='.$prop);
	}

	if (preg_match_all('/([^\\;]+);?/', $line[1], $regs2)) {
	$entry = array();
	$field = strtoupper($regs2[1][0]);
	$enc = null;

	foreach($regs2[1] as $attrid => $attr) {
	if ((list($key, $value) = explode('=', $attr)) && $value) {
	$value = trim($value);
	if ($key == 'ENCODING') {
	$value = strtoupper($value);
	// add next line(s) to value string if QP line end detected
	if ($value == 'QUOTED-PRINTABLE') {
	while (preg_match('/=$/', $lines[$i]))
	$line[2] .= "\n" . $lines[++$i];
	}
	$enc = $value;
	}
	else {
	$lc_key = strtolower($key);
	$entry[$lc_key] = array_merge((array)$entry[$lc_key], (array)self::vcard_unquote($value, ','));
	}
	}
	else if ($attrid > 0) {
	$entry[strtolower($key)] = true; // true means attr without =value
	}
	}

	// decode value
	if ($enc \|\| !empty($entry['base64'])) {
	// save encoding type (#1488432)
	if ($enc == 'B') {
	$entry['encoding'] = 'B';
	// should we use vCard 3.0 instead?
	// $entry['base64'] = true;
	}
	$line[2] = self::decode_value($line[2], $enc ? $enc : 'base64');
	}

	if ($enc != 'B' && empty($entry['base64'])) {
	$line[2] = self::vcard_unquote($line[2]);
	}

	$entry = array_merge($entry, (array) $line[2]);
	$data[$field][] = $entry;
	}
	}

	unset($data['VERSION']);
	return $data;
	}


	/**
	* Decode a given string with the encoding rule from ENCODING attributes
	*
	* @param string String to decode
	* @param string Encoding type (quoted-printable and base64 supported)
	* @return string Decoded 8bit value
	*/
	private static function decode_value($value, $encoding)
	{
	switch (strtolower($encoding)) {
	case 'quoted-printable':
	self::$values_decoded = true;
	return quoted_printable_decode($value);

	case 'base64':
	case 'b':
	self::$values_decoded = true;
	return base64_decode($value);

	default:
	return $value;
	}
	}


	/**
	* Encodes an entry for storage in our database (vcard 3.0 format, unfolded)
	*
	* @param array Raw data structure to encode
	* @return string vCard encoded string
	*/
	static function vcard_encode($data)
	{
	foreach((array)$data as $type => $entries) {
	/* valid N has 5 properties */
	while ($type == "N" && is_array($entries[0]) && count($entries[0]) < 5)
	$entries[0][] = "";

	// make sure FN is not empty (required by RFC2426)
	if ($type == "FN" && empty($entries))
	$entries[0] = $data['EMAIL'][0][0];

	foreach((array)$entries as $entry) {
	$attr = '';
	if (is_array($entry)) {
	$value = array();
	foreach($entry as $attrname => $attrvalues) {
	if (is_int($attrname)) {
	if (!empty($entry['base64']) \|\| $entry['encoding'] == 'B') {
	$attrvalues = base64_encode($attrvalues);
	}
	$value[] = $attrvalues;
	}
	else if (is_bool($attrvalues)) {
	if ($attrvalues) {
	$attr .= strtoupper(";$attrname"); // true means just tag, not tag=value, as in PHOTO;BASE64:...
	}
	}
	else {
	foreach((array)$attrvalues as $attrvalue)
	$attr .= strtoupper(";$attrname=") . self::vcard_quote($attrvalue, ',');
	}
	}
	}
	else {
	$value = $entry;
	}

	// skip empty entries
	if (self::is_empty($value))
	continue;

	$vcard .= self::vcard_quote($type) . $attr . ':' . self::vcard_quote($value) . self::$eol;
	}
	}

	return 'BEGIN:VCARD' . self::$eol . 'VERSION:3.0' . self::$eol . $vcard . 'END:VCARD';
	}


	/**
	* Join indexed data array to a vcard quoted string
	*
	* @param array Field data
	* @param string Separator
	* @return string Joined and quoted string
	*/
	private static function vcard_quote($s, $sep = ';')
	{
	if (is_array($s)) {
	foreach($s as $part) {
	$r[] = self::vcard_quote($part, $sep);
	}
	return(implode($sep, (array)$r));
	}
	else {
	return strtr($s, array('\\' => '\\\\', "\r" => '', "\n" => '\n', ',' => '\,', ';' => '\;'));
	}
	}


	/**
	* Split quoted string
	*
	* @param string vCard string to split
	* @param string Separator char/string
	* @return array List with splited values
	*/
	private static function vcard_unquote($s, $sep = ';')
	{
	// break string into parts separated by $sep, but leave escaped $sep alone
	if (count($parts = explode($sep, strtr($s, array("\\$sep" => "\007")))) > 1) {
	foreach($parts as $s) {
	$result[] = self::vcard_unquote(strtr($s, array("\007" => "\\$sep")), $sep);
	}
	return $result;
	}
	else {
	return strtr($s, array("\r" => '', '\\\\' => '\\', '\n' => "\n", '\N' => "\n", '\,' => ',', '\;' => ';', '\:' => ':'));
	}
	}


	/**
	* Check if vCard entry is empty: empty string or an array with
	* all entries empty.
	*
	* @param mixed $value Attribute value (string or array)
	*
	* @return bool True if the value is empty, False otherwise
	*/
	private static function is_empty($value)
	{
	foreach ((array)$value as $v) {
	if (((string)$v) !== '') {
	return false;
	}
	}

	return true;
	}

	/**
	* Extract array values by a filter
	*
	* @param array Array to filter
	* @param keys Array or comma separated list of values to keep
	* @param boolean Invert key selection: remove the listed values
	* @return array The filtered array
	*/
	private static function array_filter($arr, $values, $inverse = false)
	{
	if (!is_array($values))
	$values = explode(',', $values);

	$result = array();
	$keep = array_flip((array)$values);
	foreach ($arr as $key => $val)
	if ($inverse != isset($keep[strtolower($val)]))
	$result[$key] = $val;

	return $result;
	}

	/**
	* Returns UNICODE type based on BOM (Byte Order Mark)
	*
	* @param string Input string to test
	* @return string Detected encoding
	*/
	private static function detect_encoding($string)
	{
	$fallback = rcube::get_instance()->config->get('default_charset', 'ISO-8859-1'); // fallback to Latin-1

	return rcube_charset::detect($string, $fallback);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 3, 6:44 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 427119
Default Alt Text: (383 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions