Debian Codegraph @

src/EWS/camel/camel-ews-folder.c

raw
1 /*
2 * SPDX-FileCopyrightText: (C) 1999-2008 Novell, Inc. (www.novell.com)
3 * SPDX-License-Identifier: LGPL-2.1-or-later
4 */
5
6 /* This file is broken and suffers from multiple author syndrome.
7 This needs to be rewritten with a lot of functions cleaned up.
8 *
9 There are a lot of places where code is unneccesarily duplicated,
10 which needs to be better organized via functions */
11
12 #include "evolution-ews-config.h"
13
14 #include <errno.h>
15 #include <string.h>
16 #include <time.h>
17 #include <unistd.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20
21 #include <glib/gi18n-lib.h>
22 #include <glib/gstdio.h>
23 #include <libecal/libecal.h>
24
25 #include "common/camel-ews-settings.h"
26 #include "common/e-ews-camel-common.h"
27 #include "common/e-ews-connection.h"
28 #include "common/e-ews-item-change.h"
29 #include "common/e-ews-request.h"
30
31 #include "camel-ews-folder.h"
32 #include "camel-ews-private.h"
33 #include "camel-ews-search.h"
34 #include "camel-ews-store.h"
35 #include "camel-ews-summary.h"
36 #include "camel-ews-utils.h"
37
38 #define EWS_MAX_FETCH_COUNT 100
39
40 #define MAX_ATTACHMENT_SIZE 1*1024*1024 /*In bytes*/
41
42 /* there are written more follow-up flags, but it's read only few of them */
43 #define SUMMARY_ITEM_FLAGS "item:ResponseObjects item:Sensitivity item:Importance item:Categories"
44
45 #define ITEM_PROPS "item:Subject item:DateTimeReceived item:DateTimeSent item:DateTimeCreated item:Size " \
46 "item:HasAttachments item:InReplyTo"
47 #define SUMMARY_ITEM_PROPS ITEM_PROPS " " SUMMARY_ITEM_FLAGS
48
49
50 #define SUMMARY_MESSAGE_FLAGS SUMMARY_ITEM_FLAGS " message:IsRead"
51 #define SUMMARY_MESSAGE_PROPS ITEM_PROPS " message:From message:Sender message:ToRecipients message:CcRecipients " \
52 "message:BccRecipients message:IsRead message:References message:InternetMessageId " \
53 SUMMARY_MESSAGE_FLAGS
54 #define SUMMARY_MESSAGE_PROPS_2013 SUMMARY_MESSAGE_PROPS " item:Preview"
55
56 #define SUMMARY_POSTITEM_PROPS ITEM_PROPS " " SUMMARY_ITEM_FLAGS " message:From message:Sender"
57
58 struct _CamelEwsFolderPrivate {
59 GMutex search_lock; /* for locking the search object */
60 GRecMutex cache_lock; /* for locking the cache object */
61
62 /* For syncronizing refresh_info/sync_changes */
63 gboolean refreshing;
64 gboolean fetch_pending;
65 GMutex state_lock;
66 GCond fetch_cond;
67 GHashTable *fetching_uids;
68
69 gboolean apply_filters;
70 gboolean check_folder;
71 };
72
73 static gboolean ews_delete_messages (CamelFolder *folder, const GSList *deleted_items, gboolean expunge, GCancellable *cancellable, GError **error);
74 static gboolean ews_refresh_info_sync (CamelFolder *folder, GCancellable *cancellable, GError **error);
75
76 #define d(x)
77
78 /* The custom property ID is a CamelArg artifact.
79 * It still identifies the property in state files. */
80 enum {
81 PROP_0,
82 PROP_APPLY_FILTERS = 0x2501,
83 PROP_CHECK_FOLDER = 0x2502
84 };
85
86 G_DEFINE_TYPE_WITH_PRIVATE (CamelEwsFolder, camel_ews_folder, CAMEL_TYPE_OFFLINE_FOLDER)
87
88 static GSList *
89 ews_folder_get_summary_followup_mapi_flags (void)
90 {
91 GSList *list = NULL;
92 EEwsExtendedFieldURI *ext_uri;
93
94 ext_uri = e_ews_extended_field_uri_new ();
95 ext_uri->prop_tag = g_strdup_printf ("%d", 0x1090); /* PidTagFlagStatus */
96 ext_uri->prop_type = g_strdup ("Integer");
97 list = g_slist_append (list, ext_uri);
98
99 ext_uri = e_ews_extended_field_uri_new ();
100 ext_uri->prop_tag = g_strdup_printf ("%d", 0x1091); /* PidTagFlagCompleteTime */
101 ext_uri->prop_type = g_strdup ("SystemTime");
102 list = g_slist_append (list, ext_uri);
103
104 ext_uri = e_ews_extended_field_uri_new ();
105 ext_uri->prop_tag = g_strdup_printf ("%d", 0x007D); /* PidTagTransportMessageHeaders */
106 ext_uri->prop_type = g_strdup ("String");
107 list = g_slist_append (list, ext_uri);
108
109 ext_uri = e_ews_extended_field_uri_new ();
110 ext_uri->distinguished_prop_set_id = g_strdup ("Common");
111 ext_uri->prop_id = g_strdup_printf ("%d", 0x8530); /* PidLidFlagRequest */
112 ext_uri->prop_type = g_strdup ("String");
113 list = g_slist_append (list, ext_uri);
114
115 ext_uri = e_ews_extended_field_uri_new ();
116 ext_uri->distinguished_prop_set_id = g_strdup ("Task");
117 ext_uri->prop_id = g_strdup_printf ("%d", 0x8105); /* PidLidTaskDueDate */
118 ext_uri->prop_type = g_strdup ("SystemTime");
119 list = g_slist_append (list, ext_uri);
120
121 return list;
122 }
123
124 static GSList *
125 ews_folder_get_summary_message_mapi_flags (void)
126 {
127 GSList *list;
128 EEwsExtendedFieldURI *ext_uri;
129
130 list = ews_folder_get_summary_followup_mapi_flags ();
131
132 /* PidTagMessageFlags */
133 ext_uri = e_ews_extended_field_uri_new ();
134 ext_uri->prop_tag = g_strdup_printf ("%d", 0x0e07);
135 ext_uri->prop_type = g_strdup ("Integer");
136 list = g_slist_append (list, ext_uri);
137
138 /* PidTagMessageStatus */
139 ext_uri = e_ews_extended_field_uri_new ();
140 ext_uri->prop_tag = g_strdup_printf ("%d", 0x0e17);
141 ext_uri->prop_type = g_strdup ("Integer");
142 list = g_slist_append (list, ext_uri);
143
144 /* PidTagIconIndex */
145 ext_uri = e_ews_extended_field_uri_new ();
146 ext_uri->prop_tag = g_strdup_printf ("%d", 0x1080);
147 ext_uri->prop_type = g_strdup ("Integer");
148 list = g_slist_append (list, ext_uri);
149
150 /* PidTagLastVerbExecuted */
151 ext_uri = e_ews_extended_field_uri_new ();
152 ext_uri->prop_tag = g_strdup_printf ("%d", 0x1081);
153 ext_uri->prop_type = g_strdup ("Integer");
154 list = g_slist_append (list, ext_uri);
155
156 /* PidTagReadReceiptRequested */
157 ext_uri = e_ews_extended_field_uri_new ();
158 ext_uri->prop_tag = g_strdup_printf ("%d", 0x0029);
159 ext_uri->prop_type = g_strdup ("Boolean");
160 list = g_slist_append (list, ext_uri);
161
162 return list;
163 }
164
165 static gchar *
166 ews_get_filename (CamelFolder *folder,
167 const gchar *uid,
168 GError **error)
169 {
170 CamelEwsFolder *ews_folder = CAMEL_EWS_FOLDER (folder);
171 GChecksum *sha = g_checksum_new (G_CHECKSUM_SHA256);
172 gchar *filename;
173
174 g_checksum_update (sha, (guchar *) uid, strlen (uid));
175 filename = camel_data_cache_get_filename (
176 ews_folder->cache, "cur", g_checksum_get_string (sha));
177 g_checksum_free (sha);
178
179 return filename;
180 }
181
182 static CamelStream *
183 ews_data_cache_add (CamelDataCache *cdc,
184 const gchar *path,
185 const gchar *key,
186 GError **error)
187 {
188 GIOStream *base_stream;
189 CamelStream *stream = NULL;
190 GChecksum *sha = g_checksum_new (G_CHECKSUM_SHA256);
191
192 g_checksum_update (sha, (guchar *) key, strlen (key));
193 base_stream = camel_data_cache_add (
194 cdc, path, g_checksum_get_string (sha), error);
195 g_checksum_free (sha);
196
197 if (base_stream != NULL) {
198 stream = camel_stream_new (base_stream);
199 g_object_unref (base_stream);
200 }
201
202 return stream;
203 }
204
205 static gint
206 ews_data_cache_remove (CamelDataCache *cdc,
207 const gchar *path,
208 const gchar *key,
209 GError **error)
210 {
211 GChecksum *sha = g_checksum_new (G_CHECKSUM_SHA256);
212 gint ret;
213
214 g_checksum_update (sha, (guchar *) key, strlen (key));
215 ret = camel_data_cache_remove (
216 cdc, path, g_checksum_get_string (sha), error);
217 g_checksum_free (sha);
218
219 return ret;
220 }
221
222 static CamelStream *
223 ews_data_cache_get (CamelDataCache *cdc,
224 const gchar *path,
225 const gchar *key,
226 GError **error)
227 {
228 GChecksum *sha = g_checksum_new (G_CHECKSUM_SHA256);
229 CamelStream *stream = NULL;
230 GIOStream *base_stream;
231
232 g_checksum_update (sha, (guchar *) key, strlen (key));
233 base_stream = camel_data_cache_get (
234 cdc, path, g_checksum_get_string (sha), error);
235 if (base_stream != NULL) {
236 stream = camel_stream_new (base_stream);
237 g_object_unref (base_stream);
238 }
239 g_checksum_free (sha);
240
241 return stream;
242 }
243
244 static gchar *
245 ews_data_cache_get_filename (CamelDataCache *cdc,
246 const gchar *path,
247 const gchar *key,
248 GError **error)
249 {
250 GChecksum *sha = g_checksum_new (G_CHECKSUM_SHA256);
251 gchar *filename;
252
253 g_checksum_update (sha, (guchar *) key, strlen (key));
254 filename = camel_data_cache_get_filename (
255 cdc, path, g_checksum_get_string (sha));
256 g_checksum_free (sha);
257
258 return filename;
259 }
260
261 static CamelMimeMessage *
262 camel_ews_folder_get_message_from_cache (CamelEwsFolder *ews_folder,
263 const gchar *uid,
264 GCancellable *cancellable,
265 GError **error)
266 {
267 CamelStream *stream;
268 CamelMimeMessage *msg;
269 CamelEwsFolderPrivate *priv;
270
271 priv = ews_folder->priv;
272
273 g_rec_mutex_lock (&priv->cache_lock);
274 stream = ews_data_cache_get (ews_folder->cache, "cur", uid, error);
275 if (!stream) {
276 gchar *old_fname = camel_data_cache_get_filename (
277 ews_folder->cache, "cur", uid);
278 if (!g_access (old_fname, R_OK)) {
279 gchar *new_fname = ews_data_cache_get_filename (
280 ews_folder->cache,
281 "cur", uid, error);
282 if (g_rename (old_fname, new_fname) == -1) {
283 g_warning ("%s: Failed to rename '%s' to '%s': %s", G_STRFUNC,
284 old_fname, new_fname, g_strerror (errno));
285 }
286 g_free (new_fname);
287 stream = ews_data_cache_get (ews_folder->cache, "cur", uid, error);
288 }
289 g_free (old_fname);
290 if (!stream) {
291 g_rec_mutex_unlock (&priv->cache_lock);
292 return NULL;
293 }
294 }
295
296 msg = camel_mime_message_new ();
297
298 if (!camel_data_wrapper_construct_from_stream_sync (
299 (CamelDataWrapper *) msg, stream, cancellable, error)) {
300 g_object_unref (msg);
301 msg = NULL;
302 }
303
304 g_rec_mutex_unlock (&priv->cache_lock);
305 g_object_unref (stream);
306
307 return msg;
308 }
309
310 static CamelMimePart *
311 ews_get_calendar_mime_part (CamelMimePart *mimepart)
312 {
313 guint partnumber, i;
314 CamelDataWrapper *datawrapper;
315 datawrapper = camel_medium_get_content (CAMEL_MEDIUM (mimepart));
316
317 if (CAMEL_IS_MULTIPART (datawrapper)) {
318 partnumber = camel_multipart_get_number (CAMEL_MULTIPART (datawrapper));
319 for (i = 0; i < partnumber; i++) {
320 CamelMimePart *child_mimepart = NULL;
321 CamelMimePart *ret_mimepart = NULL;
322 child_mimepart = camel_multipart_get_part (CAMEL_MULTIPART (datawrapper), i);
323
324 if (!child_mimepart)
325 goto exit;
326
327 ret_mimepart = ews_get_calendar_mime_part (child_mimepart);
328 if (ret_mimepart)
329 return ret_mimepart;
330 }
331 }
332 else {
333 gchar *type;
334 type = camel_data_wrapper_get_mime_type (datawrapper);
335 if (!g_ascii_strcasecmp (type, "text/calendar")) {
336 g_free (type);
337 return mimepart;
338 }
339 g_free (type);
340 }
341 exit:
342 return NULL;
343 }
344
345 static gchar *
346 ews_update_mtgrequest_mime_calendar_itemid (const gchar *mime_fname,
347 const EwsId *calendar_item_id,
348 gboolean is_calendar_UID,
349 const EwsId *mail_item_id,
350 const gchar *html_body,
351 GError **error)
352 {
353 CamelMimeParser *mimeparser;
354 CamelMimeMessage *msg;
355 CamelMimePart *mimepart = NULL;
356 gint fd_old;
357 gchar *mime_fname_new = NULL;
358
359 /* original mime file */
360 fd_old = open (mime_fname, O_RDONLY);
361 if (fd_old == -1) {
362 g_set_error (
363 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
364 _("Unable to open mimecontent temporary file!"));
365 return NULL;
366 }
367
368 mimeparser = camel_mime_parser_new ();
369 if (camel_mime_parser_init_with_fd (mimeparser, fd_old) == -1) {
370 g_set_error (
371 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
372 _("Unable to generate parser from mimecontent!"));
373 goto exit_parser;
374 }
375
376 msg = camel_mime_message_new ();
377 if (camel_mime_part_construct_from_parser_sync (
378 CAMEL_MIME_PART (msg), mimeparser, NULL, error) == -1) {
379 g_set_error (
380 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
381 _("Unable to parse meeting request mimecontent!"));
382 goto exit_msg;
383 }
384
385 mimepart = ews_get_calendar_mime_part (CAMEL_MIME_PART (msg));
386 if (mimepart) {
387 CamelDataWrapper *dw;
388 CamelStream *tmpstream = NULL, *newstream = NULL;
389 GByteArray *ba;
390 ICalComponent *icomp = NULL;
391 gchar *dir;
392 gint fd;
393 gboolean success = FALSE;
394
395 dw = camel_medium_get_content (CAMEL_MEDIUM (mimepart));
396 tmpstream = camel_stream_mem_new ();
397 if (camel_data_wrapper_decode_to_stream_sync (
398 dw, tmpstream, NULL, error) == -1) {
399 g_object_unref (tmpstream);
400 goto exit_msg;
401 }
402 ba = camel_stream_mem_get_byte_array (CAMEL_STREAM_MEM (tmpstream));
403 if (ba && ba->len) {
404 g_byte_array_append (ba, (guint8 *) "\0", 1);
405 icomp = i_cal_parser_parse_string ((gchar *) ba->data);
406 if (!icomp) {
407 const gchar *content = (const gchar *) ba->data;
408 const gchar *begin_vcalendar, *end_vcalendar;
409
410 /* Workaround Office365.com error, which returns invalid iCalendar object (without 'END:VCALENDAR'),
411 in the MimeContent's text/calendar attachments as of 2023-12-12. */
412 begin_vcalendar = camel_strstrcase (content, "BEGIN:VCALENDAR");
413 end_vcalendar = camel_strstrcase (content, "END:VCALENDAR");
414
415 /* If it exists, then it should be alone on a separate line */
416 if (!(begin_vcalendar && (begin_vcalendar == content || begin_vcalendar[-1] == '\n') &&
417 (begin_vcalendar[15 /* strlen ("BEGIN:VCALENDAR") */] == '\r' || begin_vcalendar[15] == '\n')))
418 begin_vcalendar = NULL;
419
420 /* If it exists, then it should be alone on a separate line and not at the very beginning of the mime_content */
421 if (!(end_vcalendar && end_vcalendar > content && end_vcalendar[-1] == '\n' &&
422 (end_vcalendar[13 /* strlen ("END:VCALENDAR") */] == '\r' || end_vcalendar[13] == '\n' || end_vcalendar[13] == '\0')))
423 end_vcalendar = NULL;
424
425 if (begin_vcalendar && !end_vcalendar) {
426 g_byte_array_remove_index (ba, ba->len - 1);
427 #define add_str(_str) g_byte_array_append (ba, (guint8 *) _str, strlen (_str))
428 add_str ("\r\nEND:VCALENDAR\r\n");
429 #undef add_str
430 g_byte_array_append (ba, (guint8 *) "\0", 1);
431
432 icomp = i_cal_parser_parse_string ((const gchar *) ba->data);
433 }
434 }
435 }
436 if (icomp) {
437 ICalComponent *subcomp;
438 ICalProperty *prop;
439 gchar *calstring_new;
440
441 subcomp = i_cal_component_get_first_component (icomp, I_CAL_VEVENT_COMPONENT);
442 prop = i_cal_property_new_x (calendar_item_id->change_key);
443 i_cal_property_set_x_name (prop, "X-EVOLUTION-CHANGEKEY");
444 i_cal_component_take_property (subcomp, prop);
445
446 /* In order to accept items we have to store AssociatedCalendarItemId (X-EVOLUTION-ITEMID)
447 * or mail id (X-EVOLUTION-ACCEPT-ID) when we do not have AssociatedCalendarItemId */
448 if (is_calendar_UID) {
449 prop = i_cal_property_new_x (calendar_item_id->id);
450 i_cal_property_set_x_name (prop, "X-EVOLUTION-ITEMID");
451 i_cal_component_take_property (subcomp, prop);
452 }
453
454 prop = i_cal_property_new_x (mail_item_id->id);
455 i_cal_property_set_x_name (prop, "X-EVOLUTION-ACCEPT-ID");
456 i_cal_component_take_property (subcomp, prop);
457
458 if (html_body && *html_body) {
459 prop = i_cal_component_get_first_property (subcomp, I_CAL_DESCRIPTION_PROPERTY);
460
461 /* The server can return empty HTML (with "<html><body></body></html>" only),
462 thus add it only if there was any DESCRIPTION provided as well. */
463 if (prop) {
464 g_clear_object (&prop);
465
466 prop = i_cal_property_new_x (html_body);
467 i_cal_property_set_x_name (prop, "X-ALT-DESC");
468 i_cal_property_set_parameter_from_string (prop, "FMTTYPE", "text/html");
469 i_cal_component_take_property (subcomp, prop);
470 }
471 }
472
473 calstring_new = i_cal_component_as_ical_string (icomp);
474 if (calstring_new) {
475 camel_mime_part_set_content (
476 mimepart,
477 (const gchar *) calstring_new,
478 strlen (calstring_new),
479 "text/calendar");
480 g_free (calstring_new);
481 }
482 g_object_unref (subcomp);
483 g_object_unref (icomp);
484 }
485 g_object_unref (tmpstream);
486
487 /* Create a new file to store updated mimecontent */
488 dir = g_path_get_dirname (mime_fname);
489 mime_fname_new = g_build_filename ((const gchar *) dir, "XXXXXX", NULL);
490 fd = g_mkstemp (mime_fname_new);
491 if (fd == -1) {
492 g_set_error (
493 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
494 _("Unable to create cache file"));
495 goto exit_save;
496 }
497 newstream = camel_stream_fs_new_with_fd (fd);
498 if (camel_data_wrapper_write_to_stream_sync (
499 CAMEL_DATA_WRAPPER (msg),
500 newstream, NULL, error) == -1)
501 goto exit_save;
502 if (camel_stream_flush (newstream, NULL, error) == -1)
503 goto exit_save;
504 if (camel_stream_close (newstream, NULL, error) == -1)
505 goto exit_save;
506 if (g_remove (mime_fname) == -1) {
507 g_warning ("%s: Failed to remove file '%s': %s",
508 G_STRFUNC, mime_fname, g_strerror (errno));
509 }
510 success = TRUE;
511 exit_save:
512 if (fd != -1)
513 close (fd);
514 g_free (dir);
515 if (newstream)
516 g_object_unref (newstream);
517 if (!success) {
518 g_free (mime_fname_new);
519 mime_fname_new = NULL;
520 }
521 }
522 exit_msg:
523 g_object_unref (msg);
524 exit_parser:
525 g_object_unref (mimeparser);
526 close (fd_old);
527
528 /* must be freed in the caller */
529 return mime_fname_new;
530 }
531
532 static void
533 ews_fetch_cancellable_cancelled_cb (GCancellable *cancellable,
534 GCond *fetch_cond)
535 {
536 g_return_if_fail (fetch_cond != NULL);
537
538 g_cond_broadcast (fetch_cond);
539 }
540
541 static gboolean
542 ews_message_from_properties_sync (CamelEwsFolder *ews_folder,
543 EEwsConnection *cnc,
544 gint pri,
545 GSList *ids,
546 const gchar *mime_dir,
547 GSList **out_items, /* EEwsItem * */
548 GCancellable *cancellable,
549 GError **error)
550 {
551 EEwsAdditionalProps *add_props;
552 const CamelNameValueArray *headers;
553 CamelMessageInfo *mi;
554 CamelMimeMessage *msg;
555 CamelStream *new_stream;
556 EEwsItem *item;
557 gboolean bval = FALSE;
558 gchar *mime_fname_new;
559 gint fd;
560 GSList *items = NULL;
561
562 g_return_val_if_fail (CAMEL_IS_EWS_FOLDER (ews_folder), FALSE);
563 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
564 g_return_val_if_fail (ids != NULL, FALSE);
565 g_return_val_if_fail (mime_dir != NULL, FALSE);
566 g_return_val_if_fail (out_items != NULL, FALSE);
567
568 add_props = e_ews_additional_props_new ();
569 if (e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2013))
570 add_props->field_uri = g_strdup (SUMMARY_MESSAGE_PROPS_2013 " item:Body item:Attachments");
571 else
572 add_props->field_uri = g_strdup (SUMMARY_MESSAGE_PROPS " item:Body item:Attachments");
573 add_props->extended_furis = ews_folder_get_summary_message_mapi_flags ();
574
575 if (!e_ews_connection_get_items_sync (cnc, pri, ids, "IdOnly", add_props,
576 FALSE, NULL, E_EWS_BODY_TYPE_TEXT, &items, NULL, NULL, cancellable, error) || !items) {
577 e_ews_additional_props_free (add_props);
578 return FALSE;
579 }
580
581 e_ews_additional_props_free (add_props);
582
583 mi = camel_ews_utils_item_to_message_info (ews_folder, cnc, items->data, cancellable);
584 if (!mi) {
585 g_slist_free_full (items, g_object_unref);
586 return FALSE;
587 }
588
589 item = items->data;
590 msg = camel_mime_message_new ();
591
592 headers = camel_message_info_get_headers (mi);
593 if (headers) {
594 CamelMedium *medium = CAMEL_MEDIUM (msg);
595 guint ii, len;
596
597 len = camel_name_value_array_get_length (headers);
598
599 for (ii = 0; ii < len; ii++) {
600 const gchar *name = NULL, *value = NULL;
601
602 /* Skip any content-describing headers */
603 if (camel_name_value_array_get (headers, ii, &name, &value) &&
604 name && g_ascii_strncasecmp (name, "Content-", 8) != 0) {
605 camel_medium_add_header (medium, name, value);
606 }
607 }
608 } else {
609 CamelMedium *medium = CAMEL_MEDIUM (msg);
610
611 camel_mime_message_set_date (msg, e_ews_item_get_date_sent (item), 0);
612 camel_mime_message_set_message_id (msg, e_ews_item_get_msg_id (item));
613 if (e_ews_item_get_in_replyto (item))
614 camel_medium_set_header (medium, "In-Reply-To", e_ews_item_get_in_replyto (item));
615 if (e_ews_item_get_references (item))
616 camel_medium_set_header (medium, "References", e_ews_item_get_references (item));
617 camel_medium_set_header (medium, "From", camel_message_info_get_from (mi));
618 camel_medium_set_header (medium, "To", camel_message_info_get_to (mi));
619 camel_medium_set_header (medium, "Cc", camel_message_info_get_from (mi));
620 camel_mime_message_set_subject (msg, camel_message_info_get_subject (mi));
621 }
622
623 if (e_ews_item_has_attachments (item, &bval) && bval &&
624 e_ews_item_get_attachments_ids (item)) {
625 CamelMimePart *part;
626 CamelMultipart *m_mixed;
627 const gchar *body = e_ews_item_get_body (item);
628 GSList *attach_ids, *attachments = NULL, *link;
629
630 m_mixed = camel_multipart_new ();
631 camel_data_wrapper_set_mime_type (CAMEL_DATA_WRAPPER (m_mixed), "multipart/mixed");
632 camel_multipart_set_boundary (m_mixed, NULL);
633
634 if (!body || !*body)
635 body = " ";
636
637 part = camel_mime_part_new ();
638 camel_mime_part_set_encoding (part, CAMEL_TRANSFER_ENCODING_8BIT);
639 camel_mime_part_set_content (part, body, strlen (body), "text/plain");
640 camel_multipart_add_part (m_mixed, part);
641 g_object_unref (part);
642
643 attach_ids = e_ews_item_get_attachments_ids (item);
644 if (e_ews_connection_get_attachments_sync (cnc, EWS_PRIORITY_MEDIUM, NULL, attach_ids, NULL, FALSE, &attachments,
645 NULL, NULL, cancellable, error)) {
646 for (link = attachments; link; link = g_slist_next (link)) {
647 EEwsAttachmentInfo *ainfo = link->data;
648
649 if (ainfo && e_ews_attachment_info_get_type (ainfo) == E_EWS_ATTACHMENT_INFO_TYPE_INLINED) {
650 const gchar *mime_type;
651 const gchar *filename;
652 const gchar *content;
653 gsize content_len = 0;
654
655 mime_type = e_ews_attachment_info_get_mime_type (ainfo);
656 if (!mime_type)
657 mime_type = "application/octet-stream";
658
659 filename = e_ews_attachment_info_get_prefer_filename (ainfo);
660 if (!filename)
661 filename = e_ews_attachment_info_get_filename (ainfo);
662
663 content = e_ews_attachment_info_get_inlined_data (ainfo, &content_len);
664 if (!content) {
665 content = " ";
666 content_len = 1;
667 }
668
669 part = camel_mime_part_new ();
670 camel_mime_part_set_disposition (part, "attachment");
671 camel_mime_part_set_encoding (part, CAMEL_TRANSFER_ENCODING_BASE64);
672 camel_mime_part_set_content (part, content, content_len, mime_type);
673
674 if (filename)
675 camel_mime_part_set_filename (part, filename);
676
677 camel_multipart_add_part (m_mixed, part);
678 g_object_unref (part);
679 }
680 }
681
682 g_slist_free_full (attachments, (GDestroyNotify) e_ews_attachment_info_free);
683 }
684
685 camel_medium_set_content (CAMEL_MEDIUM (msg), CAMEL_DATA_WRAPPER (m_mixed));
686
687 g_object_unref (m_mixed);
688 } else {
689 const gchar *body = e_ews_item_get_body (item);
690
691 if (!body || !*body)
692 body = " ";
693
694 camel_mime_part_set_encoding (CAMEL_MIME_PART (msg), CAMEL_TRANSFER_ENCODING_8BIT);
695 camel_mime_part_set_content (CAMEL_MIME_PART (msg), body, strlen (body), "text/plain");
696 }
697
698 mime_fname_new = g_build_filename (mime_dir, "XXXXXX", NULL);
699 fd = g_mkstemp (mime_fname_new);
700 if (fd != -1)
701 e_ews_item_set_mime_content (item, mime_fname_new);
702 g_free (mime_fname_new);
703
704 if (fd == -1) {
705 g_set_error (
706 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
707 _("Unable to create cache file"));
708
709 g_slist_free_full (items, g_object_unref);
710 g_clear_object (&msg);
711 g_clear_object (&mi);
712
713 return FALSE;
714 }
715
716 new_stream = camel_stream_fs_new_with_fd (fd);
717 if (camel_data_wrapper_write_to_stream_sync (CAMEL_DATA_WRAPPER (msg), new_stream, cancellable, error) == -1 ||
718 camel_stream_flush (new_stream, cancellable, error) == -1 ||
719 camel_stream_close (new_stream, cancellable, error) == -1) {
720 g_slist_free_full (items, g_object_unref);
721 g_clear_object (&new_stream);
722 g_clear_object (&msg);
723 g_clear_object (&mi);
724
725 return FALSE;
726 }
727
728 g_clear_object (&new_stream);
729 g_clear_object (&msg);
730 g_clear_object (&mi);
731
732 *out_items = items;
733
734 return TRUE;
735 }
736
737 static CamelMimeMessage *
738 camel_ews_folder_get_message (CamelFolder *folder,
739 const gchar *uid,
740 gint pri,
741 GCancellable *cancellable,
742 GError **error)
743 {
744 CamelEwsFolder *ews_folder;
745 CamelEwsFolderPrivate *priv;
746 EEwsConnection *cnc = NULL;
747 EEwsAdditionalProps *add_props = NULL;
748 CamelEwsStore *ews_store;
749 const gchar *mime_content;
750 CamelMimeMessage *message = NULL;
751 GSList *ids = NULL, *items = NULL;
752 gchar *mime_dir;
753 gchar *cache_file;
754 gchar *dir;
755 gboolean res;
756 gchar *mime_fname_new = NULL;
757 GError *local_error = NULL;
758
759 g_return_val_if_fail (CAMEL_IS_EWS_FOLDER (folder), NULL);
760
761 ews_store = (CamelEwsStore *) camel_folder_get_parent_store (folder);
762 ews_folder = (CamelEwsFolder *) folder;
763 priv = ews_folder->priv;
764
765 g_mutex_lock (&priv->state_lock);
766
767 message = camel_ews_folder_get_message_from_cache (ews_folder, uid, cancellable, NULL);
768 if (message) {
769 g_mutex_unlock (&priv->state_lock);
770
771 return message;
772 }
773
774 /* If another thread is already fetching this message, wait for it */
775 if (g_hash_table_lookup (priv->fetching_uids, uid)) {
776 gulong cancelled_handler_id = 0;
777
778 if (G_IS_CANCELLABLE (cancellable)) {
779 cancelled_handler_id = g_cancellable_connect (cancellable,
780 G_CALLBACK (ews_fetch_cancellable_cancelled_cb),
781 &priv->fetch_cond, NULL);
782 }
783
784 do {
785 g_cond_wait (&priv->fetch_cond, &priv->state_lock);
786 } while (g_hash_table_lookup (priv->fetching_uids, uid) &&
787 !g_cancellable_is_cancelled (cancellable));
788
789 if (cancelled_handler_id && G_IS_CANCELLABLE (cancellable))
790 g_cancellable_disconnect (cancellable, cancelled_handler_id);
791
792 if (g_cancellable_set_error_if_cancelled (cancellable, error)) {
793 g_mutex_unlock (&priv->state_lock);
794 return NULL;
795 }
796
797 message = camel_ews_folder_get_message_from_cache (ews_folder, uid, cancellable, NULL);
798 if (message || g_cancellable_set_error_if_cancelled (cancellable, error)) {
799 g_mutex_unlock (&priv->state_lock);
800 return message;
801 }
802 }
803
804 /* Because we're using this as a form of mutex, we *know* that
805 * we won't be inserting where an entry already exists. So it's
806 * OK to insert uid itself, not g_strdup (uid) */
807 g_hash_table_insert (priv->fetching_uids, (gchar *) uid, (gchar *) uid);
808 g_mutex_unlock (&priv->state_lock);
809
810 if (!camel_ews_store_connected (ews_store, cancellable, error))
811 goto exit;
812
813 cnc = camel_ews_store_ref_connection (ews_store);
814 ids = g_slist_append (ids, (gchar *) uid);
815
816 mime_dir = g_build_filename (
817 camel_data_cache_get_path (ews_folder->cache),
818 "mimecontent", NULL);
819
820 if (g_access (mime_dir, F_OK) == -1 &&
821 g_mkdir_with_parents (mime_dir, 0700) == -1) {
822 g_set_error (
823 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
824 _("Unable to create cache path “%s”: %s"),
825 mime_dir, g_strerror (errno));
826 g_free (mime_dir);
827 goto exit;
828 }
829
830 add_props = e_ews_additional_props_new ();
831 add_props->field_uri = g_strdup ("item:MimeContent message:From message:Sender");
832 add_props->indexed_furis = g_slist_prepend (NULL, e_ews_indexed_field_uri_new ("item:InternetMessageHeader", "Date"));
833
834 res = e_ews_connection_get_items_sync (
835 cnc, pri, ids, "IdOnly", add_props,
836 TRUE, mime_dir, E_EWS_BODY_TYPE_ANY,
837 &items,
838 (ESoapResponseProgressFn) camel_operation_progress,
839 (gpointer) cancellable,
840 cancellable, &local_error);
841 e_ews_additional_props_free (add_props);
842
843 if (!res || !items) {
844 camel_ews_store_maybe_disconnect (ews_store, local_error);
845 g_propagate_error (error, local_error);
846 g_free (mime_dir);
847 goto exit;
848 }
849
850 if (e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_ERROR) {
851 if (g_error_matches (e_ews_item_get_error (items->data), EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_MIMECONTENTCONVERSIONFAILED)) {
852 g_slist_free_full (items, g_object_unref);
853 items = NULL;
854 /* The server failed to convert message into the MimeContent;
855 construct it from the properties. */
856 if (!ews_message_from_properties_sync (ews_folder, cnc, pri, ids, mime_dir, &items, cancellable, &local_error) || !items) {
857 camel_ews_store_maybe_disconnect (ews_store, local_error);
858 g_propagate_error (error, local_error);
859 g_free (mime_dir);
860 goto exit;
861 }
862 }
863
864 if (e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_ERROR) {
865 local_error = g_error_copy (e_ews_item_get_error (items->data));
866 camel_ews_store_maybe_disconnect (ews_store, local_error);
867 if (local_error)
868 g_propagate_error (error, local_error);
869 g_free (mime_dir);
870 goto exit;
871 }
872 }
873
874 g_free (mime_dir);
875
876 /* The mime_content actually contains the *filename*, due to the
877 * streaming hack in ESoapResponse */
878 mime_content = e_ews_item_get_mime_content (items->data);
879 if (!mime_content)
880 goto exit;
881
882 /* Exchange returns random UID for associated calendar item, which has no way
883 * to match with calendar components saved in calendar cache. So manually get
884 * AssociatedCalendarItemId, replace the random UID with this ItemId,
885 * And save updated message data to a new temp file */
886 if (e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_MEETING_REQUEST ||
887 e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_MEETING_CANCELLATION ||
888 e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_MEETING_MESSAGE ||
889 e_ews_item_get_item_type (items->data) == E_EWS_ITEM_TYPE_MEETING_RESPONSE) {
890 GSList *items_req = NULL, *html_body_resp = NULL;
891 GSList *html_body_ids;
892 const EwsId *calendar_item_accept_id = NULL;
893 const gchar *html_body = NULL;
894 gboolean is_calendar_UID = TRUE;
895
896 add_props = e_ews_additional_props_new ();
897 add_props->field_uri = g_strdup ("meeting:AssociatedCalendarItemId");
898
899 /* Get AssociatedCalendarItemId with second get_items call */
900 res = e_ews_connection_get_items_sync (
901 cnc, pri, ids, "IdOnly", add_props,
902 FALSE, NULL, E_EWS_BODY_TYPE_ANY,
903 &items_req,
904 (ESoapResponseProgressFn) camel_operation_progress,
905 (gpointer) cancellable,
906 cancellable, &local_error);
907
908 e_ews_additional_props_free (add_props);
909
910 if (!res || (items_req && e_ews_item_get_item_type (items_req->data) == E_EWS_ITEM_TYPE_ERROR)) {
911 if (items_req) {
912 g_object_unref (items_req->data);
913 g_slist_free (items_req);
914 }
915 if (local_error) {
916 camel_ews_store_maybe_disconnect (ews_store, local_error);
917 g_propagate_error (error, local_error);
918 }
919 goto exit;
920 }
921
922 if (items_req != NULL)
923 calendar_item_accept_id = e_ews_item_get_calendar_item_accept_id (items_req->data);
924
925 /*In case of non-exchange based meetings invites the calendar backend have to create the meeting*/
926 if (calendar_item_accept_id == NULL) {
927 calendar_item_accept_id = e_ews_item_get_id (items->data);
928 is_calendar_UID = FALSE;
929 }
930
931 add_props = e_ews_additional_props_new ();
932 add_props->field_uri = g_strdup ("item:Body");
933
934 html_body_ids = g_slist_prepend (NULL, calendar_item_accept_id->id);
935
936 if (e_ews_connection_get_items_sync (
937 cnc, pri, html_body_ids, "IdOnly", add_props,
938 FALSE, NULL, E_EWS_BODY_TYPE_BEST,
939 &html_body_resp,
940 (ESoapResponseProgressFn) camel_operation_progress,
941 (gpointer) cancellable,
942 cancellable, NULL) && html_body_resp && e_ews_item_get_item_type (html_body_resp->data) != E_EWS_ITEM_TYPE_ERROR) {
943 EEwsItem *item = html_body_resp->data;
944
945 if (e_ews_item_get_body_type (item) == E_EWS_BODY_TYPE_HTML) {
946 html_body = e_ews_item_get_body (item);
947 }
948 }
949
950 e_ews_additional_props_free (add_props);
951 g_slist_free (html_body_ids);
952
953 mime_fname_new = ews_update_mtgrequest_mime_calendar_itemid (mime_content, calendar_item_accept_id, is_calendar_UID, e_ews_item_get_id (items->data), html_body, error);
954 if (mime_fname_new)
955 mime_content = (const gchar *) mime_fname_new;
956
957 g_slist_free_full (html_body_resp, g_object_unref);
958 g_slist_free_full (items_req, g_object_unref);
959 }
960
961 cache_file = ews_data_cache_get_filename (
962 ews_folder->cache, "cur", uid, error);
963 dir = g_path_get_dirname (cache_file);
964
965 if (g_mkdir_with_parents (dir, 0700) == -1) {
966 g_set_error (
967 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
968 _("Unable to create cache path “%s”: %s"),
969 dir, g_strerror (errno));
970 g_free (dir);
971 g_free (cache_file);
972 goto exit;
973 }
974 g_free (dir);
975
976 if (g_rename (mime_content, cache_file) != 0) {
977 g_set_error (
978 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
979 /* Translators: The first %s consists of the source file name,
980 the second %s of the destination file name and
981 the third %s of the error message. */
982 _("Failed to move message cache file from “%s” to “%s”: %s"),
983 mime_content, cache_file, g_strerror (errno));
984 g_free (cache_file);
985 goto exit;
986 }
987 g_free (cache_file);
988
989 message = camel_ews_folder_get_message_from_cache (ews_folder, uid, cancellable, error);
990 if (message) {
991 CamelInternetAddress *from;
992 CamelMessageInfo *mi;
993 const gchar *email = NULL, *date_header;
994 gboolean resave = FALSE;
995
996 from = camel_mime_message_get_from (message);
997
998 if (!from || !camel_internet_address_get (from, 0, NULL, &email) || !email || !*email) {
999 const EwsMailbox *mailbox;
1000
1001 mailbox = e_ews_item_get_from (items->data);
1002 if (!mailbox)
1003 mailbox = e_ews_item_get_sender (items->data);
1004 if (mailbox) {
1005 email = NULL;
1006
1007 if (g_strcmp0 (mailbox->routing_type, "EX") == 0)
1008 email = e_ews_item_util_strip_ex_address (mailbox->email);
1009
1010 from = camel_internet_address_new ();
1011 camel_internet_address_add (from, mailbox->name, email ? email : mailbox->email);
1012 camel_mime_message_set_from (message, from);
1013 g_object_unref (from);
1014
1015 resave = TRUE;
1016 }
1017 }
1018
1019 date_header = e_ews_item_get_date_header (items->data);
1020 if (date_header && *date_header) {
1021 time_t tt;
1022 gint tz_offset;
1023
1024 tt = camel_header_decode_date (date_header, &tz_offset);
1025 if (tt > 0) {
1026 camel_mime_message_set_date (message, tt, tz_offset);
1027 resave = TRUE;
1028 }
1029 }
1030
1031 if (resave) {
1032 CamelStream *cache_stream;
1033
1034 g_rec_mutex_lock (&priv->cache_lock);
1035 /* Ignore errors here, it's nothing fatal in this case */
1036 cache_stream = ews_data_cache_get (ews_folder->cache, "cur", uid, NULL);
1037 if (cache_stream) {
1038 GIOStream *iostream;
1039
1040 /* Truncate the stream first, in case the message will be shorter
1041 than the one received from the server */
1042 iostream = camel_stream_ref_base_stream (cache_stream);
1043 if (iostream) {
1044 GOutputStream *output_stream;
1045
1046 output_stream = g_io_stream_get_output_stream (iostream);
1047 if (G_IS_SEEKABLE (output_stream)) {
1048 GSeekable *seekable = G_SEEKABLE (output_stream);
1049
1050 if (g_seekable_can_truncate (seekable)) {
1051 g_seekable_truncate (seekable, 0, NULL, NULL);
1052 }
1053 }
1054
1055 g_object_unref (iostream);
1056 }
1057
1058 camel_data_wrapper_write_to_stream_sync (CAMEL_DATA_WRAPPER (message), cache_stream, cancellable, NULL);
1059 g_object_unref (cache_stream);
1060 }
1061 g_rec_mutex_unlock (&priv->cache_lock);
1062 }
1063
1064 mi = camel_folder_summary_get (camel_folder_get_folder_summary (folder), uid);
1065 if (mi) {
1066 CamelMessageFlags flags;
1067 gboolean has_attachment;
1068
1069 flags = camel_message_info_get_flags (mi);
1070 has_attachment = camel_mime_message_has_attachment (message);
1071 if (((flags & CAMEL_MESSAGE_ATTACHMENTS) && !has_attachment) ||
1072 ((flags & CAMEL_MESSAGE_ATTACHMENTS) == 0 && has_attachment)) {
1073 camel_message_info_set_flags (
1074 mi, CAMEL_MESSAGE_ATTACHMENTS,
1075 has_attachment ? CAMEL_MESSAGE_ATTACHMENTS : 0);
1076 }
1077
1078 g_clear_object (&mi);
1079 }
1080 }
1081
1082 exit:
1083 g_mutex_lock (&priv->state_lock);
1084 g_hash_table_remove (priv->fetching_uids, uid);
1085 g_cond_broadcast (&priv->fetch_cond);
1086 g_mutex_unlock (&priv->state_lock);
1087
1088 if (!message && error && !*error)
1089 g_set_error (
1090 error, CAMEL_ERROR, 1,
1091 "Could not retrieve the message");
1092 if (ids)
1093 g_slist_free (ids);
1094 if (items) {
1095 g_object_unref (items->data);
1096 g_slist_free (items);
1097 }
1098
1099 if (mime_fname_new)
1100 g_free (mime_fname_new);
1101 g_clear_object (&cnc);
1102
1103 return message;
1104 }
1105
1106 static void
1107 ews_folder_maybe_update_mlist (CamelFolder *folder,
1108 const gchar *uid,
1109 CamelMimeMessage *message)
1110 {
1111 CamelFolderSummary *summary;
1112 CamelMessageInfo *mi;
1113 const gchar *set_mlist;
1114
1115 g_return_if_fail (CAMEL_IS_FOLDER (folder));
1116 g_return_if_fail (uid != NULL);
1117 g_return_if_fail (message != NULL);
1118
1119 mi = camel_folder_summary_get (camel_folder_get_folder_summary (folder), uid);
1120 if (!mi)
1121 return;
1122
1123 summary = camel_message_info_ref_summary (mi);
1124 if (summary)
1125 camel_folder_summary_lock (summary);
1126 camel_message_info_property_lock (mi);
1127 set_mlist = camel_message_info_get_mlist (mi);
1128
1129 if (!set_mlist || !*set_mlist) {
1130 /* update mailing list information, if necessary */
1131 gchar *mlist = camel_headers_dup_mailing_list (camel_medium_get_headers (CAMEL_MEDIUM (message)));
1132
1133 if (mlist) {
1134 camel_message_info_set_mlist (mi, mlist);
1135 g_free (mlist);
1136 }
1137 }
1138
1139 camel_message_info_property_unlock (mi);
1140 if (summary)
1141 camel_folder_summary_unlock (summary);
1142
1143 g_clear_object (&summary);
1144 g_clear_object (&mi);
1145 }
1146
1147 static guint32
1148 ews_folder_get_permanent_flags (CamelFolder *folder)
1149 {
1150 return CAMEL_MESSAGE_ANSWERED |
1151 CAMEL_MESSAGE_DELETED |
1152 CAMEL_MESSAGE_DRAFT |
1153 CAMEL_MESSAGE_FLAGGED |
1154 CAMEL_MESSAGE_SEEN |
1155 CAMEL_MESSAGE_FORWARDED |
1156 CAMEL_MESSAGE_USER;
1157 }
1158
1159 /* Get the message from cache if available otherwise get it from server */
1160 static CamelMimeMessage *
1161 ews_folder_get_message_sync (CamelFolder *folder,
1162 const gchar *uid,
1163 GCancellable *cancellable,
1164 GError **error)
1165 {
1166 CamelMimeMessage *message;
1167
1168 g_return_val_if_fail (CAMEL_IS_EWS_FOLDER (folder), NULL);
1169
1170 message = camel_ews_folder_get_message (folder, uid, EWS_ITEM_HIGH, cancellable, error);
1171 if (message)
1172 ews_folder_maybe_update_mlist (folder, uid, message);
1173
1174 return message;
1175 }
1176
1177 static CamelMimeMessage *
1178 ews_folder_get_message_cached (CamelFolder *folder,
1179 const gchar *message_uid,
1180 GCancellable *cancellable)
1181 {
1182 return camel_ews_folder_get_message_from_cache ((CamelEwsFolder *) folder, message_uid, cancellable, NULL);
1183 }
1184
1185 static GPtrArray *
1186 ews_folder_search_by_expression (CamelFolder *folder,
1187 const gchar *expression,
1188 GCancellable *cancellable,
1189 GError **error)
1190 {
1191 CamelEwsFolder *ews_folder;
1192 CamelEwsSearch *ews_search;
1193 CamelEwsFolderPrivate *priv;
1194 GPtrArray *matches;
1195
1196 ews_folder = CAMEL_EWS_FOLDER (folder);
1197 priv = ews_folder->priv;
1198
1199 g_mutex_lock (&priv->search_lock);
1200
1201 ews_search = CAMEL_EWS_SEARCH (ews_folder->search);
1202
1203 camel_folder_search_set_folder (ews_folder->search, folder);
1204 camel_ews_search_clear_cached_results (ews_search);
1205 camel_ews_search_set_cancellable_and_error (ews_search, cancellable, error);
1206
1207 matches = camel_folder_search_search (ews_folder->search, expression, NULL, cancellable, error);
1208
1209 camel_ews_search_set_cancellable_and_error (ews_search, NULL, NULL);
1210 camel_ews_search_clear_cached_results (ews_search);
1211
1212 g_mutex_unlock (&priv->search_lock);
1213
1214 return matches;
1215 }
1216
1217 static guint32
1218 ews_folder_count_by_expression (CamelFolder *folder,
1219 const gchar *expression,
1220 GCancellable *cancellable,
1221 GError **error)
1222 {
1223 CamelEwsFolder *ews_folder;
1224 CamelEwsSearch *ews_search;
1225 CamelEwsFolderPrivate *priv;
1226 guint32 matches;
1227
1228 ews_folder = CAMEL_EWS_FOLDER (folder);
1229 priv = ews_folder->priv;
1230
1231 g_mutex_lock (&priv->search_lock);
1232
1233 ews_search = CAMEL_EWS_SEARCH (ews_folder->search);
1234
1235 camel_folder_search_set_folder (ews_folder->search, folder);
1236 camel_ews_search_clear_cached_results (ews_search);
1237 camel_ews_search_set_cancellable_and_error (ews_search, cancellable, error);
1238
1239 matches = camel_folder_search_count (ews_folder->search, expression, cancellable, error);
1240
1241 camel_ews_search_set_cancellable_and_error (ews_search, NULL, NULL);
1242 camel_ews_search_clear_cached_results (ews_search);
1243
1244 g_mutex_unlock (&priv->search_lock);
1245
1246 return matches;
1247 }
1248
1249 static GPtrArray *
1250 ews_folder_search_by_uids (CamelFolder *folder,
1251 const gchar *expression,
1252 GPtrArray *uids,
1253 GCancellable *cancellable,
1254 GError **error)
1255 {
1256 CamelEwsFolder *ews_folder;
1257 CamelEwsSearch *ews_search;
1258 CamelEwsFolderPrivate *priv;
1259 GPtrArray *matches;
1260
1261 ews_folder = CAMEL_EWS_FOLDER (folder);
1262 priv = ews_folder->priv;
1263
1264 if (uids->len == 0)
1265 return g_ptr_array_new ();
1266
1267 g_mutex_lock (&priv->search_lock);
1268
1269 ews_search = CAMEL_EWS_SEARCH (ews_folder->search);
1270
1271 camel_folder_search_set_folder (ews_folder->search, folder);
1272 camel_ews_search_clear_cached_results (ews_search);
1273 camel_ews_search_set_cancellable_and_error (ews_search, cancellable, error);
1274
1275 matches = camel_folder_search_search (ews_folder->search, expression, uids, cancellable, error);
1276
1277 camel_ews_search_set_cancellable_and_error (ews_search, NULL, NULL);
1278 camel_ews_search_clear_cached_results (ews_search);
1279
1280 g_mutex_unlock (&priv->search_lock);
1281
1282 return matches;
1283 }
1284
1285 static void
1286 ews_folder_search_free (CamelFolder *folder,
1287 GPtrArray *uids)
1288 {
1289 CamelEwsFolder *ews_folder;
1290 CamelEwsFolderPrivate *priv;
1291
1292 ews_folder = CAMEL_EWS_FOLDER (folder);
1293 priv = ews_folder->priv;
1294
1295 g_return_if_fail (ews_folder->search);
1296
1297 g_mutex_lock (&priv->search_lock);
1298
1299 camel_folder_search_free_result (ews_folder->search, uids);
1300
1301 g_mutex_unlock (&priv->search_lock);
1302
1303 return;
1304 }
1305
1306 /********************* folder functions*************************/
1307
1308 static gboolean
1309 msg_update_flags (ESoapRequest *request,
1310 gpointer user_data,
1311 GError **error)
1312 {
1313 /* the mi_list is owned by the caller */
1314 const GSList *mi_list = user_data, *iter;
1315 CamelMessageInfo *mi;
1316 CamelEwsMessageInfo *emi;
1317
1318 for (iter = mi_list; iter; iter = g_slist_next (iter)) {
1319 CamelFolderSummary *summary;
1320 guint32 flags_changed, mi_flags;
1321 GSList *user_flags;
1322
1323 mi = iter->data;
1324 emi = CAMEL_EWS_MESSAGE_INFO (mi);
1325
1326 if (!mi || !emi)
1327 continue;
1328
1329 summary = camel_message_info_ref_summary (mi);
1330 if (summary)
1331 camel_folder_summary_lock (summary);
1332 camel_message_info_property_lock (mi);
1333
1334 mi_flags = camel_message_info_get_flags (mi);
1335 flags_changed = camel_ews_message_info_get_server_flags (emi) ^ mi_flags;
1336
1337 e_ews_request_start_item_change (
1338 request, E_EWS_ITEMCHANGE_TYPE_ITEM,
1339 camel_message_info_get_uid (mi), camel_ews_message_info_get_change_key (emi), 0);
1340 if (flags_changed & CAMEL_MESSAGE_FLAGGED) {
1341 const gchar *flag;
1342
1343 if ((mi_flags & CAMEL_MESSAGE_FLAGGED) != 0)
1344 flag = "High";
1345 else
1346 flag = "Normal";
1347
1348 e_soap_request_start_element (request, "SetItemField", NULL, NULL);
1349
1350 e_soap_request_start_element (request, "FieldURI", NULL, NULL);
1351 e_soap_request_add_attribute (request, "FieldURI", "item:Importance", NULL, NULL);
1352 e_soap_request_end_element (request);
1353
1354 e_soap_request_start_element (request, "Message", NULL, NULL);
1355
1356 e_ews_request_write_string_parameter (request, "Importance", NULL, flag);
1357
1358 e_soap_request_end_element (request); /* Message */
1359 e_soap_request_end_element (request); /* SetItemField */
1360 }
1361
1362 if (flags_changed & CAMEL_MESSAGE_SEEN) {
1363 e_soap_request_start_element (request, "SetItemField", NULL, NULL);
1364
1365 e_soap_request_start_element (request, "FieldURI", NULL, NULL);
1366 e_soap_request_add_attribute (request, "FieldURI", "message:IsRead", NULL, NULL);
1367 e_soap_request_end_element (request);
1368
1369 e_soap_request_start_element (request, "Message", NULL, NULL);
1370 e_ews_request_write_string_parameter (request, "IsRead", NULL,
1371 (mi_flags & CAMEL_MESSAGE_SEEN) ? "true" : "false");
1372
1373 e_soap_request_end_element (request); /* Message */
1374 e_soap_request_end_element (request); /* SetItemField */
1375 }
1376 /* Ick Ick Ick. Why in hell is there a field in the database for the Icon
1377 * *anyway*? Why isn't there a better place for forwarded/answered status? */
1378 if (flags_changed & (CAMEL_MESSAGE_FORWARDED | CAMEL_MESSAGE_ANSWERED)) {
1379 gint icon = (mi_flags & CAMEL_MESSAGE_SEEN) ? 0x100 : 0x101;
1380
1381 if (mi_flags & CAMEL_MESSAGE_ANSWERED)
1382 icon = 0x105;
1383 if (mi_flags & CAMEL_MESSAGE_FORWARDED)
1384 icon = 0x106;
1385
1386 e_ews_request_add_set_item_field_extended_tag_int (request, NULL, "Message", 0x1080, icon);
1387 }
1388
1389 /* now update the Categories */
1390 user_flags = ews_utils_gather_server_user_flags (request, mi);
1391 if (user_flags) {
1392 GSList *link;
1393
1394 e_soap_request_start_element (request, "SetItemField", NULL, NULL);
1395
1396 e_soap_request_start_element (request, "FieldURI", NULL, NULL);
1397 e_soap_request_add_attribute (request, "FieldURI", "item:Categories", NULL, NULL);
1398 e_soap_request_end_element (request);
1399
1400 e_soap_request_start_element (request, "Message", NULL, NULL);
1401 e_soap_request_start_element (request, "Categories", NULL, NULL);
1402
1403 for (link = user_flags; link; link = g_slist_next (link)) {
1404 const gchar *user_flag = link->data;
1405
1406 e_ews_request_write_string_parameter (request, "String", NULL, user_flag);
1407 }
1408
1409 e_soap_request_end_element (request); /* Categories */
1410 e_soap_request_end_element (request); /* Message */
1411 e_soap_request_end_element (request); /* SetItemField */
1412 } else {
1413 e_ews_request_add_delete_item_field (request, "Categories", "item");
1414 }
1415
1416 g_slist_free_full (user_flags, g_free);
1417
1418 ews_utils_update_followup_flags (request, mi);
1419
1420 e_ews_request_end_item_change (request);
1421
1422 camel_message_info_set_folder_flagged (mi, FALSE);
1423
1424 camel_message_info_property_unlock (mi);
1425 if (summary)
1426 camel_folder_summary_unlock (summary);
1427 g_clear_object (&summary);
1428 }
1429
1430 return TRUE;
1431 }
1432
1433 static gboolean
1434 ews_suppress_read_receipt (ESoapRequest *request,
1435 gpointer user_data,
1436 GError **error)
1437 {
1438 /* the mi_list is owned by the caller */
1439 const GSList *mi_list = user_data, *iter;
1440 CamelMessageInfo *mi;
1441
1442 for (iter = mi_list; iter; iter = g_slist_next (iter)) {
1443 CamelFolderSummary *summary;
1444
1445 mi = iter->data;
1446 if (!mi || (camel_message_info_get_flags (mi) & CAMEL_EWS_MESSAGE_MSGFLAG_RN_PENDING) == 0)
1447 continue;
1448
1449 summary = camel_message_info_ref_summary (mi);
1450 if (summary)
1451 camel_folder_summary_lock (summary);
1452 camel_message_info_property_lock (mi);
1453 camel_message_info_freeze_notifications (mi);
1454
1455 /* There was requested a read-receipt, but it is handled by evolution-ews,
1456 thus prevent an automatic send of it by the server */
1457 e_soap_request_start_element (request, "SuppressReadReceipt", NULL, NULL);
1458 e_soap_request_start_element (request, "ReferenceItemId", NULL, NULL);
1459 e_soap_request_add_attribute (request, "Id", camel_message_info_get_uid (mi), NULL, NULL);
1460 e_soap_request_add_attribute (request, "ChangeKey", camel_ews_message_info_get_change_key (CAMEL_EWS_MESSAGE_INFO (mi)), NULL, NULL);
1461 e_soap_request_end_element (request); /* "ReferenceItemId" */
1462 e_soap_request_end_element (request); /* SuppressReadReceipt */
1463
1464 camel_message_info_set_flags (mi, CAMEL_EWS_MESSAGE_MSGFLAG_RN_PENDING, 0);
1465
1466 if (!camel_message_info_get_user_flag (mi, "receipt-handled"))
1467 camel_message_info_set_user_flag (mi, "receipt-handled", TRUE);
1468
1469 camel_message_info_thaw_notifications (mi);
1470 camel_message_info_property_unlock (mi);
1471 if (summary)
1472 camel_folder_summary_unlock (summary);
1473 g_clear_object (&summary);
1474 }
1475
1476 return TRUE;
1477 }
1478
1479 static gboolean
1480 ews_sync_mi_flags (CamelFolder *folder,
1481 const GSList *mi_list,
1482 GCancellable *cancellable,
1483 GError **error)
1484 {
1485 CamelEwsStore *ews_store;
1486 EEwsConnection *cnc;
1487 const GSList *iter;
1488 GError *local_error = NULL;
1489 gboolean res = TRUE;
1490
1491 ews_store = (CamelEwsStore *) camel_folder_get_parent_store (folder);
1492
1493 if (!camel_ews_store_connected (ews_store, cancellable, error)) {
1494 return FALSE;
1495 }
1496
1497 cnc = camel_ews_store_ref_connection (ews_store);
1498
1499 for (iter = mi_list; iter; iter = g_slist_next (iter)) {
1500 CamelMessageInfo *mi = iter->data;
1501
1502 if (mi && (camel_message_info_get_flags (mi) & CAMEL_EWS_MESSAGE_MSGFLAG_RN_PENDING) != 0)
1503 break;
1504 }
1505
1506 /* NULL means all had been checked and none has the flag set */
1507 if (iter) {
1508 GSList *ids = NULL;
1509
1510 res = e_ews_connection_create_items_sync (
1511 cnc, EWS_PRIORITY_LOW,
1512 "SaveOnly", NULL, NULL,
1513 ews_suppress_read_receipt, (gpointer) mi_list,
1514 &ids, cancellable, &local_error);
1515
1516 g_slist_free_full (ids, g_object_unref);
1517
1518 /* ignore this error, it's not a big problem */
1519 if (g_error_matches (local_error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_READRECEIPTNOTPENDING)) {
1520 g_clear_error (&local_error);
1521 res = TRUE;
1522 }
1523 }
1524
1525 if (res) {
1526 res = e_ews_connection_update_items_sync (
1527 cnc, EWS_PRIORITY_LOW,
1528 "AlwaysOverwrite", "SaveOnly",
1529 NULL, NULL,
1530 msg_update_flags, (gpointer) mi_list, NULL,
1531 cancellable, &local_error);
1532 }
1533
1534 camel_folder_summary_save (camel_folder_get_folder_summary (folder), NULL);
1535
1536 if (local_error) {
1537 camel_ews_store_maybe_disconnect (ews_store, local_error);
1538 g_propagate_error (error, local_error);
1539 }
1540
1541 g_object_unref (cnc);
1542
1543 return res;
1544 }
1545
1546 static gboolean
1547 ews_save_flags (CamelFolder *folder,
1548 const GSList *mi_list,
1549 GCancellable *cancellable,
1550 GError **error)
1551 {
1552 gboolean ret;
1553 GError *local_error = NULL;
1554
1555 ret = ews_sync_mi_flags (folder, mi_list, cancellable, &local_error);
1556
1557 if (local_error != NULL) {
1558 if (g_error_matches (local_error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_ACCESSDENIED)) {
1559 /*
1560 * If cannot save flags, then it can be a public
1561 * or a foreign folder with no write access;
1562 * the flags will be saved locally, at least
1563 */
1564 g_clear_error (&local_error);
1565 ret = TRUE;
1566 } else {
1567 g_propagate_error (error, local_error);
1568 }
1569 }
1570
1571 return ret;
1572 }
1573
1574 static gboolean
1575 ews_folder_is_of_type (CamelFolder *folder,
1576 guint32 folder_type)
1577 {
1578 CamelStore *parent_store;
1579 CamelEwsStore *ews_store;
1580 gboolean is_of_type;
1581 gchar *folder_id;
1582
1583 g_return_val_if_fail (folder != NULL, FALSE);
1584
1585 parent_store = camel_folder_get_parent_store (folder);
1586 ews_store = CAMEL_EWS_STORE (parent_store);
1587
1588 g_return_val_if_fail (ews_store != NULL, FALSE);
1589
1590 folder_type = folder_type & CAMEL_FOLDER_TYPE_MASK;
1591 folder_id = camel_ews_store_summary_get_folder_id_from_name (ews_store->summary, camel_folder_get_full_name (folder));
1592 is_of_type = folder_id &&
1593 (camel_ews_store_summary_get_folder_flags (ews_store->summary, folder_id, NULL) & CAMEL_FOLDER_TYPE_MASK) == folder_type;
1594 g_free (folder_id);
1595
1596 return is_of_type;
1597 }
1598
1599 static gboolean
1600 ews_folder_is_public_or_foreign (CamelFolder *folder)
1601 {
1602 CamelStore *parent_store;
1603 CamelEwsStore *ews_store;
1604 gboolean res;
1605 gchar *folder_id;
1606
1607 g_return_val_if_fail (folder != NULL, FALSE);
1608
1609 parent_store = camel_folder_get_parent_store (folder);
1610 ews_store = CAMEL_EWS_STORE (parent_store);
1611
1612 g_return_val_if_fail (ews_store != NULL, FALSE);
1613
1614 folder_id = camel_ews_store_summary_get_folder_id_from_name (ews_store->summary, camel_folder_get_full_name (folder));
1615 res = folder_id && (camel_ews_store_summary_get_public (ews_store->summary, folder_id, NULL) ||
1616 camel_ews_store_summary_get_foreign (ews_store->summary, folder_id, NULL));
1617 g_free (folder_id);
1618
1619 return res;
1620 }
1621
1622 static gboolean
1623 ews_move_to_special_folder (CamelFolder *folder,
1624 const GSList *uids,
1625 guint32 folder_type,
1626 GCancellable *cancellable,
1627 GError **error)
1628 {
1629 CamelEwsFolder *ews_folder;
1630 CamelStore *parent_store;
1631 CamelEwsStore *ews_store;
1632 EEwsConnection *cnc;
1633 gboolean status = TRUE;
1634
1635 if (ews_folder_is_of_type (folder, folder_type)) {
1636 /* cannot move to itself, but treat it as success */
1637 return TRUE;
1638 }
1639
1640 parent_store = camel_folder_get_parent_store (folder);
1641 ews_folder = CAMEL_EWS_FOLDER (folder);
1642 ews_store = CAMEL_EWS_STORE (parent_store);
1643
1644 if (!camel_ews_store_connected (ews_store, cancellable, error))
1645 return FALSE;
1646
1647 cnc = camel_ews_store_ref_connection (ews_store);
1648
1649 if (uids) {
1650 GSList *moved_items = NULL;
1651 GError *local_error = NULL;
1652 gchar *folder_id;
1653
1654 folder_id = camel_ews_store_summary_get_folder_id_from_folder_type (ews_store->summary, folder_type);
1655
1656 status = e_ews_connection_move_items_in_chunks_sync (
1657 cnc, EWS_PRIORITY_MEDIUM, folder_id, FALSE,
1658 uids, &moved_items, cancellable, &local_error);
1659
1660 if (!status && local_error && local_error->code == EWS_CONNECTION_ERROR_ITEMNOTFOUND) {
1661 /* If move failed due to the item not found, ignore the error,
1662 * trigger folder info refresh and then go on to clear the
1663 * cache of the remove items anyway. */
1664 g_clear_error (&local_error);
1665 status = ews_refresh_info_sync (folder, cancellable, &local_error);
1666 }
1667
1668 /* Messages could be moved partially only, like when
1669 the user cancels the operation in the middle */
1670 if (status || moved_items) {
1671 CamelFolderChangeInfo *changes;
1672 const GSList *iter, *items_iter;
1673
1674 changes = camel_folder_change_info_new ();
1675
1676 for (iter = uids, items_iter = moved_items; iter && items_iter; iter = g_slist_next (iter), items_iter = g_slist_next (items_iter)) {
1677 const gchar *uid = iter->data;
1678 EEwsItem *item = items_iter->data;
1679
1680 if (!item || e_ews_item_get_item_type (item) == E_EWS_ITEM_TYPE_ERROR)
1681 continue;
1682
1683 camel_folder_summary_lock (camel_folder_get_folder_summary (folder));
1684
1685 camel_folder_change_info_remove_uid (changes, uid);
1686 camel_folder_summary_remove_uid (camel_folder_get_folder_summary (folder), uid);
1687 ews_data_cache_remove (ews_folder->cache, "cur", uid, NULL);
1688
1689 camel_folder_summary_unlock (camel_folder_get_folder_summary (folder));
1690 }
1691
1692 if (camel_folder_change_info_changed (changes)) {
1693 camel_folder_summary_touch (camel_folder_get_folder_summary (folder));
1694 camel_folder_changed (folder, changes);
1695 }
1696 camel_folder_change_info_free (changes);
1697 }
1698
1699 g_slist_free_full (moved_items, g_object_unref);
1700 g_free (folder_id);
1701
1702 if (local_error) {
1703 camel_ews_store_maybe_disconnect (ews_store, local_error);
1704 g_propagate_error (error, local_error);
1705 }
1706 }
1707
1708 g_object_unref (cnc);
1709
1710 return status;
1711 }
1712
1713 static gboolean
1714 ews_synchronize_sync (CamelFolder *folder,
1715 gboolean expunge,
1716 GCancellable *cancellable,
1717 GError **error)
1718 {
1719 CamelEwsStore *ews_store;
1720 CamelFolderSummary *folder_summary;
1721 GPtrArray *uids;
1722 GSList *mi_list = NULL, *deleted_uids = NULL, *junk_uids = NULL, *inbox_uids = NULL;
1723 gint mi_list_len = 0;
1724 gboolean is_junk_folder;
1725 gboolean success = TRUE;
1726 gint i;
1727 GError *local_error = NULL;
1728
1729 ews_store = (CamelEwsStore *) camel_folder_get_parent_store (folder);
1730
1731 if (!camel_ews_store_connected (ews_store, cancellable, error))
1732 return FALSE;
1733
1734 folder_summary = camel_folder_get_folder_summary (folder);
1735 if (camel_folder_summary_get_deleted_count (folder_summary) > 0 ||
1736 camel_folder_summary_get_junk_count (folder_summary) > 0) {
1737 camel_folder_summary_prepare_fetch_all (folder_summary, NULL);
1738 uids = camel_folder_summary_get_array (folder_summary);
1739 } else {
1740 uids = camel_folder_summary_get_changed (folder_summary);
1741 }
1742 if (!uids || !uids->len) {
1743 camel_folder_summary_free_array (uids);
1744 return TRUE;
1745 }
1746
1747 is_junk_folder = ews_folder_is_of_type (folder, CAMEL_FOLDER_TYPE_JUNK);
1748
1749 for (i = 0; success && i < uids->len; i++) {
1750 guint32 flags_changed, flags_set;
1751 CamelMessageInfo *mi = camel_folder_summary_get (folder_summary, uids->pdata[i]);
1752
1753 if (!mi)
1754 continue;
1755
1756 flags_set = camel_message_info_get_flags (mi);
1757 flags_changed = camel_ews_message_info_get_server_flags (CAMEL_EWS_MESSAGE_INFO (mi)) ^ flags_set;
1758
1759 /* Exchange doesn't seem to have a sane representation
1760 * for most flags — not even replied/forwarded. */
1761 if ((flags_set & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0 &&
1762 (flags_changed & (CAMEL_MESSAGE_SEEN | CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_FORWARDED | CAMEL_MESSAGE_FLAGGED)) != 0) {
1763 mi_list = g_slist_prepend (mi_list, mi);
1764 mi_list_len++;
1765
1766 if (flags_set & CAMEL_MESSAGE_DELETED)
1767 deleted_uids = g_slist_prepend (deleted_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1768 else if (flags_set & CAMEL_MESSAGE_JUNK)
1769 junk_uids = g_slist_prepend (junk_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1770 else if (is_junk_folder && (flags_set & CAMEL_MESSAGE_NOTJUNK) != 0)
1771 inbox_uids = g_slist_prepend (inbox_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1772 } else if (flags_set & CAMEL_MESSAGE_DELETED) {
1773 deleted_uids = g_slist_prepend (deleted_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1774 g_clear_object (&mi);
1775 } else if (flags_set & CAMEL_MESSAGE_JUNK) {
1776 junk_uids = g_slist_prepend (junk_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1777 g_clear_object (&mi);
1778 } else if (is_junk_folder && (flags_set & CAMEL_MESSAGE_NOTJUNK) != 0) {
1779 inbox_uids = g_slist_prepend (inbox_uids, (gpointer) camel_pstring_strdup (uids->pdata[i]));
1780 g_clear_object (&mi);
1781 } else if ((flags_set & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0) {
1782 /* OK, the change must have been the labels */
1783 mi_list = g_slist_prepend (mi_list, mi);
1784 mi_list_len++;
1785 } else {
1786 g_clear_object (&mi);
1787 }
1788
1789 if (mi_list_len == EWS_MAX_FETCH_COUNT) {
1790 success = ews_save_flags (folder, mi_list, cancellable, &local_error);
1791 g_slist_free_full (mi_list, g_object_unref);
1792 mi_list = NULL;
1793 mi_list_len = 0;
1794 }
1795 }
1796
1797 if (mi_list != NULL && success)
1798 success = ews_save_flags (folder, mi_list, cancellable, &local_error);
1799 g_slist_free_full (mi_list, g_object_unref);
1800
1801 if (deleted_uids && success)
1802 success = ews_delete_messages (folder, deleted_uids, ews_folder_is_of_type (folder, CAMEL_FOLDER_TYPE_TRASH), cancellable, &local_error);
1803 g_slist_free_full (deleted_uids, (GDestroyNotify) camel_pstring_free);
1804
1805 if (junk_uids && success)
1806 success = ews_move_to_special_folder (folder, junk_uids, CAMEL_FOLDER_TYPE_JUNK, cancellable, &local_error);
1807 g_slist_free_full (junk_uids, (GDestroyNotify) camel_pstring_free);
1808
1809 if (inbox_uids && success)
1810 success = ews_move_to_special_folder (folder, inbox_uids, CAMEL_FOLDER_TYPE_INBOX, cancellable, &local_error);
1811 g_slist_free_full (inbox_uids, (GDestroyNotify) camel_pstring_free);
1812
1813 camel_folder_summary_save (folder_summary, NULL);
1814 camel_folder_summary_free_array (uids);
1815
1816 if (local_error)
1817 g_propagate_error (error, local_error);
1818
1819 return success;
1820 }
1821
1822 static void
1823 ews_folder_count_notify_cb (CamelFolderSummary *folder_summary,
1824 GParamSpec *param,
1825 CamelFolder *folder)
1826 {
1827 gint count;
1828 CamelEwsStore *ews_store;
1829 CamelEwsStoreSummary *store_summary;
1830 gchar *folder_id;
1831
1832 g_return_if_fail (folder_summary != NULL);
1833 g_return_if_fail (param != NULL);
1834 g_return_if_fail (folder != NULL);
1835 g_return_if_fail (camel_folder_get_folder_summary (folder) == folder_summary);
1836
1837 ews_store = CAMEL_EWS_STORE (camel_folder_get_parent_store (folder));
1838 g_return_if_fail (ews_store != NULL);
1839
1840 store_summary = ews_store->summary;
1841 folder_id = camel_ews_store_summary_get_folder_id_from_name (ews_store->summary, camel_folder_get_full_name (folder));
1842
1843 /* this can happen on folder delete/unsubscribe, after folder summary clear */
1844 if (!folder_id)
1845 return;
1846
1847 if (g_strcmp0 (g_param_spec_get_name (param), "saved-count") == 0) {
1848 count = camel_folder_summary_get_saved_count (folder_summary);
1849 camel_ews_store_summary_set_folder_total (store_summary, folder_id, count);
1850 } else if (g_strcmp0 (g_param_spec_get_name (param), "unread-count") == 0) {
1851 count = camel_folder_summary_get_unread_count (folder_summary);
1852 camel_ews_store_summary_set_folder_unread (store_summary, folder_id, count);
1853 } else {
1854 g_warn_if_reached ();
1855 }
1856
1857 g_free (folder_id);
1858 }
1859
1860 static gboolean
1861 folder_has_inbox_type (CamelEwsStore *ews_store,
1862 const gchar *folder_name)
1863 {
1864 gchar *folder_id;
1865 guint64 flags;
1866
1867 g_return_val_if_fail (CAMEL_IS_EWS_STORE (ews_store), FALSE);
1868 g_return_val_if_fail (folder_name != NULL, FALSE);
1869
1870 folder_id = camel_ews_store_summary_get_folder_id_from_name (ews_store->summary, folder_name);
1871 if (!folder_id)
1872 return FALSE;
1873
1874 flags = camel_ews_store_summary_get_folder_flags (ews_store->summary, folder_id, NULL);
1875
1876 g_free (folder_id);
1877
1878 return (flags & CAMEL_FOLDER_TYPE_MASK) == CAMEL_FOLDER_TYPE_INBOX;
1879 }
1880
1881 CamelFolder *
1882 camel_ews_folder_new (CamelStore *store,
1883 const gchar *folder_name,
1884 const gchar *folder_dir,
1885 GCancellable *cancellable,
1886 GError **error)
1887 {
1888 CamelFolder *folder;
1889 CamelFolderSummary *folder_summary;
1890 CamelEwsFolder *ews_folder;
1891 CamelSettings *settings;
1892 gboolean filter_inbox = FALSE;
1893 gboolean filter_junk = FALSE;
1894 gboolean filter_junk_inbox = FALSE;
1895 gboolean offline_limit_by_age = FALSE;
1896 CamelTimeUnit offline_limit_unit;
1897 gint offline_limit_value = 0;
1898 guint32 add_folder_flags = 0;
1899 gchar *state_file;
1900 const gchar *short_name;
1901
1902 short_name = strrchr (folder_name, '/');
1903 if (!short_name)
1904 short_name = folder_name;
1905 else
1906 short_name++;
1907
1908 folder = g_object_new (
1909 CAMEL_TYPE_EWS_FOLDER,
1910 "display_name", short_name, "full-name", folder_name,
1911 "parent_store", store, NULL);
1912
1913 ews_folder = CAMEL_EWS_FOLDER (folder);
1914
1915 folder_summary = camel_ews_summary_new (folder);
1916
1917 if (!folder_summary) {
1918 g_object_unref (folder);
1919 g_set_error (
1920 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
1921 _("Could not load summary for %s"), folder_name);
1922 return NULL;
1923 }
1924
1925 settings = camel_service_ref_settings (CAMEL_SERVICE (store));
1926
1927 g_object_get (
1928 settings,
1929 "filter-inbox", &filter_inbox,
1930 "filter-junk", &filter_junk,
1931 "filter-junk-inbox", &filter_junk_inbox,
1932 "limit-by-age", &offline_limit_by_age,
1933 "limit-unit", &offline_limit_unit,
1934 "limit-value", &offline_limit_value,
1935 NULL);
1936
1937 g_clear_object (&settings);
1938
1939 camel_folder_take_folder_summary (folder, folder_summary);
1940
1941 /* set/load persistent state */
1942 state_file = g_build_filename (folder_dir, "cmeta", NULL);
1943 camel_object_set_state_filename (CAMEL_OBJECT (folder), state_file);
1944 camel_object_state_read (CAMEL_OBJECT (folder));
1945 g_free (state_file);
1946
1947 ews_folder->cache = camel_data_cache_new (folder_dir, error);
1948 if (!ews_folder->cache) {
1949 g_object_unref (folder);
1950 return NULL;
1951 }
1952
1953 if (camel_offline_folder_can_downsync (CAMEL_OFFLINE_FOLDER (folder))) {
1954 time_t when = (time_t) 0;
1955
1956 if (offline_limit_by_age)
1957 when = camel_time_value_apply (when, offline_limit_unit, offline_limit_value);
1958
1959 if (when <= (time_t) 0)
1960 when = (time_t) -1;
1961
1962 /* Ensure cache will expire when set up, otherwise
1963 * it causes redownload of messages too soon. */
1964 camel_data_cache_set_expire_age (ews_folder->cache, when);
1965 camel_data_cache_set_expire_access (ews_folder->cache, when);
1966 } else {
1967 /* Set cache expiration for one week. */
1968 camel_data_cache_set_expire_age (ews_folder->cache, 60 * 60 * 24 * 7);
1969 camel_data_cache_set_expire_access (ews_folder->cache, 60 * 60 * 24 * 7);
1970 }
1971
1972 camel_binding_bind_property (store, "online",
1973 ews_folder->cache, "expire-enabled",
1974 G_BINDING_SYNC_CREATE);
1975
1976 if (!g_ascii_strcasecmp (folder_name, "Inbox") ||
1977 folder_has_inbox_type (CAMEL_EWS_STORE (store), folder_name)) {
1978 if (filter_inbox)
1979 add_folder_flags |= CAMEL_FOLDER_FILTER_RECENT;
1980
1981 if (filter_junk)
1982 add_folder_flags |= CAMEL_FOLDER_FILTER_JUNK;
1983 } else {
1984 if (camel_ews_folder_get_apply_filters (ews_folder))
1985 add_folder_flags |= CAMEL_FOLDER_FILTER_RECENT;
1986
1987 if (filter_junk && !filter_junk_inbox)
1988 add_folder_flags |= CAMEL_FOLDER_FILTER_JUNK;
1989 }
1990
1991 if (add_folder_flags)
1992 camel_folder_set_flags (folder, camel_folder_get_flags (folder) | add_folder_flags);
1993
1994 ews_folder->search = camel_ews_search_new (CAMEL_EWS_STORE (store));
1995 if (!ews_folder->search) {
1996 g_object_unref (folder);
1997 return NULL;
1998 }
1999
2000 g_signal_connect (folder_summary, "notify::saved-count", G_CALLBACK (ews_folder_count_notify_cb), folder);
2001 g_signal_connect (folder_summary, "notify::unread-count", G_CALLBACK (ews_folder_count_notify_cb), folder);
2002
2003 return folder;
2004 }
2005
2006 static void
2007 sync_updated_items (CamelEwsFolder *ews_folder,
2008 EEwsConnection *cnc,
2009 gboolean is_drafts_folder,
2010 GSList *updated_items,
2011 CamelFolderChangeInfo *change_info,
2012 GCancellable *cancellable,
2013 GError **error)
2014 {
2015 CamelEwsStore *ews_store;
2016 CamelFolder *folder = (CamelFolder *) ews_folder;
2017 GSList *items = NULL, *l;
2018 GSList *generic_item_ids = NULL, *msg_ids = NULL;
2019 GError *local_error = NULL;
2020
2021 ews_store = CAMEL_EWS_STORE (camel_folder_get_parent_store (folder));
2022
2023 for (l = updated_items; l != NULL; l = g_slist_next (l)) {
2024 EEwsItem *item = (EEwsItem *) l->data;
2025 const EwsId *id;
2026 EEwsItemType item_type;
2027 CamelMessageInfo *mi;
2028
2029 if (!item)
2030 continue;
2031
2032 id = e_ews_item_get_id (item);
2033 item_type = e_ews_item_get_item_type (item);
2034
2035 if (!id) {
2036 g_warning ("%s: Missing ItemId for item type %d (subject:%s)", G_STRFUNC, item_type,
2037 e_ews_item_get_subject (item) ? e_ews_item_get_subject (item) : "???");
2038 g_object_unref (item);
2039 continue;
2040 }
2041
2042 /* Compare the item_type from summary as the updated items seems to
2043 * arrive as generic types while it's not the case */
2044 mi = camel_folder_summary_get (camel_folder_get_folder_summary (folder), id->id);
2045 if (!mi) {
2046 g_object_unref (item);
2047 continue;
2048 }
2049
2050 /* Check if the item has really changed */
2051 if (!g_strcmp0 (camel_ews_message_info_get_change_key (CAMEL_EWS_MESSAGE_INFO (mi)), id->change_key)) {
2052 g_clear_object (&mi);
2053 g_object_unref (item);
2054 continue;
2055 }
2056
2057 if (item_type == E_EWS_ITEM_TYPE_GENERIC_ITEM)
2058 generic_item_ids = g_slist_append (generic_item_ids, g_strdup (id->id));
2059 else if (item_type == E_EWS_ITEM_TYPE_MESSAGE ||
2060 item_type == E_EWS_ITEM_TYPE_MEETING_REQUEST ||
2061 item_type == E_EWS_ITEM_TYPE_MEETING_MESSAGE ||
2062 item_type == E_EWS_ITEM_TYPE_MEETING_RESPONSE ||
2063 item_type == E_EWS_ITEM_TYPE_MEETING_CANCELLATION ||
2064 item_type == E_EWS_ITEM_TYPE_POST_ITEM ||
2065 /* Unknown for items received through the server notifications;
2066 it's part of the summary, thus it is a message anyway */
2067 item_type == E_EWS_ITEM_TYPE_UNKNOWN)
2068 msg_ids = g_slist_append (msg_ids, g_strdup (id->id));
2069
2070 g_clear_object (&mi);
2071 g_object_unref (item);
2072 }
2073 g_slist_free (updated_items);
2074
2075
2076 if (msg_ids) {
2077 EEwsAdditionalProps *add_props;
2078
2079 add_props = e_ews_additional_props_new ();
2080 add_props->field_uri = g_strdup (is_drafts_folder ?
2081 (e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2013) ? SUMMARY_MESSAGE_PROPS_2013 : SUMMARY_MESSAGE_PROPS) :
2082 SUMMARY_MESSAGE_FLAGS);
2083 add_props->extended_furis = ews_folder_get_summary_message_mapi_flags ();
2084
2085 e_ews_connection_get_items_sync (
2086 cnc, EWS_PRIORITY_MEDIUM,
2087 msg_ids, "IdOnly", add_props,
2088 FALSE, NULL, E_EWS_BODY_TYPE_ANY, &items, NULL, NULL,
2089 cancellable, &local_error);
2090
2091 e_ews_additional_props_free (add_props);
2092 }
2093
2094 camel_ews_utils_sync_updated_items (ews_folder, cnc, is_drafts_folder, items, change_info, cancellable);
2095 items = NULL;
2096 if (local_error) {
2097 camel_ews_store_maybe_disconnect (ews_store, local_error);
2098 g_propagate_error (error, local_error);
2099 goto exit;
2100 }
2101
2102 if (generic_item_ids) {
2103 EEwsAdditionalProps *add_props;
2104
2105 add_props = e_ews_additional_props_new ();
2106 add_props->field_uri = g_strdup (is_drafts_folder ? SUMMARY_ITEM_PROPS : SUMMARY_ITEM_FLAGS);
2107 add_props->extended_furis = ews_folder_get_summary_followup_mapi_flags ();
2108
2109 e_ews_connection_get_items_sync (
2110 cnc, EWS_PRIORITY_MEDIUM,
2111 generic_item_ids, "IdOnly", add_props,
2112 FALSE, NULL, E_EWS_BODY_TYPE_ANY, &items, NULL, NULL,
2113 cancellable, &local_error);
2114
2115 e_ews_additional_props_free (add_props);
2116 }
2117 camel_ews_utils_sync_updated_items (ews_folder, cnc, is_drafts_folder, items, change_info, cancellable);
2118
2119 if (local_error) {
2120 camel_ews_store_maybe_disconnect (ews_store, local_error);
2121 g_propagate_error (error, local_error);
2122 }
2123
2124 exit:
2125 if (msg_ids) {
2126 g_slist_foreach (msg_ids, (GFunc) g_free, NULL);
2127 g_slist_free (msg_ids);
2128 }
2129
2130 if (generic_item_ids) {
2131 g_slist_foreach (generic_item_ids, (GFunc) g_free, NULL);
2132 g_slist_free (generic_item_ids);
2133 }
2134 }
2135
2136 void
2137 camel_ews_folder_remove_cached_message (CamelEwsFolder *ews_folder,
2138 const gchar *uid)
2139 {
2140 g_return_if_fail (CAMEL_IS_EWS_FOLDER (ews_folder));
2141 g_return_if_fail (uid != NULL);
2142
2143 ews_data_cache_remove (ews_folder->cache, "cur", uid, NULL);
2144 }
2145
2146 static void
2147 sync_created_items (CamelEwsFolder *ews_folder,
2148 EEwsConnection *cnc,
2149 gboolean is_drafts_folder,
2150 GSList *created_items,
2151 GHashTable *updating_summary_uids,
2152 CamelFolderChangeInfo *change_info,
2153 GCancellable *cancellable,
2154 GError **error)
2155 {
2156 CamelEwsStore *ews_store;
2157 GSList *items = NULL, *l;
2158 GSList *generic_item_ids = NULL, *msg_ids = NULL, *post_item_ids = NULL;
2159 GError *local_error = NULL;
2160
2161 ews_store = CAMEL_EWS_STORE (camel_folder_get_parent_store (CAMEL_FOLDER (ews_folder)));
2162
2163 for (l = created_items; l != NULL; l = g_slist_next (l)) {
2164 EEwsItem *item = (EEwsItem *) l->data;
2165 const EwsId *id;
2166 EEwsItemType item_type;
2167
2168 if (!item)
2169 continue;
2170
2171 id = e_ews_item_get_id (item);
2172 item_type = e_ews_item_get_item_type (item);
2173
2174 if (!id) {
2175 g_warning ("%s: Missing ItemId for item type %d (subject:%s)", G_STRFUNC, item_type,
2176 e_ews_item_get_subject (item) ? e_ews_item_get_subject (item) : "???");
2177 g_object_unref (item);
2178 continue;
2179 }
2180
2181 if (updating_summary_uids) {
2182 const gchar *pooled_uid = camel_pstring_strdup (id->id);
2183 gboolean known;
2184
2185 known = g_hash_table_remove (updating_summary_uids, pooled_uid);
2186
2187 camel_pstring_free (pooled_uid);
2188
2189 if (known) {
2190 g_object_unref (item);
2191 continue;
2192 }
2193 }
2194
2195 /* created_msg_ids are items other than generic item. We fetch them
2196 * separately since the property sets vary */
2197 /* FIXME: Do we need to handle any other item types
2198 * "specially"? */
2199 if (item_type == E_EWS_ITEM_TYPE_MESSAGE ||
2200 item_type == E_EWS_ITEM_TYPE_MEETING_REQUEST ||
2201 item_type == E_EWS_ITEM_TYPE_MEETING_MESSAGE ||
2202 item_type == E_EWS_ITEM_TYPE_MEETING_RESPONSE ||
2203 item_type == E_EWS_ITEM_TYPE_MEETING_CANCELLATION)
2204 msg_ids = g_slist_append (msg_ids, g_strdup (id->id));
2205 else if (item_type == E_EWS_ITEM_TYPE_POST_ITEM)
2206 post_item_ids = g_slist_append (post_item_ids, g_strdup (id->id));
2207 else if (item_type == E_EWS_ITEM_TYPE_GENERIC_ITEM)
2208 generic_item_ids = g_slist_append (generic_item_ids, g_strdup (id->id));
2209
2210 g_object_unref (item);
2211 }
2212 g_slist_free (created_items);
2213
2214
2215 if (msg_ids) {
2216 EEwsAdditionalProps *add_props;
2217
2218 add_props = e_ews_additional_props_new ();
2219 add_props->field_uri = g_strdup (e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2013) ? SUMMARY_MESSAGE_PROPS_2013 : SUMMARY_MESSAGE_PROPS);
2220 add_props->extended_furis = ews_folder_get_summary_message_mapi_flags ();
2221
2222 e_ews_connection_get_items_sync (
2223 cnc, EWS_PRIORITY_MEDIUM,
2224 msg_ids, "IdOnly", add_props,
2225 FALSE, NULL, E_EWS_BODY_TYPE_ANY, &items, NULL, NULL,
2226 cancellable, &local_error);
2227
2228 e_ews_additional_props_free (add_props);
2229 }
2230
2231 if (local_error) {
2232 camel_ews_store_maybe_disconnect (ews_store, local_error);
2233 g_propagate_error (error, local_error);
2234 goto exit;
2235 }
2236
2237 camel_ews_utils_sync_created_items (ews_folder, cnc, is_drafts_folder, items, change_info, cancellable);
2238 items = NULL;
2239
2240
2241 if (post_item_ids) {
2242 EEwsAdditionalProps *add_props;
2243
2244 add_props = e_ews_additional_props_new ();
2245 add_props->field_uri = g_strdup (SUMMARY_POSTITEM_PROPS);
2246 add_props->extended_furis = ews_folder_get_summary_followup_mapi_flags ();
2247
2248 e_ews_connection_get_items_sync (
2249 cnc, EWS_PRIORITY_MEDIUM,
2250 post_item_ids, "IdOnly", add_props,
2251 FALSE, NULL, E_EWS_BODY_TYPE_ANY, &items, NULL, NULL,
2252 cancellable, &local_error);
2253
2254 e_ews_additional_props_free (add_props);
2255 }
2256
2257 if (local_error) {
2258 camel_ews_store_maybe_disconnect (ews_store, local_error);
2259 g_propagate_error (error, local_error);
2260 goto exit;
2261 }
2262
2263 camel_ews_utils_sync_created_items (ews_folder, cnc, is_drafts_folder, items, change_info, cancellable);
2264 items = NULL;
2265
2266 if (generic_item_ids) {
2267 EEwsAdditionalProps *add_props;
2268
2269 add_props = e_ews_additional_props_new ();
2270 add_props->field_uri = g_strdup (SUMMARY_ITEM_PROPS);
2271 add_props->extended_furis = ews_folder_get_summary_followup_mapi_flags ();
2272
2273 e_ews_connection_get_items_sync (
2274 cnc, EWS_PRIORITY_MEDIUM,
2275 generic_item_ids, "IdOnly", add_props,
2276 FALSE, NULL, E_EWS_BODY_TYPE_ANY, &items, NULL, NULL,
2277 cancellable, &local_error);
2278
2279 e_ews_additional_props_free (add_props);
2280 }
2281
2282 camel_ews_utils_sync_created_items (ews_folder, cnc, is_drafts_folder, items, change_info, cancellable);
2283
2284 if (local_error) {
2285 camel_ews_store_maybe_disconnect (ews_store, local_error);
2286 g_propagate_error (error, local_error);
2287 }
2288
2289 exit:
2290 if (msg_ids) {
2291 g_slist_foreach (msg_ids, (GFunc) g_free, NULL);
2292 g_slist_free (msg_ids);
2293 }
2294
2295 if (post_item_ids) {
2296 g_slist_foreach (post_item_ids, (GFunc) g_free, NULL);
2297 g_slist_free (post_item_ids);
2298 }
2299
2300 if (generic_item_ids) {
2301 g_slist_foreach (generic_item_ids, (GFunc) g_free, NULL);
2302 g_slist_free (generic_item_ids);
2303 }
2304 }
2305
2306 static void
2307 ews_folder_forget_all_mails (CamelEwsFolder *ews_folder)
2308 {
2309 CamelFolder *folder;
2310 CamelFolderChangeInfo *changes;
2311 CamelFolderSummary *folder_summary;
2312 GPtrArray *known_uids;
2313 gint ii;
2314
2315 g_return_if_fail (CAMEL_IS_EWS_FOLDER (ews_folder));
2316
2317 folder = CAMEL_FOLDER (ews_folder);
2318 g_return_if_fail (folder != NULL);
2319
2320 known_uids = camel_folder_summary_get_array (camel_folder_get_folder_summary (folder));
2321 if (!known_uids)
2322 return;
2323
2324 changes = camel_folder_change_info_new ();
2325 folder_summary = camel_folder_get_folder_summary (folder);
2326
2327 camel_folder_summary_lock (folder_summary);
2328 for (ii = 0; ii < known_uids->len; ii++) {
2329 const gchar *uid = g_ptr_array_index (known_uids, ii);
2330
2331 camel_folder_change_info_remove_uid (changes, uid);
2332 camel_folder_summary_remove_uid (folder_summary, uid);
2333 ews_data_cache_remove (ews_folder->cache, "cur", uid, NULL);
2334 }
2335 camel_folder_summary_unlock (folder_summary);
2336
2337 if (camel_folder_change_info_changed (changes)) {
2338 camel_folder_summary_touch (folder_summary);
2339 camel_folder_summary_save (folder_summary, NULL);
2340 camel_folder_changed (folder, changes);
2341 }
2342
2343 camel_folder_change_info_free (changes);
2344 camel_folder_summary_free_array (known_uids);
2345 }
2346
2347 static gboolean
2348 ews_refresh_info_sync (CamelFolder *folder,
2349 GCancellable *cancellable,
2350 GError **error)
2351 {
2352 CamelFolderChangeInfo *change_info;
2353 CamelFolderSummary *folder_summary;
2354 CamelEwsFolder *ews_folder;
2355 CamelEwsFolderPrivate *priv;
2356 GHashTable *updating_summary_uids = NULL;
2357 EEwsConnection *cnc;
2358 CamelEwsStore *ews_store;
2359 CamelEwsSettings *settings;
2360 const gchar *full_name;
2361 gchar *id;
2362 gchar *sync_state;
2363 gboolean includes_last_item = FALSE;
2364 gboolean is_drafts_folder;
2365 gint64 last_folder_update_time;
2366 GError *local_error = NULL;
2367
2368 full_name = camel_folder_get_full_name (folder);
2369 ews_store = (CamelEwsStore *) camel_folder_get_parent_store (folder);
2370
2371 ews_folder = (CamelEwsFolder *) folder;
2372 priv = ews_folder->priv;
2373
2374 if (!camel_ews_store_connected (ews_store, cancellable, error))
2375 return FALSE;
2376
2377 g_mutex_lock (&priv->state_lock);
2378
2379 if (priv->refreshing) {
2380 g_mutex_unlock (&priv->state_lock);
2381 return TRUE;
2382 }
2383
2384 priv->refreshing = TRUE;
2385 g_mutex_unlock (&priv->state_lock);
2386
2387 cnc = camel_ews_store_ref_connection (ews_store);
2388 g_return_val_if_fail (cnc != NULL, FALSE);
2389
2390 folder_summary = camel_folder_get_folder_summary (folder);
2391 camel_folder_summary_prepare_fetch_all (folder_summary, NULL);
2392
2393 change_info = camel_folder_change_info_new ();
2394 last_folder_update_time = g_get_monotonic_time ();
2395 id = camel_ews_store_summary_get_folder_id_from_name (
2396 ews_store->summary, full_name);
2397
2398 camel_operation_push_message (cancellable, _("Refreshing folder “%s”"), camel_folder_get_display_name (folder));
2399
2400 is_drafts_folder = camel_ews_utils_folder_is_drafts_folder (ews_folder);
2401
2402 /* Sync folder items does not return the fields ToRecipients,
2403 * CCRecipients. With the item_type unknown, it's not possible
2404 * to fetch the right properties which are valid for an item type.
2405 * Due to these reasons we just get the item ids and its type in
2406 * SyncFolderItem request and fetch the item using the
2407 * GetItem request. */
2408
2409 settings = e_ews_connection_ref_settings (cnc);
2410
2411 if (settings && camel_ews_summary_get_sync_tag_stamp (CAMEL_EWS_SUMMARY (folder_summary)) != camel_ews_settings_get_sync_tag_stamp (settings))
2412 sync_state = NULL;
2413 else
2414 sync_state = camel_ews_summary_dup_sync_state (CAMEL_EWS_SUMMARY (folder_summary));
2415
2416 if (!sync_state ||
2417 camel_ews_summary_get_version (CAMEL_EWS_SUMMARY (folder_summary)) < CAMEL_EWS_SUMMARY_VERSION) {
2418 updating_summary_uids = camel_folder_summary_get_hash (folder_summary);
2419 }
2420
2421 do {
2422 GSList *items_created = NULL, *items_updated = NULL;
2423 GSList *items_deleted = NULL;
2424 gchar *new_sync_state = NULL;
2425 guint32 total, unread;
2426
2427 e_ews_connection_sync_folder_items_sync (cnc, EWS_PRIORITY_MEDIUM, sync_state, id, "IdOnly", NULL, EWS_MAX_FETCH_COUNT,
2428 &new_sync_state, &includes_last_item, &items_created, &items_updated, &items_deleted,
2429 cancellable, &local_error);
2430
2431 g_free (sync_state);
2432 sync_state = new_sync_state;
2433
2434 if (g_error_matches (local_error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_INVALIDSYNCSTATEDATA)) {
2435 g_clear_error (&local_error);
2436 camel_ews_summary_set_sync_state (CAMEL_EWS_SUMMARY (folder_summary), NULL);
2437 g_free (sync_state);
2438 sync_state = NULL;
2439 ews_folder_forget_all_mails (ews_folder);
2440 if (updating_summary_uids) {
2441 g_hash_table_destroy (updating_summary_uids);
2442 updating_summary_uids = NULL;
2443 }
2444
2445 e_ews_connection_sync_folder_items_sync (cnc, EWS_PRIORITY_MEDIUM, NULL, id, "IdOnly", NULL, EWS_MAX_FETCH_COUNT,
2446 &sync_state, &includes_last_item, &items_created, &items_updated, &items_deleted,
2447 cancellable, &local_error);
2448 }
2449
2450 if (local_error) {
2451 camel_ews_store_maybe_disconnect (ews_store, local_error);
2452 break;
2453 }
2454
2455 if (items_deleted)
2456 camel_ews_utils_sync_deleted_items (ews_folder, items_deleted, change_info);
2457
2458 if (items_created)
2459 sync_created_items (ews_folder, cnc, is_drafts_folder, items_created, updating_summary_uids, change_info, cancellable, &local_error);
2460
2461 if (local_error) {
2462 if (items_updated) {
2463 g_slist_foreach (items_updated, (GFunc) g_object_unref, NULL);
2464 g_slist_free (items_updated);
2465 }
2466
2467 break;
2468 }
2469
2470 if (items_updated)
2471 sync_updated_items (ews_folder, cnc, is_drafts_folder, items_updated, change_info, cancellable, &local_error);
2472
2473 if (local_error)
2474 break;
2475
2476 total = camel_folder_summary_count (folder_summary);
2477 unread = camel_folder_summary_get_unread_count (folder_summary);
2478
2479 camel_ews_store_summary_set_folder_total (ews_store->summary, id, total);
2480 camel_ews_store_summary_set_folder_unread (ews_store->summary, id, unread);
2481 camel_ews_store_summary_save (ews_store->summary, NULL);
2482
2483 camel_ews_summary_set_sync_state (CAMEL_EWS_SUMMARY (folder_summary), sync_state);
2484 if (settings)
2485 camel_ews_summary_set_sync_tag_stamp (CAMEL_EWS_SUMMARY (folder_summary), camel_ews_settings_get_sync_tag_stamp (settings));
2486
2487 camel_folder_summary_touch (folder_summary);
2488
2489 if (camel_folder_change_info_changed (change_info)) {
2490 camel_folder_summary_save (folder_summary, NULL);
2491 /* Notify any listeners only once per 10 seconds, as such notify can cause UI update */
2492 if (g_get_monotonic_time () - last_folder_update_time >= 10 * G_USEC_PER_SEC) {
2493 last_folder_update_time = g_get_monotonic_time ();
2494 camel_folder_changed (folder, change_info);
2495 camel_folder_change_info_clear (change_info);
2496 }
2497 }
2498 } while (!local_error && !includes_last_item && !g_cancellable_is_cancelled (cancellable));
2499
2500 if (updating_summary_uids) {
2501 if (!local_error && !g_cancellable_is_cancelled (cancellable) &&
2502 g_hash_table_size (updating_summary_uids) > 0) {
2503 GHashTableIter iter;
2504 gpointer key;
2505 GList *removed_uids = NULL;
2506
2507 g_hash_table_iter_init (&iter, updating_summary_uids);
2508 while (g_hash_table_iter_next (&iter, &key, NULL)) {
2509 const gchar *uid = key;
2510
2511 camel_folder_change_info_remove_uid (change_info, uid);
2512 ews_data_cache_remove (ews_folder->cache, "cur", uid, NULL);
2513
2514 removed_uids = g_list_prepend (removed_uids, (gpointer) uid);
2515 }
2516
2517 camel_folder_summary_remove_uids (folder_summary, removed_uids);
2518
2519 g_list_free (removed_uids);
2520 }
2521
2522 g_hash_table_destroy (updating_summary_uids);
2523 updating_summary_uids = NULL;
2524 }
2525
2526 camel_operation_pop_message (cancellable);
2527
2528 if (camel_folder_change_info_changed (change_info)) {
2529 camel_folder_summary_touch (folder_summary);
2530 camel_folder_summary_save (folder_summary, NULL);
2531 camel_folder_changed (folder, change_info);
2532 } else {
2533 camel_folder_summary_save (folder_summary, NULL);
2534 }
2535
2536 camel_folder_change_info_free (change_info);
2537
2538 if (local_error)
2539 g_propagate_error (error, local_error);
2540
2541 g_mutex_lock (&priv->state_lock);
2542 priv->refreshing = FALSE;
2543 g_mutex_unlock (&priv->state_lock);
2544
2545 g_clear_object (&settings);
2546 g_object_unref (cnc);
2547 g_free (sync_state);
2548 g_free (id);
2549
2550 return !local_error;
2551 }
2552
2553 static gboolean
2554 ews_append_message_sync (CamelFolder *folder,
2555 CamelMimeMessage *message,
2556 CamelMessageInfo *info,
2557 gchar **appended_uid,
2558 GCancellable *cancellable,
2559 GError **error)
2560 {
2561 gchar *itemid, *changekey;
2562 const gchar *folder_name;
2563 gchar *folder_id;
2564 EwsFolderId *fid;
2565 CamelAddress *from;
2566 CamelEwsStore *ews_store;
2567 EEwsConnection *cnc;
2568 GError *local_error = NULL;
2569
2570 ews_store = (CamelEwsStore *) camel_folder_get_parent_store (folder);
2571
2572 if (!camel_ews_store_connected (ews_store, cancellable, error)) {
2573 return FALSE;
2574 }
2575
2576 folder_name = camel_folder_get_full_name (folder);
2577 folder_id = camel_ews_store_summary_get_folder_id_from_name (
2578 ews_store->summary,
2579 folder_name);
2580 if (!folder_id)
2581 return FALSE;
2582
2583 from = CAMEL_ADDRESS (camel_mime_message_get_from (message));
2584
2585 cnc = camel_ews_store_ref_connection (ews_store);
2586
2587 if (!cnc) {
2588 g_free (folder_id);
2589 g_set_error (
2590 error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
2591 _("Cannot perform actions on the folder while in offline mode"));
2592 return FALSE;
2593 }
2594
2595 fid = e_ews_folder_id_new (folder_id, NULL, FALSE);
2596 if (!camel_ews_utils_create_mime_message (
2597 cnc, "SaveOnly", fid, message,
2598 info, from, NULL, &itemid, &changekey,
2599 cancellable, &local_error)) {
2600 camel_ews_store_maybe_disconnect (ews_store, local_error);
2601 g_propagate_error (error, local_error);
2602 e_ews_folder_id_free (fid);
2603 g_free (folder_id);
2604 g_object_unref (cnc);
2605 return FALSE;
2606 }
2607 e_ews_folder_id_free (fid);
2608 g_free (folder_id);
2609
2610 if (camel_ews_summary_add_message (camel_folder_get_folder_summary (folder), itemid, changekey, info, message)) {
2611 CamelFolderChangeInfo *changes;
2612
2613 changes = camel_folder_change_info_new ();
2614
2615 camel_folder_change_info_add_uid (changes, itemid);
2616
2617 if (camel_folder_change_info_changed (changes))
2618 camel_folder_changed (folder, changes);
2619
2620 camel_folder_change_info_free (changes);
2621 }
2622
2623 if (appended_uid)
2624 *appended_uid = itemid;
2625 else
2626 g_free (itemid);
2627 g_free (changekey);
2628
2629 g_object_unref (cnc);
2630
2631 return TRUE;
2632 }
2633
2634 /* move messages */
2635 static gboolean
2636 ews_transfer_messages_to_sync (CamelFolder *source,
2637 GPtrArray *uids,
2638 CamelFolder *destination,
2639 gboolean delete_originals,
2640 GPtrArray **transferred_uids,
2641 GCancellable *cancellable,
2642 GError **error)
2643 {
2644 EEwsConnection *cnc;
2645 CamelEwsStore *dst_ews_store;
2646 const gchar *dst_full_name;
2647 gchar *dst_id;
2648 GError *local_error = NULL;
2649 GSList *ids = NULL, *ret_items = NULL, *mi_list = NULL;
2650 gint i = 0, mi_list_len = 0;
2651 gboolean success = TRUE;
2652
2653 dst_full_name = camel_folder_get_full_name (destination);
2654 dst_ews_store = (CamelEwsStore *) camel_folder_get_parent_store (destination);
2655
2656 if (!camel_ews_store_connected (dst_ews_store, cancellable, error))
2657 return FALSE;
2658
2659 cnc = camel_ews_store_ref_connection (dst_ews_store);
2660 dst_id = camel_ews_store_summary_get_folder_id_from_name (
2661 dst_ews_store->summary, dst_full_name);
2662
2663 for (i = 0; success && i < uids->len; i++) {
2664 guint32 flags_set;
2665 CamelMessageInfo *mi;
2666
2667 ids = g_slist_prepend (ids, (gchar *) uids->pdata[i]);
2668
2669 mi = camel_folder_summary_get (camel_folder_get_folder_summary (source), uids->pdata[i]);
2670 if (!mi)
2671 continue;
2672
2673 flags_set = camel_message_info_get_flags (mi);
2674
2675 /* Exchange doesn't seem to have a sane representation
2676 * for most flags — not even replied/forwarded. */
2677 if ((flags_set & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0) {
2678 mi_list = g_slist_prepend (mi_list, mi);
2679 mi_list_len++;
2680 } else {
2681 g_clear_object (&mi);
2682 }
2683
2684 if (mi_list_len == EWS_MAX_FETCH_COUNT) {
2685 success = ews_save_flags (source, mi_list, cancellable, &local_error);
2686 g_slist_free_full (mi_list, g_object_unref);
2687 mi_list = NULL;
2688 mi_list_len = 0;
2689 }
2690 }
2691
2692 if (mi_list != NULL && success)
2693 success = ews_save_flags (source, mi_list, cancellable, &local_error);
2694 g_slist_free_full (mi_list, g_object_unref);
2695
2696 ids = g_slist_reverse (ids);
2697
2698 success = success && e_ews_connection_move_items_in_chunks_sync (
2699 cnc, EWS_PRIORITY_MEDIUM,
2700 dst_id, !delete_originals,
2701 ids, &ret_items,
2702 cancellable, &local_error);
2703
2704 /* Messages could be copied/moved partially only, like when
2705 the user cancels the operation in the middle */
2706 if (success || ret_items) {
2707 CamelFolderChangeInfo *changes;
2708 GSList *l, *processed_items = NULL;
2709
2710 changes = camel_folder_change_info_new ();
2711
2712 for (l = ret_items, i = 0; l != NULL; l = l->next, i++) {
2713 CamelMimeMessage *message;
2714 CamelStream *stream;
2715 CamelMessageInfo *info;
2716 CamelMessageInfo *clone;
2717 const EwsId *id;
2718
2719 if (e_ews_item_get_item_type (l->data) == E_EWS_ITEM_TYPE_ERROR) {
2720 if (!local_error)
2721 local_error = g_error_copy (e_ews_item_get_error (l->data));
2722 continue;
2723 }
2724
2725 id = e_ews_item_get_id (l->data);
2726 processed_items = g_slist_prepend (processed_items, uids->pdata[i]);
2727
2728 message = ews_folder_get_message_cached (source, uids->pdata[i], cancellable);
2729 if (message == NULL)
2730 continue;
2731
2732 stream = ews_data_cache_add (
2733 CAMEL_EWS_FOLDER (destination)->cache, "cur", id->id, NULL);
2734 if (stream == NULL) {
2735 g_object_unref (message);
2736
2737 continue;
2738 }
2739
2740 camel_data_wrapper_write_to_stream_sync (
2741 CAMEL_DATA_WRAPPER (message), stream, cancellable, NULL);
2742
2743 info = camel_folder_summary_get (camel_folder_get_folder_summary (source), uids->pdata[i]);
2744 if (info == NULL) {
2745 g_object_unref (stream);
2746 g_object_unref (message);
2747
2748 continue;
2749 }
2750
2751 clone = camel_message_info_clone (info, NULL);
2752
2753 if (camel_ews_summary_add_message (camel_folder_get_folder_summary (destination), id->id, id->change_key, clone, message))
2754 camel_folder_change_info_add_uid (changes, id->id);
2755
2756 g_clear_object (&clone);
2757 g_clear_object (&info);
2758 g_object_unref (stream);
2759 g_object_unref (message);
2760 }
2761
2762 if (camel_folder_change_info_changed (changes))
2763 camel_folder_changed (destination, changes);
2764
2765 camel_folder_change_info_free (changes);
2766
2767 if (delete_originals) {
2768 changes = camel_folder_change_info_new ();
2769
2770 for (l = processed_items; l; l = g_slist_next (l)) {
2771 const gchar *uid = l->data;
2772
2773 camel_folder_summary_remove_uid (camel_folder_get_folder_summary (source), uid);
2774 camel_folder_change_info_remove_uid (changes, uid);
2775 ews_data_cache_remove (CAMEL_EWS_FOLDER (source)->cache, "cur", uid, NULL);
2776 }
2777 if (camel_folder_change_info_changed (changes)) {
2778 camel_folder_summary_touch (camel_folder_get_folder_summary (source));
2779 camel_folder_changed (source, changes);
2780 }
2781
2782 camel_folder_change_info_free (changes);
2783 }
2784
2785 /* update destination folder only if not frozen, to not update
2786 for each single message transfer during filtering
2787 */
2788 if (!camel_folder_is_frozen (destination)) {
2789 camel_operation_progress (cancellable, -1);
2790
2791 ews_refresh_info_sync (destination, cancellable, NULL);
2792 }
2793
2794 g_slist_free (processed_items);
2795 }
2796 g_free (dst_id);
2797
2798 if (local_error) {
2799 camel_ews_store_maybe_disconnect (dst_ews_store, local_error);
2800 g_propagate_error (error, local_error);
2801 }
2802
2803 g_object_unref (cnc);
2804 g_slist_free (ids);
2805 g_slist_free_full (ret_items, g_object_unref);
2806
2807 return !local_error;
2808 }
2809
2810 static void
2811 ews_prepare_content_refresh (CamelFolder *folder)
2812 {
2813 g_return_if_fail (CAMEL_IS_EWS_FOLDER (folder));
2814
2815 camel_ews_summary_set_sync_state (CAMEL_EWS_SUMMARY (camel_folder_get_folder_summary (folder)), NULL);
2816 }
2817
2818 static gboolean
2819 ews_delete_messages_from_server (CamelEwsStore *ews_store,
2820 const GSList *deleted_items,
2821 EwsDeleteType delete_type,
2822 GCancellable *cancellable,
2823 GError **error)
2824 {
2825 EEwsConnection *cnc;
2826 gboolean ret;
2827
2828 cnc = camel_ews_store_ref_connection (ews_store);
2829
2830 ret = e_ews_connection_delete_items_in_chunks_sync (
2831 cnc, EWS_PRIORITY_MEDIUM, deleted_items, delete_type,
2832 EWS_SEND_TO_NONE, EWS_NONE_OCCURRENCES, cancellable, error);
2833
2834 g_object_unref (cnc);
2835
2836 return ret;
2837 }
2838
2839 static void
2840 ews_delete_messages_from_folder (CamelFolder *folder,
2841 const GSList *deleted_items)
2842 {
2843 CamelFolderChangeInfo *changes;
2844 CamelFolderSummary *folder_summary;
2845 const GSList *iter;
2846
2847 changes = camel_folder_change_info_new ();
2848 folder_summary = camel_folder_get_folder_summary (folder);
2849
2850 for (iter = deleted_items; iter != NULL; iter = iter->next) {
2851 const gchar *uid = iter->data;
2852
2853 camel_folder_summary_lock (folder_summary);
2854 camel_folder_change_info_remove_uid (changes, uid);
2855 camel_folder_summary_remove_uid (folder_summary, uid);
2856 ews_data_cache_remove (CAMEL_EWS_FOLDER (folder)->cache, "cur", uid, NULL);
2857 camel_folder_summary_unlock (folder_summary);
2858 }
2859
2860 if (camel_folder_change_info_changed (changes)) {
2861 camel_folder_summary_touch (folder_summary);
2862 camel_folder_changed (folder, changes);
2863 }
2864
2865 camel_folder_change_info_free (changes);
2866 }
2867
2868 static gboolean
2869 ews_delete_messages (CamelFolder *folder,
2870 const GSList *deleted_items,
2871 gboolean expunge,
2872 GCancellable *cancellable,
2873 GError **error)
2874 {
2875 CamelStore *parent_store;
2876 CamelEwsStore *ews_store;
2877 GError *local_error = NULL;
2878
2879 if (deleted_items == NULL)
2880 return TRUE;
2881
2882 parent_store = camel_folder_get_parent_store (folder);
2883 ews_store = CAMEL_EWS_STORE (parent_store);
2884
2885 if (!camel_ews_store_connected (ews_store, cancellable, error))
2886 return FALSE;
2887
2888 if (!expunge)
2889 expunge = ews_folder_is_public_or_foreign (folder);
2890
2891 ews_delete_messages_from_server (
2892 ews_store,
2893 deleted_items,
2894 expunge ? EWS_HARD_DELETE : EWS_MOVE_TO_DELETED_ITEMS,
2895 cancellable,
2896 &local_error);
2897
2898 if (local_error != NULL && local_error->code == EWS_CONNECTION_ERROR_ITEMNOTFOUND) {
2899 /* If delete failed due to the item not found, ignore the error,
2900 * trigger folder info refresh and then go on to clear the
2901 * cache of the deleted items anyway. */
2902 g_clear_error (&local_error);
2903 ews_refresh_info_sync (folder, cancellable, &local_error);
2904 }
2905
2906 if (local_error != NULL) {
2907 camel_ews_store_maybe_disconnect (ews_store, local_error);
2908 g_propagate_error (error, local_error);
2909
2910 return FALSE;
2911 }
2912
2913 ews_delete_messages_from_folder (folder, deleted_items);
2914
2915 return TRUE;
2916 }
2917
2918 static gboolean
2919 ews_expunge_deleted_items_sync (CamelFolder *folder,
2920 CamelEwsStore *ews_store,
2921 gboolean *delete_items,
2922 GCancellable *cancellable,
2923 GError **error)
2924 {
2925 EEwsConnection *cnc;
2926 CamelFolderInfo *folder_info = NULL;
2927 CamelFolderInfo *to_delete;
2928 gchar *trash_id;
2929 gchar *folder_name;
2930 gboolean ret = FALSE;
2931 gboolean expunge_deleted_items_at_once = FALSE;
2932
2933 cnc = camel_ews_store_ref_connection (ews_store);
2934 trash_id = camel_ews_store_summary_get_folder_id_from_folder_type (ews_store->summary, CAMEL_FOLDER_TYPE_TRASH);
2935
2936 folder_name = camel_ews_store_summary_get_folder_full_name (ews_store->summary, trash_id, error);
2937 if (folder_name == NULL)
2938 goto exit;
2939
2940 folder_info = camel_store_get_folder_info_sync (
2941 CAMEL_STORE (ews_store), folder_name,
2942 CAMEL_STORE_FOLDER_INFO_RECURSIVE |
2943 CAMEL_STORE_FOLDER_INFO_SUBSCRIBED,
2944 cancellable, error);
2945
2946
2947 if (folder_info == NULL)
2948 goto exit;
2949
2950 to_delete = folder_info->child;
2951
2952 expunge_deleted_items_at_once = e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2010);
2953
2954 if (expunge_deleted_items_at_once) {
2955 ret = e_ews_connection_empty_folder_sync (
2956 cnc,
2957 EWS_PRIORITY_MEDIUM,
2958 trash_id,
2959 FALSE,
2960 "HardDelete",
2961 TRUE,
2962 cancellable,
2963 error);
2964
2965 if (!ret)
2966 goto exit;
2967 } else {
2968 /*
2969 * As we cannot delete the "Deleted Items" folder itself, we have to walk throught its first
2970 * level subfolders and delete each folder one by one from the server,
2971 */
2972 while (to_delete != NULL) {
2973 gchar *fid;
2974
2975 fid = camel_ews_store_summary_get_folder_id_from_name (
2976 ews_store->summary, to_delete->full_name);
2977
2978 ret = e_ews_connection_delete_folder_sync (
2979 cnc,
2980 EWS_PRIORITY_MEDIUM,
2981 fid,
2982 FALSE,
2983 "HardDelete",
2984 cancellable,
2985 error);
2986
2987 g_free (fid);
2988
2989 if (!ret)
2990 goto exit;
2991
2992 to_delete = to_delete->next;
2993 }
2994 }
2995
2996 to_delete = folder_info->child;
2997 ret = camel_ews_utils_delete_folders_from_summary_recursive (ews_store, to_delete, TRUE, error);
2998
2999 exit:
3000 camel_folder_info_free (folder_info);
3001 g_free (folder_name);
3002 g_free (trash_id);
3003 g_object_unref (cnc);
3004
3005 *delete_items = !expunge_deleted_items_at_once;
3006
3007 return ret;
3008 }
3009
3010 static gboolean
3011 ews_expunge_sync (CamelFolder *folder,
3012 GCancellable *cancellable,
3013 GError **error)
3014 {
3015 CamelStore *parent_store;
3016 GSList *deleted_items = NULL;
3017 gint i;
3018 gboolean is_trash;
3019 gboolean delete_items_from_server = TRUE;
3020 gboolean ret;
3021 GPtrArray *known_uids;
3022 GError *local_error = NULL;
3023
3024 parent_store = camel_folder_get_parent_store (folder);
3025
3026 if (!camel_ews_store_connected (CAMEL_EWS_STORE (parent_store), cancellable, error))
3027 return FALSE;
3028
3029 /*
3030 * If the user is expunging the trash folder, we should delete
3031 * all messages, subfolders and subfolders' messages inside the
3032 * trash folder.
3033 */
3034 is_trash = ews_folder_is_of_type (folder, CAMEL_FOLDER_TYPE_TRASH);
3035
3036 camel_folder_summary_prepare_fetch_all (camel_folder_get_folder_summary (folder), NULL);
3037 known_uids = camel_folder_summary_get_array (camel_folder_get_folder_summary (folder));
3038
3039 if (known_uids == NULL)
3040 return TRUE;
3041
3042 if (is_trash) {
3043 ews_expunge_deleted_items_sync (
3044 folder,
3045 CAMEL_EWS_STORE (parent_store),
3046 &delete_items_from_server,
3047 cancellable,
3048 &local_error);
3049
3050 if (local_error != NULL) {
3051 camel_ews_store_maybe_disconnect (CAMEL_EWS_STORE (parent_store), local_error);
3052 g_propagate_error (error, local_error);
3053
3054 camel_folder_summary_free_array (known_uids);
3055
3056 return FALSE;
3057 }
3058 }
3059
3060 for (i = 0; i < known_uids->len; i++) {
3061 CamelMessageInfo *info;
3062 const gchar *uid = g_ptr_array_index (known_uids, i);
3063
3064 info = camel_folder_summary_get (camel_folder_get_folder_summary (folder), uid);
3065
3066 if (info && (is_trash || (camel_message_info_get_flags (info) & CAMEL_MESSAGE_DELETED) != 0))
3067 deleted_items = g_slist_prepend (deleted_items, (gpointer) camel_pstring_strdup (uid));
3068
3069 g_clear_object (&info);
3070 }
3071
3072 if (is_trash && !delete_items_from_server) {
3073 ews_delete_messages_from_folder (folder, deleted_items);
3074 ret = TRUE;
3075 } else {
3076 ret = ews_delete_messages (folder, deleted_items, TRUE, cancellable, error);
3077 }
3078
3079 g_slist_free_full (deleted_items, (GDestroyNotify) camel_pstring_free);
3080 camel_folder_summary_free_array (known_uids);
3081
3082 return ret;
3083 }
3084
3085 static gint
3086 ews_cmp_uids (CamelFolder *folder,
3087 const gchar *uid1,
3088 const gchar *uid2)
3089 {
3090 g_return_val_if_fail (uid1 != NULL, 0);
3091 g_return_val_if_fail (uid2 != NULL, 0);
3092
3093 return strcmp (uid1, uid2);
3094 }
3095
3096 static void
3097 ews_folder_set_property (GObject *object,
3098 guint property_id,
3099 const GValue *value,
3100 GParamSpec *pspec)
3101 {
3102 switch (property_id) {
3103 case PROP_APPLY_FILTERS:
3104 camel_ews_folder_set_apply_filters (
3105 CAMEL_EWS_FOLDER (object),
3106 g_value_get_boolean (value));
3107 return;
3108
3109 case PROP_CHECK_FOLDER:
3110 camel_ews_folder_set_check_folder (
3111 CAMEL_EWS_FOLDER (object),
3112 g_value_get_boolean (value));
3113 return;
3114 }
3115
3116 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3117 }
3118
3119 static void
3120 ews_folder_get_property (GObject *object,
3121 guint property_id,
3122 GValue *value,
3123 GParamSpec *pspec)
3124 {
3125 switch (property_id) {
3126 case PROP_APPLY_FILTERS:
3127 g_value_set_boolean (
3128 value,
3129 camel_ews_folder_get_apply_filters (
3130 CAMEL_EWS_FOLDER (object)));
3131 return;
3132
3133 case PROP_CHECK_FOLDER:
3134 g_value_set_boolean (
3135 value,
3136 camel_ews_folder_get_check_folder (
3137 CAMEL_EWS_FOLDER (object)));
3138 return;
3139 }
3140
3141 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3142 }
3143
3144 static void
3145 ews_folder_dispose (GObject *object)
3146 {
3147 CamelEwsFolder *ews_folder = CAMEL_EWS_FOLDER (object);
3148 CamelFolderSummary *summary;
3149
3150 summary = camel_folder_get_folder_summary (CAMEL_FOLDER (ews_folder));
3151 if (summary) {
3152 g_signal_handlers_disconnect_by_func (summary, G_CALLBACK (ews_folder_count_notify_cb), ews_folder);
3153
3154 /* save changes, if there are any unsaved */
3155 camel_folder_summary_save (summary, NULL);
3156 }
3157
3158 if (ews_folder->cache != NULL) {
3159 g_object_unref (ews_folder->cache);
3160 ews_folder->cache = NULL;
3161 }
3162
3163 if (ews_folder->search != NULL) {
3164 g_object_unref (ews_folder->search);
3165 ews_folder->search = NULL;
3166 }
3167
3168 /* Chain up to parent's dispose() method. */
3169 G_OBJECT_CLASS (camel_ews_folder_parent_class)->dispose (object);
3170 }
3171
3172 static void
3173 ews_folder_finalize (GObject *object)
3174 {
3175 CamelEwsFolder *ews_folder;
3176
3177 ews_folder = CAMEL_EWS_FOLDER (object);
3178
3179 g_mutex_clear (&ews_folder->priv->search_lock);
3180 g_mutex_clear (&ews_folder->priv->state_lock);
3181 g_rec_mutex_clear (&ews_folder->priv->cache_lock);
3182 g_hash_table_destroy (ews_folder->priv->fetching_uids);
3183 g_cond_clear (&ews_folder->priv->fetch_cond);
3184
3185 /* Chain up to parent's finalize() method. */
3186 G_OBJECT_CLASS (camel_ews_folder_parent_class)->finalize (object);
3187 }
3188
3189 static void
3190 ews_folder_constructed (GObject *object)
3191 {
3192 CamelNetworkSettings *network_settings;
3193 CamelSettings *settings;
3194 CamelStore *parent_store;
3195 CamelService *service;
3196 CamelFolder *folder;
3197 const gchar *full_name;
3198 gchar *description;
3199 gchar *host;
3200 gchar *user;
3201
3202 /* Chain up to parent's method. */
3203 G_OBJECT_CLASS (camel_ews_folder_parent_class)->constructed (object);
3204
3205 folder = CAMEL_FOLDER (object);
3206 full_name = camel_folder_get_full_name (folder);
3207 parent_store = camel_folder_get_parent_store (folder);
3208
3209 service = CAMEL_SERVICE (parent_store);
3210
3211 settings = camel_service_ref_settings (service);
3212
3213 network_settings = CAMEL_NETWORK_SETTINGS (settings);
3214 host = camel_ews_utils_get_host_name (settings);
3215 user = camel_network_settings_dup_user (network_settings);
3216
3217 g_object_unref (settings);
3218
3219 description = g_strdup_printf (
3220 "%s@%s:%s", user, host, full_name);
3221 camel_folder_set_description (folder, description);
3222 g_free (description);
3223
3224 g_free (host);
3225 g_free (user);
3226 }
3227
3228 static void
3229 camel_ews_folder_class_init (CamelEwsFolderClass *class)
3230 {
3231 GObjectClass *object_class;
3232 CamelFolderClass *folder_class;
3233
3234 object_class = G_OBJECT_CLASS (class);
3235 object_class->set_property = ews_folder_set_property;
3236 object_class->get_property = ews_folder_get_property;
3237 object_class->dispose = ews_folder_dispose;
3238 object_class->finalize = ews_folder_finalize;
3239 object_class->constructed = ews_folder_constructed;
3240
3241 folder_class = CAMEL_FOLDER_CLASS (class);
3242 folder_class->get_permanent_flags = ews_folder_get_permanent_flags;
3243 folder_class->get_message_sync = ews_folder_get_message_sync;
3244 folder_class->get_message_cached = ews_folder_get_message_cached;
3245 folder_class->search_by_expression = ews_folder_search_by_expression;
3246 folder_class->count_by_expression = ews_folder_count_by_expression;
3247 folder_class->cmp_uids = ews_cmp_uids;
3248 folder_class->search_by_uids = ews_folder_search_by_uids;
3249 folder_class->search_free = ews_folder_search_free;
3250 folder_class->append_message_sync = ews_append_message_sync;
3251 folder_class->refresh_info_sync = ews_refresh_info_sync;
3252 folder_class->synchronize_sync = ews_synchronize_sync;
3253 folder_class->expunge_sync = ews_expunge_sync;
3254 folder_class->transfer_messages_to_sync = ews_transfer_messages_to_sync;
3255 folder_class->prepare_content_refresh = ews_prepare_content_refresh;
3256 folder_class->get_filename = ews_get_filename;
3257
3258 g_object_class_install_property (
3259 object_class,
3260 PROP_APPLY_FILTERS,
3261 g_param_spec_boolean (
3262 "apply-filters",
3263 "Apply Filters",
3264 _("Apply message _filters to this folder"),
3265 FALSE,
3266 G_PARAM_READWRITE |
3267 G_PARAM_EXPLICIT_NOTIFY |
3268 CAMEL_PARAM_PERSISTENT));
3269
3270 g_object_class_install_property (
3271 object_class,
3272 PROP_CHECK_FOLDER,
3273 g_param_spec_boolean (
3274 "check-folder",
3275 "Check Folder",
3276 _("Always check for _new mail in this folder"),
3277 FALSE,
3278 G_PARAM_READWRITE |
3279 G_PARAM_EXPLICIT_NOTIFY |
3280 CAMEL_PARAM_PERSISTENT));
3281 }
3282
3283 static void
3284 camel_ews_folder_init (CamelEwsFolder *ews_folder)
3285 {
3286 CamelFolder *folder = CAMEL_FOLDER (ews_folder);
3287
3288 ews_folder->priv = camel_ews_folder_get_instance_private (ews_folder);
3289
3290 camel_folder_set_flags (folder, CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY);
3291
3292 g_mutex_init (&ews_folder->priv->search_lock);
3293 g_mutex_init (&ews_folder->priv->state_lock);
3294 g_rec_mutex_init (&ews_folder->priv->cache_lock);
3295
3296 ews_folder->priv->refreshing = FALSE;
3297
3298 g_cond_init (&ews_folder->priv->fetch_cond);
3299 ews_folder->priv->fetching_uids = g_hash_table_new (g_str_hash, g_str_equal);
3300 camel_folder_set_lock_async (folder, TRUE);
3301 }
3302
3303 static void
3304 camel_ews_folder_update_flags (CamelEwsFolder *self)
3305 {
3306 CamelFolder *folder = CAMEL_FOLDER (self);
3307 CamelSettings *settings;
3308 CamelStore *store;
3309 gboolean filter_inbox = FALSE, filter_junk = FALSE, filter_junk_inbox = FALSE;
3310 guint32 flags;
3311
3312 store = camel_folder_get_parent_store (folder);
3313 if (!store)
3314 return;
3315
3316 settings = camel_service_ref_settings (CAMEL_SERVICE (store));
3317
3318 g_object_get (
3319 settings,
3320 "filter-inbox", &filter_inbox,
3321 "filter-junk", &filter_junk,
3322 "filter-junk-inbox", &filter_junk_inbox,
3323 NULL);
3324
3325 g_clear_object (&settings);
3326
3327 flags = camel_folder_get_flags (folder) & (~(CAMEL_FOLDER_FILTER_RECENT | CAMEL_FOLDER_FILTER_JUNK));
3328
3329 if (!g_ascii_strcasecmp (camel_folder_get_full_name (folder), "Inbox") ||
3330 folder_has_inbox_type (CAMEL_EWS_STORE (store), camel_folder_get_full_name (folder))) {
3331 if (filter_inbox)
3332 flags |= CAMEL_FOLDER_FILTER_RECENT;
3333
3334 if (filter_junk)
3335 flags |= CAMEL_FOLDER_FILTER_JUNK;
3336 } else {
3337 if (camel_ews_folder_get_apply_filters (self))
3338 flags |= CAMEL_FOLDER_FILTER_RECENT;
3339
3340 if (filter_junk && !filter_junk_inbox)
3341 flags |= CAMEL_FOLDER_FILTER_JUNK;
3342 }
3343
3344 camel_folder_set_flags (folder, flags);
3345 }
3346
3347 gboolean
3348 camel_ews_folder_get_apply_filters (CamelEwsFolder *self)
3349 {
3350 g_return_val_if_fail (CAMEL_IS_EWS_FOLDER (self), FALSE);
3351
3352 return self->priv->apply_filters;
3353 }
3354
3355 void
3356 camel_ews_folder_set_apply_filters (CamelEwsFolder *self,
3357 gboolean apply_filters)
3358 {
3359 g_return_if_fail (CAMEL_IS_EWS_FOLDER (self));
3360
3361 if ((self->priv->apply_filters ? 1 : 0) == (apply_filters ? 1 : 0))
3362 return;
3363
3364 self->priv->apply_filters = apply_filters;
3365
3366 g_object_notify (G_OBJECT (self), "apply-filters");
3367 camel_ews_folder_update_flags (self);
3368 }
3369
3370 gboolean
3371 camel_ews_folder_get_check_folder (CamelEwsFolder *self)
3372 {
3373 g_return_val_if_fail (CAMEL_IS_EWS_FOLDER (self), FALSE);
3374
3375 return self->priv->check_folder;
3376 }
3377
3378 void
3379 camel_ews_folder_set_check_folder (CamelEwsFolder *self,
3380 gboolean check_folder)
3381 {
3382 g_return_if_fail (CAMEL_IS_EWS_FOLDER (self));
3383
3384 if ((self->priv->check_folder ? 1 : 0) == (check_folder ? 1 : 0))
3385 return;
3386
3387 self->priv->check_folder = check_folder;
3388
3389 g_object_notify (G_OBJECT (self), "check-folder");
3390 camel_ews_folder_update_flags (self);
3391 }