Context Navigation

source: subversion/trunk/roundcubemail/program/include/rcube_imap_cache.php @ 5286

Last change on this file since 5286 was 5286, checked in by alec, 20 months ago
Hide PHP warning when max() is used with an empty array
Property svn:keywords set to `Id Date Author`
File size: 39.3 KB

Line
1	<?php
2
3	/*
4	+-----------------------------------------------------------------------+
5	\| program/include/rcube_imap_cache.php \|
6	\| \|
7	\| This file is part of the Roundcube Webmail client \|
8	\| Copyright (C) 2005-2011, The Roundcube Dev Team \|
9	\| Licensed under the GNU GPL \|
10	\| \|
11	\| PURPOSE: \|
12	\| Caching of IMAP folder contents (messages and index) \|
13	\| \|
14	+-----------------------------------------------------------------------+
15	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
16	\| Author: Aleksander Machniak <alec@alec.pl> \|
17	+-----------------------------------------------------------------------+
18
19	$Id$
20
21	*/
22
23
24	/**
25	* Interface class for accessing Roundcube messages cache
26	*
27	* @package Cache
28	* @author Thomas Bruederli <roundcube@gmail.com>
29	* @author Aleksander Machniak <alec@alec.pl>
30	* @version 1.0
31	*/
32	class rcube_imap_cache
33	{
34	/**
35	* Instance of rcube_imap
36	*
37	* @var rcube_imap
38	*/
39	private $imap;
40
41	/**
42	* Instance of rcube_mdb2
43	*
44	* @var rcube_mdb2
45	*/
46	private $db;
47
48	/**
49	* User ID
50	*
51	* @var int
52	*/
53	private $userid;
54
55	/**
56	* Internal (in-memory) cache
57	*
58	* @var array
59	*/
60	private $icache = array();
61
62	private $skip_deleted = false;
63
64	/**
65	* List of known flags. Thanks to this we can handle flag changes
66	* with good performance. Bad thing is we need to know used flags.
67	*/
68	public $flags = array(
69	1 => 'SEEN', // RFC3501
70	2 => 'DELETED', // RFC3501
71	4 => 'ANSWERED', // RFC3501
72	8 => 'FLAGGED', // RFC3501
73	16 => 'DRAFT', // RFC3501
74	32 => 'MDNSENT', // RFC3503
75	64 => 'FORWARDED', // RFC5550
76	128 => 'SUBMITPENDING', // RFC5550
77	256 => 'SUBMITTED', // RFC5550
78	512 => 'JUNK',
79	1024 => 'NONJUNK',
80	2048 => 'LABEL1',
81	4096 => 'LABEL2',
82	8192 => 'LABEL3',
83	16384 => 'LABEL4',
84	32768 => 'LABEL5',
85	);
86
87
88	/**
89	* Object constructor.
90	*/
91	function __construct($db, $imap, $userid, $skip_deleted)
92	{
93	$this->db = $db;
94	$this->imap = $imap;
95	$this->userid = (int)$userid;
96	$this->skip_deleted = $skip_deleted;
97	}
98
99
100	/**
101	* Cleanup actions (on shutdown).
102	*/
103	public function close()
104	{
105	$this->save_icache();
106	$this->icache = null;
107	}
108
109
110	/**
111	* Return (sorted) messages index.
112	* If index doesn't exist or is invalid, will be updated.
113	*
114	* @param string $mailbox Folder name
115	* @param string $sort_field Sorting column
116	* @param string $sort_order Sorting order (ASC\|DESC)
117	* @param bool $exiting Skip index initialization if it doesn't exist in DB
118	*
119	* @return array Messages index
120	*/
121	function get_index($mailbox, $sort_field = null, $sort_order = null, $existing = false)
122	{
123	if (empty($this->icache[$mailbox]))
124	$this->icache[$mailbox] = array();
125
126	$sort_order = strtoupper($sort_order) == 'ASC' ? 'ASC' : 'DESC';
127
128	// Seek in internal cache
129	if (array_key_exists('index', $this->icache[$mailbox])) {
130	// The index was fetched from database already, but not validated yet
131	if (!array_key_exists('result', $this->icache[$mailbox]['index'])) {
132	$index = $this->icache[$mailbox]['index'];
133	}
134	// We've got a valid index
135	else if ($sort_field == 'ANY' \|\| $this->icache[$mailbox]['index']['sort_field'] == $sort_field
136	) {
137	if ($this->icache[$mailbox]['index']['sort_order'] == $sort_order)
138	return $this->icache[$mailbox]['index']['result'];
139	else
140	return array_reverse($this->icache[$mailbox]['index']['result'], true);
141	}
142	}
143
144	// Get index from DB (if DB wasn't already queried)
145	if (empty($index) && empty($this->icache[$mailbox]['index_queried'])) {
146	$index = $this->get_index_row($mailbox);
147
148	// set the flag that DB was already queried for index
149	// this way we'll be able to skip one SELECT, when
150	// get_index() is called more than once
151	$this->icache[$mailbox]['index_queried'] = true;
152	}
153
154	$data = null;
155
156	// @TODO: Think about skipping validation checks.
157	// If we could check only every 10 minutes, we would be able to skip
158	// expensive checks, mailbox selection or even IMAP connection, this would require
159	// additional logic to force cache invalidation in some cases
160	// and many rcube_imap changes to connect when needed
161
162	// Entry exists, check cache status
163	if (!empty($index)) {
164	$exists = true;
165
166	if ($sort_field == 'ANY') {
167	$sort_field = $index['sort_field'];
168	}
169
170	if ($sort_field != $index['sort_field']) {
171	$is_valid = false;
172	}
173	else {
174	$is_valid = $this->validate($mailbox, $index, $exists);
175	}
176
177	if ($is_valid) {
178	// build index, assign sequence IDs to unique IDs
179	$data = array_combine($index['seq'], $index['uid']);
180	// revert the order if needed
181	if ($index['sort_order'] != $sort_order)
182	$data = array_reverse($data, true);
183	}
184	}
185	else {
186	if ($existing) {
187	return null;
188	}
189	else if ($sort_field == 'ANY') {
190	$sort_field = '';
191	}
192
193	// Got it in internal cache, so the row already exist
194	$exists = array_key_exists('index', $this->icache[$mailbox]);
195	}
196
197	// Index not found, not valid or sort field changed, get index from IMAP server
198	if ($data === null) {
199	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
200	$mbox_data = $this->imap->mailbox_data($mailbox);
201	$data = $this->get_index_data($mailbox, $sort_field, $sort_order, $mbox_data);
202
203	// insert/update
204	$this->add_index_row($mailbox, $sort_field, $sort_order, $data, $mbox_data,
205	$exists, $index['modseq']);
206	}
207
208	$this->icache[$mailbox]['index'] = array(
209	'result' => $data,
210	'sort_field' => $sort_field,
211	'sort_order' => $sort_order,
212	'modseq' => !empty($index['modseq']) ? $index['modseq'] : $mbox_data['HIGHESTMODSEQ']
213	);
214
215	return $data;
216	}
217
218
219	/**
220	* Return messages thread.
221	* If threaded index doesn't exist or is invalid, will be updated.
222	*
223	* @param string $mailbox Folder name
224	* @param string $sort_field Sorting column
225	* @param string $sort_order Sorting order (ASC\|DESC)
226	*
227	* @return array Messages threaded index
228	*/
229	function get_thread($mailbox)
230	{
231	if (empty($this->icache[$mailbox]))
232	$this->icache[$mailbox] = array();
233
234	// Seek in internal cache
235	if (array_key_exists('thread', $this->icache[$mailbox])) {
236	return array(
237	$this->icache[$mailbox]['thread']['tree'],
238	$this->icache[$mailbox]['thread']['depth'],
239	$this->icache[$mailbox]['thread']['children'],
240	);
241	}
242
243	// Get thread from DB (if DB wasn't already queried)
244	if (empty($this->icache[$mailbox]['thread_queried'])) {
245	$index = $this->get_thread_row($mailbox);
246
247	// set the flag that DB was already queried for thread
248	// this way we'll be able to skip one SELECT, when
249	// get_thread() is called more than once or after clear()
250	$this->icache[$mailbox]['thread_queried'] = true;
251	}
252
253	$data = null;
254
255	// Entry exist, check cache status
256	if (!empty($index)) {
257	$exists = true;
258	$is_valid = $this->validate($mailbox, $index, $exists);
259
260	if (!$is_valid) {
261	$index = null;
262	}
263	}
264
265	// Index not found or not valid, get index from IMAP server
266	if ($index === null) {
267	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
268	$mbox_data = $this->imap->mailbox_data($mailbox);
269
270	if ($mbox_data['EXISTS']) {
271	// get all threads (default sort order)
272	list ($thread_tree, $msg_depth, $has_children) = $this->imap->fetch_threads($mailbox, true);
273	}
274
275	$index = array(
276	'tree' => !empty($thread_tree) ? $thread_tree : array(),
277	'depth' => !empty($msg_depth) ? $msg_depth : array(),
278	'children' => !empty($has_children) ? $has_children : array(),
279	);
280
281	// insert/update
282	$this->add_thread_row($mailbox, $index, $mbox_data, $exists);
283	}
284
285	$this->icache[$mailbox]['thread'] = $index;
286
287	return array($index['tree'], $index['depth'], $index['children']);
288	}
289
290
291	/**
292	* Returns list of messages (headers). See rcube_imap::fetch_headers().
293	*
294	* @param string $mailbox Folder name
295	* @param array $msgs Message sequence numbers
296	* @param bool $is_uid True if $msgs contains message UIDs
297	*
298	* @return array The list of messages (rcube_mail_header) indexed by UID
299	*/
300	function get_messages($mailbox, $msgs = array(), $is_uid = true)
301	{
302	if (empty($msgs)) {
303	return array();
304	}
305
306	// @TODO: it would be nice if we could work with UIDs only
307	// then index would be not needed. For now we need it to
308	// map id to uid here and to update message id for cached message
309
310	// Convert IDs to UIDs
311	$index = $this->get_index($mailbox, 'ANY');
312	if (!$is_uid) {
313	foreach ($msgs as $idx => $msgid)
314	if ($uid = $index[$msgid])
315	$msgs[$idx] = $uid;
316	}
317
318	// Fetch messages from cache
319	$sql_result = $this->db->query(
320	"SELECT uid, data, flags"
321	." FROM ".get_table_name('cache_messages')
322	." WHERE user_id = ?"
323	." AND mailbox = ?"
324	." AND uid IN (".$this->db->array2list($msgs, 'integer').")",
325	$this->userid, $mailbox);
326
327	$msgs = array_flip($msgs);
328	$result = array();
329
330	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
331	$uid = intval($sql_arr['uid']);
332	$result[$uid] = $this->build_message($sql_arr);
333
334	// save memory, we don't need message body here (?)
335	$result[$uid]->body = null;
336
337	// update message ID according to index data
338	if (!empty($index) && ($id = array_search($uid, $index)))
339	$result[$uid]->id = $id;
340
341	if (!empty($result[$uid])) {
342	unset($msgs[$uid]);
343	}
344	}
345
346	// Fetch not found messages from IMAP server
347	if (!empty($msgs)) {
348	$messages = $this->imap->fetch_headers($mailbox, array_keys($msgs), true, true);
349
350	// Insert to DB and add to result list
351	if (!empty($messages)) {
352	foreach ($messages as $msg) {
353	$this->add_message($mailbox, $msg, !array_key_exists($msg->uid, $result));
354	$result[$msg->uid] = $msg;
355	}
356	}
357	}
358
359	return $result;
360	}
361
362
363	/**
364	* Returns message data.
365	*
366	* @param string $mailbox Folder name
367	* @param int $uid Message UID
368	* @param bool $update If message doesn't exists in cache it will be fetched
369	* from IMAP server
370	* @param bool $no_cache Enables internal cache usage
371	*
372	* @return rcube_mail_header Message data
373	*/
374	function get_message($mailbox, $uid, $update = true, $cache = true)
375	{
376	// Check internal cache
377	if (($message = $this->icache['message'])
378	&& $message['mailbox'] == $mailbox && $message['object']->uid == $uid
379	) {
380	return $this->icache['message']['object'];
381	}
382
383	$sql_result = $this->db->query(
384	"SELECT flags, data"
385	." FROM ".get_table_name('cache_messages')
386	." WHERE user_id = ?"
387	." AND mailbox = ?"
388	." AND uid = ?",
389	$this->userid, $mailbox, (int)$uid);
390
391	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
392	$message = $this->build_message($sql_arr);
393	$found = true;
394
395	// update message ID according to index data
396	$index = $this->get_index($mailbox, 'ANY');
397	if (!empty($index) && ($id = array_search($uid, $index)))
398	$message->id = $id;
399	}
400
401	// Get the message from IMAP server
402	if (empty($message) && $update) {
403	$message = $this->imap->get_headers($uid, $mailbox, true);
404	// cache will be updated in close(), see below
405	}
406
407	// Save the message in internal cache, will be written to DB in close()
408	// Common scenario: user opens unseen message
409	// - get message (SELECT)
410	// - set message headers/structure (INSERT or UPDATE)
411	// - set \Seen flag (UPDATE)
412	// This way we can skip one UPDATE
413	if (!empty($message) && $cache) {
414	// Save current message from internal cache
415	$this->save_icache();
416
417	$this->icache['message'] = array(
418	'object' => $message,
419	'mailbox' => $mailbox,
420	'exists' => $found,
421	'md5sum' => md5(serialize($message)),
422	);
423	}
424
425	return $message;
426	}
427
428
429	/**
430	* Saves the message in cache.
431	*
432	* @param string $mailbox Folder name
433	* @param rcube_mail_header $message Message data
434	* @param bool $force Skips message in-cache existance check
435	*/
436	function add_message($mailbox, $message, $force = false)
437	{
438	if (!is_object($message) \|\| empty($message->uid))
439	return;
440
441	$msg = serialize($this->db->encode(clone $message));
442	$flags = 0;
443
444	if (!empty($message->flags)) {
445	foreach ($this->flags as $idx => $flag)
446	if (!empty($message->flags[$flag]))
447	$flags += $idx;
448	}
449	unset($msg->flags);
450
451	// update cache record (even if it exists, the update
452	// here will work as select, assume row exist if affected_rows=0)
453	if (!$force) {
454	$res = $this->db->query(
455	"UPDATE ".get_table_name('cache_messages')
456	." SET flags = ?, data = ?, changed = ".$this->db->now()
457	." WHERE user_id = ?"
458	." AND mailbox = ?"
459	." AND uid = ?",
460	$flags, $msg, $this->userid, $mailbox, (int) $message->uid);
461
462	if ($this->db->affected_rows())
463	return;
464	}
465
466	// insert new record
467	$this->db->query(
468	"INSERT INTO ".get_table_name('cache_messages')
469	." (user_id, mailbox, uid, flags, changed, data)"
470	." VALUES (?, ?, ?, ?, ".$this->db->now().", ?)",
471	$this->userid, $mailbox, (int) $message->uid, $flags, $msg);
472	}
473
474
475	/**
476	* Sets the flag for specified message.
477	*
478	* @param string $mailbox Folder name
479	* @param array $uids Message UIDs or null to change flag
480	* of all messages in a folder
481	* @param string $flag The name of the flag
482	* @param bool $enabled Flag state
483	*/
484	function change_flag($mailbox, $uids, $flag, $enabled = false)
485	{
486	$flag = strtoupper($flag);
487	$idx = (int) array_search($flag, $this->flags);
488
489	if (!$idx) {
490	return;
491	}
492
493	// Internal cache update
494	if ($uids && count($uids) == 1 && ($uid = current($uids))
495	&& ($message = $this->icache['message'])
496	&& $message['mailbox'] == $mailbox && $message['object']->uid == $uid
497	) {
498	$message['object']->flags[$flag] = $enabled;
499	return;
500	}
501
502	$this->db->query(
503	"UPDATE ".get_table_name('cache_messages')
504	." SET changed = ".$this->db->now()
505	.", flags = flags ".($enabled ? "+ $idx" : "- $idx")
506	." WHERE user_id = ?"
507	." AND mailbox = ?"
508	.($uids !== null ? " AND uid IN (".$this->db->array2list((array)$uids, 'integer').")" : "")
509	." AND (flags & $idx) ".($enabled ? "= 0" : "= $idx"),
510	$this->userid, $mailbox);
511	}
512
513
514	/**
515	* Removes message(s) from cache.
516	*
517	* @param string $mailbox Folder name
518	* @param array $uids Message UIDs, NULL removes all messages
519	*/
520	function remove_message($mailbox = null, $uids = null)
521	{
522	if (!strlen($mailbox)) {
523	$this->db->query(
524	"DELETE FROM ".get_table_name('cache_messages')
525	." WHERE user_id = ?",
526	$this->userid);
527	}
528	else {
529	// Remove the message from internal cache
530	if (!empty($uids) && !is_array($uids) && ($message = $this->icache['message'])
531	&& $message['mailbox'] == $mailbox && $message['object']->uid == $uids
532	) {
533	$this->icache['message'] = null;
534	}
535
536	$this->db->query(
537	"DELETE FROM ".get_table_name('cache_messages')
538	." WHERE user_id = ?"
539	." AND mailbox = ".$this->db->quote($mailbox)
540	.($uids !== null ? " AND uid IN (".$this->db->array2list((array)$uids, 'integer').")" : ""),
541	$this->userid);
542	}
543
544	}
545
546
547	/**
548	* Clears index cache.
549	*
550	* @param string $mailbox Folder name
551	* @param bool $remove Enable to remove the DB row
552	*/
553	function remove_index($mailbox = null, $remove = false)
554	{
555	// The index should be only removed from database when
556	// UIDVALIDITY was detected or the mailbox is empty
557	// otherwise use 'valid' flag to not loose HIGHESTMODSEQ value
558	if ($remove)
559	$this->db->query(
560	"DELETE FROM ".get_table_name('cache_index')
561	." WHERE user_id = ".intval($this->userid)
562	.(strlen($mailbox) ? " AND mailbox = ".$this->db->quote($mailbox) : "")
563	);
564	else
565	$this->db->query(
566	"UPDATE ".get_table_name('cache_index')
567	." SET valid = 0"
568	." WHERE user_id = ".intval($this->userid)
569	.(strlen($mailbox) ? " AND mailbox = ".$this->db->quote($mailbox) : "")
570	);
571
572	if (strlen($mailbox)) {
573	unset($this->icache[$mailbox]['index']);
574	// Index removed, set flag to skip SELECT query in get_index()
575	$this->icache[$mailbox]['index_queried'] = true;
576	}
577	else
578	$this->icache = array();
579	}
580
581
582	/**
583	* Clears thread cache.
584	*
585	* @param string $mailbox Folder name
586	*/
587	function remove_thread($mailbox = null)
588	{
589	$this->db->query(
590	"DELETE FROM ".get_table_name('cache_thread')
591	." WHERE user_id = ".intval($this->userid)
592	.(strlen($mailbox) ? " AND mailbox = ".$this->db->quote($mailbox) : "")
593	);
594
595	if (strlen($mailbox)) {
596	unset($this->icache[$mailbox]['thread']);
597	// Thread data removed, set flag to skip SELECT query in get_thread()
598	$this->icache[$mailbox]['thread_queried'] = true;
599	}
600	else
601	$this->icache = array();
602	}
603
604
605	/**
606	* Clears the cache.
607	*
608	* @param string $mailbox Folder name
609	* @param array $uids Message UIDs, NULL removes all messages in a folder
610	*/
611	function clear($mailbox = null, $uids = null)
612	{
613	$this->remove_index($mailbox, true);
614	$this->remove_thread($mailbox);
615	$this->remove_message($mailbox, $uids);
616	}
617
618
619	/**
620	* @param string $mailbox Folder name
621	* @param int $id Message (sequence) ID
622	*
623	* @return int Message UID
624	*/
625	function id2uid($mailbox, $id)
626	{
627	if (!empty($this->icache['pending_index_update']))
628	return null;
629
630	// get index if it exists
631	$index = $this->get_index($mailbox, 'ANY', null, true);
632
633	return $index[$id];
634	}
635
636
637	/**
638	* @param string $mailbox Folder name
639	* @param int $uid Message UID
640	*
641	* @return int Message (sequence) ID
642	*/
643	function uid2id($mailbox, $uid)
644	{
645	if (!empty($this->icache['pending_index_update']))
646	return null;
647
648	// get index if it exists
649	$index = $this->get_index($mailbox, 'ANY', null, true);
650
651	return array_search($uid, (array)$index);
652	}
653
654	/**
655	* Fetches index data from database
656	*/
657	private function get_index_row($mailbox)
658	{
659	// Get index from DB
660	$sql_result = $this->db->query(
661	"SELECT data, valid"
662	." FROM ".get_table_name('cache_index')
663	." WHERE user_id = ?"
664	." AND mailbox = ?",
665	$this->userid, $mailbox);
666
667	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
668	$data = explode('@', $sql_arr['data']);
669
670	return array(
671	'valid' => $sql_arr['valid'],
672	'seq' => explode(',', $data[0]),
673	'uid' => explode(',', $data[1]),
674	'sort_field' => $data[2],
675	'sort_order' => $data[3],
676	'deleted' => $data[4],
677	'validity' => $data[5],
678	'uidnext' => $data[6],
679	'modseq' => $data[7],
680	);
681	}
682
683	return null;
684	}
685
686
687	/**
688	* Fetches thread data from database
689	*/
690	private function get_thread_row($mailbox)
691	{
692	// Get thread from DB
693	$sql_result = $this->db->query(
694	"SELECT data"
695	." FROM ".get_table_name('cache_thread')
696	." WHERE user_id = ?"
697	." AND mailbox = ?",
698	$this->userid, $mailbox);
699
700	if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
701	$data = explode('@', $sql_arr['data']);
702
703	// Uncompress data, see add_thread_row()
704	// $data[0] = str_replace(array('*', '^', '#'), array(';a:0:{}', 'i:', ';a:1:'), $data[0]);
705	$data[0] = unserialize($data[0]);
706
707	// build 'depth' and 'children' arrays
708	$depth = $children = array();
709	$this->build_thread_data($data[0], $depth, $children);
710
711	return array(
712	'tree' => $data[0],
713	'depth' => $depth,
714	'children' => $children,
715	'deleted' => $data[1],
716	'validity' => $data[2],
717	'uidnext' => $data[3],
718	);
719	}
720
721	return null;
722	}
723
724
725	/**
726	* Saves index data into database
727	*/
728	private function add_index_row($mailbox, $sort_field, $sort_order,
729	$data = array(), $mbox_data = array(), $exists = false, $modseq = null)
730	{
731	$data = array(
732	implode(',', array_keys($data)),
733	implode(',', array_values($data)),
734	$sort_field,
735	$sort_order,
736	(int) $this->skip_deleted,
737	(int) $mbox_data['UIDVALIDITY'],
738	(int) $mbox_data['UIDNEXT'],
739	$modseq ? $modseq : $mbox_data['HIGHESTMODSEQ'],
740	);
741	$data = implode('@', $data);
742
743	if ($exists)
744	$sql_result = $this->db->query(
745	"UPDATE ".get_table_name('cache_index')
746	." SET data = ?, valid = 1, changed = ".$this->db->now()
747	." WHERE user_id = ?"
748	." AND mailbox = ?",
749	$data, $this->userid, $mailbox);
750	else
751	$sql_result = $this->db->query(
752	"INSERT INTO ".get_table_name('cache_index')
753	." (user_id, mailbox, data, valid, changed)"
754	." VALUES (?, ?, ?, 1, ".$this->db->now().")",
755	$this->userid, $mailbox, $data);
756	}
757
758
759	/**
760	* Saves thread data into database
761	*/
762	private function add_thread_row($mailbox, $data = array(), $mbox_data = array(), $exists = false)
763	{
764	$tree = serialize($data['tree']);
765	// This significantly reduces data length
766	// $tree = str_replace(array(';a:0:{}', 'i:', ';a:1:'), array('*', '^', '#'), $tree);
767
768	$data = array(
769	$tree,
770	(int) $this->skip_deleted,
771	(int) $mbox_data['UIDVALIDITY'],
772	(int) $mbox_data['UIDNEXT'],
773	);
774	$data = implode('@', $data);
775
776	if ($exists)
777	$sql_result = $this->db->query(
778	"UPDATE ".get_table_name('cache_thread')
779	." SET data = ?, changed = ".$this->db->now()
780	." WHERE user_id = ?"
781	." AND mailbox = ?",
782	$data, $this->userid, $mailbox);
783	else
784	$sql_result = $this->db->query(
785	"INSERT INTO ".get_table_name('cache_thread')
786	." (user_id, mailbox, data, changed)"
787	." VALUES (?, ?, ?, ".$this->db->now().")",
788	$this->userid, $mailbox, $data);
789	}
790
791
792	/**
793	* Checks index/thread validity
794	*/
795	private function validate($mailbox, $index, &$exists = true)
796	{
797	$is_thread = isset($index['tree']);
798
799	// Get mailbox data (UIDVALIDITY, counters, etc.) for status check
800	$mbox_data = $this->imap->mailbox_data($mailbox);
801
802	// @TODO: Think about skipping validation checks.
803	// If we could check only every 10 minutes, we would be able to skip
804	// expensive checks, mailbox selection or even IMAP connection, this would require
805	// additional logic to force cache invalidation in some cases
806	// and many rcube_imap changes to connect when needed
807
808	// Check UIDVALIDITY
809	if ($index['validity'] != $mbox_data['UIDVALIDITY']) {
810	$this->clear($mailbox);
811	$exists = false;
812	return false;
813	}
814
815	// Folder is empty but cache isn't
816	if (empty($mbox_data['EXISTS'])) {
817	if (!empty($index['seq']) \|\| !empty($index['tree'])) {
818	$this->clear($mailbox);
819	$exists = false;
820	return false;
821	}
822	}
823	// Folder is not empty but cache is
824	else if (empty($index['seq']) && empty($index['tree'])) {
825	unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
826	return false;
827	}
828
829	// Validation flag
830	if (!$is_thread && empty($index['valid'])) {
831	unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
832	return false;
833	}
834
835	// Index was created with different skip_deleted setting
836	if ($this->skip_deleted != $index['deleted']) {
837	return false;
838	}
839
840	// Check HIGHESTMODSEQ
841	if (!empty($index['modseq']) && !empty($mbox_data['HIGHESTMODSEQ'])
842	&& $index['modseq'] == $mbox_data['HIGHESTMODSEQ']
843	) {
844	return true;
845	}
846
847	// Check UIDNEXT
848	if ($index['uidnext'] != $mbox_data['UIDNEXT']) {
849	unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
850	return false;
851	}
852
853	// @TODO: find better validity check for threaded index
854	if ($is_thread) {
855	// check messages number...
856	if ($mbox_data['EXISTS'] != @max(array_keys($index['depth']))) {
857	return false;
858	}
859	return true;
860	}
861
862	// The rest of checks, more expensive
863	if (!empty($this->skip_deleted)) {
864	// compare counts if available
865	if ($mbox_data['COUNT_UNDELETED'] != null
866	&& $mbox_data['COUNT_UNDELETED'] != count($index['uid'])) {
867	return false;
868	}
869	// compare UID sets
870	if ($mbox_data['ALL_UNDELETED'] != null) {
871	$uids_new = rcube_imap_generic::uncompressMessageSet($mbox_data['ALL_UNDELETED']);
872	$uids_old = $index['uid'];
873
874	if (count($uids_new) != count($uids_old)) {
875	return false;
876	}
877
878	sort($uids_new, SORT_NUMERIC);
879	sort($uids_old, SORT_NUMERIC);
880
881	if ($uids_old != $uids_new)
882	return false;
883	}
884	else {
885	// get all undeleted messages excluding cached UIDs
886	$ids = $this->imap->search_once($mailbox, 'ALL UNDELETED NOT UID '.
887	rcube_imap_generic::compressMessageSet($index['uid']));
888
889	if (!empty($ids)) {
890	return false;
891	}
892	}
893	}
894	else {
895	// check messages number...
896	if ($mbox_data['EXISTS'] != max($index['seq'])) {
897	return false;
898	}
899	// ... and max UID
900	if (max($index['uid']) != $this->imap->id2uid($mbox_data['EXISTS'], $mailbox, true)) {
901	return false;
902	}
903	}
904
905	return true;
906	}
907
908
909	/**
910	* Synchronizes the mailbox.
911	*
912	* @param string $mailbox Folder name
913	*/
914	function synchronize($mailbox)
915	{
916	// RFC4549: Synchronization Operations for Disconnected IMAP4 Clients
917	// RFC4551: IMAP Extension for Conditional STORE Operation
918	// or Quick Flag Changes Resynchronization
919	// RFC5162: IMAP Extensions for Quick Mailbox Resynchronization
920
921	// @TODO: synchronize with other methods?
922	$qresync = $this->imap->get_capability('QRESYNC');
923	$condstore = $qresync ? true : $this->imap->get_capability('CONDSTORE');
924
925	if (!$qresync && !$condstore) {
926	return;
927	}
928
929	// Get stored index
930	$index = $this->get_index_row($mailbox);
931
932	// database is empty
933	if (empty($index)) {
934	// set the flag that DB was already queried for index
935	// this way we'll be able to skip one SELECT in get_index()
936	$this->icache[$mailbox]['index_queried'] = true;
937	return;
938	}
939
940	$this->icache[$mailbox]['index'] = $index;
941
942	// no last HIGHESTMODSEQ value
943	if (empty($index['modseq'])) {
944	return;
945	}
946
947	// NOTE: make sure the mailbox isn't selected, before
948	// enabling QRESYNC and invoking SELECT
949	if ($this->imap->conn->selected !== null) {
950	$this->imap->conn->close();
951	}
952
953	// Enable QRESYNC
954	$res = $this->imap->conn->enable($qresync ? 'QRESYNC' : 'CONDSTORE');
955	if (!is_array($res)) {
956	return;
957	}
958
959	// Get mailbox data (UIDVALIDITY, HIGHESTMODSEQ, counters, etc.)
960	$mbox_data = $this->imap->mailbox_data($mailbox);
961
962	if (empty($mbox_data)) {
963	return;
964	}
965
966	// Check UIDVALIDITY
967	if ($index['validity'] != $mbox_data['UIDVALIDITY']) {
968	$this->clear($mailbox);
969	return;
970	}
971
972	// QRESYNC not supported on specified mailbox
973	if (!empty($mbox_data['NOMODSEQ']) \|\| empty($mbox_data['HIGHESTMODSEQ'])) {
974	return;
975	}
976
977	// Nothing new
978	if ($mbox_data['HIGHESTMODSEQ'] == $index['modseq']) {
979	return;
980	}
981
982	// Get known uids
983	$uids = array();
984	$sql_result = $this->db->query(
985	"SELECT uid"
986	." FROM ".get_table_name('cache_messages')
987	." WHERE user_id = ?"
988	." AND mailbox = ?",
989	$this->userid, $mailbox);
990
991	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
992	$uids[] = $sql_arr['uid'];
993	}
994
995	// No messages in database, nothing to sync
996	if (empty($uids)) {
997	return;
998	}
999
1000	// Get modified flags and vanished messages
1001	// UID FETCH 1:* (FLAGS) (CHANGEDSINCE 0123456789 VANISHED)
1002	$result = $this->imap->conn->fetch($mailbox,
1003	!empty($uids) ? $uids : '1:*', true, array('FLAGS'),
1004	$index['modseq'], $qresync);
1005
1006	$invalidated = false;
1007
1008	if (!empty($result)) {
1009	foreach ($result as $id => $msg) {
1010	$uid = $msg->uid;
1011	// Remove deleted message
1012	if ($this->skip_deleted && !empty($msg->flags['DELETED'])) {
1013	$this->remove_message($mailbox, $uid);
1014
1015	if (!$invalidated) {
1016	$invalidated = true;
1017	// Invalidate thread indexes (?)
1018	$this->remove_thread($mailbox);
1019	// Invalidate index
1020	$index['valid'] = false;
1021	}
1022	continue;
1023	}
1024
1025	$flags = 0;
1026	if (!empty($msg->flags)) {
1027	foreach ($this->flags as $idx => $flag)
1028	if (!empty($msg->flags[$flag]))
1029	$flags += $idx;
1030	}
1031
1032	$this->db->query(
1033	"UPDATE ".get_table_name('cache_messages')
1034	." SET flags = ?, changed = ".$this->db->now()
1035	." WHERE user_id = ?"
1036	." AND mailbox = ?"
1037	." AND uid = ?"
1038	." AND flags <> ?",
1039	$flags, $this->userid, $mailbox, $uid, $flags);
1040	}
1041	}
1042
1043	// Get VANISHED
1044	if ($qresync) {
1045	$mbox_data = $this->imap->mailbox_data($mailbox);
1046
1047	// Removed messages
1048	if (!empty($mbox_data['VANISHED'])) {
1049	$uids = rcube_imap_generic::uncompressMessageSet($mbox_data['VANISHED']);
1050	if (!empty($uids)) {
1051	// remove messages from database
1052	$this->remove_message($mailbox, $uids);
1053
1054	// Invalidate thread indexes (?)
1055	$this->remove_thread($mailbox);
1056	// Invalidate index
1057	$index['valid'] = false;
1058	}
1059	}
1060	}
1061
1062	$sort_field = $index['sort_field'];
1063	$sort_order = $index['sort_order'];
1064	$exists = true;
1065
1066	// Validate index
1067	if (!$this->validate($mailbox, $index, $exists)) {
1068	// Update index
1069	$data = $this->get_index_data($mailbox, $sort_field, $sort_order, $mbox_data);
1070	}
1071	else {
1072	$data = array_combine($index['seq'], $index['uid']);
1073	}
1074
1075	// update index and/or HIGHESTMODSEQ value
1076	$this->add_index_row($mailbox, $sort_field, $sort_order, $data, $mbox_data, $exists);
1077
1078	// update internal cache for get_index()
1079	$this->icache[$mailbox]['index']['result'] = $data;
1080	}
1081
1082
1083	/**
1084	* Converts cache row into message object.
1085	*
1086	* @param array $sql_arr Message row data
1087	*
1088	* @return rcube_mail_header Message object
1089	*/
1090	private function build_message($sql_arr)
1091	{
1092	$message = $this->db->decode(unserialize($sql_arr['data']));
1093
1094	if ($message) {
1095	$message->flags = array();
1096	foreach ($this->flags as $idx => $flag)
1097	if (($sql_arr['flags'] & $idx) == $idx)
1098	$message->flags[$flag] = true;
1099	}
1100
1101	return $message;
1102	}
1103
1104
1105	/**
1106	* Creates 'depth' and 'children' arrays from stored thread 'tree' data.
1107	*/
1108	private function build_thread_data($data, &$depth, &$children, $level = 0)
1109	{
1110	foreach ((array)$data as $key => $val) {
1111	$children[$key] = !empty($val);
1112	$depth[$key] = $level;
1113	if (!empty($val))
1114	$this->build_thread_data($val, $depth, $children, $level + 1);
1115	}
1116	}
1117
1118
1119	/**
1120	* Saves message stored in internal cache
1121	*/
1122	private function save_icache()
1123	{
1124	// Save current message from internal cache
1125	if ($message = $this->icache['message']) {
1126	// clean up some object's data
1127	$object = $this->message_object_prepare($message['object']);
1128
1129	// calculate current md5 sum
1130	$md5sum = md5(serialize($object));
1131
1132	if ($message['md5sum'] != $md5sum) {
1133	$this->add_message($message['mailbox'], $object, !$message['exists']);
1134	}
1135
1136	$this->icache['message']['md5sum'] = $md5sum;
1137	}
1138	}
1139
1140
1141	/**
1142	* Prepares message object to be stored in database.
1143	*/
1144	private function message_object_prepare($msg)
1145	{
1146	// Remove body too big (>25kB)
1147	if ($msg->body && strlen($msg->body) > 25 * 1024) {
1148	unset($msg->body);
1149	}
1150
1151	// Fix mimetype which might be broken by some code when message is displayed
1152	// Another solution would be to use object's copy in rcube_message class
1153	// to prevent related issues, however I'm not sure which is better
1154	if ($msg->mimetype) {
1155	list($msg->ctype_primary, $msg->ctype_secondary) = explode('/', $msg->mimetype);
1156	}
1157
1158	if (is_array($msg->structure->parts)) {
1159	foreach ($msg->structure->parts as $idx => $part) {
1160	$msg->structure->parts[$idx] = $this->message_object_prepare($part);
1161	}
1162	}
1163
1164	return $msg;
1165	}
1166
1167
1168	/**
1169	* Fetches index data from IMAP server
1170	*/
1171	private function get_index_data($mailbox, $sort_field, $sort_order, $mbox_data = array())
1172	{
1173	$data = array();
1174
1175	if (empty($mbox_data)) {
1176	$mbox_data = $this->imap->mailbox_data($mailbox);
1177	}
1178
1179	// Prevent infinite loop.
1180	// It happens when rcube_imap::message_index_direct() is called.
1181	// There id2uid() is called which will again call get_index() and so on.
1182	if (!$sort_field && !$this->skip_deleted)
1183	$this->icache['pending_index_update'] = true;
1184
1185	if ($mbox_data['EXISTS']) {
1186	// fetch sorted sequence numbers
1187	$data_seq = $this->imap->message_index_direct($mailbox, $sort_field, $sort_order);
1188	// fetch UIDs
1189	if (!empty($data_seq)) {
1190	// Seek in internal cache
1191	if (array_key_exists('index', (array)$this->icache[$mailbox])
1192	&& array_key_exists('result', (array)$this->icache[$mailbox]['index'])
1193	)
1194	$data_uid = $this->icache[$mailbox]['index']['result'];
1195	else
1196	$data_uid = $this->imap->conn->fetchUIDs($mailbox, $data_seq);
1197
1198	// build index
1199	if (!empty($data_uid)) {
1200	foreach ($data_seq as $seq)
1201	if ($uid = $data_uid[$seq])
1202	$data[$seq] = $uid;
1203	}
1204	}
1205	}
1206
1207	// Reset internal flags
1208	$this->icache['pending_index_update'] = false;
1209
1210	return $data;
1211	}
1212	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: