githubFork/roundcubemail.git

			@@ -33,10 +33,8 @@
			{
			public $debug_level = 1;
			public $skip_deleted = false;
			public $root_dir = '';
			public $page_size = 10;
			public $list_page = 1;
			public $delimiter = NULL;
			public $threading = false;
			public $fetch_add_headers = '';
			public $get_all_headers = false;
			@@ -54,8 +52,9 @@
			* @var rcube_mdb2
			*/
			private $db;
			private $root_ns = '';
			private $mailbox = 'INBOX';
			private $delimiter = NULL;
			private $namespace = NULL;
			private $sort_field = '';
			private $sort_order = 'DESC';
			private $caching_enabled = false;
			@@ -101,6 +100,16 @@
			'RETURN-PATH',
			);

			const UNKNOWN = 0;
			const NOPERM = 1;
			const READONLY = 2;
			const TRYCREATE = 3;
			const INUSE = 4;
			const OVERQUOTA = 5;
			const ALREADYEXISTS = 6;
			const NONEXISTENT = 7;
			const CONTACTADMIN = 8;


			/**
			* Object constructor
			@@ -113,7 +122,7 @@
			$this->conn = new rcube_imap_generic();
			}



			/**
			* Connect to an IMAP server
			*
			@@ -156,32 +165,27 @@
			$this->port = $port;
			$this->ssl = $use_ssl;

			// print trace messages
			if ($this->conn->connected()) {
			if ($this->conn->message && ($this->debug_level & 8)) {
			console($this->conn->message);
			}

			// get server properties
			if (!empty($this->conn->rootdir))
			$this->set_rootdir($this->conn->rootdir);
			if (empty($this->delimiter))
			$this->get_hierarchy_delimiter();

			// get namespace and delimiter
			$this->set_env();
			return true;
			}
			// write error log
			else if ($this->conn->error) {
			if ($pass && $user)
			if ($pass && $user) {
			$message = sprintf("Login failed for %s from %s. %s",
			$user, rcmail_remote_ip(), $this->conn->error);

			raise_error(array('code' => 403, 'type' => 'imap',
			'file' => __FILE__, 'line' => __LINE__,
			'message' => $this->conn->error), true, false);
			'message' => $message), true, false);
			}
			}

			return false;
			}



			/**
			* Close IMAP connection
			* Usually done on script shutdown
			@@ -190,11 +194,11 @@
			*/
			function close()
			{
			$this->conn->close();
			$this->conn->closeConnection();
			$this->write_cache();
			}



			/**
			* Close IMAP connection and re-connect
			* This is used to avoid some strange socket errors when talking to Courier IMAP
			@@ -203,11 +207,11 @@
			*/
			function reconnect()
			{
			$this->close();
			$this->connect($this->host, $this->user, $this->pass, $this->port, $this->ssl);
			$this->conn->closeConnection();
			$connected = $this->connect($this->host, $this->user, $this->pass, $this->port, $this->ssl);

			// issue SELECT command to restore connection status
			if ($this->mailbox)
			if ($connected && strlen($this->mailbox))
			$this->conn->select($this->mailbox);
			}

			@@ -230,9 +234,53 @@
			*/
			function get_error_str()
			{
			return ($this->conn) ? $this->conn->error : '';
			return ($this->conn) ? $this->conn->error : null;
			}



			/**
			* Returns code of last command response
			*
			* @return int Response code
			*/
			function get_response_code()
			{
			if (!$this->conn)
			return self::UNKNOWN;

			switch ($this->conn->resultcode) {
			case 'NOPERM':
			return self::NOPERM;
			case 'READ-ONLY':
			return self::READONLY;
			case 'TRYCREATE':
			return self::TRYCREATE;
			case 'INUSE':
			return self::INUSE;
			case 'OVERQUOTA':
			return self::OVERQUOTA;
			case 'ALREADYEXISTS':
			return self::ALREADYEXISTS;
			case 'NONEXISTENT':
			return self::NONEXISTENT;
			case 'CONTACTADMIN':
			return self::CONTACTADMIN;
			default:
			return self::UNKNOWN;
			}
			}


			/**
			* Returns last command response
			*
			* @return string Response
			*/
			function get_response_str()
			{
			return ($this->conn) ? $this->conn->result : null;
			}


			/**
			* Set options to be used in rcube_imap_generic::connect()
			@@ -244,29 +292,7 @@
			$this->options = array_merge($this->options, (array)$opt);
			}


			/**
			* Set a root folder for the IMAP connection.
			*
			* Only folders within this root folder will be displayed
			* and all folder paths will be translated using this folder name
			*
			* @param string $root Root folder
			* @access public
			*/
			function set_rootdir($root)
			{
			if (preg_match('/[.\/]$/', $root)) //(substr($root, -1, 1)==='/')
			$root = substr($root, 0, -1);

			$this->root_dir = $root;
			$this->options['rootdir'] = $root;

			if (empty($this->delimiter))
			$this->get_hierarchy_delimiter();
			}


			/**
			* Set default message charset
			*
			@@ -280,7 +306,7 @@
			$this->default_charset = $cs;
			}



			/**
			* This list of folders will be listed above all other folders
			*
			@@ -298,7 +324,7 @@
			}
			}



			/**
			* Set internal mailbox reference.
			*
			@@ -320,7 +346,27 @@
			$this->_clear_messagecount($mailbox);
			}



			/**
			* Forces selection of a mailbox
			*
			* @param string $mailbox Mailbox/Folder name
			* @access public
			*/
			function select_mailbox($mailbox=null)
			{
			$mailbox = strlen($mailbox) ? $this->mod_mailbox($mailbox) : $this->mailbox;

			$selected = $this->conn->select($mailbox);

			if ($selected && $this->mailbox != $mailbox) {
			// clear messagecount cache for this mailbox
			$this->_clear_messagecount($mailbox);
			$this->mailbox = $mailbox;
			}
			}


			/**
			* Set internal list page
			*
			@@ -332,7 +378,7 @@
			$this->list_page = (int)$page;
			}



			/**
			* Set internal page size
			*
			@@ -344,7 +390,7 @@
			$this->page_size = (int)$size;
			}



			/**
			* Save a set of message ids for future message listing methods
			*
			@@ -371,7 +417,7 @@
			$this->search_sorted = $sorted;
			}



			/**
			* Return the saved search set as hash array
			* @return array Search set
			@@ -387,7 +433,7 @@
			);
			}



			/**
			* Returns the currently used mailbox name
			*
			@@ -399,7 +445,7 @@
			return $this->conn->connected() ? $this->mod_mailbox($this->mailbox, 'out') : '';
			}



			/**
			* Returns the IMAP server's capability
			*
			@@ -412,7 +458,7 @@
			return $this->conn->getCapability(strtoupper($cap));
			}



			/**
			* Sets threading flag to the best supported THREAD algorithm
			*
			@@ -436,7 +482,7 @@
			return $this->threading;
			}



			/**
			* Checks the PERMANENTFLAGS capability of the current mailbox
			* and returns true if the given flag is supported by the IMAP server
			@@ -449,10 +495,10 @@
			{
			$flag = strtoupper($flag);
			$imap_flag = $this->conn->flags[$flag];
			return (in_array_nocase($imap_flag, $this->conn->permanentflags));
			return (in_array_nocase($imap_flag, $this->conn->data['PERMANENTFLAGS']));
			}



			/**
			* Returns the delimiter that is used by the IMAP server for folder separation
			*
			@@ -461,16 +507,104 @@
			*/
			function get_hierarchy_delimiter()
			{
			if ($this->conn && empty($this->delimiter))
			$this->delimiter = $this->conn->getHierarchyDelimiter();

			if (empty($this->delimiter))
			$this->delimiter = '/';

			return $this->delimiter;
			}



			/**
			* Get namespace
			*
			* @return array Namespace data
			* @access public
			*/
			function get_namespace()
			{
			return $this->namespace;
			}


			/**
			* Sets delimiter and namespaces
			*
			* @access private
			*/
			private function set_env()
			{
			if ($this->delimiter !== null && $this->namespace !== null) {
			return;
			}

			if (isset($_SESSION['imap_namespace']) && isset($_SESSION['imap_delimiter'])) {
			$this->namespace = $_SESSION['imap_namespace'];
			$this->delimiter = $_SESSION['imap_delimiter'];
			return;
			}

			$config = rcmail::get_instance()->config;
			$imap_personal = $config->get('imap_ns_personal');
			$imap_other = $config->get('imap_ns_other');
			$imap_shared = $config->get('imap_ns_shared');
			$imap_delimiter = $config->get('imap_delimiter');

			if (!$this->conn)
			return;

			$ns = $this->conn->getNamespace();

			// Set namespaces (NAMESPACE supported)
			if (is_array($ns)) {
			$this->namespace = $ns;
			}
			else {
			$this->namespace = array(
			'personal' => NULL,
			'other' => NULL,
			'shared' => NULL,
			);
			}

			if ($imap_delimiter) {
			$this->delimiter = $imap_delimiter;
			}
			if (empty($this->delimiter)) {
			$this->delimiter = $this->namespace['personal'][0][1];
			}
			if (empty($this->delimiter)) {
			$this->delimiter = $this->conn->getHierarchyDelimiter();
			}
			if (empty($this->delimiter)) {
			$this->delimiter = '/';
			}

			// Overwrite namespaces
			if ($imap_personal !== null) {
			$this->namespace['personal'] = NULL;
			foreach ((array)$imap_personal as $dir) {
			$this->namespace['personal'][] = array($dir, $this->delimiter);
			}
			}
			if ($imap_other !== null) {
			$this->namespace['other'] = NULL;
			foreach ((array)$imap_other as $dir) {
			if ($dir) {
			$this->namespace['other'][] = array($dir, $this->delimiter);
			}
			}
			}
			if ($imap_shared !== null) {
			$this->namespace['shared'] = NULL;
			foreach ((array)$imap_shared as $dir) {
			if ($dir) {
			$this->namespace['shared'][] = array($dir, $this->delimiter);
			}
			}
			}

			$_SESSION['imap_namespace'] = $this->namespace;
			$_SESSION['imap_delimiter'] = $this->delimiter;
			}


			/**
			* Get message count for a specific mailbox
			*
			@@ -484,11 +618,11 @@
			*/
			function messagecount($mbox_name='', $mode='ALL', $force=false, $status=true)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			return $this->_messagecount($mailbox, $mode, $force, $status);
			}



			/**
			* Private method for getting nr of messages
			*
			@@ -505,7 +639,7 @@
			{
			$mode = strtoupper($mode);

			if (empty($mailbox))
			if (!strlen($mailbox))
			$mailbox = $this->mailbox;

			// count search set
			@@ -526,32 +660,52 @@
			$a_mailbox_cache[$mailbox] = array();

			if ($mode == 'THREADS') {
			$count = $this->_threadcount($mailbox, $msg_count);
			$res = $this->_threadcount($mailbox, $msg_count);
			$count = $res['count'];

			if ($status) {
			$this->set_folder_stats($mailbox, 'cnt', $msg_count);
			$this->set_folder_stats($mailbox, 'maxuid', $msg_count ? $this->_id2uid($msg_count, $mailbox) : 0);
			$this->set_folder_stats($mailbox, 'cnt', $res['msgcount']);
			$this->set_folder_stats($mailbox, 'maxuid', $res['maxuid'] ? $this->_id2uid($res['maxuid'], $mailbox) : 0);
			}
			}
			// RECENT count is fetched a bit different
			else if ($mode == 'RECENT') {
			$count = $this->conn->checkForRecent($mailbox);
			$count = $this->conn->countRecent($mailbox);
			}
			// use SEARCH for message counting
			else if ($this->skip_deleted) {
			$search_str = "ALL UNDELETED";
			$keys = array('COUNT');
			$need_uid = false;

			// get message count and store in cache
			if ($mode == 'UNSEEN')
			if ($mode == 'UNSEEN') {
			$search_str .= " UNSEEN";
			// get message count using SEARCH
			}
			else {
			if ($this->caching_enabled) {
			$keys[] = 'ALL';
			}
			if ($status) {
			$keys[] = 'MAX';
			$need_uid = true;
			}
			}

			// get message count using (E)SEARCH
			// not very performant but more precise (using UNDELETED)
			$index = $this->conn->search($mailbox, $search_str);
			$index = $this->conn->search($mailbox, $search_str, $need_uid, $keys);

			$count = is_array($index) ? count($index) : 0;
			$count = is_array($index) ? $index['COUNT'] : 0;

			if ($mode == 'ALL' && $status) {
			$this->set_folder_stats($mailbox, 'cnt', $count);
			$this->set_folder_stats($mailbox, 'maxuid', $index ? $this->_id2uid(max($index), $mailbox) : 0);
			if ($mode == 'ALL') {
			if ($need_uid && $this->caching_enabled) {
			// Save messages index for check_cache_status()
			$this->icache['all_undeleted_idx'] = $index['ALL'];
			}
			if ($status) {
			$this->set_folder_stats($mailbox, 'cnt', $count);
			$this->set_folder_stats($mailbox, 'maxuid', is_array($index) ? $index['MAX'] : 0);
			}
			}
			}
			else {
			@@ -579,24 +733,36 @@
			* Private method for getting nr of threads
			*
			* @param string $mailbox Folder name
			* @param int $msg_count Number of messages in the folder
			*
			* @returns array Array containing items: 'count' - threads count,
			* 'msgcount' = messages count, 'maxuid' = max. UID in the set
			* @access private
			* @see rcube_imap::messagecount()
			*/
			private function _threadcount($mailbox, &$msg_count)
			private function _threadcount($mailbox)
			{
			if (!empty($this->icache['threads']))
			return count($this->icache['threads']['tree']);
			$result = array();

			if (is_array($result = $this->_fetch_threads($mailbox)))
			$thread_tree = array_shift($result);
			if (!empty($this->icache['threads'])) {
			$dcount = count($this->icache['threads']['depth']);
			$result = array(
			'count' => count($this->icache['threads']['tree']),
			'msgcount' => $dcount,
			'maxuid' => $dcount ? max(array_keys($this->icache['threads']['depth'])) : 0,
			);
			}
			else if (is_array($result = $this->_fetch_threads($mailbox))) {
			$dcount = count($result[1]);
			$result = array(
			'count' => count($result[0]),
			'msgcount' => $dcount,
			'maxuid' => $dcount ? max(array_keys($result[1])) : 0,
			);
			}

			// list ($thread_tree, $msg_depth, $has_children) = $result;
			// $this->update_thread_cache($mailbox, $thread_tree, $msg_depth, $has_children);
			return count($thread_tree);
			return $result;
			}



			/**
			* Public method for listing headers
			* convert mailbox name with root dir first
			@@ -611,11 +777,11 @@
			*/
			function list_headers($mbox_name='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			return $this->_list_headers($mailbox, $page, $sort_field, $sort_order, false, $slice);
			}



			/**
			* Private method for listing message headers
			*
			@@ -745,7 +911,7 @@
			return array_values($a_msg_headers);
			}



			/**
			* Private method for listing message headers using threads
			*
			@@ -791,14 +957,14 @@
			{
			if (empty($this->icache['threads'])) {
			// get all threads
			list ($thread_tree, $msg_depth, $has_children) = $this->conn->thread(
			$mailbox, $this->threading, $this->skip_deleted ? 'UNDELETED' : '');
			$result = $this->conn->thread($mailbox, $this->threading,
			$this->skip_deleted ? 'UNDELETED' : '');

			// add to internal (fast) cache
			$this->icache['threads'] = array();
			$this->icache['threads']['tree'] = $thread_tree;
			$this->icache['threads']['depth'] = $msg_depth;
			$this->icache['threads']['has_children'] = $has_children;
			$this->icache['threads']['tree'] = is_array($result) ? $result[0] : array();
			$this->icache['threads']['depth'] = is_array($result) ? $result[1] : array();
			$this->icache['threads']['has_children'] = is_array($result) ? $result[2] : array();
			}

			return array(
			@@ -838,7 +1004,7 @@
			// flatten threads array
			// @TODO: fetch children only in expanded mode (?)
			$all_ids = array();
			foreach($msg_index as $root) {
			foreach ($msg_index as $root) {
			$all_ids[] = $root;
			if (!empty($thread_tree[$root]))
			$all_ids = array_merge($all_ids, array_keys_recursive($thread_tree[$root]));
			@@ -1150,7 +1316,7 @@

			$for_create[] = $headers->uid;
			}


			if ($for_remove)
			$this->remove_message_cache($cache_key, $for_remove);

			@@ -1176,7 +1342,7 @@
			*/
			function mailbox_status($mbox_name = null)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$old = $this->get_folder_stats($mailbox);

			// refresh message count -> will update
			@@ -1243,11 +1409,11 @@

			$this->_set_sort_order($sort_field, $sort_order);

			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$key = "{$mailbox}:{$this->sort_field}:{$this->sort_order}:{$this->search_string}.msgi";

			// we have a saved search result, get index from there
			if (!isset($this->cache[$key]) && $this->search_string
			if (!isset($this->icache[$key]) && $this->search_string
			&& !$this->search_threads && $mailbox == $this->mailbox) {
			// use message index sort as default sorting
			if (!$this->sort_field) {
			@@ -1257,9 +1423,9 @@
			sort($msgs);

			if ($this->sort_order == 'DESC')
			$this->cache[$key] = array_reverse($msgs);
			$this->icache[$key] = array_reverse($msgs);
			else
			$this->cache[$key] = $msgs;
			$this->icache[$key] = $msgs;
			}
			// sort with SORT command
			else if ($this->search_sorted) {
			@@ -1267,9 +1433,9 @@
			$this->search('', $this->search_string, $this->search_charset, $this->sort_field);

			if ($this->sort_order == 'DESC')
			$this->cache[$key] = array_reverse($this->search_set);
			$this->icache[$key] = array_reverse($this->search_set);
			else
			$this->cache[$key] = $this->search_set;
			$this->icache[$key] = $this->search_set;
			}
			else {
			$a_index = $this->conn->fetchHeaderIndex($mailbox,
			@@ -1281,17 +1447,17 @@
			else if ($this->sort_order=="DESC")
			arsort($a_index);

			$this->cache[$key] = array_keys($a_index);
			$this->icache[$key] = array_keys($a_index);
			}
			else {
			$this->cache[$key] = array();
			$this->icache[$key] = array();
			}
			}
			}

			// have stored it in RAM
			if (isset($this->cache[$key]))
			return $this->cache[$key];
			if (isset($this->icache[$key]))
			return $this->icache[$key];

			// check local cache
			$cache_key = $mailbox.'.msg';
			@@ -1315,7 +1481,7 @@
			if ($a_index !== false && $this->sort_order == 'DESC')
			$a_index = array_reverse($a_index);

			$this->cache[$key] = $a_index;
			$this->icache[$key] = $a_index;
			}
			// fetch complete message index
			else if ($this->get_capability('SORT') &&
			@@ -1325,7 +1491,7 @@
			if ($this->sort_order == 'DESC')
			$a_index = array_reverse($a_index);

			$this->cache[$key] = $a_index;
			$this->icache[$key] = $a_index;
			}
			else if ($a_index = $this->conn->fetchHeaderIndex(
			$mailbox, "1:*", $this->sort_field, $this->skip_deleted)) {
			@@ -1334,10 +1500,10 @@
			else if ($this->sort_order=="DESC")
			arsort($a_index);

			$this->cache[$key] = array_keys($a_index);
			$this->icache[$key] = array_keys($a_index);
			}

			return $this->cache[$key] !== false ? $this->cache[$key] : array();
			return $this->icache[$key] !== false ? $this->icache[$key] : array();
			}


			@@ -1353,20 +1519,20 @@
			{
			$this->_set_sort_order($sort_field, $sort_order);

			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$key = "{$mailbox}:{$this->sort_field}:{$this->sort_order}:{$this->search_string}.thi";

			// we have a saved search result, get index from there
			if (!isset($this->cache[$key]) && $this->search_string
			if (!isset($this->icache[$key]) && $this->search_string
			&& $this->search_threads && $mailbox == $this->mailbox) {
			// use message IDs for better performance
			$ids = array_keys_recursive($this->search_set['tree']);
			$this->cache[$key] = $this->_flatten_threads($mailbox, $this->search_set['tree'], $ids);
			$this->icache[$key] = $this->_flatten_threads($mailbox, $this->search_set['tree'], $ids);
			}

			// have stored it in RAM
			if (isset($this->cache[$key]))
			return $this->cache[$key];
			if (isset($this->icache[$key]))
			return $this->icache[$key];
			/*
			// check local cache
			$cache_key = $mailbox.'.msg';
			@@ -1381,9 +1547,9 @@
			// get all threads (default sort order)
			list ($thread_tree) = $this->_fetch_threads($mailbox);

			$this->cache[$key] = $this->_flatten_threads($mailbox, $thread_tree);
			$this->icache[$key] = $this->_flatten_threads($mailbox, $thread_tree);

			return $this->cache[$key];
			return $this->icache[$key];
			}


			@@ -1410,7 +1576,7 @@

			// flatten threads array
			$all_ids = array();
			foreach($msg_index as $root) {
			foreach ($msg_index as $root) {
			$all_ids[] = $root;
			if (!empty($thread_tree[$root])) {
			foreach (array_keys_recursive($thread_tree[$root]) as $val)
			@@ -1530,7 +1696,7 @@
			if (!$str)
			return false;

			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;

			$results = $this->_search_index($mailbox, $str, $charset, $sort_field);

			@@ -1579,7 +1745,7 @@

			return $a_messages;
			}


			if ($sort_field && $this->get_capability('SORT')) {
			$charset = $charset ? $charset : $this->default_charset;
			$a_messages = $this->conn->sort($mailbox, $sort_field, $criteria, false, $charset);
			@@ -1635,7 +1801,7 @@
			if (!$str)
			return false;

			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;

			return $this->conn->search($mailbox, $str, $ret_uid);
			}
			@@ -1812,7 +1978,7 @@
			*/
			function get_headers($id, $mbox_name=NULL, $is_uid=true, $bodystr=false)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$uid = $is_uid ? $id : $this->_id2uid($id, $mailbox);

			// get cached headers
			@@ -2263,20 +2429,21 @@

			// TODO: Add caching for message parts

			if (!$part) $part = 'TEXT';
			if (!$part) {
			$part = 'TEXT';
			}

			$body = $this->conn->handlePartBody($this->mailbox, $uid, true, $part,
			$o_part->encoding, $print, $fp);

			if ($fp \|\| $print)
			if ($fp \|\| $print) {
			return true;
			}

			// convert charset (if text or message part)
			if ($body && ($o_part->ctype_primary == 'text' \|\| $o_part->ctype_primary == 'message')) {
			// assume default if no charset specified
			if (empty($o_part->charset) \|\| strtolower($o_part->charset) == 'us-ascii')
			$o_part->charset = $this->default_charset;

			// convert charset (if text or message part) and part's charset is specified
			if ($body && $o_part->charset
			&& preg_match('/^(text\|message)$/', $o_part->ctype_primary)
			) {
			$body = rcube_charset_convert($body, $o_part->charset);
			}

			@@ -2341,11 +2508,11 @@
			* @param string $flag Flag to set: SEEN, UNDELETED, DELETED, RECENT, ANSWERED, DRAFT, MDNSENT
			* @param string $mbox_name Folder name
			* @param boolean $skip_cache True to skip message cache clean up
			* @return int Number of flagged messages, -1 on failure
			* @return boolean Operation status
			*/
			function set_flag($uids, $flag, $mbox_name=NULL, $skip_cache=false)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;

			$flag = strtoupper($flag);
			list($uids, $all_mode) = $this->_parse_uids($uids, $mailbox);
			@@ -2355,7 +2522,7 @@
			else
			$result = $this->conn->flag($mailbox, $uids, $flag);

			if ($result >= 0) {
			if ($result) {
			// reload message headers if cached
			if ($this->caching_enabled && !$skip_cache) {
			$cache_key = $mailbox.'.msg';
			@@ -2364,13 +2531,15 @@
			else
			$this->remove_message_cache($cache_key, explode(',', $uids));
			}
			// update counters
			if ($flag=='SEEN')
			$this->_set_messagecount($mailbox, 'UNSEEN', $result*(-1));
			else if ($flag=='UNSEEN')
			$this->_set_messagecount($mailbox, 'UNSEEN', $result);
			else if ($flag=='DELETED')
			$this->_set_messagecount($mailbox, 'ALL', $result*(-1));

			// clear cached counters
			if ($flag == 'SEEN' \|\| $flag == 'UNSEEN') {
			$this->_clear_messagecount($mailbox, 'SEEN');
			$this->_clear_messagecount($mailbox, 'UNSEEN');
			}
			else if ($flag == 'DELETED') {
			$this->_clear_messagecount($mailbox, 'DELETED');
			}
			}

			return $result;
			@@ -2407,7 +2576,7 @@
			$mailbox = $this->mod_mailbox($mbox_name);

			// make sure mailbox exists
			if ($this->mailbox_exists($mbox_name, true)) {
			if ($this->mailbox_exists($mbox_name)) {
			if ($is_file)
			$saved = $this->conn->appendFromFile($mailbox, $message, $headers);
			else
			@@ -2436,7 +2605,10 @@
			$fbox = $from_mbox;
			$tbox = $to_mbox;
			$to_mbox = $this->mod_mailbox($to_mbox);
			$from_mbox = $from_mbox ? $this->mod_mailbox($from_mbox) : $this->mailbox;
			$from_mbox = strlen($from_mbox) ? $this->mod_mailbox($from_mbox) : $this->mailbox;

			if ($to_mbox === $from_mbox)
			return false;

			list($uids, $all_mode) = $this->_parse_uids($uids, $from_mbox);

			@@ -2445,7 +2617,7 @@
			return false;

			// make sure mailbox exists
			if ($to_mbox != 'INBOX' && !$this->mailbox_exists($tbox, true)) {
			if ($to_mbox != 'INBOX' && !$this->mailbox_exists($tbox)) {
			if (in_array($tbox, $this->default_folders))
			$this->create_mailbox($tbox, true);
			else
			@@ -2460,8 +2632,7 @@
			}

			// move messages
			$move = $this->conn->move($uids, $from_mbox, $to_mbox);
			$moved = !($move === false \|\| $move < 0);
			$moved = $this->conn->move($uids, $from_mbox, $to_mbox);

			// send expunge command in order to have the moved message
			// really deleted from the source mailbox
			@@ -2522,11 +2693,12 @@
			list($uids, $all_mode) = $this->_parse_uids($uids, $from_mbox);

			// exit if no message uids are specified
			if (empty($uids))
			if (empty($uids)) {
			return false;
			}

			// make sure mailbox exists
			if ($to_mbox != 'INBOX' && !$this->mailbox_exists($tbox, true)) {
			if ($to_mbox != 'INBOX' && !$this->mailbox_exists($tbox)) {
			if (in_array($tbox, $this->default_folders))
			$this->create_mailbox($tbox, true);
			else
			@@ -2534,8 +2706,7 @@
			}

			// copy messages
			$copy = $this->conn->copy($uids, $from_mbox, $to_mbox);
			$copied = !($copy === false \|\| $copy < 0);
			$copied = $this->conn->copy($uids, $from_mbox, $to_mbox);

			if ($copied) {
			$this->_clear_messagecount($to_mbox);
			@@ -2554,7 +2725,7 @@
			*/
			function delete_message($uids, $mbox_name='')
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;

			list($uids, $all_mode) = $this->_parse_uids($uids, $mailbox);

			@@ -2607,14 +2778,12 @@
			*/
			function clear_mailbox($mbox_name=NULL)
			{
			$mailbox = !empty($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$msg_count = $this->_messagecount($mailbox, 'ALL');
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;

			if (!$msg_count) {
			return 0;
			// SELECT will set messages count for clearFolder()
			if ($this->conn->select($mailbox)) {
			$cleared = $this->conn->clearFolder($mailbox);
			}

			$cleared = $this->conn->clearFolder($mailbox);

			// make sure the message count cache is cleared as well
			if ($cleared) {
			@@ -2637,7 +2806,7 @@
			*/
			function expunge($mbox_name='', $clear_cache=true)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			return $this->_expunge($mailbox, $clear_cache);
			}

			@@ -2659,9 +2828,25 @@
			else
			$a_uids = NULL;

			$result = $this->conn->expunge($mailbox, $a_uids);
			// force mailbox selection and check if mailbox is writeable
			// to prevent a situation when CLOSE is executed on closed
			// or EXPUNGE on read-only mailbox
			$result = $this->conn->select($mailbox);
			if (!$result) {
			return false;
			}
			if (!$this->conn->data['READ-WRITE']) {
			$this->conn->setError(rcube_imap_generic::ERROR_READONLY, "Mailbox is read-only");
			return false;
			}

			if ($result>=0 && $clear_cache) {
			// CLOSE(+SELECT) should be faster than EXPUNGE
			if (empty($a_uids) \|\| $a_uids == '1:*')
			$result = $this->conn->close();
			else
			$result = $this->conn->expunge($mailbox, $a_uids);

			if ($result && $clear_cache) {
			$this->clear_message_cache($mailbox.'.msg');
			$this->_clear_messagecount($mailbox);
			}
			@@ -2722,7 +2907,7 @@
			*/
			function get_id($uid, $mbox_name=NULL)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			return $this->_uid2id($uid, $mailbox);
			}

			@@ -2734,9 +2919,9 @@
			* @param string $mbox_name Mailbox name
			* @return int Message UID
			*/
			function get_uid($id,$mbox_name=NULL)
			function get_uid($id, $mbox_name=NULL)
			{
			$mailbox = $mbox_name ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $this->mod_mailbox($mbox_name) : $this->mailbox;
			return $this->_id2uid($id, $mailbox);
			}

			@@ -2762,7 +2947,7 @@
			$a_mboxes = $this->_list_mailboxes($root, $filter);

			foreach ($a_mboxes as $idx => $mbox_row) {
			if ($name = $this->mod_mailbox($mbox_row, 'out'))
			if (strlen($name = $this->mod_mailbox($mbox_row, 'out')))
			$a_out[] = $name;
			unset($a_mboxes[$idx]);
			}
			@@ -2804,8 +2989,29 @@
			$a_folders = $data['folders'];
			}
			else {
			// retrieve list of folders from IMAP server
			$a_folders = $this->conn->listSubscribed($this->mod_mailbox($root), $filter);
			// Server supports LIST-EXTENDED, we can use selection options
			$config = rcmail::get_instance()->config;
			// #1486225: Some dovecot versions returns wrong result using LIST-EXTENDED
			if (!$config->get('imap_force_lsub') && $this->get_capability('LIST-EXTENDED')) {
			// This will also set mailbox options, LSUB doesn't do that
			$a_folders = $this->conn->listMailboxes($this->mod_mailbox($root), $filter,
			NULL, array('SUBSCRIBED'));

			// remove non-existent folders
			if (is_array($a_folders)) {
			foreach ($a_folders as $idx => $folder) {
			if ($this->conn->data['LIST'] && ($opts = $this->conn->data['LIST'][$folder])
			&& in_array('\\NonExistent', $opts)
			) {
			unset($a_folders[$idx]);
			}
			}
			}
			}
			// retrieve list of folders from IMAP server using LSUB
			else {
			$a_folders = $this->conn->listSubscribed($this->mod_mailbox($root), $filter);
			}
			}

			if (!is_array($a_folders) \|\| !sizeof($a_folders))
			@@ -2845,7 +3051,7 @@

			// modify names with root dir
			foreach ($a_mboxes as $idx => $mbox_name) {
			if ($name = $this->mod_mailbox($mbox_name, 'out'))
			if (strlen($name = $this->mod_mailbox($mbox_name, 'out')))
			$a_folders[] = $name;
			unset($a_mboxes[$idx]);
			}
			@@ -2872,6 +3078,26 @@
			return $this->conn->getQuota();

			return false;
			}


			/**
			* Get mailbox size (size of all messages in a mailbox)
			*
			* @param string $name Mailbox name
			* @return int Mailbox size in bytes, False on error
			*/
			function get_mailbox_size($name)
			{
			$name = $this->mod_mailbox($name);

			// @TODO: could we try to use QUOTA here?
			$result = $this->conn->fetchHeaderIndex($name, '1:*', 'SIZE', false);

			if (is_array($result))
			$result = array_sum($result);

			return $result;
			}


			@@ -2910,129 +3136,120 @@
			/**
			* Create a new mailbox on the server and register it in local cache
			*
			* @param string $name New mailbox name (as utf-7 string)
			* @param string $name New mailbox name
			* @param boolean $subscribe True if the new mailbox should be subscribed
			* @param string Name of the created mailbox, false on error
			* @param boolean True on success
			*/
			function create_mailbox($name, $subscribe=false)
			{
			$result = false;

			// reduce mailbox name to 100 chars
			$name = substr($name, 0, 100);
			$result = false;
			$abs_name = $this->mod_mailbox($name);
			$result = $this->conn->createFolder($abs_name);
			$result = $this->conn->createFolder($abs_name);

			// try to subscribe it
			if ($result && $subscribe)
			$this->subscribe($name);

			return $result ? $name : false;
			return $result;
			}


			/**
			* Set a new name to an existing mailbox
			*
			* @param string $mbox_name Mailbox to rename (as utf-7 string)
			* @param string $new_name New mailbox name (as utf-7 string)
			* @return string Name of the renames mailbox, False on error
			* @param string $mbox_name Mailbox to rename
			* @param string $new_name New mailbox name
			*
			* @return boolean True on success
			*/
			function rename_mailbox($mbox_name, $new_name)
			{
			$result = false;

			// encode mailbox name and reduce it to 100 chars
			$name = substr($new_name, 0, 100);

			// make absolute path
			$mailbox = $this->mod_mailbox($mbox_name);
			$abs_name = $this->mod_mailbox($name);
			$mailbox = $this->mod_mailbox($mbox_name);
			$abs_name = $this->mod_mailbox($new_name);
			$delm = $this->get_hierarchy_delimiter();

			// check if mailbox is subscribed
			$a_subscribed = $this->_list_mailboxes();
			$subscribed = in_array($mailbox, $a_subscribed);

			// unsubscribe folder
			if ($subscribed)
			$this->conn->unsubscribe($mailbox);
			// get list of subscribed folders
			if ((strpos($mailbox, '%') === false) && (strpos($mailbox, '*') === false)) {
			$a_subscribed = $this->_list_mailboxes('', $mbox_name . $delm . '*');
			$subscribed = $this->mailbox_exists($mbox_name, true);
			}
			else {
			$a_subscribed = $this->_list_mailboxes();
			$subscribed = in_array($mailbox, $a_subscribed);
			}

			if (strlen($abs_name))
			$result = $this->conn->renameFolder($mailbox, $abs_name);

			if ($result) {
			$delm = $this->get_hierarchy_delimiter();
			// unsubscribe the old folder, subscribe the new one
			if ($subscribed) {
			$this->conn->unsubscribe($mailbox);
			$this->conn->subscribe($abs_name);
			}

			// check if mailbox children are subscribed
			foreach ($a_subscribed as $c_subscribed)
			foreach ($a_subscribed as $c_subscribed) {
			if (preg_match('/^'.preg_quote($mailbox.$delm, '/').'/', $c_subscribed)) {
			$this->conn->unsubscribe($c_subscribed);
			$this->conn->subscribe(preg_replace('/^'.preg_quote($mailbox, '/').'/',
			$abs_name, $c_subscribed));
			}
			}

			// clear cache
			$this->clear_message_cache($mailbox.'.msg');
			$this->clear_cache('mailboxes');
			}

			// try to subscribe it
			if ($result && $subscribed)
			$this->conn->subscribe($abs_name);

			return $result ? $name : false;
			return $result;
			}


			/**
			* Remove mailboxes from server
			* Remove mailbox from server
			*
			* @param string\|array $mbox_name sMailbox name(s) string/array
			* @param string $mbox_name Mailbox name
			*
			* @return boolean True on success
			*/
			function delete_mailbox($mbox_name)
			{
			$deleted = false;
			$result = false;
			$mailbox = $this->mod_mailbox($mbox_name);
			$delm = $this->get_hierarchy_delimiter();

			if (is_array($mbox_name))
			$a_mboxes = $mbox_name;
			else if (is_string($mbox_name) && strlen($mbox_name))
			$a_mboxes = explode(',', $mbox_name);
			// get list of folders
			if ((strpos($mailbox, '%') === false) && (strpos($mailbox, '*') === false))
			$sub_mboxes = $this->list_unsubscribed('', $mailbox . $delm . '*');
			else
			$sub_mboxes = $this->list_unsubscribed();

			if (is_array($a_mboxes)) {
			foreach ($a_mboxes as $mbox_name) {
			$mailbox = $this->mod_mailbox($mbox_name);
			$sub_mboxes = $this->conn->listMailboxes($this->mod_mailbox(''),
			$mbox_name . $this->delimiter . '*');
			// send delete command to server
			$result = $this->conn->deleteFolder($mailbox);

			// unsubscribe mailbox before deleting
			$this->conn->unsubscribe($mailbox);
			if ($result) {
			// unsubscribe mailbox
			$this->conn->unsubscribe($mailbox);

			// send delete command to server
			$result = $this->conn->deleteFolder($mailbox);
			if ($result) {
			$deleted = true;
			$this->clear_message_cache($mailbox.'.msg');
			}

			foreach ($sub_mboxes as $c_mbox) {
			if ($c_mbox != 'INBOX') {
			$this->conn->unsubscribe($c_mbox);
			$result = $this->conn->deleteFolder($c_mbox);
			if ($result) {
			$deleted = true;
			$this->clear_message_cache($c_mbox.'.msg');
			}
			foreach ($sub_mboxes as $c_mbox) {
			if (preg_match('/^'.preg_quote($mailbox.$delm, '/').'/', $c_mbox)) {
			$this->conn->unsubscribe($c_mbox);
			if ($this->conn->deleteFolder($c_mbox)) {
			$this->clear_message_cache($c_mbox.'.msg');
			}
			}
			}

			// clear mailbox-related cache
			$this->clear_message_cache($mailbox.'.msg');
			$this->clear_cache('mailboxes');
			}

			// clear mailboxlist cache
			if ($deleted)
			$this->clear_cache('mailboxes');

			return $deleted;
			return $result;
			}


			@@ -3060,25 +3277,25 @@
			*/
			function mailbox_exists($mbox_name, $subscription=false)
			{
			if ($mbox_name) {
			if ($mbox_name == 'INBOX')
			return true;
			if ($mbox_name == 'INBOX')
			return true;

			$key = $subscription ? 'subscribed' : 'existing';
			if (is_array($this->icache[$key]) && in_array($mbox_name, $this->icache[$key]))
			return true;
			$key = $subscription ? 'subscribed' : 'existing';
			$mbox = $this->mod_mailbox($mbox_name);

			if ($subscription) {
			$a_folders = $this->conn->listSubscribed($this->mod_mailbox(''), $mbox_name);
			}
			else {
			$a_folders = $this->conn->listMailboxes($this->mod_mailbox(''), $mbox_name);
			}
			if (is_array($this->icache[$key]) && in_array($mbox, $this->icache[$key]))
			return true;

			if (is_array($a_folders) && in_array($this->mod_mailbox($mbox_name), $a_folders)) {
			$this->icache[$key][] = $mbox_name;
			return true;
			}
			if ($subscription) {
			$a_folders = $this->conn->listSubscribed('', $mbox);
			}
			else {
			$a_folders = $this->conn->listMailboxes('', $mbox);
			}

			if (is_array($a_folders) && in_array($mbox, $a_folders)) {
			$this->icache[$key][] = $mbox;
			return true;
			}

			return false;
			@@ -3094,17 +3311,87 @@
			*/
			function mod_mailbox($mbox_name, $mode='in')
			{
			if ($mbox_name == 'INBOX')
			return $mbox_name;
			if (!strlen($mbox_name))
			return '';

			if (!empty($this->root_dir)) {
			if ($mode=='in')
			$mbox_name = $this->root_dir.$this->delimiter.$mbox_name;
			else if (!empty($mbox_name)) // $mode=='out'
			$mbox_name = substr($mbox_name, strlen($this->root_dir)+1);
			if ($mode == 'in') {
			// If folder contains namespace prefix, don't modify it
			if (is_array($this->namespace['shared'])) {
			foreach ($this->namespace['shared'] as $ns) {
			foreach ((array)$ns as $root) {
			if ($root[0] && strpos($mbox_name, $root[0]) === 0) {
			return $mbox_name;
			}
			}
			}
			}
			if (is_array($this->namespace['other'])) {
			foreach ($this->namespace['other'] as $ns) {
			foreach ((array)$ns as $root) {
			if ($root[0] && strpos($mbox_name, $root[0]) === 0) {
			return $mbox_name;
			}
			}
			}
			}
			if (is_array($this->namespace['personal'])) {
			foreach ($this->namespace['personal'] as $ns) {
			foreach ((array)$ns as $root) {
			if ($root[0] && strpos($mbox_name, $root[0]) === 0) {
			return $mbox_name;
			}
			}
			}
			// Add prefix if first personal namespace is non-empty
			if ($this->namespace['personal'][0][0]) {
			return $this->namespace['personal'][0][0].$mbox_name;
			}
			}
			}
			else {
			// Remove prefix if folder is from first ("non-empty") personal namespace
			if (is_array($this->namespace['personal'])) {
			if ($prefix = $this->namespace['personal'][0][0]) {
			if (strpos($mbox_name, $prefix) === 0) {
			return substr($mbox_name, strlen($prefix));
			}
			}
			}
			}

			return $mbox_name;
			}


			/**
			* Gets folder options from LIST response, e.g. \Noselect, \Noinferiors
			*
			* @param string $mbox_name Folder name
			* @param bool $force Set to True if options should be refreshed
			* Options are available after LIST command only
			*
			* @return array Options list
			*/
			function mailbox_options($mbox_name, $force=false)
			{
			$mbox = $this->mod_mailbox($mbox_name);

			if ($mbox == 'INBOX') {
			return array();
			}

			if (!is_array($this->conn->data['LIST']) \|\| !is_array($this->conn->data['LIST'][$mbox])) {
			if ($force) {
			$this->conn->listMailboxes('', $mbox_name);
			}
			else {
			return array();
			}
			}

			$opts = $this->conn->data['LIST'][$mbox];

			return is_array($opts) ? $opts : array();
			}


			@@ -3254,8 +3541,8 @@
			if ($mailbox)
			$mailbox = $this->mod_mailbox($mailbox);

			if ($this->get_capability('METADATA') \|\|
			empty($mailbox) && $this->get_capability('METADATA-SERVER')
			if ($this->get_capability('METADATA') \|\|
			(!strlen($mailbox) && $this->get_capability('METADATA-SERVER'))
			) {
			return $this->conn->setMetadata($mailbox, $entries);
			}
			@@ -3288,7 +3575,7 @@
			$mailbox = $this->mod_mailbox($mailbox);

			if ($this->get_capability('METADATA') \|\|
			empty($mailbox) && $this->get_capability('METADATA-SERVER')
			(!strlen($mailbox) && $this->get_capability('METADATA-SERVER'))
			) {
			return $this->conn->deleteMetadata($mailbox, $entries);
			}
			@@ -3322,7 +3609,7 @@
			$mailbox = $this->mod_mailbox($mailbox);

			if ($this->get_capability('METADATA') \|\|
			empty($mailbox) && $this->get_capability('METADATA-SERVER')
			!strlen(($mailbox) && $this->get_capability('METADATA-SERVER'))
			) {
			return $this->conn->getMetadata($mailbox, $entries, $options);
			}
			@@ -3584,45 +3871,43 @@
			$cache_count = count($cache_index);

			// empty mailbox
			if (!$msg_count)
			if (!$msg_count) {
			return $cache_count ? -2 : 1;
			}

			if ($cache_count==$msg_count) {
			if ($cache_count == $msg_count) {
			if ($this->skip_deleted) {
			$h_index = $this->conn->fetchHeaderIndex($mailbox, "1:*", 'UID', $this->skip_deleted);

			// Save index in internal cache, will be used when syncing the cache
			$this->icache['folder_index'] = $h_index;

			if (empty($h_index))
			return -2;

			if (sizeof($h_index) == $cache_count) {
			$cache_index = array_flip($cache_index);
			foreach ($h_index as $idx => $uid)
			unset($cache_index[$uid]);

			if (empty($cache_index))
			return 1;
			}
			return -2;
			if (!empty($this->icache['all_undeleted_idx'])) {
			$uids = rcube_imap_generic::uncompressMessageSet($this->icache['all_undeleted_idx']);
			$uids = array_flip($uids);
			foreach ($cache_index as $uid) {
			unset($uids[$uid]);
			}
			}
			else {
			// get all undeleted messages excluding cached UIDs
			$uids = $this->search_once($mailbox, 'ALL UNDELETED NOT UID '.
			rcube_imap_generic::compressMessageSet($cache_index));
			}
			if (empty($uids)) {
			return 1;
			}
			} else {
			// get UID of the message with highest index
			$uid = $this->_id2uid($msg_count, $mailbox);
			$cache_uid = array_pop($cache_index);

			// uids of highest message matches -> cache seems OK
			if ($cache_uid == $uid)
			if ($cache_uid == $uid) {
			return 1;
			}
			}
			// cache is dirty
			return -1;
			}

			// if cache count differs less than 10% report as dirty
			else if (abs($msg_count - $cache_count) < $msg_count/10)
			return -1;
			else
			return -2;
			return (abs($msg_count - $cache_count) < $msg_count/10) ? -1 : -2;
			}


			@@ -3996,10 +4281,7 @@
			foreach ($a as $val) {
			$j++;
			$address = trim($val['address']);
			$name = trim($val['name']);

			if ($name && preg_match('/^[\'"]/', $name) && preg_match('/[\'"]$/', $name))
			$name = trim($name, '\'"');
			$name = trim($val['name']);

			if ($name && $address && $name != $address)
			$string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address);
			@@ -4258,7 +4540,7 @@
			*/
			private function _uid2id($uid, $mbox_name=NULL)
			{
			if (!$mbox_name)
			if (!strlen($mbox_name))
			$mbox_name = $this->mailbox;

			if (!isset($this->uid_id_map[$mbox_name][$uid])) {
			@@ -4280,7 +4562,7 @@
			*/
			private function _id2uid($id, $mbox_name=NULL)
			{
			if (!$mbox_name)
			if (!strlen($mbox_name))
			$mbox_name = $this->mailbox;

			if ($uid = array_search($id, (array)$this->uid_id_map[$mbox_name]))
			@@ -4341,7 +4623,7 @@
			private function _set_messagecount($mbox_name, $mode, $increment)
			{
			$a_mailbox_cache = false;
			$mailbox = $mbox_name ? $mbox_name : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $mbox_name : $this->mailbox;
			$mode = strtoupper($mode);

			$a_mailbox_cache = $this->get_cache('messagecount');
			@@ -4367,15 +4649,19 @@
			* Remove messagecount of a specific mailbox from cache
			* @access private
			*/
			private function _clear_messagecount($mbox_name='')
			private function _clear_messagecount($mbox_name='', $mode=null)
			{
			$a_mailbox_cache = false;
			$mailbox = $mbox_name ? $mbox_name : $this->mailbox;
			$mailbox = strlen($mbox_name) ? $mbox_name : $this->mailbox;

			$a_mailbox_cache = $this->get_cache('messagecount');

			if (is_array($a_mailbox_cache[$mailbox])) {
			unset($a_mailbox_cache[$mailbox]);
			if ($mode) {
			unset($a_mailbox_cache[$mailbox][$mode]);
			}
			else {
			unset($a_mailbox_cache[$mailbox]);
			}
			$this->update_cache('messagecount', $a_mailbox_cache);
			}
			}
			@@ -4415,22 +4701,40 @@
			$result = array();

			foreach ($a as $key => $val) {
			$val = preg_replace("/([\"\w])</", "$1 <", $val);
			$sub_a = rcube_explode_quoted_string(' ', $decode ? $this->decode_header($val) : $val);
			$result[$key]['name'] = '';
			$name = '';
			$address = '';
			$val = trim($val);

			foreach ($sub_a as $k => $v) {
			// use angle brackets in regexp to not handle names with @ sign
			if (preg_match('/^<\S+@\S+>$/', $v))
			$result[$key]['address'] = trim($v, '<>');
			else
			$result[$key]['name'] .= (empty($result[$key]['name'])?'':' ').str_replace("\"",'',stripslashes($v));
			if (preg_match('/(.*)<(\S+@\S+)>$/', $val, $m)) {
			$address = $m[2];
			$name = trim($m[1]);
			}
			else if (preg_match('/^(\S+@\S+)$/', $val, $m)) {
			$address = $m[1];
			$name = '';
			}
			else {
			$name = $val;
			}

			// if (empty($result[$key]['name']))
			// $result[$key]['name'] = $result[$key]['address'];
			if (empty($result[$key]['address']))
			$result[$key]['address'] = $result[$key]['name'];
			// dequote and/or decode name
			if ($name) {
			if ($name[0] == '"') {
			$name = substr($name, 1, -1);
			$name = stripslashes($name);
			}
			if ($decode) {
			$name = $this->decode_header($name);
			}
			}

			if (!$address && $name) {
			$address = $name;
			}

			if ($address) {
			$result[$key] = array('name' => $name, 'address' => $address);
			}
			}

			return $result;