No OneTemporary
Actions

Size

76 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/program/lib/Roundcube/rcube_imap_cache.php b/program/lib/Roundcube/rcube_imap_cache.php
	index 81df07641..560b3b843 100644
	--- a/program/lib/Roundcube/rcube_imap_cache.php
	+++ b/program/lib/Roundcube/rcube_imap_cache.php
	@@ -1,1321 +1,1321 @@
	<?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: \|
	\| Caching of IMAP folder contents (messages and index) \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Interface class for accessing Roundcube messages cache
	*
	* @package Framework
	* @subpackage Storage
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @author Aleksander Machniak <alec@alec.pl>
	*/
	class rcube_imap_cache
	{
	const MODE_INDEX = 1;
	const MODE_MESSAGE = 2;

	/**
	* Instance of rcube_imap
	*
	* @var rcube_imap
	*/
	private $imap;

	/**
	* Instance of rcube_db
	*
	* @var rcube_db
	*/
	private $db;

	/**
	* User ID
	*
	* @var int
	*/
	private $userid;

	/**
	* Expiration time in seconds
	*
	* @var int
	*/
	private $ttl;

	/**
	* Maximum cached message size
	*
	* @var int
	*/
	private $threshold;

	/**
	* Internal (in-memory) cache
	*
	* @var array
	*/
	private $icache = array();

	private $skip_deleted = false;
	private $mode;

	/**
	* List of known flags. Thanks to this we can handle flag changes
	* with good performance. Bad thing is we need to know used flags.
	*/
	public $flags = array(
	1 => 'SEEN', // RFC3501
	2 => 'DELETED', // RFC3501
	4 => 'ANSWERED', // RFC3501
	8 => 'FLAGGED', // RFC3501
	16 => 'DRAFT', // RFC3501
	32 => 'MDNSENT', // RFC3503
	64 => 'FORWARDED', // RFC5550
	128 => 'SUBMITPENDING', // RFC5550
	256 => 'SUBMITTED', // RFC5550
	512 => 'JUNK',
	1024 => 'NONJUNK',
	2048 => 'LABEL1',
	4096 => 'LABEL2',
	8192 => 'LABEL3',
	16384 => 'LABEL4',
	32768 => 'LABEL5',
	);



	/**
	* Object constructor.
	*
	* @param rcube_db $db DB handler
	* @param rcube_imap $imap IMAP handler
	* @param int $userid User identifier
	* @param bool $skip_deleted skip_deleted flag
	* @param string $ttl Expiration time of memcache/apc items
	* @param int $threshold Maximum cached message size
	*/
	function __construct($db, $imap, $userid, $skip_deleted, $ttl=0, $threshold=0)
	{
	// convert ttl string to seconds
	$ttl = get_offset_sec($ttl);
	if ($ttl > 2592000) $ttl = 2592000;

	$this->db = $db;
	$this->imap = $imap;
	$this->userid = $userid;
	$this->skip_deleted = $skip_deleted;
	$this->ttl = $ttl;
	$this->threshold = $threshold;

	// cache all possible information by default
	$this->mode = self::MODE_INDEX \| self::MODE_MESSAGE;

	// database tables
	$this->index_table = $db->table_name('cache_index', true);
	$this->thread_table = $db->table_name('cache_thread', true);
	$this->messages_table = $db->table_name('cache_messages', true);
	}


	/**
	* Cleanup actions (on shutdown).
	*/
	public function close()
	{
	$this->save_icache();
	$this->icache = null;
	}


	/**
	* Set cache mode
	*
	* @param int $mode Cache mode
	*/
	public function set_mode($mode)
	{
	$this->mode = $mode;
	}


	/**
	* Return (sorted) messages index (UIDs).
	* If index doesn't exist or is invalid, will be updated.
	*
	* @param string $mailbox Folder name
	* @param string $sort_field Sorting column
	* @param string $sort_order Sorting order (ASC\|DESC)
	* @param bool $exiting Skip index initialization if it doesn't exist in DB
	*
	* @return array Messages index
	*/
	function get_index($mailbox, $sort_field = null, $sort_order = null, $existing = false)
	{
	if (empty($this->icache[$mailbox])) {
	$this->icache[$mailbox] = array();
	}

	$sort_order = strtoupper($sort_order) == 'ASC' ? 'ASC' : 'DESC';

	// Seek in internal cache
	if (array_key_exists('index', $this->icache[$mailbox])) {
	// The index was fetched from database already, but not validated yet
	if (empty($this->icache[$mailbox]['index']['validated'])) {
	$index = $this->icache[$mailbox]['index'];
	}
	// We've got a valid index
	else if ($sort_field == 'ANY' \|\| $this->icache[$mailbox]['index']['sort_field'] == $sort_field) {
	$result = $this->icache[$mailbox]['index']['object'];
	if ($result->get_parameters('ORDER') != $sort_order) {
	$result->revert();
	}
	return $result;
	}
	}

	// Get index from DB (if DB wasn't already queried)
	if (empty($index) && empty($this->icache[$mailbox]['index_queried'])) {
	$index = $this->get_index_row($mailbox);

	// set the flag that DB was already queried for index
	// this way we'll be able to skip one SELECT, when
	// get_index() is called more than once
	$this->icache[$mailbox]['index_queried'] = true;
	}

	$data = null;

	// @TODO: Think about skipping validation checks.
	// If we could check only every 10 minutes, we would be able to skip
	// expensive checks, mailbox selection or even IMAP connection, this would require
	// additional logic to force cache invalidation in some cases
	// and many rcube_imap changes to connect when needed

	// Entry exists, check cache status
	if (!empty($index)) {
	$exists = true;

	if ($sort_field == 'ANY') {
	$sort_field = $index['sort_field'];
	}

	if ($sort_field != $index['sort_field']) {
	$is_valid = false;
	}
	else {
	$is_valid = $this->validate($mailbox, $index, $exists);
	}

	if ($is_valid) {
	$data = $index['object'];
	// revert the order if needed
	if ($data->get_parameters('ORDER') != $sort_order) {
	$data->revert();
	}
	}
	}
	else {
	if ($existing) {
	return null;
	}
	else if ($sort_field == 'ANY') {
	$sort_field = '';
	}

	// Got it in internal cache, so the row already exist
	$exists = array_key_exists('index', $this->icache[$mailbox]);
	}

	// Index not found, not valid or sort field changed, get index from IMAP server
	if ($data === null) {
	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
	$mbox_data = $this->imap->folder_data($mailbox);
	$data = $this->get_index_data($mailbox, $sort_field, $sort_order, $mbox_data);

	// insert/update
	$this->add_index_row($mailbox, $sort_field, $data, $mbox_data, $exists, $index['modseq']);
	}

	$this->icache[$mailbox]['index'] = array(
	'validated' => true,
	'object' => $data,
	'sort_field' => $sort_field,
	'modseq' => !empty($index['modseq']) ? $index['modseq'] : $mbox_data['HIGHESTMODSEQ']
	);

	return $data;
	}


	/**
	* Return messages thread.
	* If threaded index doesn't exist or is invalid, will be updated.
	*
	* @param string $mailbox Folder name
	*
	* @return array Messages threaded index
	*/
	function get_thread($mailbox)
	{
	if (empty($this->icache[$mailbox])) {
	$this->icache[$mailbox] = array();
	}

	// Seek in internal cache
	if (array_key_exists('thread', $this->icache[$mailbox])) {
	return $this->icache[$mailbox]['thread']['object'];
	}

	// Get thread from DB (if DB wasn't already queried)
	if (empty($this->icache[$mailbox]['thread_queried'])) {
	$index = $this->get_thread_row($mailbox);

	// set the flag that DB was already queried for thread
	// this way we'll be able to skip one SELECT, when
	// get_thread() is called more than once or after clear()
	$this->icache[$mailbox]['thread_queried'] = true;
	}

	// Entry exist, check cache status
	if (!empty($index)) {
	$exists = true;
	$is_valid = $this->validate($mailbox, $index, $exists);

	if (!$is_valid) {
	$index = null;
	}
	}

	// Index not found or not valid, get index from IMAP server
	if ($index === null) {
	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
	$mbox_data = $this->imap->folder_data($mailbox);
	// Get THREADS result
	$index['object'] = $this->get_thread_data($mailbox, $mbox_data);

	// insert/update
	$this->add_thread_row($mailbox, $index['object'], $mbox_data, $exists);
	}

	$this->icache[$mailbox]['thread'] = $index;

	return $index['object'];
	}


	/**
	* Returns list of messages (headers). See rcube_imap::fetch_headers().
	*
	* @param string $mailbox Folder name
	* @param array $msgs Message UIDs
	*
	* @return array The list of messages (rcube_message_header) indexed by UID
	*/
	function get_messages($mailbox, $msgs = array())
	{
	if (empty($msgs)) {
	return array();
	}

	$result = array();

	if ($this->mode & self::MODE_MESSAGE) {
	// Fetch messages from cache
	$sql_result = $this->db->query(
	"SELECT `uid`, `data`, `flags`"
	." FROM {$this->messages_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	." AND `uid` IN (".$this->db->array2list($msgs, 'integer').")",
	$this->userid, $mailbox);

	$msgs = array_flip($msgs);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$uid = intval($sql_arr['uid']);
	$result[$uid] = $this->build_message($sql_arr);

	if (!empty($result[$uid])) {
	// save memory, we don't need message body here (?)
	$result[$uid]->body = null;

	unset($msgs[$uid]);
	}
	}

	$msgs = array_flip($msgs);
	}

	// Fetch not found messages from IMAP server
	if (!empty($msgs)) {
	$messages = $this->imap->fetch_headers($mailbox, $msgs, false, true);

	// Insert to DB and add to result list
	if (!empty($messages)) {
	foreach ($messages as $msg) {
	if ($this->mode & self::MODE_MESSAGE) {
	$this->add_message($mailbox, $msg, !array_key_exists($msg->uid, $result));
	}

	$result[$msg->uid] = $msg;
	}
	}
	}

	return $result;
	}


	/**
	* Returns message data.
	*
	* @param string $mailbox Folder name
	* @param int $uid Message UID
	* @param bool $update If message doesn't exists in cache it will be fetched
	* from IMAP server
	* @param bool $no_cache Enables internal cache usage
	*
	* @return rcube_message_header Message data
	*/
	function get_message($mailbox, $uid, $update = true, $cache = true)
	{
	// Check internal cache
	if ($this->icache['__message']
	&& $this->icache['__message']['mailbox'] == $mailbox
	&& $this->icache['__message']['object']->uid == $uid
	) {
	return $this->icache['__message']['object'];
	}

	if ($this->mode & self::MODE_MESSAGE) {
	$sql_result = $this->db->query(
	"SELECT `flags`, `data`"
	." FROM {$this->messages_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	." AND `uid` = ?",
	$this->userid, $mailbox, (int)$uid);

	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$message = $this->build_message($sql_arr);
	$found = true;
	}
	}

	// Get the message from IMAP server
	if (empty($message) && $update) {
	$message = $this->imap->get_message_headers($uid, $mailbox, true);
	// cache will be updated in close(), see below
	}

	if (!($this->mode & self::MODE_MESSAGE)) {
	return $message;
	}

	// Save the message in internal cache, will be written to DB in close()
	// Common scenario: user opens unseen message
	// - get message (SELECT)
	// - set message headers/structure (INSERT or UPDATE)
	// - set \Seen flag (UPDATE)
	// This way we can skip one UPDATE
	if (!empty($message) && $cache) {
	// Save current message from internal cache
	$this->save_icache();

	$this->icache['__message'] = array(
	'object' => $message,
	'mailbox' => $mailbox,
	'exists' => $found,
	'md5sum' => md5(serialize($message)),
	);
	}

	return $message;
	}


	/**
	* Saves the message in cache.
	*
	* @param string $mailbox Folder name
	* @param rcube_message_header $message Message data
	* @param bool $force Skips message in-cache existance check
	*/
	function add_message($mailbox, $message, $force = false)
	{
	if (!is_object($message) \|\| empty($message->uid)) {
	return;
	}

	if (!($this->mode & self::MODE_MESSAGE)) {
	return;
	}

	$flags = 0;
	$msg = clone $message;

	if (!empty($message->flags)) {
	foreach ($this->flags as $idx => $flag) {
	if (!empty($message->flags[$flag])) {
	$flags += $idx;
	}
	}
	}

	unset($msg->flags);
	$msg = $this->db->encode($msg, true);

	// update cache record (even if it exists, the update
	// here will work as select, assume row exist if affected_rows=0)
	if (!$force) {
	$res = $this->db->query(
	"UPDATE {$this->messages_table}"
	." SET `flags` = ?, `data` = ?, `expires` = " . ($this->ttl ? $this->db->now($this->ttl) : 'NULL')
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	." AND `uid` = ?",
	$flags, $msg, $this->userid, $mailbox, (int) $message->uid);

	if ($this->db->affected_rows($res)) {
	return;
	}
	}

	$this->db->set_option('ignore_key_errors', true);
	-
	+console($msg);
	// insert new record
	$res = $this->db->query(
	"INSERT INTO {$this->messages_table}"
	." (`user_id`, `mailbox`, `uid`, `flags`, `expires`, `data`)"
	." VALUES (?, ?, ?, ?, ". ($this->ttl ? $this->db->now($this->ttl) : 'NULL') . ", ?)",
	$this->userid, $mailbox, (int) $message->uid, $flags, $msg);

	// race-condition, insert failed so try update (#1489146)
	// thanks to ignore_key_errors "duplicate row" errors will be ignored
	if ($force && !$res && !$this->db->is_error($res)) {
	$this->db->query(
	"UPDATE {$this->messages_table}"
	." SET `expires` = " . ($this->ttl ? $this->db->now($this->ttl) : 'NULL')
	.", `flags` = ?, `data` = ?"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	." AND `uid` = ?",
	$flags, $msg, $this->userid, $mailbox, (int) $message->uid);
	}

	$this->db->set_option('ignore_key_errors', false);
	}


	/**
	* Sets the flag for specified message.
	*
	* @param string $mailbox Folder name
	* @param array $uids Message UIDs or null to change flag
	* of all messages in a folder
	* @param string $flag The name of the flag
	* @param bool $enabled Flag state
	*/
	function change_flag($mailbox, $uids, $flag, $enabled = false)
	{
	if (empty($uids)) {
	return;
	}

	if (!($this->mode & self::MODE_MESSAGE)) {
	return;
	}

	$flag = strtoupper($flag);
	$idx = (int) array_search($flag, $this->flags);
	$uids = (array) $uids;

	if (!$idx) {
	return;
	}

	// Internal cache update
	if (($message = $this->icache['__message'])
	&& $message['mailbox'] === $mailbox
	&& in_array($message['object']->uid, $uids)
	) {
	$message['object']->flags[$flag] = $enabled;

	if (count($uids) == 1) {
	return;
	}
	}

	$binary_check = $this->db->db_provider == 'oracle' ? "BITAND(`flags`, %d)" : "(`flags` & %d)";

	$this->db->query(
	"UPDATE {$this->messages_table}"
	." SET `expires` = ". ($this->ttl ? $this->db->now($this->ttl) : 'NULL')
	.", `flags` = `flags` ".($enabled ? "+ $idx" : "- $idx")
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	.(!empty($uids) ? " AND `uid` IN (".$this->db->array2list($uids, 'integer').")" : "")
	." AND " . sprintf($binary_check, $idx) . ($enabled ? " = 0" : " = $idx"),
	$this->userid, $mailbox);
	}


	/**
	* Removes message(s) from cache.
	*
	* @param string $mailbox Folder name
	* @param array $uids Message UIDs, NULL removes all messages
	*/
	function remove_message($mailbox = null, $uids = null)
	{
	if (!($this->mode & self::MODE_MESSAGE)) {
	return;
	}

	if (!strlen($mailbox)) {
	$this->db->query(
	"DELETE FROM {$this->messages_table}"
	." WHERE `user_id` = ?",
	$this->userid);
	}
	else {
	// Remove the message from internal cache
	if (!empty($uids) && ($message = $this->icache['__message'])
	&& $message['mailbox'] === $mailbox
	&& in_array($message['object']->uid, (array)$uids)
	) {
	$this->icache['__message'] = null;
	}

	$this->db->query(
	"DELETE FROM {$this->messages_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	.($uids !== null ? " AND `uid` IN (".$this->db->array2list((array)$uids, 'integer').")" : ""),
	$this->userid, $mailbox);
	}
	}


	/**
	* Clears index cache.
	*
	* @param string $mailbox Folder name
	* @param bool $remove Enable to remove the DB row
	*/
	function remove_index($mailbox = null, $remove = false)
	{
	// The index should be only removed from database when
	// UIDVALIDITY was detected or the mailbox is empty
	// otherwise use 'valid' flag to not loose HIGHESTMODSEQ value
	if ($remove) {
	$this->db->query(
	"DELETE FROM {$this->index_table}"
	." WHERE `user_id` = ?"
	.(strlen($mailbox) ? " AND `mailbox` = ".$this->db->quote($mailbox) : ""),
	$this->userid
	);
	}
	else {
	$this->db->query(
	"UPDATE {$this->index_table}"
	." SET `valid` = 0"
	." WHERE `user_id` = ?"
	.(strlen($mailbox) ? " AND `mailbox` = ".$this->db->quote($mailbox) : ""),
	$this->userid
	);
	}

	if (strlen($mailbox)) {
	unset($this->icache[$mailbox]['index']);
	// Index removed, set flag to skip SELECT query in get_index()
	$this->icache[$mailbox]['index_queried'] = true;
	}
	else {
	$this->icache = array();
	}
	}


	/**
	* Clears thread cache.
	*
	* @param string $mailbox Folder name
	*/
	function remove_thread($mailbox = null)
	{
	$this->db->query(
	"DELETE FROM {$this->thread_table}"
	." WHERE `user_id` = ?"
	.(strlen($mailbox) ? " AND `mailbox` = ".$this->db->quote($mailbox) : ""),
	$this->userid
	);

	if (strlen($mailbox)) {
	unset($this->icache[$mailbox]['thread']);
	// Thread data removed, set flag to skip SELECT query in get_thread()
	$this->icache[$mailbox]['thread_queried'] = true;
	}
	else {
	$this->icache = array();
	}
	}


	/**
	* Clears the cache.
	*
	* @param string $mailbox Folder name
	* @param array $uids Message UIDs, NULL removes all messages in a folder
	*/
	function clear($mailbox = null, $uids = null)
	{
	$this->remove_index($mailbox, true);
	$this->remove_thread($mailbox);
	$this->remove_message($mailbox, $uids);
	}


	/**
	* Delete expired cache entries
	*/
	static function gc()
	{
	$rcube = rcube::get_instance();
	$db = $rcube->get_dbh();
	$now = $db->now();

	$db->query("DELETE FROM " . $db->table_name('cache_messages', true)
	." WHERE `expires` < $now");

	$db->query("DELETE FROM " . $db->table_name('cache_index', true)
	." WHERE `expires` < $now");

	$db->query("DELETE FROM ".$db->table_name('cache_thread', true)
	." WHERE `expires` < $now");
	}


	/**
	* Fetches index data from database
	*/
	private function get_index_row($mailbox)
	{
	// Get index from DB
	$sql_result = $this->db->query(
	"SELECT `data`, `valid`"
	." FROM {$this->index_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$this->userid, $mailbox);

	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$data = explode('@', $sql_arr['data']);
	$index = $this->db->decode($data[0], true);
	unset($data[0]);

	if (empty($index)) {
	$index = new rcube_result_index($mailbox);
	}

	return array(
	'valid' => $sql_arr['valid'],
	'object' => $index,
	'sort_field' => $data[1],
	'deleted' => $data[2],
	'validity' => $data[3],
	'uidnext' => $data[4],
	'modseq' => $data[5],
	);
	}

	return null;
	}


	/**
	* Fetches thread data from database
	*/
	private function get_thread_row($mailbox)
	{
	// Get thread from DB
	$sql_result = $this->db->query(
	"SELECT `data`"
	." FROM {$this->thread_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$this->userid, $mailbox);

	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$data = explode('@', $sql_arr['data']);
	$thread = $this->db->decode($data[0], true);
	unset($data[0]);

	if (empty($thread)) {
	$thread = new rcube_result_thread($mailbox);
	}

	return array(
	'object' => $thread,
	'deleted' => $data[1],
	'validity' => $data[2],
	'uidnext' => $data[3],
	);
	}

	return null;
	}


	/**
	* Saves index data into database
	*/
	private function add_index_row($mailbox, $sort_field,
	$data, $mbox_data = array(), $exists = false, $modseq = null)
	{
	$data = array(
	$this->db->encode($data, true),
	$sort_field,
	(int) $this->skip_deleted,
	(int) $mbox_data['UIDVALIDITY'],
	(int) $mbox_data['UIDNEXT'],
	$modseq ? $modseq : $mbox_data['HIGHESTMODSEQ'],
	);

	$data = implode('@', $data);
	$expires = $this->ttl ? $this->db->now($this->ttl) : 'NULL';

	if ($exists) {
	$res = $this->db->query(
	"UPDATE {$this->index_table}"
	." SET `data` = ?, `valid` = 1, `expires` = $expires"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$data, $this->userid, $mailbox);

	if ($this->db->affected_rows($res)) {
	return;
	}
	}

	$this->db->set_option('ignore_key_errors', true);

	$res = $this->db->query(
	"INSERT INTO {$this->index_table}"
	." (`user_id`, `mailbox`, `valid`, `expires`, `data`)"
	." VALUES (?, ?, 1, $expires, ?)",
	$this->userid, $mailbox, $data);

	// race-condition, insert failed so try update (#1489146)
	// thanks to ignore_key_errors "duplicate row" errors will be ignored
	if (!$exists && !$res && !$this->db->is_error($res)) {
	$res = $this->db->query(
	"UPDATE {$this->index_table}"
	." SET `data` = ?, `valid` = 1, `expires` = $expires"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$data, $this->userid, $mailbox);
	}

	$this->db->set_option('ignore_key_errors', false);
	}


	/**
	* Saves thread data into database
	*/
	private function add_thread_row($mailbox, $data, $mbox_data = array(), $exists = false)
	{
	$data = array(
	$this->db->encode($data, true),
	(int) $this->skip_deleted,
	(int) $mbox_data['UIDVALIDITY'],
	(int) $mbox_data['UIDNEXT'],
	);

	$data = implode('@', $data);
	$expires = $this->ttl ? $this->db->now($this->ttl) : 'NULL';

	if ($exists) {
	$res = $this->db->query(
	"UPDATE {$this->thread_table}"
	." SET `data` = ?, `expires` = $expires"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$data, $this->userid, $mailbox);

	if ($this->db->affected_rows($res)) {
	return;
	}
	}

	$this->db->set_option('ignore_key_errors', true);

	$res = $this->db->query(
	"INSERT INTO {$this->thread_table}"
	." (`user_id`, `mailbox`, `expires`, `data`)"
	." VALUES (?, ?, $expires, ?)",
	$this->userid, $mailbox, $data);

	// race-condition, insert failed so try update (#1489146)
	// thanks to ignore_key_errors "duplicate row" errors will be ignored
	if (!$exists && !$res && !$this->db->is_error($res)) {
	$this->db->query(
	"UPDATE {$this->thread_table}"
	." SET `expires` = $expires, `data` = ?"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$data, $this->userid, $mailbox);
	}

	$this->db->set_option('ignore_key_errors', false);
	}


	/**
	* Checks index/thread validity
	*/
	private function validate($mailbox, $index, &$exists = true)
	{
	$object = $index['object'];
	$is_thread = is_a($object, 'rcube_result_thread');

	// sanity check
	if (empty($object)) {
	return false;
	}

	$index['validated'] = true;

	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
	$mbox_data = $this->imap->folder_data($mailbox);

	// @TODO: Think about skipping validation checks.
	// If we could check only every 10 minutes, we would be able to skip
	// expensive checks, mailbox selection or even IMAP connection, this would require
	// additional logic to force cache invalidation in some cases
	// and many rcube_imap changes to connect when needed

	// Check UIDVALIDITY
	if ($index['validity'] != $mbox_data['UIDVALIDITY']) {
	$this->clear($mailbox);
	$exists = false;
	return false;
	}

	// Folder is empty but cache isn't
	if (empty($mbox_data['EXISTS'])) {
	if (!$object->is_empty()) {
	$this->clear($mailbox);
	$exists = false;
	return false;
	}
	}
	// Folder is not empty but cache is
	else if ($object->is_empty()) {
	unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
	return false;
	}

	// Validation flag
	if (!$is_thread && empty($index['valid'])) {
	unset($this->icache[$mailbox]['index']);
	return false;
	}

	// Index was created with different skip_deleted setting
	if ($this->skip_deleted != $index['deleted']) {
	return false;
	}

	// Check HIGHESTMODSEQ
	if (!empty($index['modseq']) && !empty($mbox_data['HIGHESTMODSEQ'])
	&& $index['modseq'] == $mbox_data['HIGHESTMODSEQ']
	) {
	return true;
	}

	// Check UIDNEXT
	if ($index['uidnext'] != $mbox_data['UIDNEXT']) {
	unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
	return false;
	}

	// @TODO: find better validity check for threaded index
	if ($is_thread) {
	// check messages number...
	if (!$this->skip_deleted && $mbox_data['EXISTS'] != $object->count_messages()) {
	return false;
	}
	return true;
	}

	// The rest of checks, more expensive
	if (!empty($this->skip_deleted)) {
	// compare counts if available
	if (!empty($mbox_data['UNDELETED'])
	&& $mbox_data['UNDELETED']->count() != $object->count()
	) {
	return false;
	}
	// compare UID sets
	if (!empty($mbox_data['UNDELETED'])) {
	$uids_new = $mbox_data['UNDELETED']->get();
	$uids_old = $object->get();

	if (count($uids_new) != count($uids_old)) {
	return false;
	}

	sort($uids_new, SORT_NUMERIC);
	sort($uids_old, SORT_NUMERIC);

	if ($uids_old != $uids_new)
	return false;
	}
	else {
	// get all undeleted messages excluding cached UIDs
	$ids = $this->imap->search_once($mailbox, 'ALL UNDELETED NOT UID '.
	rcube_imap_generic::compressMessageSet($object->get()));

	if (!$ids->is_empty()) {
	return false;
	}
	}
	}
	else {
	// check messages number...
	if ($mbox_data['EXISTS'] != $object->count()) {
	return false;
	}
	// ... and max UID
	if ($object->max() != $this->imap->id2uid($mbox_data['EXISTS'], $mailbox, true)) {
	return false;
	}
	}

	return true;
	}


	/**
	* Synchronizes the mailbox.
	*
	* @param string $mailbox Folder name
	*/
	function synchronize($mailbox)
	{
	// RFC4549: Synchronization Operations for Disconnected IMAP4 Clients
	// RFC4551: IMAP Extension for Conditional STORE Operation
	// or Quick Flag Changes Resynchronization
	// RFC5162: IMAP Extensions for Quick Mailbox Resynchronization

	// @TODO: synchronize with other methods?
	$qresync = $this->imap->get_capability('QRESYNC');
	$condstore = $qresync ? true : $this->imap->get_capability('CONDSTORE');

	if (!$qresync && !$condstore) {
	return;
	}

	// Get stored index
	$index = $this->get_index_row($mailbox);

	// database is empty
	if (empty($index)) {
	// set the flag that DB was already queried for index
	// this way we'll be able to skip one SELECT in get_index()
	$this->icache[$mailbox]['index_queried'] = true;
	return;
	}

	$this->icache[$mailbox]['index'] = $index;

	// no last HIGHESTMODSEQ value
	if (empty($index['modseq'])) {
	return;
	}

	if (!$this->imap->check_connection()) {
	return;
	}

	// Enable QRESYNC
	$res = $this->imap->conn->enable($qresync ? 'QRESYNC' : 'CONDSTORE');
	if ($res === false) {
	return;
	}

	// Close mailbox if already selected to get most recent data
	if ($this->imap->conn->selected == $mailbox) {
	$this->imap->conn->close();
	}

	// Get mailbox data (UIDVALIDITY, HIGHESTMODSEQ, counters, etc.)
	$mbox_data = $this->imap->folder_data($mailbox);

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

	// Check UIDVALIDITY
	if ($index['validity'] != $mbox_data['UIDVALIDITY']) {
	$this->clear($mailbox);
	return;
	}

	// QRESYNC not supported on specified mailbox
	if (!empty($mbox_data['NOMODSEQ']) \|\| empty($mbox_data['HIGHESTMODSEQ'])) {
	return;
	}

	// Nothing new
	if ($mbox_data['HIGHESTMODSEQ'] == $index['modseq']) {
	return;
	}

	$uids = array();
	$removed = array();

	// Get known UIDs
	if ($this->mode & self::MODE_MESSAGE) {
	$sql_result = $this->db->query(
	"SELECT `uid`"
	." FROM {$this->messages_table}"
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?",
	$this->userid, $mailbox);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$uids[] = $sql_arr['uid'];
	}
	}

	// Synchronize messages data
	if (!empty($uids)) {
	// Get modified flags and vanished messages
	// UID FETCH 1:* (FLAGS) (CHANGEDSINCE 0123456789 VANISHED)
	$result = $this->imap->conn->fetch($mailbox,
	$uids, true, array('FLAGS'), $index['modseq'], $qresync);

	if (!empty($result)) {
	foreach ($result as $msg) {
	$uid = $msg->uid;
	// Remove deleted message
	if ($this->skip_deleted && !empty($msg->flags['DELETED'])) {
	$removed[] = $uid;
	// Invalidate index
	$index['valid'] = false;
	continue;
	}

	$flags = 0;
	if (!empty($msg->flags)) {
	foreach ($this->flags as $idx => $flag) {
	if (!empty($msg->flags[$flag])) {
	$flags += $idx;
	}
	}
	}

	$this->db->query(
	"UPDATE {$this->messages_table}"
	." SET `flags` = ?, `expires` = " . ($this->ttl ? $this->db->now($this->ttl) : 'NULL')
	." WHERE `user_id` = ?"
	." AND `mailbox` = ?"
	." AND `uid` = ?"
	." AND `flags` <> ?",
	$flags, $this->userid, $mailbox, $uid, $flags);
	}
	}

	// VANISHED found?
	if ($qresync) {
	$mbox_data = $this->imap->folder_data($mailbox);

	// Removed messages found
	$uids = rcube_imap_generic::uncompressMessageSet($mbox_data['VANISHED']);
	if (!empty($uids)) {
	$removed = array_merge($removed, $uids);
	// Invalidate index
	$index['valid'] = false;
	}
	}

	// remove messages from database
	if (!empty($removed)) {
	$this->remove_message($mailbox, $removed);
	}
	}

	$sort_field = $index['sort_field'];
	$sort_order = $index['object']->get_parameters('ORDER');
	$exists = true;

	// Validate index
	if (!$this->validate($mailbox, $index, $exists)) {
	// Invalidate (remove) thread index
	// if $exists=false it was already removed in validate()
	if ($exists) {
	$this->remove_thread($mailbox);
	}

	// Update index
	$data = $this->get_index_data($mailbox, $sort_field, $sort_order, $mbox_data);
	}
	else {
	$data = $index['object'];
	}

	// update index and/or HIGHESTMODSEQ value
	$this->add_index_row($mailbox, $sort_field, $data, $mbox_data, $exists);

	// update internal cache for get_index()
	$this->icache[$mailbox]['index']['object'] = $data;
	}


	/**
	* Converts cache row into message object.
	*
	* @param array $sql_arr Message row data
	*
	* @return rcube_message_header Message object
	*/
	private function build_message($sql_arr)
	{
	$message = $this->db->decode($sql_arr['data'], true);

	if ($message) {
	$message->flags = array();
	foreach ($this->flags as $idx => $flag) {
	if (($sql_arr['flags'] & $idx) == $idx) {
	$message->flags[$flag] = true;
	}
	}
	}

	return $message;
	}


	/**
	* Saves message stored in internal cache
	*/
	private function save_icache()
	{
	// Save current message from internal cache
	if ($message = $this->icache['__message']) {
	// clean up some object's data
	$this->message_object_prepare($message['object']);

	// calculate current md5 sum
	$md5sum = md5(serialize($message['object']));

	if ($message['md5sum'] != $md5sum) {
	$this->add_message($message['mailbox'], $message['object'], !$message['exists']);
	}

	$this->icache['__message']['md5sum'] = $md5sum;
	}
	}


	/**
	* Prepares message object to be stored in database.
	*
	* @param rcube_message_header\|rcube_message_part
	*/
	private function message_object_prepare(&$msg, &$size = 0)
	{
	// Remove body too big
	if (isset($msg->body)) {
	$length = strlen($msg->body);

	if ($msg->body_modified \|\| $size + $length > $this->threshold * 1024) {
	unset($msg->body);
	}
	else {
	$size += $length;
	}
	}

	// Fix mimetype which might be broken by some code when message is displayed
	// Another solution would be to use object's copy in rcube_message class
	// to prevent related issues, however I'm not sure which is better
	if ($msg->mimetype) {
	list($msg->ctype_primary, $msg->ctype_secondary) = explode('/', $msg->mimetype);
	}

	unset($msg->replaces);

	if (is_object($msg->structure)) {
	$this->message_object_prepare($msg->structure, $size);
	}

	if (is_array($msg->parts)) {
	foreach ($msg->parts as $part) {
	$this->message_object_prepare($part, $size);
	}
	}
	}


	/**
	* Fetches index data from IMAP server
	*/
	private function get_index_data($mailbox, $sort_field, $sort_order, $mbox_data = array())
	{
	if (empty($mbox_data)) {
	$mbox_data = $this->imap->folder_data($mailbox);
	}

	if ($mbox_data['EXISTS']) {
	// fetch sorted sequence numbers
	$index = $this->imap->index_direct($mailbox, $sort_field, $sort_order);
	}
	else {
	$index = new rcube_result_index($mailbox, '* SORT');
	}

	return $index;
	}


	/**
	* Fetches thread data from IMAP server
	*/
	private function get_thread_data($mailbox, $mbox_data = array())
	{
	if (empty($mbox_data)) {
	$mbox_data = $this->imap->folder_data($mailbox);
	}

	if ($mbox_data['EXISTS']) {
	// get all threads (default sort order)
	return $this->imap->threads_direct($mailbox);
	}

	return new rcube_result_thread($mailbox, '* THREAD');
	}

	}

	// for backward compat.
	class rcube_mail_header extends rcube_message_header { }
	diff --git a/program/lib/Roundcube/rcube_mime.php b/program/lib/Roundcube/rcube_mime.php
	index f66cf1437..3f2fcc330 100644
	--- a/program/lib/Roundcube/rcube_mime.php
	+++ b/program/lib/Roundcube/rcube_mime.php
	@@ -1,925 +1,913 @@
	<?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) 2005-2014, The Roundcube Dev Team \|
	+ \| Copyright (C) 2011-2014, Kolab Systems AG \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| 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 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->mime_id = $part->mime_id ?: (empty($parent) ? (string)$count : "$parent.$count");
	+ $struct->headers = $part->headers;
	+ $struct->mimetype = $part->ctype_primary . '/' . $part->ctype_secondary;
	+ $struct->ctype_primary = $part->ctype_primary;
	+ $struct->ctype_secondary = $part->ctype_secondary;
	$struct->ctype_parameters = $part->ctype_parameters;

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

	- $part_charset = $struct->charset ? $struct->charset : self::get_charset();
	+ $part_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->body = $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
	* @param boolean $addronly Return flat array with e-mail addresses only
	*
	* @return array Indexed list of addresses
	*/
	static function decode_address_list($input, $max = null, $decode = true, $fallback = null, $addronly = false)
	{
	$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']);

	if ($addronly) {
	$out[$j] = $address;
	}
	else {
	$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 = '';
	}
	// special case (#1489092)
	else if (preg_match('/(\s*<MAILER-DAEMON>)$/', $val, $m)) {
	$address = 'MAILER-DAEMON';
	$name = substr($val, 0, -strlen($m[1]));
	}
	else if (preg_match('/('.$email_rx.')/', $val, $m)) {
	$name = $m[1];
	}
	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);
	// some clients encode addressee name with quotes around it
	if ($name[0] == '"' && $name[strlen($name)-1] == '"') {
	$name = substr($name, 1, -1);
	}
	}
	}

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

	if ($address) {
	$address = self::fix_email($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
	* @param string $mark Mark each flowed line with specified character
	*
	* @return string Interpreted text with unwrapped lines and stuffed space removed
	*/
	public static function unfold_flowed($text, $mark = null)
	{
	- $text = preg_split('/\r?\n/', $text);
	- $last = -1;
	+ $text = preg_split('/\r?\n/', $text);
	+ $last = -1;
	$q_level = 0;
	- $marks = array();
	+ $marks = array();

	foreach ($text as $idx => $line) {
	if (preg_match('/^(>+)/', $line, $m)) {
	// remove quote chars
	$q = strlen($m[1]);
	$line = preg_replace('/^>+/', '', $line);
	// remove (optional) space-staffing
	$line = preg_replace('/^ /', '', $line);

	// The same paragraph (We join current line with the previous one) when:
	// - the same level of quoting
	// - previous line was flowed
	// - previous line contains more than only one single space (and quote char(s))
	if ($q == $q_level
	&& isset($text[$last]) && $text[$last][strlen($text[$last])-1] == ' '
	&& !preg_match('/^>+ {0,1}$/', $text[$last])
	) {
	$text[$last] .= $line;
	unset($text[$idx]);

	if ($mark) {
	$marks[$last] = true;
	}
	}
	else {
	$last = $idx;
	}
	}
	else {
	$q = 0;
	if ($line == '-- ') {
	$last = $idx;
	}
	else {
	// remove space-stuffing
	$line = preg_replace('/^ /', '', $line);

	if (isset($text[$last]) && $line
	&& $text[$last] != '-- '
	&& $text[$last][strlen($text[$last])-1] == ' '
	) {
	$text[$last] .= $line;
	unset($text[$idx]);

	if ($mark) {
	$marks[$last] = true;
	}
	}
	else {
	$text[$idx] = $line;
	$last = $idx;
	}
	}
	}
	$q_level = $q;
	}

	if (!empty($marks)) {
	foreach (array_keys($marks) as $mk) {
	$text[$mk] = $mark . $text[$mk];
	}
	}

	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 $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 (preg_match('/^(>+)/', $line, $m)) {
	// remove quote chars
	$level = strlen($m[1]);
	$line = preg_replace('/^>+/', '', $line);
	// remove (optional) space-staffing and spaces before the line end
	$line = preg_replace('/(^ \| +$)/', '', $line);
	$prefix = str_repeat('>', $level) . ' ';
	$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 with multibyte support.
	* The code is based on Zend_Text_MultiByte::wordWrap().
	*
	* @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
	* @param bool $wrap_quoted When enabled quoted lines will not be wrapped
	*
	* @return string Text
	*/
	public static function wordwrap($string, $width=75, $break="\n", $cut=false, $charset=null, $wrap_quoted=true)
	{
	// Note: Never try to use iconv instead of mbstring functions here
	// Iconv's substr/strlen are 100x slower (#1489113)

	if ($charset && $charset != RCUBE_CHARSET && function_exists('mb_internal_encoding')) {
	mb_internal_encoding($charset);
	}

	// Convert \r\n to \n, this is our line-separator
	$string = str_replace("\r\n", "\n", $string);
	$separator = "\n"; // must be 1 character length
	$result = array();

	while (($stringLength = mb_strlen($string)) > 0) {
	$breakPos = mb_strpos($string, $separator, 0);

	// quoted line (do not wrap)
	if ($wrap_quoted && $string[0] == '>') {
	if ($breakPos === $stringLength - 1 \|\| $breakPos === false) {
	$subString = $string;
	$cutLength = null;
	}
	else {
	$subString = mb_substr($string, 0, $breakPos);
	$cutLength = $breakPos + 1;
	}
	}
	// next line found and current line is shorter than the limit
	else if ($breakPos !== false && $breakPos < $width) {
	if ($breakPos === $stringLength - 1) {
	$subString = $string;
	$cutLength = null;
	}
	else {
	$subString = mb_substr($string, 0, $breakPos);
	$cutLength = $breakPos + 1;
	}
	}
	else {
	$subString = mb_substr($string, 0, $width);

	// last line
	if ($breakPos === false && $subString === $string) {
	$cutLength = null;
	}
	else {
	$nextChar = mb_substr($string, $width, 1);

	if ($nextChar === ' ' \|\| $nextChar === $separator) {
	$afterNextChar = mb_substr($string, $width + 1, 1);

	// Note: mb_substr() does never return False
	if ($afterNextChar === false \|\| $afterNextChar === '') {
	$subString .= $nextChar;
	}

	$cutLength = mb_strlen($subString) + 1;
	}
	else {
	$spacePos = mb_strrpos($subString, ' ', 0);

	if ($spacePos !== false) {
	$subString = mb_substr($subString, 0, $spacePos);
	$cutLength = $spacePos + 1;
	}
	else if ($cut === false) {
	$spacePos = mb_strpos($string, ' ', 0);

	if ($spacePos !== false && ($breakPos === false \|\| $spacePos < $breakPos)) {
	$subString = mb_substr($string, 0, $spacePos);
	$cutLength = $spacePos + 1;
	}
	else if ($breakPos === false) {
	$subString = $string;
	$cutLength = null;
	}
	else {
	$subString = mb_substr($string, 0, $breakPos);
	$cutLength = $breakPos + 1;
	}
	}
	else {
	$cutLength = $width;
	}
	}
	}
	}

	$result[] = $subString;

	if ($cutLength !== null) {
	$string = mb_substr($string, $cutLength, ($stringLength - $cutLength));
	}
	else {
	break;
	}
	}

	if ($charset && $charset != RCUBE_CHARSET && function_exists('mb_internal_encoding')) {
	mb_internal_encoding(RCUBE_CHARSET);
	}

	return implode($break, $result);
	}

	-
	/**
	* A method to guess the mime_type of an attachment.
	*
	* @param string $path Path to the file or file contents
	* @param string $name File name (with suffix)
	* @param string $failover Mime type supplied for failover
	* @param boolean $is_stream Set to True if $path contains file contents
	* @param boolean $skip_suffix Set to True if the config/mimetypes.php mappig should be ignored
	*
	* @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, $skip_suffix = false)
	{
	static $mime_ext = array();

	- $mime_type = null;
	- $config = rcube::get_instance()->config;
	+ $mime_type = null;
	+ $config = rcube::get_instance()->config;
	$mime_magic = $config->get('mime_magic');

	if (!$skip_suffix && empty($mime_ext)) {
	foreach ($config->resolve_paths('mimetypes.php') as $fpath) {
	$mime_ext = array_merge($mime_ext, (array) @include($fpath));
	}
	}

	// use file name suffix with hard-coded mime-type map
	if (!$skip_suffix && 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')) {
	// null as a 2nd argument should be the same as no argument
	// this however is not true on all systems/versions
	if ($mime_magic) {
	$finfo = finfo_open(FILEINFO_MIME, $mime_magic);
	}
	else {
	$finfo = finfo_open(FILEINFO_MIME);
	}

	if ($finfo) {
	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;
	}

	-
	/**
	* Get mimetype => file extension mapping
	*
	- * @param string Mime-Type to get extensions for
	- * @return array List of extensions matching the given mimetype or a hash array with ext -> mimetype mappings if $mimetype is not given
	+ * @param string Mime-Type to get extensions for
	+ *
	+ * @return array List of extensions matching the given mimetype or a hash array
	+ * with ext -> mimetype mappings if $mimetype is not given
	*/
	public static function get_mime_extensions($mimetype = null)
	{
	static $mime_types, $mime_extensions;

	// return cached data
	if (is_array($mime_types)) {
	return $mimetype ? $mime_types[$mimetype] : $mime_extensions;
	}

	// load mapping file
	$file_paths = array();

	if ($mime_types = rcube::get_instance()->config->get('mime_types')) {
	$file_paths[] = $mime_types;
	}

	// try common locations
	if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
	$file_paths[] = 'C:/xampp/apache/conf/mime.types.';
	}
	else {
	$file_paths[] = '/etc/mime.types';
	$file_paths[] = '/etc/httpd/mime.types';
	$file_paths[] = '/etc/httpd2/mime.types';
	$file_paths[] = '/etc/apache/mime.types';
	$file_paths[] = '/etc/apache2/mime.types';
	$file_paths[] = '/etc/nginx/mime.types';
	$file_paths[] = '/usr/local/etc/httpd/conf/mime.types';
	$file_paths[] = '/usr/local/etc/apache/conf/mime.types';
	}

	foreach ($file_paths as $fp) {
	if (@is_readable($fp)) {
	$lines = file($fp, FILE_IGNORE_NEW_LINES \| FILE_SKIP_EMPTY_LINES);
	break;
	}
	}

	$mime_types = $mime_extensions = array();
	$regex = "/([\w\+\-\.\/]+)\s+([\w\s]+)/i";
	foreach((array)$lines as $line) {
	// skip comments or mime types w/o any extensions
	if ($line[0] == '#' \|\| !preg_match($regex, $line, $matches))
	continue;

	$mime = $matches[1];
	foreach (explode(' ', $matches[2]) as $ext) {
	$ext = trim($ext);
	$mime_types[$mime][] = $ext;
	$mime_extensions[$ext] = $mime;
	}
	}

	// fallback to some well-known types most important for daily emails
	if (empty($mime_types)) {
	foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) {
	$mime_extensions = array_merge($mime_extensions, (array) @include($fpath));
	}

	foreach ($mime_extensions as $ext => $mime) {
	$mime_types[$mime][] = $ext;
	}
	}

	// Add some known aliases that aren't included by some mime.types (#1488891)
	// the order is important here so standard extensions have higher prio
	$aliases = array(
	'image/gif' => array('gif'),
	'image/png' => array('png'),
	'image/x-png' => array('png'),
	'image/jpeg' => array('jpg', 'jpeg', 'jpe'),
	'image/jpg' => array('jpg', 'jpeg', 'jpe'),
	'image/pjpeg' => array('jpg', 'jpeg', 'jpe'),
	'image/tiff' => array('tif'),
	'message/rfc822' => array('eml'),
	'text/x-mail' => array('eml'),
	);

	foreach ($aliases as $mime => $exts) {
	$mime_types[$mime] = array_unique(array_merge((array) $mime_types[$mime], $exts));

	foreach ($exts as $ext) {
	if (!isset($mime_extensions[$ext])) {
	$mime_extensions[$ext] = $mime;
	}
	}
	}

	return $mimetype ? $mime_types[$mimetype] : $mime_extensions;
	}

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

	/**
	* Try to fix invalid email addresses
	*/
	public static function fix_email($email)
	{
	$parts = rcube_utils::explode_quoted_string('@', $email);
	foreach ($parts as $idx => $part) {
	// remove redundant quoting (#1490040)
	if ($part[0] == '"' && preg_match('/^"([a-zA-Z0-9._+=-]+)"$/', $part, $m)) {
	$parts[$idx] = $m[1];
	}
	}

	return implode('@', $parts);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 1:59 AM (14 h, 22 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 165429
Default Alt Text: (76 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions