Debian Codegraph @

src/EWS/common/e-ews-connection.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 #include "evolution-ews-config.h"
7
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <fcntl.h>
11 #include <ctype.h>
12 #include <errno.h>
13 #include <glib/gi18n-lib.h>
14 #include <glib/gstdio.h>
15 #include <libedataserver/libedataserver.h>
16 #include <libecal/libecal.h>
17
18 #include <libxml/parser.h>
19 #include <libxml/xpath.h>
20 #include <libxml/xpathInternals.h>
21 #include <libxml/tree.h>
22
23 #include "e-ews-connection.h"
24 #include "e-ews-connection-utils.h"
25 #include "e-ews-request.h"
26 #include "e-ews-item-change.h"
27 #include "e-ews-debug.h"
28 #include "e-ews-notification.h"
29 #include "e-ews-oof-settings.h"
30
31 /* A chunk size limit when moving items in chunks. */
32 #define EWS_MOVE_ITEMS_CHUNK_SIZE 500
33
34 #define EWS_RETRY_IO_ERROR_SECONDS 3
35 #define EWS_RETRY_AUTH_ERROR_SECONDS 0.1
36
37 #define QUEUE_LOCK(x) (g_rec_mutex_lock(&(x)->priv->queue_lock))
38 #define QUEUE_UNLOCK(x) (g_rec_mutex_unlock(&(x)->priv->queue_lock))
39
40 #define NOTIFICATION_LOCK(x) (g_mutex_lock(&(x)->priv->notification_lock))
41 #define NOTIFICATION_UNLOCK(x) (g_mutex_unlock(&(x)->priv->notification_lock))
42
43 static GMutex connecting;
44 static GHashTable *loaded_connections_permissions = NULL;
45
46 struct _EEwsSoupThreadData {
47 GMutex mutex;
48 GCond cond;
49 GMainContext *main_context;
50 GMainLoop *main_loop;
51 SoupSession *session;
52 GThread *thread;
53 };
54
55 /* Connection APIS */
56
57 struct _EEwsConnectionPrivate {
58 ESource *source;
59 struct _EEwsSoupThreadData soup;
60
61 GProxyResolver *proxy_resolver;
62 EEwsNotification *notification;
63 guint notification_delay_id;
64
65 CamelEwsSettings *settings;
66 guint concurrent_connections;
67 GMutex property_lock;
68 GMutex try_credentials_lock;
69
70 /* Hash key for the loaded_connections_permissions table. */
71 gchar *hash_key;
72
73 gchar *uri;
74 gchar *email;
75 gchar *impersonate_user;
76
77 GSList *jobs;
78 GSList *active_job_queue;
79 GRecMutex queue_lock;
80 GMutex notification_lock;
81
82 GHashTable *subscriptions;
83 GSList *subscribed_folders;
84 /* The subscription ID is not tight to the actual connection, it survives
85 disconnects, thus remember it and unsubscribe from it, before adding
86 a new subscription. */
87 gchar *last_subscription_id;
88
89 EEwsServerVersion version;
90 gboolean backoff_enabled;
91
92 /* Set to TRUE when this connection had been disconnected and cannot be used anymore */
93 gboolean disconnected_flag;
94 gboolean testing_sources;
95
96 gboolean ssl_info_set;
97 gchar *ssl_certificate_pem;
98 GTlsCertificateFlags ssl_certificate_errors;
99
100 ENamedParameters *credentials;
101 gboolean credentials_changed;
102 };
103
104 enum {
105 PROP_0,
106 PROP_PASSWORD,
107 PROP_PROXY_RESOLVER,
108 PROP_SETTINGS,
109 PROP_SOURCE,
110 PROP_CONCURRENT_CONNECTIONS
111 };
112
113 enum {
114 SERVER_NOTIFICATION,
115 PASSWORD_WILL_EXPIRE,
116 SUBSCRIPTION_ID_CHANGED,
117 LAST_SIGNAL
118 };
119
120 static guint signals[LAST_SIGNAL];
121
122 static guint notification_key = 1;
123
124 typedef struct _EwsUrls EwsUrls;
125
126 struct _EwsUrls {
127 xmlChar *as_url;
128 xmlChar *oab_url;
129
130 /* all the below variables are for future use */
131 xmlChar *oof_url;
132 gpointer future1;
133 gpointer future2;
134 };
135
136 G_DEFINE_TYPE_WITH_PRIVATE (EEwsConnection, e_ews_connection, G_TYPE_OBJECT)
137
138 /*
139 * e_ews_debug_handler:
140 *
141 * GLib debug message handler, which is passed all messages from g_debug() calls,
142 * and decides whether to print them.
143 */
144 static void
145 e_ews_debug_handler (const gchar *log_domain,
146 GLogLevelFlags log_level,
147 const gchar *message,
148 gpointer user_data)
149 {
150 if (e_ews_debug_get_log_level () >= 4)
151 g_log_default_handler (log_domain, log_level, message, NULL);
152 }
153
154 /*
155 * e_ews_soup_log_print:
156 *
157 * Log printer for the libsoup logging functionality, which just marshal all soup log
158 * output to the standard GLib logging framework (and thus to debug_handler(), above).
159 */
160 static void
161 e_ews_soup_log_printer (SoupLogger *logger,
162 SoupLoggerLogLevel level,
163 char direction,
164 const gchar *data,
165 gpointer user_data)
166 {
167 g_debug ("%c %s", direction, e_ews_debug_redact_headers (direction, data));
168 }
169
170 static ESoupSession *
171 e_ews_connection_create_soup_session (EEwsConnection *cnc)
172 {
173 ESoupSession *session;
174 gint log_level;
175
176 session = g_object_new (E_TYPE_SOUP_SESSION,
177 "source", cnc->priv->source,
178 "timeout", 90,
179 "max-conns", cnc->priv->concurrent_connections,
180 "max-conns-per-host", cnc->priv->concurrent_connections,
181 NULL);
182
183 e_binding_bind_property (
184 cnc->priv->settings, "timeout",
185 session, "timeout",
186 G_BINDING_SYNC_CREATE);
187
188 e_binding_bind_property (
189 cnc->priv->settings, "force-http1",
190 session, "force-http1",
191 G_BINDING_SYNC_CREATE);
192
193 e_binding_bind_property (
194 cnc, "proxy-resolver",
195 session, "proxy-resolver",
196 G_BINDING_SYNC_CREATE);
197
198 log_level = e_ews_debug_get_log_level ();
199
200 if (log_level >= 1) {
201 SoupLogger *logger;
202
203 logger = soup_logger_new (log_level == 1 ? SOUP_LOGGER_LOG_HEADERS : SOUP_LOGGER_LOG_BODY);
204
205 if (log_level >= 4)
206 soup_logger_set_printer (logger, e_ews_soup_log_printer, NULL, NULL);
207 else if (log_level == 1 || log_level == 2)
208 soup_logger_set_printer (logger, e_ews_debug_soup_log_printer_stdout, NULL, NULL);
209
210 soup_session_add_feature (SOUP_SESSION (session), SOUP_SESSION_FEATURE (logger));
211
212 g_object_unref (logger);
213 }
214
215 soup_session_add_feature_by_type (SOUP_SESSION (session), SOUP_TYPE_COOKIE_JAR);
216
217 return session;
218 }
219
220 static gpointer
221 e_ews_soup_worker_thread (gpointer user_data)
222 {
223 EEwsConnection *cnc = user_data;
224 CamelEwsSettings *settings;
225
226 g_warn_if_fail (cnc->priv->soup.session == NULL);
227
228 settings = e_ews_connection_ref_settings (cnc);
229
230 g_main_context_push_thread_default (cnc->priv->soup.main_context);
231 g_mutex_lock (&cnc->priv->soup.mutex);
232 cnc->priv->soup.session = SOUP_SESSION (e_ews_connection_create_soup_session (cnc));
233
234 g_cond_broadcast (&cnc->priv->soup.cond);
235 g_mutex_unlock (&cnc->priv->soup.mutex);
236
237 g_clear_object (&settings);
238
239 g_main_loop_run (cnc->priv->soup.main_loop);
240
241 soup_session_abort (cnc->priv->soup.session);
242 g_clear_object (&cnc->priv->soup.session);
243
244 g_main_context_pop_thread_default (cnc->priv->soup.main_context);
245
246 return NULL;
247 }
248
249 static gboolean
250 ews_connection_credentials_failed (EEwsConnection *connection,
251 SoupMessage *message,
252 gboolean can_emit,
253 GError **error)
254 {
255 gint expire_in_days = 0;
256 gboolean expired = FALSE;
257 gchar *service_url = NULL;
258
259 g_return_val_if_fail (E_IS_EWS_CONNECTION (connection), FALSE);
260
261 if (!message)
262 return FALSE;
263
264 if (!e_ews_connection_utils_check_x_ms_credential_headers (message, &expire_in_days, &expired, &service_url))
265 return FALSE;
266
267 if (can_emit) {
268 if (expired) {
269 e_ews_connection_utils_expired_password_to_error (service_url, error);
270 } else if (expire_in_days > 0) {
271 g_signal_emit (connection, signals[PASSWORD_WILL_EXPIRE], 0, expire_in_days, service_url);
272 }
273 }
274
275 g_free (service_url);
276
277 return expired;
278 }
279
280 static gboolean
281 e_ews_connection_accept_certificate_for_testing_sources_cb (SoupMessage *message,
282 GTlsCertificate *tls_peer_certificate,
283 GTlsCertificateFlags tls_peer_errors,
284 gpointer user_data)
285 {
286 return TRUE;
287 }
288
289 static void
290 e_ews_connection_maybe_prepare_message_for_testing_sources (EEwsConnection *cnc,
291 SoupMessage *message)
292 {
293 if (e_ews_connection_get_testing_sources (cnc)) {
294 g_signal_connect (message, "accept-certificate",
295 G_CALLBACK (e_ews_connection_accept_certificate_for_testing_sources_cb), NULL);
296 }
297 }
298
299 typedef struct _ProcessData {
300 GMutex mutex;
301 GCond cond;
302 gboolean done;
303 gboolean repeat;
304 EEwsConnection *cnc;
305 ESoapRequest *request;
306 ESoapResponse *response;
307 SoupMessage *message;
308 gpointer prepare_data;
309 GCancellable *cancellable;
310 GError *error;
311 gchar **out_certificate_pem;
312 GTlsCertificateFlags *out_certificate_errors;
313 } ProcessData;
314
315 static void
316 e_ews_connection_process_request_ready_cb (GObject *source_object,
317 GAsyncResult *result,
318 gpointer user_data)
319 {
320 ProcessData *pd = user_data;
321 GInputStream *input_stream;
322
323 g_mutex_lock (&pd->mutex);
324
325 input_stream = e_soup_session_send_message_finish (E_SOUP_SESSION (source_object), result, pd->out_certificate_pem, pd->out_certificate_errors, &pd->error);
326
327 /* Need to process the 'input_stream' in this thread */
328 if (!ews_connection_credentials_failed (pd->cnc, pd->message, FALSE, NULL) &&
329 soup_message_get_status (pd->message) != SOUP_STATUS_UNAUTHORIZED &&
330 input_stream) {
331 ESoapRequestCustomProcessFn custom_process_fn = NULL;
332 gpointer custom_process_data = NULL;
333
334 e_soap_request_get_custom_process_fn (pd->request, &custom_process_fn, &custom_process_data);
335
336 if (custom_process_fn) {
337 custom_process_fn (pd->request, pd->message, input_stream, custom_process_data, &pd->repeat, pd->cancellable, &pd->error);
338 } else {
339 pd->response = e_soap_response_new ();
340
341 e_soap_request_setup_response (pd->request, pd->response);
342
343 if (!e_soap_response_from_message_sync (pd->response, pd->message, input_stream, pd->cancellable, &pd->error)) {
344 g_clear_object (&pd->response);
345
346 if (!pd->error) {
347 g_set_error (&pd->error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_NORESPONSE,
348 _("No response: %s"), soup_message_get_reason_phrase (pd->message));
349 }
350 }
351 }
352 }
353
354 pd->done = TRUE;
355 g_cond_signal (&pd->cond);
356 g_mutex_unlock (&pd->mutex);
357
358 g_clear_object (&input_stream);
359 }
360
361 static gboolean
362 e_ews_connection_process_request_run_cb (gpointer user_data)
363 {
364 ProcessData *pd = user_data;
365
366 if (pd->cnc->priv->soup.session) {
367 e_soup_session_send_message (E_SOUP_SESSION (pd->cnc->priv->soup.session), pd->message, G_PRIORITY_DEFAULT,
368 pd->prepare_data, pd->cancellable, e_ews_connection_process_request_ready_cb, pd);
369 } else {
370 g_mutex_lock (&pd->mutex);
371 g_set_error_literal (&pd->error, G_IO_ERROR, G_IO_ERROR_FAILED, "SoupSession missing");
372 pd->done = TRUE;
373 g_cond_signal (&pd->cond);
374 g_mutex_unlock (&pd->mutex);
375 }
376
377 return FALSE;
378 }
379
380 static ESoapResponse *
381 e_ews_connection_process_request_sync (EEwsConnection *cnc,
382 ESoapRequest *request,
383 SoupMessage **out_message,
384 gchar **out_certificate_pem,
385 GTlsCertificateFlags *out_certificate_errors,
386 gboolean *out_repeat,
387 GCancellable *cancellable,
388 GError **error)
389 {
390 ProcessData pd;
391 const gchar *persistent_auth;
392 CamelEwsSettings *settings;
393 GSource *source;
394
395 g_return_val_if_fail (E_IS_SOAP_REQUEST (request), NULL);
396 g_return_val_if_fail (out_message != NULL, NULL);
397 g_return_val_if_fail (out_repeat != NULL, NULL);
398
399 *out_message = NULL;
400 *out_repeat = FALSE;
401
402 settings = e_ews_connection_ref_settings (cnc);
403
404 g_mutex_lock (&cnc->priv->soup.mutex);
405 if (!cnc->priv->soup.thread) {
406 g_mutex_lock (&cnc->priv->property_lock);
407 cnc->priv->credentials_changed = TRUE;
408 g_mutex_unlock (&cnc->priv->property_lock);
409 cnc->priv->soup.thread = g_thread_new ("e_ews_soup_worker_thread", e_ews_soup_worker_thread, cnc);
410 }
411 while (!cnc->priv->soup.session) {
412 g_cond_wait (&cnc->priv->soup.cond, &cnc->priv->soup.mutex);
413 }
414 g_mutex_unlock (&cnc->priv->soup.mutex);
415
416 pd.request = request;
417 pd.response = NULL;
418 pd.message = e_soap_request_persist (request, E_SOUP_SESSION (cnc->priv->soup.session), settings, error);
419
420 g_clear_object (&settings);
421
422 if (!pd.message)
423 return NULL;
424
425 e_ews_connection_maybe_prepare_message_for_testing_sources (cnc, pd.message);
426
427 g_mutex_lock (&cnc->priv->property_lock);
428 if (cnc->priv->credentials_changed) {
429 cnc->priv->credentials_changed = FALSE;
430
431 e_soup_session_set_credentials (E_SOUP_SESSION (cnc->priv->soup.session), cnc->priv->credentials);
432 }
433 g_mutex_unlock (&cnc->priv->property_lock);
434
435 pd.prepare_data = e_soup_session_prepare_message_send_sync (E_SOUP_SESSION (cnc->priv->soup.session), pd.message, cancellable, error);
436
437 if (!pd.prepare_data) {
438 if (error && (g_error_matches (*error, E_SOUP_SESSION_ERROR, SOUP_STATUS_UNAUTHORIZED) ||
439 /* Returned by the OAuth2 service when the token cannot be refreshed */
440 g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED))) {
441 (*error)->domain = EWS_CONNECTION_ERROR;
442 (*error)->code = EWS_CONNECTION_ERROR_AUTHENTICATION_FAILED;
443 }
444
445 g_clear_object (&pd.message);
446 return NULL;
447 }
448
449 g_mutex_init (&pd.mutex);
450 g_cond_init (&pd.cond);
451 pd.done = FALSE;
452 pd.repeat = FALSE;
453 pd.cnc = cnc;
454 pd.cancellable = cancellable;
455 pd.error = NULL;
456 pd.out_certificate_pem = out_certificate_pem;
457 pd.out_certificate_errors = out_certificate_errors;
458
459 g_mutex_lock (&pd.mutex);
460
461 source = g_idle_source_new ();
462 g_source_set_priority (source, G_PRIORITY_DEFAULT);
463 g_source_set_callback (source, e_ews_connection_process_request_run_cb, &pd, NULL);
464 g_source_attach (source, cnc->priv->soup.main_context);
465 g_source_unref (source);
466
467 while (!pd.done) {
468 g_cond_wait (&pd.cond, &pd.mutex);
469 }
470
471 g_mutex_unlock (&pd.mutex);
472
473 persistent_auth = soup_message_headers_get_one (soup_message_get_response_headers (pd.message), "Persistent-Auth");
474 if (persistent_auth && g_ascii_strcasecmp (persistent_auth, "false") == 0) {
475 SoupSessionFeature *feature;
476
477 feature = soup_session_get_feature (cnc->priv->soup.session, SOUP_TYPE_AUTH_MANAGER);
478 if (feature) {
479 soup_auth_manager_clear_cached_credentials (SOUP_AUTH_MANAGER (feature));
480 }
481 }
482
483 *out_message = g_steal_pointer (&pd.message);
484 *out_repeat = pd.repeat;
485
486 g_clear_object (&pd.message);
487 g_mutex_clear (&pd.mutex);
488 g_cond_clear (&pd.cond);
489
490 if (pd.error)
491 g_propagate_error (error, pd.error);
492
493 return pd.response;
494 }
495
496 static void
497 e_ews_connection_wait_ms (gint wait_ms,
498 GCancellable *cancellable)
499 {
500 if (wait_ms > 0) {
501 EFlag *flag;
502
503 flag = e_flag_new ();
504
505 while (wait_ms > 0 && !g_cancellable_is_cancelled (cancellable)) {
506 gint64 now = g_get_monotonic_time ();
507 gint left_minutes, left_seconds;
508
509 left_minutes = wait_ms / 60000;
510 left_seconds = (wait_ms / 1000) % 60;
511
512 if (left_minutes > 0) {
513 camel_operation_push_message (cancellable,
514 g_dngettext (GETTEXT_PACKAGE,
515 "Exchange server is busy, waiting to retry (%d:%02d minute)",
516 "Exchange server is busy, waiting to retry (%d:%02d minutes)", left_minutes),
517 left_minutes, left_seconds);
518 } else {
519 camel_operation_push_message (cancellable,
520 g_dngettext (GETTEXT_PACKAGE,
521 "Exchange server is busy, waiting to retry (%d second)",
522 "Exchange server is busy, waiting to retry (%d seconds)", left_seconds),
523 left_seconds);
524 }
525
526 e_flag_wait_until (flag, now + (G_TIME_SPAN_MILLISECOND * (wait_ms > 1000 ? 1000 : wait_ms)));
527
528 now = g_get_monotonic_time () - now;
529 now = now / G_TIME_SPAN_MILLISECOND;
530
531 if (now >= wait_ms)
532 wait_ms = 0;
533 wait_ms -= now;
534
535 camel_operation_pop_message (cancellable);
536 }
537
538 e_flag_free (flag);
539 }
540 }
541
542 static gboolean
543 e_ews_connection_handle_backoff_policy (EEwsConnection *cnc,
544 ESoapResponse *response,
545 GCancellable *cancellable,
546 GError **error)
547 {
548 ESoapParameter *param;
549 gint wait_ms = 0;
550 gboolean repeat = FALSE;
551
552 if (e_ews_connection_get_backoff_enabled (cnc))
553 param = e_soap_response_get_first_parameter_by_name (response, "detail", NULL);
554 else
555 param = NULL;
556 if (param)
557 param = e_soap_parameter_get_first_child_by_name (param, "ResponseCode");
558 if (param) {
559 gchar *value;
560
561 value = e_soap_parameter_get_string_value (param);
562 if (value && ews_get_error_code (value) == EWS_CONNECTION_ERROR_SERVERBUSY) {
563 param = e_soap_response_get_first_parameter_by_name (response, "detail", NULL);
564 if (param)
565 param = e_soap_parameter_get_first_child_by_name (param, "MessageXml");
566 if (param) {
567 param = e_soap_parameter_get_first_child_by_name (param, "Value");
568 if (param) {
569 g_free (value);
570
571 value = e_soap_parameter_get_property (param, "Name");
572 if (g_strcmp0 (value, "BackOffMilliseconds") == 0) {
573 wait_ms = e_soap_parameter_get_int_value (param);
574 }
575 }
576 }
577 }
578
579 g_free (value);
580 }
581
582 if (wait_ms > 0) {
583 e_ews_connection_wait_ms (wait_ms, cancellable);
584
585 repeat = !g_cancellable_set_error_if_cancelled (cancellable, error);
586 }
587
588 return repeat;
589 }
590
591 static ESoapResponse *
592 e_ews_connection_send_request_sync (EEwsConnection *cnc,
593 ESoapRequest *request,
594 GCancellable *cancellable,
595 GError **error)
596 {
597 ESoapResponse *response = NULL;
598 SoupMessage *message = NULL;
599 gchar *certificate_pem = NULL;
600 GTlsCertificateFlags certificate_errors = 0;
601 gboolean retrying_after_io_error = FALSE;
602 gboolean repeat = TRUE;
603 GError *local_error = NULL;
604
605 while (repeat) {
606 GError *local_error2 = NULL;
607
608 repeat = FALSE;
609
610 g_clear_error (&local_error);
611
612 response = e_ews_connection_process_request_sync (cnc, request, &message, &certificate_pem, &certificate_errors, &repeat, cancellable, &local_error);
613
614 g_mutex_lock (&cnc->priv->property_lock);
615 g_clear_pointer (&cnc->priv->ssl_certificate_pem, g_free);
616 cnc->priv->ssl_info_set = certificate_pem != NULL;
617 cnc->priv->ssl_certificate_pem = g_strdup (certificate_pem);
618 cnc->priv->ssl_certificate_errors = certificate_errors;
619 g_mutex_unlock (&cnc->priv->property_lock);
620
621 e_soap_request_take_tls_error_details (request, certificate_pem, certificate_errors);
622
623 if (message && !ews_connection_credentials_failed (cnc, message, TRUE, &local_error2)) {
624 if (soup_message_get_status (message) == SOUP_STATUS_UNAUTHORIZED) {
625 /* This can happen when the server terminated the connection before the request started */
626 if (!retrying_after_io_error &&
627 soup_message_get_request_headers (message) &&
628 !soup_message_headers_get_one (soup_message_get_request_headers (message), "Authorization")) {
629 g_clear_error (&local_error2);
630
631 e_ews_connection_wait_ms (EWS_RETRY_AUTH_ERROR_SECONDS * 1000, cancellable);
632
633 retrying_after_io_error = TRUE;
634 repeat = !g_cancellable_set_error_if_cancelled (cancellable, &local_error2);
635 } else {
636 if (soup_message_get_response_headers (message)) {
637 const gchar *diagnostics;
638
639 diagnostics = soup_message_headers_get_list (soup_message_get_response_headers (message), "X-MS-DIAGNOSTICS");
640 if (diagnostics && strstr (diagnostics, "invalid_grant")) {
641 g_clear_error (&local_error2);
642 g_set_error_literal (&local_error2, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_ACCESSDENIED, diagnostics);
643 } else if (diagnostics && *diagnostics) {
644 g_clear_error (&local_error2);
645 g_set_error_literal (&local_error2, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_AUTHENTICATION_FAILED, diagnostics);
646 }
647 }
648
649 if (!local_error2)
650 g_set_error_literal (&local_error2, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_AUTHENTICATION_FAILED, _("Authentication failed"));
651 }
652 }
653 }
654
655 if (local_error2) {
656 g_clear_error (&local_error);
657 local_error = local_error2;
658 }
659
660 if (!local_error && response && !repeat) {
661 repeat = e_ews_connection_handle_backoff_policy (cnc, response, cancellable, &local_error);
662
663 if (repeat || local_error)
664 g_clear_object (&response);
665 }
666
667 if (!repeat && !retrying_after_io_error && local_error &&
668 g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT)) {
669 g_clear_object (&response);
670 g_clear_error (&local_error);
671
672 e_ews_connection_wait_ms (EWS_RETRY_IO_ERROR_SECONDS * 1000, cancellable);
673
674 retrying_after_io_error = TRUE;
675 repeat = !g_cancellable_set_error_if_cancelled (cancellable, &local_error);
676 }
677
678 if (repeat)
679 g_clear_object (&response);
680 g_clear_object (&message);
681 }
682
683 if (local_error)
684 g_propagate_error (error, local_error);
685
686 if (response && cnc->priv->version == E_EWS_EXCHANGE_UNKNOWN) {
687 ESoapParameter *param;
688
689 param = e_soap_response_get_first_parameter_by_name (response, "ServerVersionInfo", NULL);
690 if (param) {
691 gchar *version;
692
693 version = e_soap_parameter_get_property (param, "Version");
694
695 e_ews_connection_set_server_version_from_string (cnc, version);
696
697 g_free (version);
698 }
699 }
700
701 return response;
702 }
703
704 static guint
705 ews_connection_get_concurrent_connections (EEwsConnection *cnc)
706 {
707 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), 1);
708
709 return cnc->priv->concurrent_connections;
710 }
711
712 static void
713 ews_connection_set_concurrent_connections (EEwsConnection *cnc,
714 guint concurrent_connections)
715 {
716 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
717
718 concurrent_connections = CLAMP (
719 concurrent_connections,
720 MIN_CONCURRENT_CONNECTIONS,
721 MAX_CONCURRENT_CONNECTIONS);
722
723 if (cnc->priv->concurrent_connections == concurrent_connections)
724 return;
725
726 /* Will be updated in the priv->soup.session the next time it's created,
727 because "max-conns" is a construct-only property */
728 cnc->priv->concurrent_connections = concurrent_connections;
729
730 g_object_notify (G_OBJECT (cnc), "concurrent-connections");
731 }
732
733 GQuark
734 ews_connection_error_quark (void)
735 {
736 static GQuark quark = 0;
737
738 if (G_UNLIKELY (quark == 0)) {
739 const gchar *string = "ews-connection-error-quark";
740 quark = g_quark_from_static_string (string);
741 }
742
743 return quark;
744 }
745
746 EEwsNotificationEvent *
747 e_ews_notification_event_new (void)
748 {
749 return g_new0 (EEwsNotificationEvent, 1);
750 }
751
752 void
753 e_ews_notification_event_free (EEwsNotificationEvent *event)
754 {
755 if (event != NULL) {
756 g_free (event->folder_id);
757 g_free (event->old_folder_id);
758 g_free (event);
759 }
760 }
761
762 EEwsCalendarTo *
763 e_ews_calendar_to_new (void)
764 {
765 return g_new0 (EEwsCalendarTo, 1);
766 }
767
768 void
769 e_ews_calendar_to_free (EEwsCalendarTo *to) {
770 if (to != NULL) {
771 g_free (to->kind);
772 g_free (to->value);
773 g_free (to);
774 }
775 }
776
777 EEwsCalendarAbsoluteDateTransition *
778 e_ews_calendar_absolute_date_transition_new (void)
779 {
780 return g_new0 (EEwsCalendarAbsoluteDateTransition, 1);
781 }
782
783 void
784 e_ews_calendar_absolute_date_transition_free (EEwsCalendarAbsoluteDateTransition *adt)
785 {
786 if (adt != NULL) {
787 e_ews_calendar_to_free (adt->to);
788 g_free (adt->date_time);
789 g_free (adt);
790 }
791 }
792
793 EEwsCalendarRecurringDayTransition *
794 e_ews_calendar_recurring_day_transition_new (void)
795 {
796 return g_new0 (EEwsCalendarRecurringDayTransition, 1);
797 }
798
799 void
800 e_ews_calendar_recurring_day_transition_free (EEwsCalendarRecurringDayTransition *rdayt)
801 {
802 if (rdayt != NULL) {
803 e_ews_calendar_to_free (rdayt->to);
804 g_free (rdayt->time_offset);
805 g_free (rdayt->month);
806 g_free (rdayt->day_of_week);
807 g_free (rdayt->occurrence);
808 g_free (rdayt);
809 }
810 }
811
812 EEwsCalendarRecurringDateTransition *
813 e_ews_calendar_recurring_date_transition_new (void)
814 {
815 return g_new0 (EEwsCalendarRecurringDateTransition, 1);
816 }
817
818 void
819 e_ews_calendar_recurring_date_transition_free (EEwsCalendarRecurringDateTransition *rdatet)
820 {
821 if (rdatet != NULL) {
822 e_ews_calendar_to_free (rdatet->to);
823 g_free (rdatet->time_offset);
824 g_free (rdatet->month);
825 g_free (rdatet->day);
826 g_free (rdatet);
827 }
828 }
829
830 EEwsCalendarPeriod *
831 e_ews_calendar_period_new (void)
832 {
833 return g_new0 (EEwsCalendarPeriod, 1);
834 }
835
836 void
837 e_ews_calendar_period_free (EEwsCalendarPeriod *period)
838 {
839 if (period != NULL) {
840 g_free (period->bias);
841 g_free (period->name);
842 g_free (period->id);
843 g_free (period);
844 }
845 }
846
847 EEwsCalendarTransitionsGroup *
848 e_ews_calendar_transitions_group_new (void)
849 {
850 return g_new0 (EEwsCalendarTransitionsGroup, 1);
851 }
852
853 void
854 e_ews_calendar_transitions_group_free (EEwsCalendarTransitionsGroup *tg)
855 {
856 if (tg != NULL) {
857 g_free (tg->id);
858 e_ews_calendar_to_free (tg->transition);
859 g_slist_free_full (
860 tg->absolute_date_transitions,
861 (GDestroyNotify) e_ews_calendar_absolute_date_transition_free);
862 g_slist_free_full (
863 tg->recurring_day_transitions,
864 (GDestroyNotify) e_ews_calendar_recurring_day_transition_free);
865 g_slist_free_full (
866 tg->recurring_date_transitions,
867 (GDestroyNotify) e_ews_calendar_recurring_date_transition_free);
868 g_free (tg);
869 }
870 }
871
872 EEwsCalendarTransitions *
873 e_ews_calendar_transitions_new (void)
874 {
875 return g_new0 (EEwsCalendarTransitions, 1);
876 }
877
878 void
879 e_ews_calendar_transitions_free (EEwsCalendarTransitions *transitions)
880 {
881 if (transitions != NULL) {
882 e_ews_calendar_to_free (transitions->transition);
883 g_slist_free_full (
884 transitions->absolute_date_transitions,
885 (GDestroyNotify) e_ews_calendar_absolute_date_transition_free);
886 g_slist_free_full (
887 transitions->recurring_day_transitions,
888 (GDestroyNotify) e_ews_calendar_recurring_day_transition_free);
889 g_slist_free_full (
890 transitions->recurring_date_transitions,
891 (GDestroyNotify) e_ews_calendar_recurring_date_transition_free);
892 g_free (transitions);
893 }
894 }
895
896 EEwsCalendarTimeZoneDefinition *
897 e_ews_calendar_time_zone_definition_new (void)
898 {
899 return g_new0 (EEwsCalendarTimeZoneDefinition, 1);
900 }
901
902 void
903 e_ews_calendar_time_zone_definition_free (EEwsCalendarTimeZoneDefinition *tzd)
904 {
905 if (tzd != NULL) {
906 g_free (tzd->name);
907 g_free (tzd->id);
908 g_slist_free_full (tzd->periods, (GDestroyNotify) e_ews_calendar_period_free);
909 g_slist_free_full (tzd->transitions_groups, (GDestroyNotify) e_ews_calendar_transitions_group_free);
910 e_ews_calendar_transitions_free (tzd->transitions);
911 g_free (tzd);
912 }
913 }
914
915 EEwsExtendedFieldURI *
916 e_ews_extended_field_uri_new (void)
917 {
918 return g_new0 (EEwsExtendedFieldURI, 1);
919 }
920
921 void
922 e_ews_extended_field_uri_free (EEwsExtendedFieldURI *ex_field_uri)
923 {
924 if (ex_field_uri != NULL) {
925 g_free (ex_field_uri->distinguished_prop_set_id);
926 g_free (ex_field_uri->prop_set_id);
927 g_free (ex_field_uri->prop_tag);
928 g_free (ex_field_uri->prop_name);
929 g_free (ex_field_uri->prop_id);
930 g_free (ex_field_uri->prop_type);
931 g_free (ex_field_uri);
932 }
933 }
934
935 EEwsIndexedFieldURI *
936 e_ews_indexed_field_uri_new (const gchar *uri,
937 const gchar *index)
938 {
939 EEwsIndexedFieldURI *furi;
940
941 furi = g_new0 (EEwsIndexedFieldURI, 1);
942 furi->field_uri = g_strdup (uri);
943 furi->field_index = g_strdup (index);
944
945 return furi;
946 }
947
948 void
949 e_ews_indexed_field_uri_free (EEwsIndexedFieldURI *id_field_uri)
950 {
951 if (id_field_uri != NULL) {
952 g_free (id_field_uri->field_uri);
953 g_free (id_field_uri->field_index);
954 g_free (id_field_uri);
955 }
956 }
957
958 EEwsAdditionalProps *
959 e_ews_additional_props_new (void)
960 {
961 return g_new0 (EEwsAdditionalProps, 1);
962 }
963
964 void
965 e_ews_additional_props_free (EEwsAdditionalProps *add_props)
966 {
967 if (add_props != NULL) {
968 g_free (add_props->field_uri);
969 g_slist_free_full (add_props->extended_furis, (GDestroyNotify) e_ews_extended_field_uri_free);
970 g_slist_free_full (add_props->indexed_furis, (GDestroyNotify) e_ews_indexed_field_uri_free);
971 g_free (add_props);
972 }
973 }
974
975 static void
976 autodiscover_parse_protocol (xmlNode *node,
977 EwsUrls *urls)
978 {
979 for (node = node->children; node; node = node->next) {
980 if (node->type == XML_ELEMENT_NODE &&
981 !strcmp ((gchar *) node->name, "ASUrl")) {
982 if (urls->as_url != NULL)
983 xmlFree (urls->as_url);
984
985 urls->as_url = xmlNodeGetContent (node);
986 } else if (node->type == XML_ELEMENT_NODE &&
987 !strcmp ((gchar *) node->name, "OABUrl")) {
988 if (urls->oab_url != NULL)
989 xmlFree (urls->oab_url);
990
991 urls->oab_url = xmlNodeGetContent (node);
992 }
993
994 /* Once we find both, we can stop looking for the URLs */
995 if (urls->as_url && urls->oab_url)
996 return;
997 }
998 }
999
1000 static xmlChar *
1001 autodiscover_get_protocol_type (xmlNode *node)
1002 {
1003 for (node = node->children; node; node = node->next) {
1004 if (node->type == XML_ELEMENT_NODE &&
1005 !strcmp ((gchar *) node->name, "Type")) {
1006 return xmlNodeGetContent (node);
1007 }
1008 }
1009
1010 return NULL;
1011 }
1012
1013 static gchar *
1014 autodiscover_dup_element_value (xmlNode *node,
1015 const gchar *element_name)
1016 {
1017 for (node = node->children; node; node = node->next) {
1018 if (node->type == XML_ELEMENT_NODE &&
1019 !g_strcmp0 ((gchar *) node->name, element_name)) {
1020 xmlChar *str = xmlNodeGetContent (node);
1021 gchar *res;
1022
1023 res = g_strdup ((const gchar *) str);
1024 xmlFree (str);
1025 return res;
1026 }
1027 }
1028
1029 return NULL;
1030 }
1031
1032 static void
1033 ews_connection_set_settings (EEwsConnection *connection,
1034 CamelEwsSettings *settings)
1035 {
1036 g_return_if_fail (CAMEL_IS_EWS_SETTINGS (settings));
1037 g_return_if_fail (connection->priv->settings == NULL);
1038
1039 connection->priv->settings = g_object_ref (settings);
1040
1041 e_binding_bind_property (connection->priv->settings, "concurrent-connections",
1042 connection, "concurrent-connections",
1043 G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
1044 }
1045
1046 static void
1047 ews_connection_set_source (EEwsConnection *connection,
1048 ESource *source)
1049 {
1050 if (source)
1051 g_return_if_fail (E_IS_SOURCE (source));
1052 g_return_if_fail (connection->priv->source == NULL);
1053
1054 connection->priv->source = source ? g_object_ref (source) : NULL;
1055 }
1056
1057 static void
1058 ews_connection_set_property (GObject *object,
1059 guint property_id,
1060 const GValue *value,
1061 GParamSpec *pspec)
1062 {
1063 switch (property_id) {
1064 case PROP_PASSWORD:
1065 e_ews_connection_set_password (
1066 E_EWS_CONNECTION (object),
1067 g_value_get_string (value));
1068 return;
1069
1070 case PROP_PROXY_RESOLVER:
1071 e_ews_connection_set_proxy_resolver (
1072 E_EWS_CONNECTION (object),
1073 g_value_get_object (value));
1074 return;
1075
1076 case PROP_SETTINGS:
1077 ews_connection_set_settings (
1078 E_EWS_CONNECTION (object),
1079 g_value_get_object (value));
1080 return;
1081
1082 case PROP_SOURCE:
1083 ews_connection_set_source (
1084 E_EWS_CONNECTION (object),
1085 g_value_get_object (value));
1086 return;
1087
1088 case PROP_CONCURRENT_CONNECTIONS:
1089 ews_connection_set_concurrent_connections (
1090 E_EWS_CONNECTION (object),
1091 g_value_get_uint (value));
1092 return;
1093 }
1094
1095 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1096 }
1097
1098 static void
1099 ews_connection_get_property (GObject *object,
1100 guint property_id,
1101 GValue *value,
1102 GParamSpec *pspec)
1103 {
1104 switch (property_id) {
1105 case PROP_PASSWORD:
1106 g_value_take_string (
1107 value,
1108 e_ews_connection_dup_password (
1109 E_EWS_CONNECTION (object)));
1110 return;
1111
1112 case PROP_PROXY_RESOLVER:
1113 g_value_take_object (
1114 value,
1115 e_ews_connection_ref_proxy_resolver (
1116 E_EWS_CONNECTION (object)));
1117 return;
1118
1119 case PROP_SETTINGS:
1120 g_value_take_object (
1121 value,
1122 e_ews_connection_ref_settings (
1123 E_EWS_CONNECTION (object)));
1124 return;
1125
1126 case PROP_SOURCE:
1127 g_value_set_object (
1128 value,
1129 e_ews_connection_get_source (
1130 E_EWS_CONNECTION (object)));
1131 return;
1132
1133 case PROP_CONCURRENT_CONNECTIONS:
1134 g_value_set_uint (
1135 value,
1136 ews_connection_get_concurrent_connections (
1137 E_EWS_CONNECTION (object)));
1138 return;
1139 }
1140
1141 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1142 }
1143
1144 static void
1145 ews_connection_constructed (GObject *object)
1146 {
1147 EEwsConnection *cnc = E_EWS_CONNECTION (object);
1148
1149 /* Chain up to parent's method. */
1150 G_OBJECT_CLASS (e_ews_connection_parent_class)->constructed (object);
1151
1152 if (cnc->priv->source && cnc->priv->settings &&
1153 e_source_has_extension (cnc->priv->source, E_SOURCE_EXTENSION_AUTHENTICATION)) {
1154 ESourceAuthentication *auth_extension;
1155 gchar *auth_method_source;
1156 const gchar *auth_method_settings;
1157
1158 auth_extension = e_source_get_extension (cnc->priv->source, E_SOURCE_EXTENSION_AUTHENTICATION);
1159 auth_method_source = e_source_authentication_dup_method (auth_extension);
1160 auth_method_settings = camel_ews_settings_get_auth_mechanism_string (cnc->priv->settings);
1161
1162 /* Make sure the ESource and the CamelEwsSettings authentication methods correspond
1163 to each other, because the NTLM is a default for any unknown value, which should
1164 be propagated into the ESoupSession (through the ESource) as well. */
1165 if (!auth_method_source ||
1166 (g_ascii_strcasecmp (auth_method_source, "Microsoft365") != 0 &&
1167 auth_method_settings && g_ascii_strcasecmp (auth_method_source, auth_method_settings) != 0)) {
1168 e_source_authentication_set_method (auth_extension, auth_method_settings);
1169 }
1170
1171 g_free (auth_method_source);
1172 }
1173
1174 if (cnc->priv->source && cnc->priv->settings) {
1175 ESourceExtension *extension;
1176
1177 /* the ESoupSession can read timeout from the WebDAV Backend extension,
1178 thus make sure the options are in sync */
1179 extension = e_source_get_extension (cnc->priv->source, E_SOURCE_EXTENSION_WEBDAV_BACKEND);
1180 e_binding_bind_property (
1181 cnc->priv->settings, "timeout",
1182 extension, "timeout",
1183 G_BINDING_SYNC_CREATE);
1184 }
1185 }
1186
1187 static void
1188 ews_connection_dispose (GObject *object)
1189 {
1190 EEwsConnection *cnc = E_EWS_CONNECTION (object);
1191
1192 g_mutex_lock (&connecting);
1193
1194 /* remove the connection from the hash table */
1195 if (loaded_connections_permissions != NULL &&
1196 g_hash_table_lookup (loaded_connections_permissions, cnc->priv->hash_key) == (gpointer) object) {
1197 g_hash_table_remove (loaded_connections_permissions, cnc->priv->hash_key);
1198 if (g_hash_table_size (loaded_connections_permissions) == 0) {
1199 g_hash_table_destroy (loaded_connections_permissions);
1200 loaded_connections_permissions = NULL;
1201 }
1202 }
1203
1204 g_mutex_unlock (&connecting);
1205
1206 NOTIFICATION_LOCK (cnc);
1207 if (cnc->priv->notification_delay_id) {
1208 g_source_remove (cnc->priv->notification_delay_id);
1209 cnc->priv->notification_delay_id = 0;
1210 }
1211
1212 if (cnc->priv->notification) {
1213 e_ews_notification_stop_listening_sync (cnc->priv->notification);
1214 g_clear_object (&cnc->priv->notification);
1215 }
1216 NOTIFICATION_UNLOCK (cnc);
1217
1218 g_mutex_lock (&cnc->priv->soup.mutex);
1219
1220 if (cnc->priv->soup.main_loop) {
1221 g_main_loop_quit (cnc->priv->soup.main_loop);
1222
1223 if (cnc->priv->soup.thread) {
1224 g_thread_join (cnc->priv->soup.thread);
1225 cnc->priv->soup.thread = NULL;
1226 }
1227
1228 g_main_loop_unref (cnc->priv->soup.main_loop);
1229 g_main_context_unref (cnc->priv->soup.main_context);
1230
1231 cnc->priv->soup.main_loop = NULL;
1232 cnc->priv->soup.main_context = NULL;
1233
1234 /* The soup thread creates and frees the session */
1235 g_warn_if_fail (cnc->priv->soup.session == NULL);
1236 }
1237
1238 g_mutex_unlock (&cnc->priv->soup.mutex);
1239
1240 g_clear_object (&cnc->priv->proxy_resolver);
1241 g_clear_object (&cnc->priv->source);
1242 g_clear_object (&cnc->priv->settings);
1243
1244 e_ews_connection_set_password (cnc, NULL);
1245
1246 QUEUE_LOCK (cnc);
1247 g_slist_free (cnc->priv->jobs);
1248 cnc->priv->jobs = NULL;
1249
1250 g_slist_free (cnc->priv->active_job_queue);
1251 cnc->priv->active_job_queue = NULL;
1252 QUEUE_UNLOCK (cnc);
1253
1254 g_slist_free_full (cnc->priv->subscribed_folders, g_free);
1255 cnc->priv->subscribed_folders = NULL;
1256
1257 if (cnc->priv->subscriptions != NULL) {
1258 g_hash_table_destroy (cnc->priv->subscriptions);
1259 cnc->priv->subscriptions = NULL;
1260 }
1261
1262 /* Chain up to parent's dispose() method. */
1263 G_OBJECT_CLASS (e_ews_connection_parent_class)->dispose (object);
1264 }
1265
1266 static void
1267 ews_connection_finalize (GObject *object)
1268 {
1269 EEwsConnection *cnc = E_EWS_CONNECTION (object);
1270
1271 e_named_parameters_free (cnc->priv->credentials);
1272 g_free (cnc->priv->uri);
1273 g_free (cnc->priv->email);
1274 g_free (cnc->priv->hash_key);
1275 g_free (cnc->priv->impersonate_user);
1276 g_free (cnc->priv->ssl_certificate_pem);
1277 g_free (cnc->priv->last_subscription_id);
1278
1279 g_mutex_clear (&cnc->priv->property_lock);
1280 g_mutex_clear (&cnc->priv->try_credentials_lock);
1281 g_rec_mutex_clear (&cnc->priv->queue_lock);
1282 g_mutex_clear (&cnc->priv->notification_lock);
1283
1284 g_mutex_clear (&cnc->priv->soup.mutex);
1285 g_cond_clear (&cnc->priv->soup.cond);
1286
1287 /* Chain up to parent's finalize() method. */
1288 G_OBJECT_CLASS (e_ews_connection_parent_class)->finalize (object);
1289 }
1290
1291 static void
1292 e_ews_connection_class_init (EEwsConnectionClass *class)
1293 {
1294 GObjectClass *object_class;
1295
1296 object_class = G_OBJECT_CLASS (class);
1297 object_class->set_property = ews_connection_set_property;
1298 object_class->get_property = ews_connection_get_property;
1299 object_class->constructed = ews_connection_constructed;
1300 object_class->dispose = ews_connection_dispose;
1301 object_class->finalize = ews_connection_finalize;
1302
1303 g_object_class_install_property (
1304 object_class,
1305 PROP_PASSWORD,
1306 g_param_spec_string (
1307 "password",
1308 "Password",
1309 "Authentication password",
1310 NULL,
1311 G_PARAM_READWRITE |
1312 G_PARAM_STATIC_STRINGS));
1313
1314 g_object_class_install_property (
1315 object_class,
1316 PROP_PROXY_RESOLVER,
1317 g_param_spec_object (
1318 "proxy-resolver",
1319 "Proxy Resolver",
1320 "The proxy resolver for this backend",
1321 G_TYPE_PROXY_RESOLVER,
1322 G_PARAM_READWRITE |
1323 G_PARAM_STATIC_STRINGS));
1324
1325 g_object_class_install_property (
1326 object_class,
1327 PROP_SETTINGS,
1328 g_param_spec_object (
1329 "settings",
1330 "Settings",
1331 "Connection settings",
1332 CAMEL_TYPE_EWS_SETTINGS,
1333 G_PARAM_READWRITE |
1334 G_PARAM_CONSTRUCT_ONLY |
1335 G_PARAM_STATIC_STRINGS));
1336
1337 g_object_class_install_property (
1338 object_class,
1339 PROP_SOURCE,
1340 g_param_spec_object (
1341 "source",
1342 "Source",
1343 "Corresponding ESource",
1344 E_TYPE_SOURCE,
1345 G_PARAM_READWRITE |
1346 G_PARAM_CONSTRUCT_ONLY |
1347 G_PARAM_STATIC_STRINGS));
1348
1349 g_object_class_install_property (
1350 object_class,
1351 PROP_CONCURRENT_CONNECTIONS,
1352 g_param_spec_uint (
1353 "concurrent-connections",
1354 "Concurrent Connections",
1355 "Number of concurrent connections to use",
1356 MIN_CONCURRENT_CONNECTIONS,
1357 MAX_CONCURRENT_CONNECTIONS,
1358 1,
1359 /* Do not construct it, otherwise it overrides the value derived from CamelEwsSettings */
1360 G_PARAM_READWRITE |
1361 G_PARAM_EXPLICIT_NOTIFY |
1362 G_PARAM_STATIC_STRINGS));
1363
1364 signals[SERVER_NOTIFICATION] = g_signal_new (
1365 "server-notification",
1366 G_OBJECT_CLASS_TYPE (object_class),
1367 G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED | G_SIGNAL_ACTION,
1368 0, NULL, NULL,
1369 g_cclosure_marshal_VOID__POINTER,
1370 G_TYPE_NONE, 1,
1371 G_TYPE_POINTER);
1372
1373 signals[PASSWORD_WILL_EXPIRE] = g_signal_new (
1374 "password-will-expire",
1375 G_OBJECT_CLASS_TYPE (object_class),
1376 G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED | G_SIGNAL_ACTION,
1377 G_STRUCT_OFFSET (EEwsConnectionClass, password_will_expire),
1378 NULL, NULL, NULL,
1379 G_TYPE_NONE, 2,
1380 G_TYPE_INT,
1381 G_TYPE_STRING);
1382
1383 signals[SUBSCRIPTION_ID_CHANGED] = g_signal_new (
1384 "subscription-id-changed",
1385 G_OBJECT_CLASS_TYPE (object_class),
1386 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
1387 0, NULL, NULL,
1388 g_cclosure_marshal_VOID__STRING,
1389 G_TYPE_NONE, 1,
1390 G_TYPE_STRING);
1391
1392 if (e_ews_debug_get_log_level () >= 4) {
1393 g_log_set_handler (
1394 G_LOG_DOMAIN,
1395 G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
1396 G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO,
1397 e_ews_debug_handler, NULL);
1398 }
1399 }
1400
1401 static void
1402 e_ews_connection_folders_list_free (gpointer data)
1403 {
1404 g_slist_free_full ((GSList *) data, g_free);
1405 }
1406
1407 static void
1408 e_ews_connection_init (EEwsConnection *cnc)
1409 {
1410 cnc->priv = e_ews_connection_get_instance_private (cnc);
1411
1412 g_mutex_init (&cnc->priv->soup.mutex);
1413 g_cond_init (&cnc->priv->soup.cond);
1414 cnc->priv->soup.main_context = g_main_context_new ();
1415 cnc->priv->soup.main_loop = g_main_loop_new (cnc->priv->soup.main_context, FALSE);
1416
1417 cnc->priv->backoff_enabled = TRUE;
1418 cnc->priv->disconnected_flag = FALSE;
1419 cnc->priv->concurrent_connections = 1;
1420 cnc->priv->version = E_EWS_EXCHANGE_UNKNOWN;
1421
1422 cnc->priv->subscriptions = g_hash_table_new_full (
1423 g_direct_hash, g_direct_equal,
1424 NULL, e_ews_connection_folders_list_free);
1425
1426 g_mutex_init (&cnc->priv->property_lock);
1427 g_mutex_init (&cnc->priv->try_credentials_lock);
1428 g_rec_mutex_init (&cnc->priv->queue_lock);
1429 g_mutex_init (&cnc->priv->notification_lock);
1430 }
1431
1432 void
1433 ews_oal_free (EwsOAL *oal)
1434 {
1435 if (oal != NULL) {
1436 g_free (oal->id);
1437 g_free (oal->dn);
1438 g_free (oal->name);
1439 g_free (oal);
1440 }
1441 }
1442
1443 void
1444 ews_oal_details_free (EwsOALDetails *details)
1445 {
1446 if (details != NULL) {
1447 g_free (details->type);
1448 g_free (details->sha);
1449 g_free (details->filename);
1450 g_free (details);
1451 }
1452 }
1453
1454 void
1455 ews_user_id_free (EwsUserId *id)
1456 {
1457 if (id) {
1458 g_free (id->sid);
1459 g_free (id->primary_smtp);
1460 g_free (id->display_name);
1461 g_free (id->distinguished_user);
1462 g_free (id->external_user);
1463 g_free (id);
1464 }
1465 }
1466
1467 void
1468 ews_delegate_info_free (EwsDelegateInfo *info)
1469 {
1470 if (!info)
1471 return;
1472
1473 ews_user_id_free (info->user_id);
1474 g_free (info);
1475 }
1476
1477 EEwsAttachmentInfo *
1478 e_ews_attachment_info_new (EEwsAttachmentInfoType type)
1479 {
1480 EEwsAttachmentInfo *info;
1481 info = g_new0 (EEwsAttachmentInfo, 1);
1482
1483 info->type = type;
1484 return info;
1485 }
1486
1487 void
1488 e_ews_attachment_info_free (EEwsAttachmentInfo *info)
1489 {
1490 if (!info)
1491 return;
1492
1493 switch (info->type) {
1494 case E_EWS_ATTACHMENT_INFO_TYPE_INLINED:
1495 g_free (info->data.inlined.filename);
1496 g_free (info->data.inlined.mime_type);
1497 g_free (info->data.inlined.data);
1498 break;
1499 case E_EWS_ATTACHMENT_INFO_TYPE_URI:
1500 g_free (info->data.uri);
1501 break;
1502 default:
1503 g_warning ("Unknown EEwsAttachmentInfoType %d", info->type);
1504 break;
1505 }
1506
1507 g_free (info->prefer_filename);
1508 g_free (info->id);
1509 g_free (info);
1510 }
1511
1512 EEwsAttachmentInfoType
1513 e_ews_attachment_info_get_type (EEwsAttachmentInfo *info)
1514 {
1515 return info->type;
1516 }
1517
1518 const gchar *
1519 e_ews_attachment_info_get_prefer_filename (EEwsAttachmentInfo *info)
1520 {
1521 g_return_val_if_fail (info != NULL, NULL);
1522
1523 return info->prefer_filename;
1524 }
1525
1526 void
1527 e_ews_attachment_info_set_prefer_filename (EEwsAttachmentInfo *info,
1528 const gchar *prefer_filename)
1529 {
1530 g_return_if_fail (info != NULL);
1531
1532 if (info->prefer_filename == prefer_filename)
1533 return;
1534
1535 g_free (info->prefer_filename);
1536 info->prefer_filename = g_strdup (prefer_filename);
1537 }
1538
1539 const gchar *
1540 e_ews_attachment_info_get_inlined_data (EEwsAttachmentInfo *info,
1541 gsize *len)
1542 {
1543 g_return_val_if_fail (info != NULL, NULL);
1544 g_return_val_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED, NULL);
1545
1546 *len = info->data.inlined.length;
1547 return info->data.inlined.data;
1548 }
1549
1550 void
1551 e_ews_attachment_info_set_inlined_data (EEwsAttachmentInfo *info,
1552 const guchar *data,
1553 gsize len)
1554 {
1555 g_return_if_fail (info != NULL);
1556 g_return_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED);
1557
1558 info->data.inlined.data = g_malloc (len);
1559 memcpy (info->data.inlined.data, data, len);
1560 info->data.inlined.length = len;
1561 }
1562
1563 const gchar *
1564 e_ews_attachment_info_get_mime_type (EEwsAttachmentInfo *info)
1565 {
1566 g_return_val_if_fail (info != NULL, NULL);
1567 g_return_val_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED, NULL);
1568
1569 return info->data.inlined.mime_type;
1570 }
1571
1572 void
1573 e_ews_attachment_info_set_mime_type (EEwsAttachmentInfo *info,
1574 const gchar *mime_type)
1575 {
1576 g_return_if_fail (info != NULL);
1577 g_return_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED);
1578
1579 g_free (info->data.inlined.mime_type);
1580 info->data.inlined.mime_type = g_strdup (mime_type);
1581 }
1582
1583 const gchar *
1584 e_ews_attachment_info_get_filename (EEwsAttachmentInfo *info)
1585 {
1586 g_return_val_if_fail (info != NULL, NULL);
1587 g_return_val_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED, NULL);
1588
1589 return info->data.inlined.filename;
1590 }
1591
1592 void
1593 e_ews_attachment_info_set_filename (EEwsAttachmentInfo *info,
1594 const gchar *filename)
1595 {
1596 g_return_if_fail (info != NULL);
1597 g_return_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_INLINED);
1598
1599 g_free (info->data.inlined.filename);
1600 info->data.inlined.filename = g_strdup (filename);
1601 }
1602
1603 const gchar *
1604 e_ews_attachment_info_get_uri (EEwsAttachmentInfo *info)
1605 {
1606 g_return_val_if_fail (info != NULL, NULL);
1607 g_return_val_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_URI, NULL);
1608
1609 return info->data.uri;
1610 }
1611
1612 void
1613 e_ews_attachment_info_set_uri (EEwsAttachmentInfo *info,
1614 const gchar *uri)
1615 {
1616 g_return_if_fail (info != NULL);
1617 g_return_if_fail (info->type == E_EWS_ATTACHMENT_INFO_TYPE_URI);
1618
1619 g_free (info->data.uri);
1620 info->data.uri = g_strdup (uri);
1621 }
1622
1623 const gchar *
1624 e_ews_attachment_info_get_id (EEwsAttachmentInfo *info)
1625 {
1626 g_return_val_if_fail (info != NULL, NULL);
1627
1628 return info->id;
1629 }
1630
1631 void
1632 e_ews_attachment_info_set_id (EEwsAttachmentInfo *info,
1633 const gchar *id)
1634 {
1635 g_return_if_fail (info != NULL);
1636
1637 if (info->id != id) {
1638 g_free (info->id);
1639 info->id = g_strdup (id);
1640 }
1641 }
1642
1643 /* Connection APIS */
1644
1645 static gchar *
1646 e_ews_connection_construct_hash_key (const gchar *uri,
1647 CamelEwsSettings *ews_settings)
1648 {
1649 gchar *impersonate_user = NULL, *user, *hash_key;
1650
1651 user = camel_network_settings_dup_user (CAMEL_NETWORK_SETTINGS (ews_settings));
1652
1653 if (camel_ews_settings_get_use_impersonation (ews_settings))
1654 impersonate_user = camel_ews_settings_dup_impersonate_user (ews_settings);
1655
1656 if (impersonate_user && *impersonate_user)
1657 hash_key = g_strdup_printf ("%s#%s@%s", impersonate_user, user, uri);
1658 else
1659 hash_key = g_strdup_printf ("%s@%s", user, uri);
1660
1661 g_free (impersonate_user);
1662 g_free (user);
1663
1664 return hash_key;
1665 }
1666
1667 /**
1668 * e_ews_connection_find
1669 * @uri: Exchange server uri
1670 * @ews_settings: a #CamelEwsSettings
1671 *
1672 * Find an existing connection for this user/uri, if it exists.
1673 *
1674 * Returns: EEwsConnection
1675 **/
1676 EEwsConnection *
1677 e_ews_connection_find (const gchar *uri,
1678 CamelEwsSettings *ews_settings)
1679 {
1680 EEwsConnection *cnc;
1681 gchar *hash_key;
1682
1683 g_mutex_lock (&connecting);
1684
1685 /* search the connection in our hash table */
1686 if (loaded_connections_permissions != NULL) {
1687 hash_key = e_ews_connection_construct_hash_key (uri, ews_settings);
1688 cnc = g_hash_table_lookup (loaded_connections_permissions, hash_key);
1689 g_free (hash_key);
1690
1691 if (E_IS_EWS_CONNECTION (cnc) &&
1692 !e_ews_connection_get_disconnected_flag (cnc)) {
1693 g_object_ref (cnc);
1694 g_mutex_unlock (&connecting);
1695 return cnc;
1696 }
1697 }
1698
1699 g_mutex_unlock (&connecting);
1700
1701 return NULL;
1702 }
1703
1704 /**
1705 * e_ews_connection_list_existing:
1706 *
1707 * Returns: (transfer full) (element-type EEwsConnection): a new #GSList of all currently
1708 * opened connections to all servers. Free the returned #GSList with
1709 * g_slist_free_full (connections, g_object_unref);
1710 * when no longer needed.
1711 **/
1712 GSList * /* EEwsConnection * */
1713 e_ews_connection_list_existing (void)
1714 {
1715 GSList *connections = NULL;
1716
1717 g_mutex_lock (&connecting);
1718
1719 /* search the connection in our hash table */
1720 if (loaded_connections_permissions != NULL) {
1721 GHashTableIter iter;
1722 gpointer value;
1723
1724 g_hash_table_iter_init (&iter, loaded_connections_permissions);
1725 while (g_hash_table_iter_next (&iter, NULL, &value)) {
1726 if (value && !e_ews_connection_get_disconnected_flag (value))
1727 connections = g_slist_prepend (connections, g_object_ref (value));
1728 }
1729 }
1730
1731 g_mutex_unlock (&connecting);
1732
1733 return connections;
1734 }
1735
1736 /**
1737 * e_ews_connection_new_full
1738 * @source: corresponding #ESource
1739 * @uri: Exchange server uri
1740 * @settings: a #CamelEwsSettings
1741 * @allow_connection_reuse: whether can return already created connection
1742 *
1743 * This does not authenticate to the server. It merely stores the username and password.
1744 * Authentication happens when a request is made to the server.
1745 *
1746 * Returns: EEwsConnection
1747 **/
1748 EEwsConnection *
1749 e_ews_connection_new_full (ESource *source,
1750 const gchar *uri,
1751 CamelEwsSettings *settings,
1752 gboolean allow_connection_reuse)
1753 {
1754 EEwsConnection *cnc;
1755 gchar *hash_key;
1756
1757 if (source)
1758 g_return_val_if_fail (E_IS_SOURCE (source), NULL);
1759 g_return_val_if_fail (uri != NULL, NULL);
1760 g_return_val_if_fail (CAMEL_IS_EWS_SETTINGS (settings), NULL);
1761
1762 hash_key = e_ews_connection_construct_hash_key (uri, settings);
1763
1764 g_mutex_lock (&connecting);
1765
1766 /* search the connection in our hash table */
1767 if (allow_connection_reuse && loaded_connections_permissions != NULL) {
1768 cnc = g_hash_table_lookup (
1769 loaded_connections_permissions, hash_key);
1770
1771 if (E_IS_EWS_CONNECTION (cnc) &&
1772 !e_ews_connection_get_disconnected_flag (cnc)) {
1773 g_object_ref (cnc);
1774
1775 g_free (hash_key);
1776
1777 g_mutex_unlock (&connecting);
1778 return cnc;
1779 }
1780 }
1781
1782 /* not found, so create a new connection */
1783 cnc = g_object_new (E_TYPE_EWS_CONNECTION,
1784 "settings", settings,
1785 "source", source,
1786 NULL);
1787
1788 cnc->priv->uri = g_strdup (uri);
1789 cnc->priv->hash_key = hash_key; /* takes ownership */
1790
1791 g_free (cnc->priv->impersonate_user);
1792 if (camel_ews_settings_get_use_impersonation (settings)) {
1793 cnc->priv->impersonate_user = camel_ews_settings_dup_impersonate_user (settings);
1794 if (cnc->priv->impersonate_user && !*cnc->priv->impersonate_user) {
1795 g_free (cnc->priv->impersonate_user);
1796 cnc->priv->impersonate_user = NULL;
1797 }
1798 } else {
1799 cnc->priv->impersonate_user = NULL;
1800 }
1801
1802 if (allow_connection_reuse) {
1803 /* add the connection to the loaded_connections_permissions hash table */
1804 if (loaded_connections_permissions == NULL)
1805 loaded_connections_permissions = g_hash_table_new_full (
1806 g_str_hash, g_str_equal,
1807 g_free, NULL);
1808 g_hash_table_insert (
1809 loaded_connections_permissions,
1810 g_strdup (cnc->priv->hash_key), cnc);
1811 }
1812
1813 /* free memory */
1814 g_mutex_unlock (&connecting);
1815 return cnc;
1816
1817 }
1818
1819 EEwsConnection *
1820 e_ews_connection_new (ESource *source,
1821 const gchar *uri,
1822 CamelEwsSettings *settings)
1823 {
1824 return e_ews_connection_new_full (source, uri, settings, TRUE);
1825 }
1826
1827 EEwsConnection *
1828 e_ews_connection_new_for_backend (EBackend *backend,
1829 ESourceRegistry *registry,
1830 const gchar *uri,
1831 CamelEwsSettings *settings)
1832 {
1833 ESource *source;
1834 EEwsConnection *cnc;
1835
1836 g_return_val_if_fail (E_IS_BACKEND (backend), NULL);
1837 g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
1838
1839 source = e_backend_get_source (backend);
1840 if (!source)
1841 return e_ews_connection_new (source, uri, settings);
1842
1843 g_object_ref (source);
1844
1845 while (source && !e_source_has_extension (source, E_SOURCE_EXTENSION_COLLECTION) &&
1846 e_source_get_parent (source)) {
1847 ESource *parent;
1848
1849 parent = e_source_registry_ref_source (registry, e_source_get_parent (source));
1850 if (!parent) {
1851 g_clear_object (&source);
1852 break;
1853 }
1854
1855 g_object_unref (source);
1856 source = parent;
1857 }
1858
1859 if (source)
1860 cnc = e_ews_connection_new (source, uri, settings);
1861 else
1862 cnc = e_ews_connection_new (e_backend_get_source (backend), uri, settings);
1863
1864 g_clear_object (&source);
1865
1866 return cnc;
1867 }
1868
1869 void
1870 e_ews_connection_set_testing_sources (EEwsConnection *cnc,
1871 gboolean testing_sources)
1872 {
1873 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
1874
1875 cnc->priv->testing_sources = testing_sources;
1876 }
1877
1878 gboolean
1879 e_ews_connection_get_testing_sources (EEwsConnection *cnc)
1880 {
1881 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
1882
1883 return cnc->priv->testing_sources;
1884 }
1885
1886 void
1887 e_ews_connection_update_credentials (EEwsConnection *cnc,
1888 const ENamedParameters *credentials)
1889 {
1890 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
1891
1892 if (credentials) {
1893 if (e_named_parameters_get (credentials, E_SOURCE_CREDENTIAL_USERNAME)) {
1894 CamelNetworkSettings *network_settings;
1895
1896 network_settings = CAMEL_NETWORK_SETTINGS (cnc->priv->settings);
1897 camel_network_settings_set_user (network_settings, e_named_parameters_get (credentials, E_SOURCE_CREDENTIAL_USERNAME));
1898 }
1899 } else {
1900 e_ews_connection_set_password (cnc, NULL);
1901 }
1902
1903 g_mutex_lock (&cnc->priv->property_lock);
1904 cnc->priv->credentials_changed = TRUE;
1905 e_named_parameters_free (cnc->priv->credentials);
1906 cnc->priv->credentials = credentials ? e_named_parameters_new_clone (credentials) : NULL;
1907 g_mutex_unlock (&cnc->priv->property_lock);
1908 }
1909
1910 ESourceAuthenticationResult
1911 e_ews_connection_try_credentials_sync (EEwsConnection *cnc,
1912 const ENamedParameters *credentials,
1913 ESource *use_source,
1914 gchar **out_certificate_pem,
1915 GTlsCertificateFlags *out_certificate_errors,
1916 GCancellable *cancellable,
1917 GError **error)
1918 {
1919 ESourceAuthenticationResult result;
1920 ESource *source;
1921 gboolean de_set_source;
1922 EwsFolderId *fid = NULL;
1923 GSList *ids = NULL;
1924 GError *local_error = NULL;
1925
1926 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), E_SOURCE_AUTHENTICATION_ERROR);
1927
1928 /* when sharing the connection between multiple sources (like in the book/calendar factory),
1929 make sure only one try_credentials() is running at a single time */
1930 g_mutex_lock (&cnc->priv->try_credentials_lock);
1931
1932 e_ews_connection_update_credentials (cnc, credentials);
1933
1934 fid = g_new0 (EwsFolderId, 1);
1935 fid->id = g_strdup ("inbox");
1936 fid->is_distinguished_id = TRUE;
1937 ids = g_slist_append (ids, fid);
1938
1939 source = e_ews_connection_get_source (cnc);
1940 if (use_source && use_source != source) {
1941 cnc->priv->source = g_object_ref (use_source);
1942 de_set_source = TRUE;
1943 } else {
1944 source = NULL;
1945 de_set_source = FALSE;
1946 }
1947
1948 e_ews_connection_get_folder_sync (
1949 cnc, EWS_PRIORITY_MEDIUM, "Default",
1950 NULL, ids, NULL, cancellable, &local_error);
1951
1952 if (de_set_source) {
1953 g_clear_object (&cnc->priv->source);
1954 cnc->priv->source = source;
1955 }
1956
1957 g_slist_free_full (ids, (GDestroyNotify) e_ews_folder_id_free);
1958
1959 if (local_error == NULL) {
1960 result = E_SOURCE_AUTHENTICATION_ACCEPTED;
1961 } else if (g_error_matches (local_error, G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE) &&
1962 e_ews_connection_get_ssl_error_details (cnc, out_certificate_pem, out_certificate_errors)) {
1963 result = E_SOURCE_AUTHENTICATION_ERROR_SSL_FAILED;
1964 } else {
1965 gboolean auth_failed;
1966
1967 auth_failed = g_error_matches (local_error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_AUTHENTICATION_FAILED);
1968 if (!auth_failed && g_error_matches (local_error, E_SOUP_SESSION_ERROR, SOUP_STATUS_FORBIDDEN) &&
1969 (!credentials || !e_named_parameters_exists (credentials, E_SOURCE_CREDENTIAL_PASSWORD)))
1970 auth_failed = TRUE;
1971
1972 if (auth_failed) {
1973 g_clear_error (&local_error);
1974
1975 if (camel_ews_settings_get_auth_mechanism (cnc->priv->settings) != EWS_AUTH_TYPE_GSSAPI &&
1976 camel_ews_settings_get_auth_mechanism (cnc->priv->settings) != EWS_AUTH_TYPE_OAUTH2 &&
1977 (!credentials || !e_named_parameters_exists (credentials, E_SOURCE_CREDENTIAL_PASSWORD))) {
1978 result = E_SOURCE_AUTHENTICATION_REQUIRED;
1979 } else {
1980 result = E_SOURCE_AUTHENTICATION_REJECTED;
1981 }
1982 } else {
1983 g_propagate_error (error, local_error);
1984 result = E_SOURCE_AUTHENTICATION_ERROR;
1985 }
1986
1987 e_ews_connection_set_password (cnc, NULL);
1988 }
1989
1990 g_mutex_unlock (&cnc->priv->try_credentials_lock);
1991
1992 return result;
1993 }
1994
1995 ESource *
1996 e_ews_connection_get_source (EEwsConnection *cnc)
1997 {
1998 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
1999
2000 return cnc->priv->source;
2001 }
2002
2003 gboolean
2004 e_ews_connection_get_ssl_error_details (EEwsConnection *cnc,
2005 gchar **out_certificate_pem,
2006 GTlsCertificateFlags *out_certificate_errors)
2007 {
2008 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
2009 g_return_val_if_fail (out_certificate_pem != NULL, FALSE);
2010 g_return_val_if_fail (out_certificate_errors != NULL, FALSE);
2011
2012 g_mutex_lock (&cnc->priv->property_lock);
2013 if (!cnc->priv->ssl_info_set) {
2014 g_mutex_unlock (&cnc->priv->property_lock);
2015 return FALSE;
2016 }
2017
2018 *out_certificate_pem = g_strdup (cnc->priv->ssl_certificate_pem);
2019 *out_certificate_errors = cnc->priv->ssl_certificate_errors;
2020
2021 g_mutex_unlock (&cnc->priv->property_lock);
2022
2023 return TRUE;
2024 }
2025
2026 const gchar *
2027 e_ews_connection_get_uri (EEwsConnection *cnc)
2028 {
2029 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2030
2031 return cnc->priv->uri;
2032 }
2033
2034 gchar *
2035 e_ews_connection_dup_password (EEwsConnection *cnc)
2036 {
2037 const gchar *password;
2038 gchar *duplicate;
2039
2040 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2041
2042 g_mutex_lock (&cnc->priv->property_lock);
2043
2044 password = cnc->priv->credentials ? e_named_parameters_get (cnc->priv->credentials, E_SOURCE_CREDENTIAL_PASSWORD) : NULL;
2045 duplicate = g_strdup (password && *password ? password : NULL);
2046
2047 g_mutex_unlock (&cnc->priv->property_lock);
2048
2049 return duplicate;
2050 }
2051
2052 void
2053 e_ews_connection_set_password (EEwsConnection *cnc,
2054 const gchar *password)
2055 {
2056 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
2057
2058 g_mutex_lock (&cnc->priv->property_lock);
2059
2060 if (cnc->priv->credentials) {
2061 cnc->priv->credentials_changed = TRUE;
2062
2063 if (password && *password)
2064 e_named_parameters_set (cnc->priv->credentials, E_SOURCE_CREDENTIAL_PASSWORD, password);
2065 else
2066 e_named_parameters_set (cnc->priv->credentials, E_SOURCE_CREDENTIAL_PASSWORD, NULL);
2067 } else if (password && *password) {
2068 cnc->priv->credentials_changed = TRUE;
2069 cnc->priv->credentials = e_named_parameters_new ();
2070 e_named_parameters_set (cnc->priv->credentials, E_SOURCE_CREDENTIAL_PASSWORD, password);
2071 }
2072
2073 g_mutex_unlock (&cnc->priv->property_lock);
2074
2075 g_object_notify (G_OBJECT (cnc), "password");
2076 }
2077
2078 const gchar *
2079 e_ews_connection_get_impersonate_user (EEwsConnection *cnc)
2080 {
2081 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2082
2083 return cnc->priv->impersonate_user;
2084 }
2085
2086 GProxyResolver *
2087 e_ews_connection_ref_proxy_resolver (EEwsConnection *cnc)
2088 {
2089 GProxyResolver *proxy_resolver = NULL;
2090
2091 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2092
2093 g_mutex_lock (&cnc->priv->property_lock);
2094
2095 if (cnc->priv->proxy_resolver != NULL)
2096 proxy_resolver = g_object_ref (cnc->priv->proxy_resolver);
2097
2098 g_mutex_unlock (&cnc->priv->property_lock);
2099
2100 return proxy_resolver;
2101 }
2102
2103 void
2104 e_ews_connection_set_proxy_resolver (EEwsConnection *cnc,
2105 GProxyResolver *proxy_resolver)
2106 {
2107 gboolean notify = FALSE;
2108
2109 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
2110
2111 g_mutex_lock (&cnc->priv->property_lock);
2112
2113 /* Emitting a "notify" signal unnecessarily might have
2114 * unwanted side effects like cancelling a SoupMessage.
2115 * Only emit if we now have a different GProxyResolver. */
2116
2117 if (proxy_resolver != cnc->priv->proxy_resolver) {
2118 g_clear_object (&cnc->priv->proxy_resolver);
2119 cnc->priv->proxy_resolver = proxy_resolver;
2120
2121 if (proxy_resolver != NULL)
2122 g_object_ref (proxy_resolver);
2123
2124 notify = TRUE;
2125 }
2126
2127 g_mutex_unlock (&cnc->priv->property_lock);
2128
2129 if (notify)
2130 g_object_notify (G_OBJECT (cnc), "proxy-resolver");
2131 }
2132
2133 CamelEwsSettings *
2134 e_ews_connection_ref_settings (EEwsConnection *cnc)
2135 {
2136 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2137
2138 return g_object_ref (cnc->priv->settings);
2139 }
2140
2141 gboolean
2142 e_ews_connection_get_backoff_enabled (EEwsConnection *cnc)
2143 {
2144 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
2145
2146 return cnc->priv->backoff_enabled;
2147 }
2148
2149 void
2150 e_ews_connection_set_backoff_enabled (EEwsConnection *cnc,
2151 gboolean enabled)
2152 {
2153 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
2154
2155 cnc->priv->backoff_enabled = enabled;
2156 }
2157
2158 gboolean
2159 e_ews_connection_get_disconnected_flag (EEwsConnection *cnc)
2160 {
2161 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
2162
2163 return cnc->priv->disconnected_flag;
2164 }
2165
2166 void
2167 e_ews_connection_set_disconnected_flag (EEwsConnection *cnc,
2168 gboolean disconnected_flag)
2169 {
2170 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
2171
2172 cnc->priv->disconnected_flag = disconnected_flag;
2173 }
2174
2175 gchar *
2176 e_ews_connection_dup_last_subscription_id (EEwsConnection *cnc)
2177 {
2178 gchar *res;
2179
2180 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
2181
2182 g_mutex_lock (&cnc->priv->property_lock);
2183
2184 res = g_strdup (cnc->priv->last_subscription_id);
2185
2186 g_mutex_unlock (&cnc->priv->property_lock);
2187
2188 return res;
2189 }
2190
2191 void
2192 e_ews_connection_set_last_subscription_id (EEwsConnection *cnc,
2193 const gchar *subscription_id)
2194 {
2195 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
2196
2197 g_mutex_lock (&cnc->priv->property_lock);
2198
2199 if (g_strcmp0 (subscription_id, cnc->priv->last_subscription_id) != 0) {
2200 g_free (cnc->priv->last_subscription_id);
2201 cnc->priv->last_subscription_id = g_strdup (subscription_id);
2202 }
2203
2204 g_mutex_unlock (&cnc->priv->property_lock);
2205 }
2206
2207 static gboolean
2208 e_ews_process_generic_response (EEwsConnection *cnc,
2209 ESoapResponse *response,
2210 GError **error)
2211 {
2212 ESoapParameter *param;
2213 ESoapParameter *subparam;
2214 GError *local_error = NULL;
2215
2216 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
2217
2218 /* Sanity check */
2219 g_return_val_if_fail (
2220 (param != NULL && local_error == NULL) ||
2221 (param == NULL && local_error != NULL), FALSE);
2222
2223 if (local_error) {
2224 g_propagate_error (error, local_error);
2225 return FALSE;
2226 }
2227
2228 subparam = e_soap_parameter_get_first_child (param);
2229
2230 while (subparam != NULL) {
2231 if (!ews_get_response_status (subparam, error))
2232 return FALSE;
2233
2234 subparam = e_soap_parameter_get_next_child (subparam);
2235 }
2236
2237 return TRUE;
2238 }
2239
2240 typedef gpointer (*ItemParser) (ESoapParameter *param);
2241
2242 static void
2243 e_ews_process_sync_xxx_response (ESoapParameter *subparam,
2244 ItemParser parser,
2245 const gchar *last_tag,
2246 const gchar *delete_id_tag,
2247 gchar **out_new_sync_state,
2248 gboolean *out_includes_last_item,
2249 GSList **out_items_created,
2250 GSList **out_items_updated,
2251 GSList **out_items_deleted)
2252 {
2253 ESoapParameter *node;
2254 gchar *new_sync_state = NULL, *value, *last;
2255 GSList *items_created = NULL, *items_updated = NULL, *items_deleted = NULL;
2256 gboolean includes_last_item;
2257
2258 node = e_soap_parameter_get_first_child_by_name (subparam, "SyncState");
2259 new_sync_state = e_soap_parameter_get_string_value (node);
2260
2261 node = e_soap_parameter_get_first_child_by_name (subparam, last_tag);
2262 last = e_soap_parameter_get_string_value (node);
2263 /*
2264 * Set the includes_last_item to TRUE as default.
2265 * It can avoid an infinite loop in caller, when, for some reason,
2266 * we don't receive the last_tag property from the server.
2267 */
2268 includes_last_item = g_strcmp0 (last, "false") != 0;
2269 g_free (last);
2270
2271 node = e_soap_parameter_get_first_child_by_name (subparam, "Changes");
2272
2273 if (node) {
2274 ESoapParameter *subparam1;
2275 for (subparam1 = e_soap_parameter_get_first_child_by_name (node, "Create");
2276 subparam1 != NULL;
2277 subparam1 = e_soap_parameter_get_next_child_by_name (subparam1, "Create")) {
2278 GObject *object;
2279
2280 object = parser (subparam1);
2281 if (object && (!E_IS_EWS_FOLDER (object) || !e_ews_folder_get_is_hidden (E_EWS_FOLDER (object))))
2282 items_created = g_slist_prepend (items_created, object);
2283 else
2284 g_clear_object (&object);
2285 }
2286
2287 for (subparam1 = e_soap_parameter_get_first_child_by_name (node, "Update");
2288 subparam1 != NULL;
2289 subparam1 = e_soap_parameter_get_next_child_by_name (subparam1, "Update")) {
2290 GObject *object;
2291
2292 object = parser (subparam1);
2293 if (object && (!E_IS_EWS_FOLDER (object) || !e_ews_folder_get_is_hidden (E_EWS_FOLDER (object))))
2294 items_updated = g_slist_prepend (items_updated, object);
2295 else
2296 g_clear_object (&object);
2297 }
2298 /* Exchange 2007SP1 introduced <ReadFlagChange> which is basically identical
2299 * to <Update>; no idea why they thought it was a good idea. */
2300 for (subparam1 = e_soap_parameter_get_first_child_by_name (node, "ReadFlagChange");
2301 subparam1 != NULL;
2302 subparam1 = e_soap_parameter_get_next_child_by_name (subparam1, "ReadFlagChange")) {
2303 GObject *object;
2304
2305 object = parser (subparam1);
2306 if (object && (!E_IS_EWS_FOLDER (object) || !e_ews_folder_get_is_hidden (E_EWS_FOLDER (object))))
2307 items_updated = g_slist_prepend (items_updated, object);
2308 else
2309 g_clear_object (&object);
2310 }
2311
2312 for (subparam1 = e_soap_parameter_get_first_child_by_name (node, "Delete");
2313 subparam1 != NULL;
2314 subparam1 = e_soap_parameter_get_next_child_by_name (subparam1, "Delete")) {
2315 ESoapParameter *folder_param;
2316
2317 folder_param = e_soap_parameter_get_first_child_by_name (subparam1, delete_id_tag);
2318 value = e_soap_parameter_get_property (folder_param, "Id");
2319 items_deleted = g_slist_prepend (items_deleted, value);
2320 }
2321 }
2322
2323 if (out_new_sync_state)
2324 *out_new_sync_state = new_sync_state;
2325 else
2326 g_free (new_sync_state);
2327
2328 if (out_includes_last_item)
2329 *out_includes_last_item = includes_last_item;
2330
2331 if (out_items_created)
2332 *out_items_created = g_slist_reverse (items_created);
2333 else
2334 g_slist_free_full (items_created, g_object_unref);
2335
2336 if (out_items_updated)
2337 *out_items_updated = g_slist_reverse (items_updated);
2338 else
2339 g_slist_free_full (items_updated, g_object_unref);
2340
2341 if (out_items_deleted)
2342 *out_items_deleted = g_slist_reverse (items_deleted);
2343 else
2344 g_slist_free_full (items_deleted, g_free);
2345 }
2346
2347 static xmlDoc *
2348 e_ews_autodiscover_ws_xml (const gchar *email_address)
2349 {
2350 xmlDoc *doc;
2351 xmlNode *node;
2352 xmlNs *ns;
2353
2354 doc = xmlNewDoc ((xmlChar *) "1.0");
2355 node = xmlNewDocNode (doc, NULL, (xmlChar *)"Autodiscover", NULL);
2356 xmlDocSetRootElement (doc, node);
2357 ns = xmlNewNs (
2358 node,
2359 (xmlChar *)"http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006", NULL);
2360
2361 node = xmlNewChild (node, ns, (xmlChar *)"Request", NULL);
2362 xmlNewChild (
2363 node, ns, (xmlChar *)"EMailAddress",
2364 (xmlChar *) email_address);
2365 xmlNewChild (
2366 node, ns, (xmlChar *)"AcceptableResponseSchema",
2367 (xmlChar *)"http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a");
2368
2369 return doc;
2370 }
2371
2372 typedef struct _AutodiscoverData {
2373 guint n_pending;
2374
2375 /* Borrowed */
2376 GMainLoop *main_loop;
2377 CamelEwsSettings *settings;
2378 ESoupSession *session;
2379 GCancellable *cancellable;
2380
2381 /* Allocated */
2382 xmlOutputBuffer *buf;
2383
2384 gchar *redirect_addr;
2385 gchar *redirect_url;
2386 gint n_redirects;
2387
2388 /* Results */
2389 gboolean success;
2390 gchar *certificate_pem;
2391 GTlsCertificateFlags certificate_errors;
2392 GError *error;
2393 gchar *as_url;
2394 gchar *oab_url;
2395 } AutodiscoverData;
2396
2397 static void
2398 autodiscover_data_clear (AutodiscoverData *ad)
2399 {
2400 g_clear_pointer (&ad->buf, xmlOutputBufferClose);
2401 g_clear_error (&ad->error);
2402
2403 g_free (ad->redirect_addr);
2404 g_free (ad->redirect_url);
2405 g_free (ad->certificate_pem);
2406 g_free (ad->as_url);
2407 g_free (ad->oab_url);
2408 }
2409
2410 /* Frees only the content, not the 'urls' structure itself */
2411 static void
2412 ews_urls_free_content (EwsUrls *urls)
2413 {
2414 if (!urls)
2415 return;
2416
2417 if (urls->as_url)
2418 xmlFree (urls->as_url);
2419 urls->as_url = NULL;
2420
2421 if (urls->oab_url)
2422 xmlFree (urls->oab_url);
2423 urls->oab_url = NULL;
2424 }
2425
2426 static gboolean
2427 e_ews_autodiscover_prepare_requests_and_send_sync (AutodiscoverData *ad,
2428 const gchar *email_address,
2429 const gchar *override_url,
2430 GCancellable *cancellable);
2431
2432 static void
2433 ews_process_autodiscover_response (AutodiscoverData *ad,
2434 GByteArray *bytes,
2435 GError **error)
2436
2437 {
2438 EwsUrls exch_urls, expr_urls;
2439 xmlDoc *doc;
2440 xmlNode *node;
2441 gchar *str;
2442
2443 g_return_if_fail (bytes != NULL);
2444
2445 memset (&exch_urls, 0, sizeof (EwsUrls));
2446 memset (&expr_urls, 0, sizeof (EwsUrls));
2447
2448 doc = xmlReadMemory ((const gchar *) bytes->data, bytes->len, "autodiscover.xml", NULL, 0);
2449
2450 if (!doc) {
2451 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1,
2452 _("Failed to parse autodiscover response XML"));
2453 return;
2454 }
2455 node = xmlDocGetRootElement (doc);
2456 if (strcmp ((gchar *) node->name, "Autodiscover")) {
2457 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1,
2458 _("Failed to find <Autodiscover> element"));
2459 goto failed;
2460 }
2461 for (node = node->children; node; node = node->next) {
2462 if (node->type == XML_ELEMENT_NODE &&
2463 !strcmp ((gchar *) node->name, "Response"))
2464 break;
2465 }
2466 if (!node) {
2467 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1,
2468 _("Failed to find <Response> element"));
2469 goto failed;
2470 }
2471 for (node = node->children; node; node = node->next) {
2472 if (node->type == XML_ELEMENT_NODE &&
2473 !strcmp ((gchar *) node->name, "Account"))
2474 break;
2475 }
2476 if (!node) {
2477 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1,
2478 _("Failed to find <Account> element"));
2479 goto failed;
2480 }
2481
2482 str = autodiscover_dup_element_value (node, "RedirectAddr");
2483 if (str) {
2484 g_free (ad->redirect_addr);
2485 ad->redirect_addr = str;
2486 }
2487
2488 str = autodiscover_dup_element_value (node, "RedirectUrl");
2489 if (str) {
2490 g_free (ad->redirect_url);
2491 ad->redirect_url = str;
2492 }
2493
2494 for (node = node->children; node; node = node->next) {
2495 if (node->type == XML_ELEMENT_NODE &&
2496 !strcmp ((gchar *) node->name, "Protocol")) {
2497 xmlChar *protocol_type = autodiscover_get_protocol_type (node);
2498
2499 if (g_strcmp0 ((const gchar *) protocol_type, "EXCH") == 0) {
2500 ews_urls_free_content (&exch_urls);
2501 autodiscover_parse_protocol (node, &exch_urls);
2502 } else if (g_strcmp0 ((const gchar *) protocol_type, "EXPR") == 0) {
2503 ews_urls_free_content (&expr_urls);
2504 autodiscover_parse_protocol (node, &expr_urls);
2505
2506 /* EXPR has precedence, thus stop once found both there */
2507 if (expr_urls.as_url && expr_urls.oab_url) {
2508 xmlFree (protocol_type);
2509 break;
2510 }
2511 }
2512
2513 if (protocol_type)
2514 xmlFree (protocol_type);
2515 }
2516 }
2517
2518 /* Make the <OABUrl> optional */
2519 if (!exch_urls.as_url && !expr_urls.as_url) {
2520 ews_urls_free_content (&exch_urls);
2521 ews_urls_free_content (&expr_urls);
2522 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1,
2523 _("Failed to find <ASUrl> in autodiscover response"));
2524 goto failed;
2525 }
2526
2527 ad->success = TRUE;
2528
2529 /* It's a good response, cancel all pending */
2530 g_cancellable_cancel (ad->cancellable);
2531
2532 if (expr_urls.as_url) {
2533 g_free (ad->as_url);
2534 ad->as_url = g_strdup ((gchar *) expr_urls.as_url);
2535 } else if (exch_urls.as_url) {
2536 g_free (ad->as_url);
2537 ad->as_url = g_strdup ((gchar *) exch_urls.as_url);
2538 }
2539
2540 if (expr_urls.as_url && expr_urls.oab_url) {
2541 g_free (ad->oab_url);
2542 ad->oab_url = g_strdup ((gchar *) expr_urls.oab_url);
2543 } else if (!expr_urls.as_url && exch_urls.oab_url) {
2544 g_free (ad->oab_url);
2545 ad->oab_url = g_strdup ((gchar *) exch_urls.oab_url);
2546 }
2547
2548 ews_urls_free_content (&exch_urls);
2549 ews_urls_free_content (&expr_urls);
2550
2551 goto exit;
2552
2553 failed:
2554 if (!g_cancellable_is_cancelled (ad->cancellable) &&
2555 (!ad->as_url || !ad->oab_url) && ad->n_redirects < 11 &&
2556 (ad->redirect_url || ad->redirect_addr) &&
2557 !g_error_matches (ad->error, E_SOUP_SESSION_ERROR, SOUP_STATUS_UNAUTHORIZED) &&
2558 (!ad->error || (ad->error->domain != G_IO_ERROR && ad->error->domain != G_TLS_ERROR))) {
2559 const gchar *host_url;
2560 gchar *redirect_addr, *redirect_url;
2561 GError *local_error;
2562
2563 redirect_addr = ad->redirect_addr;
2564 redirect_url = ad->redirect_url;
2565 local_error = ad->error;
2566
2567 /* To avoid infinite recursion */
2568 ad->redirect_addr = NULL;
2569 ad->redirect_url = NULL;
2570 ad->n_redirects++;
2571 ad->error = NULL;
2572
2573 host_url = redirect_url;
2574
2575 if (!host_url)
2576 host_url = camel_ews_settings_get_hosturl (ad->settings);
2577
2578 e_ews_autodiscover_prepare_requests_and_send_sync (ad, redirect_addr, host_url, ad->cancellable);
2579
2580 g_clear_error (&local_error);
2581 g_free (redirect_addr);
2582 g_free (redirect_url);
2583 }
2584
2585 exit:
2586 xmlFreeDoc (doc);
2587 }
2588
2589 static ESoapRequest *
2590 e_ews_create_request_for_url (const gchar *url,
2591 xmlOutputBuffer *buf,
2592 GError **error)
2593 {
2594 ESoapRequest *request;
2595
2596 if (url == NULL) {
2597 g_set_error_literal (
2598 error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
2599 _("URL cannot be NULL"));
2600 return NULL;
2601 }
2602
2603 request = e_soap_request_new (buf ? SOUP_METHOD_POST : SOUP_METHOD_GET, url, FALSE, NULL, NULL, NULL, error);
2604 if (!request)
2605 return NULL;
2606
2607 if (buf) {
2608 e_soap_request_set_custom_body (request, "text/xml; charset=utf-8",
2609 #ifdef LIBXML2_NEW_BUFFER
2610 xmlOutputBufferGetContent (buf), xmlOutputBufferGetSize (buf)
2611 #else
2612 buf->buffer->content, buf->buffer->use
2613 #endif
2614 );
2615 } else {
2616 /* No body set for the GET request */
2617 e_soap_request_set_custom_body (request, "", NULL, 0);
2618 }
2619
2620 return request;
2621 }
2622
2623 static GSList * /* ESoapRequest * */
2624 e_ews_autodiscover_prepare_requests (AutodiscoverData *ad,
2625 const gchar *email_address,
2626 const gchar *override_url,
2627 gchar **out_srv_lookup_domain,
2628 GError **error)
2629 {
2630 GUri *uri = NULL;
2631 gboolean use_secure = TRUE;
2632 gboolean is_outlook = FALSE;
2633 gchar *url1, *url2, *url3, *url4;
2634 const gchar *url5, *domain = NULL;
2635 GSList *requests = NULL;
2636 xmlDoc *doc;
2637 xmlOutputBuffer *buf;
2638 GError *local_error = NULL;
2639
2640 g_return_val_if_fail (email_address && *email_address, FALSE);
2641
2642 domain = strchr (email_address, '@');
2643 if (domain)
2644 domain++;
2645
2646 g_return_val_if_fail ((domain && *domain) || (override_url && *override_url), FALSE);
2647
2648 doc = e_ews_autodiscover_ws_xml (email_address);
2649 buf = xmlAllocOutputBuffer (NULL);
2650 xmlNodeDumpOutput (buf, doc, xmlDocGetRootElement (doc), 0, 1, NULL);
2651 xmlOutputBufferFlush (buf);
2652 xmlFreeDoc (doc);
2653
2654 url1 = NULL;
2655 url2 = NULL;
2656 url3 = NULL;
2657 url4 = NULL;
2658 url5 = NULL;
2659
2660 if (override_url)
2661 uri = g_uri_parse (override_url, SOUP_HTTP_URI_FLAGS | G_URI_FLAGS_PARSE_RELAXED, NULL);
2662
2663 if (uri) {
2664 const gchar *host = g_uri_get_host (uri);
2665 const gchar *scheme = g_uri_get_scheme (uri);
2666
2667 use_secure = g_strcmp0 (scheme, "https") == 0;
2668
2669 url1 = g_strdup_printf ("http%s://%s/autodiscover/autodiscover.xml", use_secure ? "s" : "", host);
2670 url2 = g_strdup_printf ("http%s://autodiscover.%s/autodiscover/autodiscover.xml", use_secure ? "s" : "", host);
2671
2672 is_outlook = host && g_ascii_strcasecmp (host, "outlook.office365.com") == 0;
2673
2674 /* outlook.office365.com has its autodiscovery at outlook.com */
2675 if (is_outlook && domain && g_ascii_strcasecmp (domain, "outlook.com") != 0) {
2676 url5 = "https://outlook.com/autodiscover/autodiscover.xml";
2677 } else if (!is_outlook && domain) {
2678 #define ON_MICROSOFT_COM_TEXT "onmicrosoft.com"
2679 gint len = strlen (domain);
2680 gint onmslen = strlen (ON_MICROSOFT_COM_TEXT);
2681
2682 if (len >= onmslen) {
2683 const gchar *test_domain;
2684
2685 test_domain = domain + len - onmslen;
2686
2687 /* onmicrosoft.com addresses might be handled on the outlook.com/office365.com as well */
2688 if (g_ascii_strcasecmp (test_domain, ON_MICROSOFT_COM_TEXT) == 0 &&
2689 (len == onmslen || (len > onmslen && domain[len - onmslen - 1] == '.')))
2690 url5 = "https://outlook.com/autodiscover/autodiscover.xml";
2691 }
2692 #undef ON_MICROSOFT_COM_TEXT
2693 }
2694
2695 g_uri_unref (uri);
2696 }
2697
2698 is_outlook = is_outlook || (domain && g_ascii_strcasecmp (domain, "outlook.com") == 0);
2699
2700 if (domain) {
2701 url3 = g_strdup_printf ("http%s://%s/autodiscover/autodiscover.xml", use_secure ? "s" : "", domain);
2702 url4 = g_strdup_printf ("http%s://autodiscover.%s/autodiscover/autodiscover.xml", use_secure ? "s" : "", domain);
2703 }
2704
2705 #define process_url(_url) G_STMT_START { \
2706 if (_url) { \
2707 ESoapRequest *request = e_ews_create_request_for_url (_url, buf, local_error ? NULL : &local_error); \
2708 if (request) \
2709 requests = g_slist_prepend (requests, request); \
2710 } \
2711 } G_STMT_END
2712
2713 process_url (url1);
2714 process_url (url2);
2715 process_url (url3);
2716 process_url (url4);
2717 process_url (url5);
2718
2719 #undef process_url
2720
2721 if (local_error && requests)
2722 g_clear_error (&local_error);
2723
2724 if (!is_outlook && !local_error && domain && requests && out_srv_lookup_domain)
2725 *out_srv_lookup_domain = g_strdup (domain);
2726 else if (out_srv_lookup_domain)
2727 *out_srv_lookup_domain = NULL;
2728
2729 g_free (url1);
2730 g_free (url2);
2731 g_free (url3);
2732 g_free (url4);
2733
2734 if (local_error) {
2735 xmlOutputBufferClose (buf);
2736 g_propagate_error (error, local_error);
2737 return NULL;
2738 }
2739
2740 g_clear_pointer (&ad->buf, xmlOutputBufferClose);
2741 ad->buf = buf;
2742
2743 return requests;
2744 }
2745
2746 typedef struct _AutodiscoverResponseData {
2747 AutodiscoverData *ad;
2748 SoupMessage *message;
2749 } AutodiscoverResponseData;
2750
2751 static void
2752 ews_autodiscover_response_ready_cb (GObject *source_object,
2753 GAsyncResult *result,
2754 gpointer user_data)
2755 {
2756 AutodiscoverResponseData *ard = user_data;
2757 AutodiscoverData *ad;
2758 gchar *certificate_pem = NULL;
2759 GTlsCertificateFlags certificate_errors = 0;
2760 GInputStream *input_stream;
2761 GError *local_error = NULL;
2762
2763 g_return_if_fail (ard != NULL);
2764
2765 ad = ard->ad;
2766
2767 input_stream = e_soup_session_send_message_finish (E_SOUP_SESSION (source_object), result,
2768 &certificate_pem, &certificate_errors, &local_error);
2769
2770 if (input_stream) {
2771 GByteArray *bytes;
2772 gint expected_length;
2773 gpointer buffer;
2774 gsize nread = 0;
2775 gboolean success;
2776
2777 expected_length = soup_message_headers_get_content_length (soup_message_get_response_headers (ard->message));
2778 if (expected_length > 0)
2779 bytes = g_byte_array_sized_new (expected_length > 1024 * 1024 * 10 ? 1024 * 1024 * 10 : expected_length);
2780 else
2781 bytes = g_byte_array_new ();
2782
2783 buffer = g_malloc (EWS_BUFFER_SIZE);
2784
2785 while (success = g_input_stream_read_all (input_stream, buffer, EWS_BUFFER_SIZE, &nread, ad->cancellable, &local_error),
2786 success && nread > 0) {
2787 g_byte_array_append (bytes, buffer, nread);
2788 }
2789
2790 if (success)
2791 ews_process_autodiscover_response (ad, bytes, &local_error);
2792
2793 g_free (buffer);
2794 g_byte_array_free (bytes, TRUE);
2795 g_object_unref (input_stream);
2796 }
2797
2798 if (local_error && (!ad->error ||
2799 (!g_error_matches (ad->error, E_SOUP_SESSION_ERROR, SOUP_STATUS_UNAUTHORIZED) &&
2800 (!ad->error || (ad->error->domain != G_IO_ERROR && ad->error->domain != G_TLS_ERROR))))) {
2801 g_clear_pointer (&ad->certificate_pem, g_free);
2802 ad->certificate_pem = certificate_pem;
2803 ad->certificate_errors = certificate_errors;
2804 ad->error = local_error;
2805 } else {
2806 g_free (certificate_pem);
2807 g_clear_error (&local_error);
2808 }
2809
2810 if (g_atomic_int_dec_and_test (&ad->n_pending))
2811 g_main_loop_quit (ad->main_loop);
2812
2813 g_object_unref (ard->message);
2814 g_slice_free (AutodiscoverResponseData, ard);
2815 }
2816
2817 static void
2818 ews_autodiscover_send_request (AutodiscoverData *ad,
2819 ESoapRequest *request,
2820 GCancellable *cancellable,
2821 GError **error)
2822 {
2823 SoupMessage *message;
2824
2825 message = e_soap_request_persist (request, ad->session, ad->settings, error);
2826
2827 if (message) {
2828 gpointer prepare_data;
2829
2830 prepare_data = e_soup_session_prepare_message_send_sync (ad->session, message, cancellable, error);
2831
2832 if (prepare_data) {
2833 AutodiscoverResponseData *ard;
2834
2835 g_atomic_int_inc (&ad->n_pending);
2836
2837 ard = g_slice_new (AutodiscoverResponseData);
2838 ard->ad = ad;
2839 ard->message = g_object_ref (message);
2840
2841 e_soup_session_send_message (ad->session, message, G_PRIORITY_DEFAULT, prepare_data,
2842 ad->cancellable, ews_autodiscover_response_ready_cb, ard);
2843 }
2844
2845 g_object_unref (message);
2846 }
2847 }
2848
2849 static void
2850 autodiscover_srv_record_resolved_cb (GObject *source,
2851 GAsyncResult *result,
2852 gpointer user_data)
2853 {
2854 GList *targets, *link;
2855 AutodiscoverData *ad = user_data;
2856 gchar *new_uri = NULL;
2857 gboolean success;
2858
2859 g_return_if_fail (ad != NULL);
2860
2861 targets = g_resolver_lookup_service_finish (G_RESOLVER (source), result, NULL);
2862
2863 success = !g_cancellable_is_cancelled (ad->cancellable) && targets;
2864
2865 for (link = targets; link && success; link = g_list_next (link)) {
2866 GSrvTarget *target = link->data;
2867 const gchar *hostname;
2868
2869 hostname = g_srv_target_get_hostname (target);
2870
2871 switch (g_srv_target_get_port (target)) {
2872 case 80:
2873 link = NULL;
2874 new_uri = g_strdup_printf ("http://%s/autodiscover/autodiscover.xml", hostname);
2875 break;
2876 case 443:
2877 link = NULL;
2878 new_uri = g_strdup_printf ("https://%s/autodiscover/autodiscover.xml", hostname);
2879 break;
2880 }
2881 }
2882
2883 g_list_free_full (targets, (GDestroyNotify) g_srv_target_free);
2884
2885 if (new_uri && success) {
2886 ESoapRequest *request = e_ews_create_request_for_url (new_uri, ad->buf, ad->error ? NULL : &ad->error);
2887 if (request) {
2888 ews_autodiscover_send_request (ad, request, ad->cancellable, ad->error ? NULL : &ad->error);
2889 g_object_unref (request);
2890 } else {
2891 success = FALSE;
2892 }
2893 } else {
2894 success = FALSE;
2895 }
2896
2897 if (g_atomic_int_dec_and_test (&ad->n_pending))
2898 g_main_loop_quit (ad->main_loop);
2899
2900 g_free (new_uri);
2901 }
2902
2903 static gboolean
2904 e_ews_autodiscover_prepare_requests_and_send_sync (AutodiscoverData *ad,
2905 const gchar *email_address,
2906 const gchar *override_url,
2907 GCancellable *cancellable)
2908 {
2909 GSList *requests, *link;
2910 gchar *srv_lookup_domain = NULL;
2911 GError *local_error = NULL;
2912
2913 g_return_val_if_fail (ad != NULL, FALSE);
2914
2915 /* to not have the main loop quit while doing this */
2916 g_atomic_int_inc (&ad->n_pending);
2917
2918 /* This is starting a new round, the last error and others are obsolete */
2919 g_clear_error (&ad->error);
2920 g_clear_pointer (&ad->as_url, g_free);
2921 g_clear_pointer (&ad->oab_url, g_free);
2922 g_clear_pointer (&ad->certificate_pem, g_free);
2923 ad->certificate_errors = 0;
2924
2925 requests = e_ews_autodiscover_prepare_requests (ad, email_address, override_url, &srv_lookup_domain, &local_error);
2926
2927 if (!local_error && srv_lookup_domain && *srv_lookup_domain) {
2928 g_atomic_int_inc (&ad->n_pending);
2929
2930 g_resolver_lookup_service_async (g_resolver_get_default (), "autodiscover", "tcp", srv_lookup_domain, cancellable,
2931 autodiscover_srv_record_resolved_cb, ad);
2932 }
2933
2934 for (link = requests; link; link = g_slist_next (link)) {
2935 ESoapRequest *request = link->data;
2936
2937 ews_autodiscover_send_request (ad, request, cancellable, local_error ? NULL : &local_error);
2938 }
2939
2940 if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND) &&
2941 camel_ews_settings_get_auth_mechanism (ad->settings) == EWS_AUTH_TYPE_OAUTH2) {
2942 /* To ask for the credentials when being OAuth2 and the secret is not found in the keyring */
2943 local_error->domain = E_SOUP_SESSION_ERROR;
2944 local_error->code = SOUP_STATUS_UNAUTHORIZED;
2945 }
2946
2947 if (local_error && (!ad->error ||
2948 (!g_error_matches (ad->error, E_SOUP_SESSION_ERROR, SOUP_STATUS_UNAUTHORIZED) &&
2949 (!ad->error || (ad->error->domain != G_IO_ERROR && ad->error->domain != G_TLS_ERROR))))) {
2950 g_clear_error (&ad->error);
2951 g_propagate_error (&ad->error, local_error);
2952 } else {
2953 g_clear_error (&local_error);
2954 }
2955
2956 /* pair decrement for the increment at the beginning of the function */
2957 if (g_atomic_int_dec_and_test (&ad->n_pending))
2958 g_main_loop_quit (ad->main_loop);
2959
2960 g_slist_free_full (requests, g_object_unref);
2961 g_free (srv_lookup_domain);
2962
2963 return requests != NULL;
2964 }
2965
2966 static void
2967 e_ews_cancel_cancellable_cb (GCancellable *cancellable,
2968 gpointer user_data)
2969 {
2970 GCancellable *op_cancellable = user_data;
2971
2972 g_cancellable_cancel (op_cancellable);
2973 }
2974
2975 static gboolean
2976 has_suffix_icmp (const gchar *text,
2977 const gchar *suffix)
2978 {
2979 gint ii, tlen, slen;
2980
2981 g_return_val_if_fail (text != NULL, FALSE);
2982 g_return_val_if_fail (suffix != NULL, FALSE);
2983
2984 tlen = strlen (text);
2985 slen = strlen (suffix);
2986
2987 if (!*text || !*suffix || tlen < slen)
2988 return FALSE;
2989
2990 for (ii = 0; ii < slen; ii++) {
2991 if (g_ascii_tolower (text[tlen - ii - 1]) !=
2992 g_ascii_tolower (suffix[slen - ii - 1]))
2993 break;
2994 }
2995
2996 return ii == slen;
2997 }
2998
2999 gboolean
3000 e_ews_autodiscover_ws_url_sync (ESource *source,
3001 CamelEwsSettings *settings,
3002 const gchar *email_address,
3003 const gchar *password,
3004 gchar **out_certificate_pem,
3005 GTlsCertificateFlags *out_certificate_errors,
3006 GCancellable *cancellable,
3007 GError **error)
3008 {
3009 AutodiscoverData ad;
3010 gulong cancelled_id = 0;
3011 EEwsConnection *tmp_cnc;
3012 GMainContext *main_context;
3013 const gchar *domain;
3014 const gchar *host_url;
3015
3016 g_return_val_if_fail (CAMEL_IS_EWS_SETTINGS (settings), FALSE);
3017 g_return_val_if_fail (email_address != NULL, FALSE);
3018 g_return_val_if_fail (password != NULL, FALSE);
3019
3020 domain = strchr (email_address, '@');
3021
3022 /* if it's non-NULL, then domain[0] == '@' */
3023 if (!domain || !domain[1]) {
3024 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1, _("Email address is missing a domain part"));
3025 return FALSE;
3026 }
3027
3028 memset (&ad, 0, sizeof (AutodiscoverData));
3029
3030 ad.settings = settings;
3031 ad.cancellable = g_cancellable_new ();
3032
3033 if (G_IS_CANCELLABLE (cancellable)) {
3034 cancelled_id = g_cancellable_connect (cancellable, G_CALLBACK (e_ews_cancel_cancellable_cb),
3035 ad.cancellable, NULL);
3036 }
3037
3038 main_context = g_main_context_new ();
3039 ad.main_loop = g_main_loop_new (main_context, FALSE);
3040 g_main_context_push_thread_default (main_context);
3041
3042 /*
3043 * http://msdn.microsoft.com/en-us/library/ee332364.aspx says we are
3044 * supposed to try $domain and then autodiscover.$domain. But some
3045 * people have broken firewalls on the former which drop packets
3046 * instead of rejecting connections, and make the request take ages
3047 * to time out. So run both queries in parallel and let the fastest
3048 * (successful) one win.
3049 */
3050 tmp_cnc = e_ews_connection_new_full (source, "https://autodiscover.domain", settings, FALSE);
3051 ad.session = e_ews_connection_create_soup_session (tmp_cnc);
3052 g_object_set (ad.session, "timeout", 20, NULL);
3053 e_ews_connection_set_password (tmp_cnc, password);
3054 e_soup_session_set_credentials (E_SOUP_SESSION (ad.session), tmp_cnc->priv->credentials);
3055
3056 host_url = camel_ews_settings_get_hosturl (settings);
3057
3058 if (e_ews_autodiscover_prepare_requests_and_send_sync (&ad, email_address, host_url, cancellable) &&
3059 g_atomic_int_get (&ad.n_pending) > 0)
3060 g_main_loop_run (ad.main_loop);
3061
3062 g_main_context_pop_thread_default (main_context);
3063
3064 g_main_context_unref (main_context);
3065 g_main_loop_unref (ad.main_loop);
3066 g_clear_object (&tmp_cnc);
3067 g_clear_object (&ad.session);
3068
3069 if (cancelled_id)
3070 g_cancellable_disconnect (cancellable, cancelled_id);
3071
3072 if (ad.success) {
3073 camel_ews_settings_set_hosturl (settings, ad.as_url);
3074
3075 if (ad.oab_url && !has_suffix_icmp (ad.oab_url, "oab.xml")) {
3076 gchar *tmp;
3077
3078 if (g_str_has_suffix (ad.oab_url, "/"))
3079 tmp = g_strconcat (ad.oab_url, "oab.xml", NULL);
3080 else
3081 tmp = g_strconcat (ad.oab_url, "/", "oab.xml", NULL);
3082
3083 camel_ews_settings_set_oaburl (settings, tmp);
3084 g_free (tmp);
3085 } else {
3086 camel_ews_settings_set_oaburl (settings, ad.oab_url);
3087 }
3088
3089 if (out_certificate_pem)
3090 *out_certificate_pem = NULL;
3091 if (out_certificate_errors)
3092 *out_certificate_errors = 0;
3093 } else {
3094 if (ad.error) {
3095 g_propagate_error (error, ad.error);
3096 ad.error = NULL;
3097 }
3098 if (out_certificate_pem)
3099 *out_certificate_pem = g_steal_pointer (&ad.certificate_pem);
3100 if (out_certificate_errors)
3101 *out_certificate_errors = ad.certificate_errors;
3102 }
3103
3104 autodiscover_data_clear (&ad);
3105
3106 return ad.success;
3107 }
3108
3109 typedef struct _OalRequestData {
3110 const gchar *oal_id;
3111 const gchar *oal_element;
3112
3113 GSList *oals; /* EwsOAL * */
3114 GSList *elements; /* EwsOALDetails */
3115 gchar *etag;
3116 } OalRequestData;
3117
3118 static void
3119 oal_request_data_init (OalRequestData *req_data)
3120 {
3121 memset (req_data, 0, sizeof (OalRequestData));
3122 }
3123
3124 static void
3125 oal_request_data_clear (OalRequestData *req_data)
3126 {
3127 g_free (req_data->etag);
3128
3129 g_slist_free_full (req_data->oals, (GDestroyNotify) ews_oal_free);
3130 g_slist_free_full (req_data->elements, (GDestroyNotify) ews_oal_details_free);
3131 }
3132
3133 static gchar *
3134 get_property (xmlNodePtr node_ptr,
3135 const gchar *name)
3136 {
3137 xmlChar *xml_s;
3138 gchar *s;
3139
3140 xml_s = xmlGetProp (node_ptr, (const xmlChar *) name);
3141 s = g_strdup ((gchar *) xml_s);
3142 xmlFree (xml_s);
3143
3144 return s;
3145 }
3146
3147 static guint32
3148 get_property_as_uint32 (xmlNodePtr node_ptr,
3149 const gchar *name)
3150 {
3151 gchar *s;
3152 guint32 val = -1;
3153
3154 s = get_property (node_ptr, name);
3155 if (s)
3156 sscanf (s,"%"G_GUINT32_FORMAT, &val);
3157 g_free (s);
3158
3159 return val;
3160 }
3161
3162 static gchar *
3163 get_content (xmlNodePtr node_ptr)
3164 {
3165 xmlChar *xml_s;
3166 gchar *s;
3167
3168 xml_s = xmlNodeGetContent (node_ptr);
3169 s = g_strdup ((gchar *) xml_s);
3170 xmlFree (xml_s);
3171
3172 return s;
3173 }
3174
3175 static GSList *
3176 parse_oal_full_details (xmlNode *node,
3177 const gchar *element)
3178 {
3179 GSList *elements = NULL;
3180
3181 for (node = node->children; node; node = node->next) {
3182 EwsOALDetails *det;
3183 if (node->type != XML_ELEMENT_NODE)
3184 continue;
3185 if (element && strcmp ((gchar *) node->name, element))
3186 continue;
3187 if (!element && strcmp ((gchar *) node->name, "Full") &&
3188 strcmp((gchar *) node->name, "Diff"))
3189 continue;
3190
3191 det = g_new0 (EwsOALDetails, 1);
3192 det->type = g_strdup((gchar *) node->name);
3193 det->seq = get_property_as_uint32 (node, "seq");
3194 det->ver = get_property_as_uint32 (node, "ver");
3195 det->size = get_property_as_uint32 (node, "size");
3196 det->uncompressed_size = get_property_as_uint32 (node, "uncompressedsize");
3197 det->sha = get_property (node, "uncompressedsize");
3198 det->filename = g_strstrip (get_content (node));
3199
3200 elements = g_slist_prepend (elements, det);
3201 if (element && !strcmp (element, "Full"))
3202 break;
3203 }
3204
3205 return elements;
3206 }
3207
3208 static void
3209 e_ews_process_oal_data_response (ESoapRequest *request,
3210 SoupMessage *message,
3211 GInputStream *input_stream,
3212 gpointer user_data,
3213 gboolean *out_repeat,
3214 GCancellable *cancellable,
3215 GError **error)
3216 {
3217 OalRequestData *req_data = user_data;
3218 ESoapResponse *response;
3219 const gchar *etag;
3220 xmlDoc *doc;
3221 xmlNode *node;
3222
3223 response = e_soap_response_new ();
3224
3225 e_soap_request_setup_response (request, response);
3226
3227 doc = e_soap_response_xmldoc_from_message_sync (response, message, input_stream, cancellable, error);
3228
3229 g_clear_object (&response);
3230
3231 if (!doc) {
3232 if (error && !*error)
3233 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1, _("Failed to parse oab XML"));
3234 return;
3235 }
3236
3237 etag = soup_message_headers_get_one (soup_message_get_response_headers (message), "ETag");
3238 if (etag)
3239 req_data->etag = g_strdup (etag);
3240
3241 node = xmlDocGetRootElement (doc);
3242 if (strcmp ((gchar *) node->name, "OAB") == 0) {
3243 for (node = node->children; node; node = node->next) {
3244 if (node->type == XML_ELEMENT_NODE && strcmp ((gchar *) node->name, "OAL") == 0) {
3245 if (req_data->oal_id == NULL) {
3246 EwsOAL *oal = g_new0 (EwsOAL, 1);
3247
3248 oal->id = get_property (node, "id");
3249 oal->dn = get_property (node, "dn");
3250 oal->name = get_property (node, "name");
3251
3252 req_data->oals = g_slist_prepend (req_data->oals, oal);
3253 } else {
3254 gchar *id = get_property (node, "id");
3255
3256 if (strcmp (id, req_data->oal_id) == 0) {
3257 /* parse details of full_details file */
3258 req_data->elements = parse_oal_full_details (node, req_data->oal_element);
3259
3260 g_free (id);
3261 break;
3262 }
3263
3264 g_free (id);
3265 }
3266 }
3267 }
3268
3269 req_data->oals = g_slist_reverse (req_data->oals);
3270 } else {
3271 g_set_error_literal (error, EWS_CONNECTION_ERROR, -1, _("Failed to find <OAB> element\n"));
3272 }
3273
3274 xmlFreeDoc (doc);
3275 }
3276
3277 gboolean
3278 e_ews_connection_get_oal_list_sync (EEwsConnection *cnc,
3279 GSList **out_oals,
3280 GCancellable *cancellable,
3281 GError **error)
3282 {
3283 ESoapRequest *request;
3284 ESoapResponse *response;
3285 OalRequestData req_data;
3286 GError *local_error = NULL;
3287
3288 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
3289 g_return_val_if_fail (out_oals != NULL, FALSE);
3290
3291 *out_oals = NULL;
3292
3293 request = e_ews_create_request_for_url (cnc->priv->uri, NULL, error);
3294
3295 if (!request)
3296 return FALSE;
3297
3298 oal_request_data_init (&req_data);
3299
3300 e_soap_request_set_custom_process_fn (request, e_ews_process_oal_data_response, &req_data);
3301
3302 response = e_ews_connection_send_request_sync (cnc, request, cancellable, &local_error);
3303 g_warn_if_fail (response == NULL);
3304
3305 g_clear_object (&request);
3306 g_clear_object (&response);
3307
3308 if (!local_error)
3309 *out_oals = g_steal_pointer (&req_data.oals);
3310
3311 oal_request_data_clear (&req_data);
3312
3313 if (local_error) {
3314 g_propagate_error (error, local_error);
3315 return FALSE;
3316 }
3317
3318 return TRUE;
3319 }
3320
3321 gboolean
3322 e_ews_connection_get_oal_detail_sync (EEwsConnection *cnc,
3323 const gchar *oal_uri,
3324 const gchar *oal_id,
3325 const gchar *oal_element,
3326 const gchar *old_etag,
3327 GSList **out_elements,
3328 gchar **out_etag,
3329 GCancellable *cancellable,
3330 GError **error)
3331 {
3332 ESoapRequest *request;
3333 ESoapResponse *response;
3334 OalRequestData req_data;
3335 gchar *tmp_oal_id = NULL;
3336 GError *local_error = NULL;
3337
3338 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
3339 g_return_val_if_fail (oal_id, FALSE);
3340
3341 if (out_elements)
3342 *out_elements = NULL;
3343 if (out_etag)
3344 *out_etag = NULL;
3345
3346 request = e_ews_create_request_for_url (oal_uri, NULL, error);
3347
3348 if (!request)
3349 return FALSE;
3350
3351 /* oal_id can be of form "GUID:name", but here is compared only GUID */
3352 if (strchr (oal_id, ':')) {
3353 gchar *sep;
3354
3355 tmp_oal_id = g_strdup (oal_id);
3356 sep = strchr (tmp_oal_id, ':');
3357 if (sep)
3358 *sep = '\0';
3359 }
3360
3361 oal_request_data_init (&req_data);
3362
3363 req_data.oal_id = tmp_oal_id ? tmp_oal_id : oal_id;
3364 req_data.oal_element = oal_element;
3365
3366 e_soap_request_set_custom_process_fn (request, e_ews_process_oal_data_response, &req_data);
3367 e_soap_request_set_etag (request, old_etag);
3368
3369 response = e_ews_connection_send_request_sync (cnc, request, cancellable, &local_error);
3370 g_warn_if_fail (response == NULL);
3371
3372 g_clear_object (&request);
3373 g_clear_object (&response);
3374 g_free (tmp_oal_id);
3375
3376 if (!local_error) {
3377 if (out_elements)
3378 *out_elements = g_steal_pointer (&req_data.elements);
3379 if (out_etag)
3380 *out_etag = g_steal_pointer (&req_data.etag);
3381 }
3382
3383 oal_request_data_clear (&req_data);
3384
3385 if (local_error) {
3386 g_propagate_error (error, local_error);
3387 return FALSE;
3388 }
3389
3390 return TRUE;
3391 }
3392
3393 typedef struct _DownloadOalData {
3394 const gchar *cache_filename;
3395 gint fd;
3396 } DownloadOalData;
3397
3398 static void
3399 e_ews_process_download_oal_file_response (ESoapRequest *request,
3400 SoupMessage *message,
3401 GInputStream *input_stream,
3402 gpointer user_data,
3403 gboolean *out_repeat,
3404 GCancellable *cancellable,
3405 GError **error)
3406 {
3407 DownloadOalData *dod = user_data;
3408 ESoapResponseProgressFn progress_fn = NULL;
3409 gpointer progress_data = NULL;
3410 const gchar *size;
3411 gpointer buffer;
3412 gsize response_size = 0;
3413 gsize response_received = 0;
3414 gsize progress_percent = 0;
3415 gsize nread = 0;
3416 gboolean success;
3417
3418 g_return_if_fail (dod != NULL);
3419 g_return_if_fail (dod->fd != -1);
3420
3421 e_soap_request_get_progress_fn (request, &progress_fn, &progress_data);
3422
3423 size = soup_message_headers_get_one (soup_message_get_response_headers (message), "Content-Length");
3424
3425 if (size)
3426 response_size = g_ascii_strtoll (size, NULL, 10);
3427
3428 buffer = g_malloc (EWS_BUFFER_SIZE);
3429
3430 while (success = g_input_stream_read_all (input_stream, buffer, EWS_BUFFER_SIZE, &nread, cancellable, error),
3431 success && nread > 0) {
3432 response_received += nread;
3433
3434 if (response_size && progress_fn) {
3435 gint pc = response_received * 100 / response_size;
3436 if (progress_percent != pc) {
3437 progress_percent = pc;
3438 progress_fn (progress_data, progress_percent);
3439 }
3440 }
3441
3442 if (write (dod->fd, (const gchar *) buffer, nread) != nread) {
3443 g_set_error (error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_UNKNOWN,
3444 "Failed to write streaming data to file '%s': %s", dod->cache_filename, g_strerror (errno));
3445 break;
3446 }
3447 }
3448
3449 g_free (buffer);
3450 }
3451
3452 gboolean
3453 e_ews_connection_download_oal_file_sync (EEwsConnection *cnc,
3454 const gchar *oal_uri,
3455 const gchar *cache_filename,
3456 ESoapResponseProgressFn progress_fn,
3457 gpointer progress_data,
3458 GCancellable *cancellable,
3459 GError **error)
3460 {
3461 ESoapRequest *request;
3462 ESoapResponse *response;
3463 DownloadOalData dod;
3464 GError *local_error = NULL;
3465
3466 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
3467
3468 request = e_ews_create_request_for_url (oal_uri, NULL, error);
3469
3470 if (!request)
3471 return FALSE;
3472
3473 /* Prepare the file */
3474 g_unlink (cache_filename);
3475
3476 dod.cache_filename = cache_filename;
3477 dod.fd = g_open (cache_filename, O_RDONLY | O_WRONLY | O_APPEND | O_CREAT, 0600);
3478 if (dod.fd == -1) {
3479 g_set_error (error, EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_UNKNOWN,
3480 "Failed to open the cache file '%s': %s", cache_filename, g_strerror (errno));
3481 g_clear_object (&request);
3482
3483 return FALSE;
3484 }
3485
3486 e_soap_request_set_progress_fn (request, progress_fn, progress_data);
3487
3488 e_soap_request_set_custom_process_fn (request, e_ews_process_download_oal_file_response, &dod);
3489
3490 response = e_ews_connection_send_request_sync (cnc, request, cancellable, &local_error);
3491 g_warn_if_fail (response == NULL);
3492
3493 g_clear_object (&request);
3494 g_clear_object (&response);
3495 close (dod.fd);
3496
3497 if (local_error) {
3498 g_propagate_error (error, local_error);
3499 return FALSE;
3500 }
3501
3502 return TRUE;
3503 }
3504
3505 const gchar *
3506 e_ews_connection_get_mailbox (EEwsConnection *cnc)
3507 {
3508 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), NULL);
3509
3510 if (!cnc->priv->email || !*cnc->priv->email)
3511 return camel_ews_settings_get_email (cnc->priv->settings);
3512
3513 return cnc->priv->email;
3514 }
3515
3516 void
3517 e_ews_connection_set_mailbox (EEwsConnection *cnc,
3518 const gchar *email)
3519 {
3520 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
3521 g_return_if_fail (email != NULL);
3522
3523 g_free (cnc->priv->email);
3524 cnc->priv->email = g_strdup (email);
3525 }
3526
3527 static void
3528 ews_append_additional_props_to_msg (ESoapRequest *request,
3529 const EEwsAdditionalProps *add_props)
3530 {
3531 GSList *l;
3532
3533 if (!add_props)
3534 return;
3535
3536 e_soap_request_start_element (request, "AdditionalProperties", NULL, NULL);
3537
3538 if (add_props->field_uri) {
3539 gchar **prop = g_strsplit (add_props->field_uri, " ", 0);
3540 gint i = 0;
3541
3542 while (prop[i]) {
3543 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", prop[i]);
3544 i++;
3545 }
3546
3547 g_strfreev (prop);
3548 }
3549
3550 if (add_props->extended_furis) {
3551 for (l = add_props->extended_furis; l != NULL; l = g_slist_next (l)) {
3552 EEwsExtendedFieldURI *ex_furi = l->data;
3553
3554 e_soap_request_start_element (request, "ExtendedFieldURI", NULL, NULL);
3555
3556 if (ex_furi->distinguished_prop_set_id)
3557 e_soap_request_add_attribute (request, "DistinguishedPropertySetId", ex_furi->distinguished_prop_set_id, NULL, NULL);
3558
3559 if (ex_furi->prop_tag)
3560 e_soap_request_add_attribute (request, "PropertyTag", ex_furi->prop_tag, NULL, NULL);
3561
3562 if (ex_furi->prop_set_id)
3563 e_soap_request_add_attribute (request, "PropertySetId", ex_furi->prop_set_id, NULL, NULL);
3564
3565 if (ex_furi->prop_name)
3566 e_soap_request_add_attribute (request, "PropertyName", ex_furi->prop_name, NULL, NULL);
3567
3568 if (ex_furi->prop_id)
3569 e_soap_request_add_attribute (request, "PropertyId", ex_furi->prop_id, NULL, NULL);
3570
3571 if (ex_furi->prop_type)
3572 e_soap_request_add_attribute (request, "PropertyType", ex_furi->prop_type, NULL, NULL);
3573
3574 e_soap_request_end_element (request);
3575 }
3576 }
3577
3578 if (add_props->indexed_furis) {
3579 for (l = add_props->indexed_furis; l != NULL; l = g_slist_next (l)) {
3580 EEwsIndexedFieldURI *in_furi = l->data;
3581
3582 e_soap_request_start_element (request, "IndexedFieldURI", NULL, NULL);
3583
3584 e_soap_request_add_attribute (request, "FieldURI", in_furi->field_uri, NULL, NULL);
3585 e_soap_request_add_attribute (request, "FieldIndex", in_furi->field_index, NULL, NULL);
3586
3587 e_soap_request_end_element (request);
3588 }
3589 }
3590
3591 e_soap_request_end_element (request);
3592 }
3593
3594 static void
3595 ews_write_sort_order_to_msg (ESoapRequest *request,
3596 EwsSortOrder *sort_order)
3597 {
3598 if (!sort_order)
3599 return;
3600
3601 e_soap_request_start_element (request, "SortOrder", NULL, NULL);
3602 e_soap_request_start_element (request, "FieldOrder", NULL, NULL);
3603 e_soap_request_add_attribute (request, "Order", sort_order->order, NULL, NULL);
3604
3605 if (sort_order->uri_type == NORMAL_FIELD_URI)
3606 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", (gchar *) sort_order->field_uri);
3607 else if (sort_order->uri_type == INDEXED_FIELD_URI) {
3608 EEwsIndexedFieldURI *in_furi = sort_order->field_uri;
3609
3610 e_soap_request_start_element (request, "IndexedFieldURI", NULL, NULL);
3611 e_soap_request_add_attribute (request, "FieldURI", in_furi->field_uri, NULL, NULL);
3612 e_soap_request_add_attribute (request, "FieldIndex", in_furi->field_index, NULL, NULL);
3613 e_soap_request_end_element (request);
3614 } else if (sort_order->uri_type == EXTENDED_FIELD_URI) {
3615 EEwsExtendedFieldURI *ex_furi = sort_order->field_uri;
3616
3617 e_soap_request_start_element (request, "ExtendedFieldURI", NULL, NULL);
3618
3619 if (ex_furi->distinguished_prop_set_id)
3620 e_soap_request_add_attribute (request, "DistinguishedPropertySetId", ex_furi->distinguished_prop_set_id, NULL, NULL);
3621 if (ex_furi->prop_set_id)
3622 e_soap_request_add_attribute (request, "PropertySetId", ex_furi->prop_set_id, NULL, NULL);
3623 if (ex_furi->prop_name)
3624 e_soap_request_add_attribute (request, "PropertyName", ex_furi->prop_name, NULL, NULL);
3625 if (ex_furi->prop_id)
3626 e_soap_request_add_attribute (request, "PropertyId", ex_furi->prop_id, NULL, NULL);
3627 if (ex_furi->prop_type)
3628 e_soap_request_add_attribute (request, "PropertyType", ex_furi->prop_type, NULL, NULL);
3629
3630 e_soap_request_end_element (request);
3631 }
3632
3633 e_soap_request_end_element (request);
3634 e_soap_request_end_element (request);
3635 }
3636
3637 static gboolean
3638 e_ews_process_sync_folder_items_response (EEwsConnection *cnc,
3639 ESoapResponse *response,
3640 gchar **out_new_sync_state,
3641 gboolean *out_includes_last_item,
3642 GSList **out_items_created,
3643 GSList **out_items_updated,
3644 GSList **out_items_deleted,
3645 GError **error)
3646 {
3647 ESoapParameter *param;
3648 ESoapParameter *subparam;
3649 GError *local_error = NULL;
3650
3651 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
3652
3653 /* Sanity check */
3654 g_return_val_if_fail (
3655 (param != NULL && local_error == NULL) ||
3656 (param == NULL && local_error != NULL), FALSE);
3657
3658 if (local_error) {
3659 g_propagate_error (error, local_error);
3660 return FALSE;
3661 }
3662
3663 subparam = e_soap_parameter_get_first_child (param);
3664
3665 while (subparam != NULL) {
3666 const gchar *name = (const gchar *) subparam->name;
3667
3668 if (!ews_get_response_status (subparam, error))
3669 return FALSE;
3670
3671 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "SyncFolderItemsResponseMessage")) {
3672 e_ews_process_sync_xxx_response (
3673 subparam, (ItemParser) e_ews_item_new_from_soap_parameter,
3674 "IncludesLastItemInRange", "ItemId",
3675 out_new_sync_state, out_includes_last_item, out_items_created, out_items_updated, out_items_deleted);
3676 }
3677
3678 subparam = e_soap_parameter_get_next_child (subparam);
3679 }
3680
3681 return TRUE;
3682 }
3683
3684 gboolean
3685 e_ews_connection_sync_folder_items_sync (EEwsConnection *cnc,
3686 gint pri,
3687 const gchar *old_sync_state,
3688 const gchar *fid,
3689 const gchar *default_props,
3690 const EEwsAdditionalProps *add_props,
3691 guint max_entries,
3692 gchar **out_new_sync_state,
3693 gboolean *out_includes_last_item,
3694 GSList **out_items_created,
3695 GSList **out_items_updated,
3696 GSList **out_items_deleted,
3697 GCancellable *cancellable,
3698 GError **error)
3699 {
3700 ESoapRequest *request;
3701 ESoapResponse *response;
3702 gboolean success;
3703
3704 g_return_val_if_fail (cnc != NULL, FALSE);
3705
3706 request = e_ews_request_new_with_header (
3707 cnc->priv->uri,
3708 cnc->priv->impersonate_user,
3709 "SyncFolderItems",
3710 NULL,
3711 NULL,
3712 cnc->priv->version,
3713 E_EWS_EXCHANGE_2007_SP1,
3714 FALSE,
3715 error);
3716
3717 if (!request)
3718 return FALSE;
3719
3720 e_soap_request_start_element (request, "ItemShape", "messages", NULL);
3721 e_ews_request_write_string_parameter (request, "BaseShape", NULL, default_props);
3722
3723 ews_append_additional_props_to_msg (request, add_props);
3724
3725 e_soap_request_end_element (request);
3726
3727 e_soap_request_start_element (request, "SyncFolderId", "messages", NULL);
3728 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", fid);
3729 e_soap_request_end_element (request);
3730
3731 if (old_sync_state)
3732 e_ews_request_write_string_parameter (request, "SyncState", "messages", old_sync_state);
3733
3734 /* Max changes requested */
3735 e_ews_request_write_int_parameter (request, "MaxChangesReturned", "messages", max_entries);
3736
3737 e_ews_request_write_footer (request);
3738
3739 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
3740
3741 if (!response) {
3742 g_clear_object (&request);
3743 return FALSE;
3744 }
3745
3746 success = e_ews_process_sync_folder_items_response (cnc, response,
3747 out_new_sync_state, out_includes_last_item, out_items_created,
3748 out_items_updated, out_items_deleted, error);
3749
3750 g_clear_object (&request);
3751 g_clear_object (&response);
3752
3753 return success;
3754 }
3755
3756 static void
3757 ews_append_folder_ids_to_msg (ESoapRequest *request,
3758 const gchar *email,
3759 GSList *folder_ids)
3760 {
3761 GSList *l;
3762
3763 for (l = folder_ids; l != NULL; l = g_slist_next (l)) {
3764 const EwsFolderId *fid = l->data;
3765
3766 e_ews_folder_id_append_to_request (request, email, fid);
3767 }
3768 }
3769
3770 static void
3771 ews_connection_write_only_ids_restriction (ESoapRequest *request,
3772 GPtrArray *only_ids)
3773 {
3774 guint ii;
3775
3776 g_return_if_fail (E_IS_SOAP_REQUEST (request));
3777 g_return_if_fail (only_ids && only_ids->len);
3778
3779 for (ii = 0; ii < only_ids->len; ii++) {
3780 const gchar *itemid = g_ptr_array_index (only_ids, ii);
3781
3782 e_soap_request_start_element (request, "IsEqualTo", NULL, NULL);
3783 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "item:ItemId");
3784 e_soap_request_start_element (request, "FieldURIOrConstant", NULL, NULL);
3785 e_ews_request_write_string_parameter_with_attribute (request, "Constant", NULL, NULL, "Value", itemid);
3786 e_soap_request_end_element (request); /* FieldURIOrConstant */
3787 e_soap_request_end_element (request); /* IsEqualTo */
3788 }
3789 }
3790
3791 static gboolean
3792 e_ews_process_find_folder_items_response (EEwsConnection *cnc,
3793 ESoapResponse *response,
3794 gboolean *out_includes_last_item,
3795 GSList **out_items,
3796 GError **error)
3797 {
3798 ESoapParameter *param;
3799 ESoapParameter *subparam;
3800 GError *local_error = NULL;
3801
3802 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
3803
3804 /* Sanity check */
3805 g_return_val_if_fail (
3806 (param != NULL && local_error == NULL) ||
3807 (param == NULL && local_error != NULL), FALSE);
3808
3809 if (local_error != NULL) {
3810 g_propagate_error (error, local_error);
3811 return FALSE;
3812 }
3813
3814 subparam = e_soap_parameter_get_first_child (param);
3815
3816 while (subparam != NULL) {
3817 const gchar *name = (const gchar *) subparam->name;
3818
3819 if (!ews_get_response_status (subparam, error))
3820 return FALSE;
3821
3822 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "FindItemResponseMessage")) {
3823 ESoapParameter *node, *subparam1;
3824 gchar *last;
3825 EEwsItem *item;
3826 gboolean includes_last_item;
3827
3828 node = e_soap_parameter_get_first_child_by_name (subparam, "RootFolder");
3829 last = e_soap_parameter_get_property (node, "IncludesLastItemInRange");
3830 /*
3831 * Set the includes_last_item to TRUE as default.
3832 * It can avoid an infinite loop in caller, when, for some reason,
3833 * we don't receive the last_tag property from the server.
3834 */
3835 includes_last_item = g_strcmp0 (last, "false") != 0;
3836 g_free (last);
3837
3838 node = e_soap_parameter_get_first_child_by_name (node, "Items");
3839 for (subparam1 = e_soap_parameter_get_first_child (node);
3840 subparam1; subparam1 = e_soap_parameter_get_next_child (subparam1)) {
3841 item = e_ews_item_new_from_soap_parameter (subparam1);
3842 if (item)
3843 *out_items = g_slist_prepend (*out_items, item);
3844 }
3845
3846 if (out_includes_last_item)
3847 *out_includes_last_item = includes_last_item;
3848 }
3849
3850 subparam = e_soap_parameter_get_next_child (subparam);
3851 }
3852
3853 return TRUE;
3854 }
3855
3856 gboolean
3857 e_ews_connection_find_folder_items_sync (EEwsConnection *cnc,
3858 gint pri,
3859 EwsFolderId *fid,
3860 const gchar *default_props,
3861 const EEwsAdditionalProps *add_props,
3862 EwsSortOrder *sort_order,
3863 const gchar *query,
3864 GPtrArray *only_ids, /* element-type utf8 */
3865 EEwsFolderType type,
3866 gboolean *out_includes_last_item,
3867 GSList **out_items,
3868 EwsConvertQueryCallback convert_query_cb,
3869 GCancellable *cancellable,
3870 GError **error)
3871 {
3872 ESoapRequest *request;
3873 ESoapResponse *response;
3874 gboolean success;
3875
3876 g_return_val_if_fail (cnc != NULL, FALSE);
3877 g_return_val_if_fail (out_items != NULL, FALSE);
3878
3879 *out_items = NULL;
3880
3881 request = e_ews_request_new_with_header (
3882 cnc->priv->uri,
3883 cnc->priv->impersonate_user,
3884 "FindItem",
3885 "Traversal",
3886 "Shallow",
3887 cnc->priv->version,
3888 E_EWS_EXCHANGE_2007_SP1,
3889 FALSE,
3890 error);
3891
3892 if (!request)
3893 return FALSE;
3894
3895 e_soap_request_start_element (request, "ItemShape", "messages", NULL);
3896 e_ews_request_write_string_parameter (request, "BaseShape", NULL, default_props);
3897
3898 ews_append_additional_props_to_msg (request, add_props);
3899
3900 e_soap_request_end_element (request);
3901
3902 /*write restriction message based on query*/
3903 if (convert_query_cb) {
3904 e_soap_request_start_element (request, "Restriction", "messages", NULL);
3905
3906 if (only_ids && only_ids->len) {
3907 e_soap_request_start_element (request, "And", "messages", NULL);
3908 e_soap_request_start_element (request, "Or", "messages", NULL);
3909 ews_connection_write_only_ids_restriction (request, only_ids);
3910 e_soap_request_end_element (request); /* Or */
3911 }
3912
3913 convert_query_cb (request, query, type);
3914
3915 if (only_ids && only_ids->len)
3916 e_soap_request_end_element (request); /* And */
3917
3918 e_soap_request_end_element (request); /* Restriction */
3919 } else if (only_ids && only_ids->len) {
3920 e_soap_request_start_element (request, "Restriction", "messages", NULL);
3921 ews_connection_write_only_ids_restriction (request, only_ids);
3922 e_soap_request_end_element (request);
3923 }
3924
3925 if (sort_order)
3926 ews_write_sort_order_to_msg (request, sort_order);
3927
3928 e_soap_request_start_element (request, "ParentFolderIds", "messages", NULL);
3929
3930 if (fid->is_distinguished_id)
3931 e_ews_request_write_string_parameter_with_attribute (request, "DistinguishedFolderId", NULL, NULL, "Id", fid->id);
3932 else
3933 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", fid->id);
3934
3935 e_soap_request_end_element (request);
3936
3937 e_ews_request_write_footer (request);
3938
3939 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
3940
3941 if (!response) {
3942 g_clear_object (&request);
3943 return FALSE;
3944 }
3945
3946 success = e_ews_process_find_folder_items_response (cnc, response, out_includes_last_item, out_items, error);
3947
3948 g_clear_object (&request);
3949 g_clear_object (&response);
3950
3951 if (success) {
3952 *out_items = g_slist_reverse (*out_items);
3953 } else {
3954 g_slist_free_full (*out_items, g_object_unref);
3955 *out_items = NULL;
3956 }
3957
3958 return success;
3959 }
3960
3961 static gboolean
3962 e_ews_process_sync_hierarchy_response (EEwsConnection *cnc,
3963 ESoapResponse *response,
3964 gchar **out_new_sync_state,
3965 gboolean *out_includes_last_item,
3966 GSList **out_items_created,
3967 GSList **out_items_updated,
3968 GSList **out_items_deleted,
3969 GError **error)
3970 {
3971 ESoapParameter *param;
3972 ESoapParameter *subparam;
3973 GError *local_error = NULL;
3974
3975 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
3976
3977 /* Sanity check */
3978 g_return_val_if_fail (
3979 (param != NULL && local_error == NULL) ||
3980 (param == NULL && local_error != NULL), FALSE);
3981
3982 if (local_error != NULL) {
3983 g_propagate_error (error, local_error);
3984 return FALSE;
3985 }
3986
3987 subparam = e_soap_parameter_get_first_child (param);
3988
3989 while (subparam != NULL) {
3990 const gchar *name = (const gchar *) subparam->name;
3991
3992 if (!ews_get_response_status (subparam, error))
3993 return FALSE;
3994
3995 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "SyncFolderHierarchyResponseMessage")) {
3996 e_ews_process_sync_xxx_response (subparam, (ItemParser) e_ews_folder_new_from_soap_parameter,
3997 "IncludesLastFolderInRange", "FolderId",
3998 out_new_sync_state, out_includes_last_item, out_items_created, out_items_updated, out_items_deleted);
3999 }
4000
4001 subparam = e_soap_parameter_get_next_child (subparam);
4002 }
4003
4004 return TRUE;
4005 }
4006
4007 gboolean
4008 e_ews_connection_sync_folder_hierarchy_sync (EEwsConnection *cnc,
4009 gint pri,
4010 const gchar *old_sync_state,
4011 gchar **out_new_sync_state,
4012 gboolean *out_includes_last_folder,
4013 GSList **out_folders_created,
4014 GSList **out_folders_updated,
4015 GSList **out_folders_deleted,
4016 GCancellable *cancellable,
4017 GError **error)
4018 {
4019 ESoapRequest *request;
4020 ESoapResponse *response;
4021 gboolean success;
4022
4023 g_return_val_if_fail (cnc != NULL, FALSE);
4024
4025 request = e_ews_request_new_with_header (
4026 cnc->priv->uri,
4027 cnc->priv->impersonate_user,
4028 "SyncFolderHierarchy",
4029 NULL,
4030 NULL,
4031 cnc->priv->version,
4032 E_EWS_EXCHANGE_2007_SP1,
4033 FALSE,
4034 error);
4035
4036 if (!request)
4037 return FALSE;
4038
4039 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
4040 e_ews_request_write_string_parameter (request, "BaseShape", NULL, "AllProperties");
4041 e_soap_request_start_element (request, "AdditionalProperties", NULL, NULL);
4042 e_soap_request_start_element (request, "ExtendedFieldURI", NULL, NULL);
4043 e_soap_request_add_attribute (request, "PropertyTag", "4340", NULL, NULL); /* PidTagAttributeHidden */
4044 e_soap_request_add_attribute (request, "PropertyType", "Boolean", NULL, NULL);
4045 e_soap_request_end_element (request); /* ExtendedFieldURI */
4046 e_soap_request_end_element (request); /* AdditionalProperties */
4047 e_soap_request_end_element (request); /* FolderShape */
4048
4049 if (old_sync_state)
4050 e_ews_request_write_string_parameter (request, "SyncState", "messages", old_sync_state);
4051
4052 e_ews_request_write_footer (request);
4053
4054 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4055
4056 if (!response) {
4057 g_clear_object (&request);
4058 return FALSE;
4059 }
4060
4061 success = e_ews_process_sync_hierarchy_response (cnc, response, out_new_sync_state, out_includes_last_folder,
4062 out_folders_created, out_folders_updated, out_folders_deleted, error);
4063
4064 g_clear_object (&request);
4065 g_clear_object (&response);
4066
4067 return success;
4068 }
4069
4070 EEwsServerVersion
4071 e_ews_connection_get_server_version (EEwsConnection *cnc)
4072 {
4073 g_return_val_if_fail (cnc != NULL, E_EWS_EXCHANGE_UNKNOWN);
4074 g_return_val_if_fail (cnc->priv != NULL, E_EWS_EXCHANGE_UNKNOWN);
4075
4076 return cnc->priv->version;
4077 }
4078
4079 void
4080 e_ews_connection_set_server_version (EEwsConnection *cnc,
4081 EEwsServerVersion version)
4082 {
4083 g_return_if_fail (cnc != NULL);
4084 g_return_if_fail (cnc->priv != NULL);
4085
4086 if (cnc->priv->version != version)
4087 cnc->priv->version = version;
4088 }
4089
4090 void
4091 e_ews_connection_set_server_version_from_string (EEwsConnection *cnc,
4092 const gchar *version)
4093 {
4094 if (!version)
4095 cnc->priv->version = E_EWS_EXCHANGE_UNKNOWN;
4096 else if (g_strcmp0 (version, "Exchange2007") == 0)
4097 cnc->priv->version = E_EWS_EXCHANGE_2007;
4098 else if (g_strcmp0 (version, "Exchange2007_SP1") == 0 ||
4099 g_str_has_prefix (version, "Exchange2007"))
4100 cnc->priv->version = E_EWS_EXCHANGE_2007_SP1;
4101 else if (g_strcmp0 (version, "Exchange2010") == 0)
4102 cnc->priv->version = E_EWS_EXCHANGE_2010;
4103 else if (g_strcmp0 (version, "Exchange2010_SP1") == 0)
4104 cnc->priv->version = E_EWS_EXCHANGE_2010_SP1;
4105 else if (g_strcmp0 (version, "Exchange2010_SP2") == 0 ||
4106 g_str_has_prefix (version, "Exchange2010"))
4107 cnc->priv->version = E_EWS_EXCHANGE_2010_SP2;
4108 else
4109 cnc->priv->version = E_EWS_EXCHANGE_FUTURE;
4110 }
4111
4112 gboolean
4113 e_ews_connection_satisfies_server_version (EEwsConnection *cnc,
4114 EEwsServerVersion version)
4115 {
4116 g_return_val_if_fail (cnc != NULL, FALSE);
4117 g_return_val_if_fail (cnc->priv != NULL, FALSE);
4118
4119 /*
4120 * This test always will fail if, for some reason, we were not able to get the server version.
4121 * It occurrs intentionally because we don't want to call any function that expects an EWS
4122 * Server version higher than 2007 SP1 without be sure we using an EWS Server with version
4123 * 2007 SP1 or later.
4124 */
4125 return cnc->priv->version >= version;
4126 }
4127
4128 static gboolean
4129 e_ews_process_get_items_response (EEwsConnection *cnc,
4130 ESoapResponse *response,
4131 GSList **out_items,
4132 GError **error)
4133 {
4134 ESoapParameter *param;
4135 ESoapParameter *subparam;
4136 GError *local_error = NULL;
4137
4138 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
4139
4140 /* Sanity check */
4141 g_return_val_if_fail (
4142 (param != NULL && local_error == NULL) ||
4143 (param == NULL && local_error != NULL), FALSE);
4144
4145 if (local_error) {
4146 g_propagate_error (error, local_error);
4147 return FALSE;
4148 }
4149
4150 subparam = e_soap_parameter_get_first_child (param);
4151
4152 while (subparam != NULL) {
4153 const gchar *name = (const gchar *) subparam->name;
4154
4155 if (g_str_has_suffix (name, "ResponseMessage")) {
4156 ESoapParameter *node;
4157 EEwsItem *item;
4158
4159 if (ews_get_response_status (subparam, &local_error))
4160 local_error = NULL;
4161
4162 for (node = e_soap_parameter_get_first_child_by_name (subparam, "Items");
4163 node;
4164 node = e_soap_parameter_get_next_child_by_name (subparam, "Items")) {
4165 if (node->children)
4166 item = e_ews_item_new_from_soap_parameter (node);
4167 else
4168 item = NULL;
4169 if (!item && local_error != NULL)
4170 item = e_ews_item_new_from_error (local_error);
4171 if (item)
4172 *out_items = g_slist_prepend (*out_items, item);
4173 }
4174 } else {
4175 g_warning ("%s: Unexpected element <%s>", G_STRFUNC, name);
4176 }
4177
4178 /* Do not stop on errors. */
4179 g_clear_error (&local_error);
4180
4181 subparam = e_soap_parameter_get_next_child (subparam);
4182 }
4183
4184 /* if there is only one item, then check whether it's an error */
4185 if (*out_items && (*out_items)->data && !(*out_items)->next) {
4186 EEwsItem *item = (*out_items)->data;
4187
4188 if (item && e_ews_item_get_item_type (item) == E_EWS_ITEM_TYPE_ERROR) {
4189 g_propagate_error (error, g_error_copy (e_ews_item_get_error (item)));
4190
4191 g_slist_free_full (*out_items, g_object_unref);
4192 *out_items = NULL;
4193
4194 return FALSE;
4195 }
4196 }
4197
4198 *out_items = g_slist_reverse (*out_items);
4199
4200 return TRUE;
4201 }
4202
4203 gboolean
4204 e_ews_connection_get_items_sync (EEwsConnection *cnc,
4205 gint pri,
4206 const GSList *ids,
4207 const gchar *default_props,
4208 const EEwsAdditionalProps *add_props,
4209 gboolean include_mime,
4210 const gchar *mime_directory,
4211 EEwsBodyType body_type,
4212 GSList **out_items,
4213 ESoapResponseProgressFn progress_fn,
4214 gpointer progress_data,
4215 GCancellable *cancellable,
4216 GError **error)
4217 {
4218 ESoapRequest *request;
4219 ESoapResponse *response;
4220 const GSList *link;
4221 gboolean success;
4222
4223 g_return_val_if_fail (cnc != NULL, FALSE);
4224 g_return_val_if_fail (out_items != NULL, FALSE);
4225
4226 *out_items = NULL;
4227
4228 request = e_ews_request_new_with_header (
4229 cnc->priv->uri,
4230 cnc->priv->impersonate_user,
4231 "GetItem",
4232 NULL,
4233 NULL,
4234 cnc->priv->version,
4235 E_EWS_EXCHANGE_2007_SP1,
4236 FALSE,
4237 error);
4238
4239 if (!request)
4240 return FALSE;
4241
4242 if (progress_fn && progress_data)
4243 e_soap_request_set_progress_fn (request, progress_fn, progress_data);
4244
4245 e_soap_request_start_element (request, "ItemShape", "messages", NULL);
4246 e_ews_request_write_string_parameter (request, "BaseShape", NULL, default_props);
4247
4248 if (include_mime)
4249 e_ews_request_write_string_parameter (request, "IncludeMimeContent", NULL, "true");
4250 else
4251 e_ews_request_write_string_parameter (request, "IncludeMimeContent", NULL, "false");
4252 if (mime_directory)
4253 e_soap_request_set_store_node_data (request, "MimeContent", mime_directory, TRUE);
4254
4255 switch (body_type) {
4256 case E_EWS_BODY_TYPE_BEST:
4257 e_ews_request_write_string_parameter (request, "BodyType", NULL, "Best");
4258 break;
4259 case E_EWS_BODY_TYPE_HTML:
4260 e_ews_request_write_string_parameter (request, "BodyType", NULL, "HTML");
4261 break;
4262 case E_EWS_BODY_TYPE_TEXT:
4263 e_ews_request_write_string_parameter (request, "BodyType", NULL, "Text");
4264 break;
4265 case E_EWS_BODY_TYPE_ANY:
4266 break;
4267 }
4268
4269 ews_append_additional_props_to_msg (request, add_props);
4270
4271 e_soap_request_end_element (request);
4272
4273 e_soap_request_start_element (request, "ItemIds", "messages", NULL);
4274
4275 for (link = ids; link; link = g_slist_next (link)) {
4276 e_ews_request_write_string_parameter_with_attribute (request, "ItemId", NULL, NULL, "Id", link->data);
4277 }
4278
4279 e_soap_request_end_element (request);
4280
4281 e_ews_request_write_footer (request);
4282
4283 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4284
4285 if (!response) {
4286 g_clear_object (&request);
4287 return FALSE;
4288 }
4289
4290 success = e_ews_process_get_items_response (cnc, response, out_items, error);
4291
4292 g_clear_object (&request);
4293 g_clear_object (&response);
4294
4295 if (!success) {
4296 g_slist_free_full (*out_items, g_object_unref);
4297 *out_items = NULL;
4298 }
4299
4300 return success;
4301 }
4302
4303 static const gchar *
4304 ews_delete_type_to_str (EwsDeleteType delete_type)
4305 {
4306 switch (delete_type) {
4307 case EWS_HARD_DELETE:
4308 return "HardDelete";
4309 case EWS_SOFT_DELETE:
4310 return "SoftDelete";
4311 case EWS_MOVE_TO_DELETED_ITEMS:
4312 return "MoveToDeletedItems";
4313 }
4314 return NULL;
4315 }
4316
4317 static const gchar *
4318 ews_send_cancels_to_str (EwsSendMeetingCancellationsType send_cancels)
4319 {
4320 switch (send_cancels) {
4321 case EWS_SEND_TO_NONE:
4322 return "SendToNone";
4323 case EWS_SEND_ONLY_TO_ALL:
4324 return "SendOnlyToAll";
4325 case EWS_SEND_TO_ALL_AND_SAVE_COPY:
4326 return "SendToAllAndSaveCopy";
4327 }
4328 return NULL;
4329 }
4330
4331 static const gchar *
4332 ews_affected_tasks_to_str (EwsAffectedTaskOccurrencesType affected_tasks)
4333 {
4334 switch (affected_tasks) {
4335 case EWS_NONE_OCCURRENCES:
4336 return NULL;
4337 case EWS_ALL_OCCURRENCES:
4338 return "AllOccurrences";
4339 case EWS_SPECIFIED_OCCURRENCE_ONLY:
4340 return "SpecifiedOccurrenceOnly";
4341 }
4342 return NULL;
4343 }
4344
4345 gboolean
4346 e_ews_connection_delete_items_sync (EEwsConnection *cnc,
4347 gint pri,
4348 const GSList *ids,
4349 EwsDeleteType delete_type,
4350 EwsSendMeetingCancellationsType send_cancels,
4351 EwsAffectedTaskOccurrencesType affected_tasks,
4352 GCancellable *cancellable,
4353 GError **error)
4354 {
4355 ESoapRequest *request;
4356 ESoapResponse *response;
4357 const GSList *link;
4358 gboolean success;
4359
4360 g_return_val_if_fail (cnc != NULL, FALSE);
4361
4362 request = e_ews_request_new_with_header (
4363 cnc->priv->uri,
4364 cnc->priv->impersonate_user,
4365 "DeleteItem",
4366 "DeleteType",
4367 ews_delete_type_to_str (delete_type),
4368 cnc->priv->version,
4369 E_EWS_EXCHANGE_2007_SP1,
4370 FALSE,
4371 error);
4372
4373 if (!request)
4374 return FALSE;
4375
4376 if (send_cancels)
4377 e_soap_request_add_attribute (request, "SendMeetingCancellations",
4378 ews_send_cancels_to_str (send_cancels), NULL, NULL);
4379
4380 if (affected_tasks)
4381 e_soap_request_add_attribute (request, "AffectedTaskOccurrences",
4382 ews_affected_tasks_to_str (affected_tasks), NULL, NULL);
4383
4384 e_soap_request_start_element (request, "ItemIds", "messages", NULL);
4385
4386 for (link = ids; link; link = g_slist_next (link)) {
4387 e_ews_request_write_string_parameter_with_attribute (request, "ItemId", NULL, NULL, "Id", link->data);
4388 }
4389
4390 e_soap_request_end_element (request);
4391
4392 e_ews_request_write_footer (request);
4393
4394 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4395
4396 if (!response) {
4397 g_clear_object (&request);
4398 return FALSE;
4399 }
4400
4401 success = e_ews_process_generic_response (cnc, response, error);
4402
4403 g_clear_object (&request);
4404 g_clear_object (&response);
4405
4406 return success;
4407 }
4408
4409 gboolean
4410 e_ews_connection_delete_item_sync (EEwsConnection *cnc,
4411 gint pri,
4412 EwsId *id,
4413 guint index,
4414 EwsDeleteType delete_type,
4415 EwsSendMeetingCancellationsType send_cancels,
4416 EwsAffectedTaskOccurrencesType affected_tasks,
4417 GCancellable *cancellable,
4418 GError **error)
4419 {
4420 ESoapRequest *request;
4421 ESoapResponse *response;
4422 gchar buffer[32];
4423 gboolean success;
4424
4425 g_return_val_if_fail (cnc != NULL, FALSE);
4426 g_return_val_if_fail (id != NULL, FALSE);
4427
4428 request = e_ews_request_new_with_header (
4429 cnc->priv->uri,
4430 cnc->priv->impersonate_user,
4431 "DeleteItem",
4432 "DeleteType",
4433 ews_delete_type_to_str (delete_type),
4434 cnc->priv->version,
4435 E_EWS_EXCHANGE_2007_SP1,
4436 FALSE,
4437 error);
4438
4439 if (!request)
4440 return FALSE;
4441
4442 if (send_cancels)
4443 e_soap_request_add_attribute (request, "SendMeetingCancellations",
4444 ews_send_cancels_to_str (send_cancels), NULL, NULL);
4445
4446 if (affected_tasks != EWS_NONE_OCCURRENCES)
4447 e_soap_request_add_attribute (request, "AffectedTaskOccurrences",
4448 ews_affected_tasks_to_str (affected_tasks), NULL, NULL);
4449
4450 e_soap_request_start_element (request, "ItemIds", "messages", NULL);
4451
4452 if (index) {
4453 e_soap_request_start_element (request, "OccurrenceItemId", NULL, NULL);
4454 e_soap_request_add_attribute (request, "RecurringMasterId", id->id, NULL, NULL);
4455 if (id->change_key)
4456 e_soap_request_add_attribute (request, "ChangeKey", id->change_key, NULL, NULL);
4457 snprintf (buffer, 32, "%u", index);
4458 e_soap_request_add_attribute (request, "InstanceIndex", buffer, NULL, NULL);
4459 e_soap_request_end_element (request);
4460 } else {
4461 e_soap_request_start_element (request, "ItemId", NULL, NULL);
4462 e_soap_request_add_attribute (request, "Id", id->id, NULL, NULL);
4463 if (id->change_key)
4464 e_soap_request_add_attribute (request, "ChangeKey", id->change_key, NULL, NULL);
4465 e_soap_request_end_element (request);
4466 }
4467
4468 e_soap_request_end_element (request);
4469
4470 e_ews_request_write_footer (request);
4471
4472 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4473
4474 if (!response) {
4475 g_clear_object (&request);
4476 return FALSE;
4477 }
4478
4479 success = e_ews_process_generic_response (cnc, response, error);
4480
4481 g_clear_object (&request);
4482 g_clear_object (&response);
4483
4484 return success;
4485 }
4486
4487 gboolean
4488 e_ews_connection_delete_items_in_chunks_sync (EEwsConnection *cnc,
4489 gint pri,
4490 const GSList *ids,
4491 EwsDeleteType delete_type,
4492 EwsSendMeetingCancellationsType send_cancels,
4493 EwsAffectedTaskOccurrencesType affected_tasks,
4494 GCancellable *cancellable,
4495 GError **error)
4496 {
4497 const GSList *iter;
4498 guint total_ids = 0, done_ids = 0;
4499 gboolean success = TRUE;
4500
4501 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
4502
4503 g_object_ref (cnc);
4504
4505 iter = ids;
4506
4507 while (success && iter) {
4508 guint n_ids;
4509 const GSList *tmp_iter;
4510
4511 for (tmp_iter = iter, n_ids = 0; tmp_iter && n_ids < EWS_MOVE_ITEMS_CHUNK_SIZE; tmp_iter = g_slist_next (tmp_iter), n_ids++) {
4512 /* Only check bounds first, to avoid unnecessary allocations */
4513 }
4514
4515 if (tmp_iter) {
4516 GSList *shorter = NULL;
4517
4518 if (total_ids == 0)
4519 total_ids = g_slist_length ((GSList *) ids);
4520
4521 for (n_ids = 0; iter && n_ids < EWS_MOVE_ITEMS_CHUNK_SIZE; iter = g_slist_next (iter), n_ids++) {
4522 shorter = g_slist_prepend (shorter, iter->data);
4523 }
4524
4525 shorter = g_slist_reverse (shorter);
4526
4527 success = e_ews_connection_delete_items_sync (cnc, pri, shorter, delete_type, send_cancels,
4528 affected_tasks, cancellable, error);
4529
4530 g_slist_free (shorter);
4531
4532 done_ids += n_ids;
4533 } else {
4534 success = e_ews_connection_delete_items_sync (cnc, pri, iter, delete_type, send_cancels,
4535 affected_tasks, cancellable, error);
4536
4537 iter = NULL;
4538 done_ids = total_ids;
4539 }
4540
4541 if (total_ids > 0)
4542 camel_operation_progress (cancellable, 100 * (gdouble) done_ids / (gdouble) total_ids);
4543 }
4544
4545 g_object_unref (cnc);
4546
4547 return success;
4548 }
4549
4550 static xmlXPathObjectPtr
4551 xpath_eval (xmlXPathContextPtr ctx,
4552 const gchar *format,
4553 ...)
4554 {
4555 xmlXPathObjectPtr result;
4556 va_list args;
4557 gchar *expr;
4558
4559 if (ctx == NULL)
4560 return NULL;
4561
4562 va_start (args, format);
4563 expr = g_strdup_vprintf (format, args);
4564 va_end (args);
4565
4566 result = xmlXPathEvalExpression ((xmlChar *) expr, ctx);
4567 g_free (expr);
4568
4569 if (result == NULL)
4570 return NULL;
4571
4572 if (result->type == XPATH_NODESET && xmlXPathNodeSetIsEmpty (result->nodesetval)) {
4573 xmlXPathFreeObject (result);
4574 return NULL;
4575 }
4576
4577 return result;
4578 }
4579
4580 static gboolean
4581 element_has_child (ESoapRequest *request,
4582 const gchar *path)
4583 {
4584 xmlDocPtr doc;
4585 xmlXPathContextPtr xpctx;
4586 xmlXPathObjectPtr result;
4587 xmlNodeSetPtr nodeset;
4588 xmlNodePtr node;
4589 gboolean ret = FALSE;
4590
4591 doc = e_soap_request_get_xml_doc (request);
4592 xpctx = xmlXPathNewContext (doc);
4593
4594 xmlXPathRegisterNs (
4595 xpctx,
4596 (xmlChar *) "s",
4597 (xmlChar *) "http://schemas.xmlsoap.org/soap/envelope/");
4598
4599 xmlXPathRegisterNs (
4600 xpctx,
4601 (xmlChar *) "m",
4602 (xmlChar *) "http://schemas.microsoft.com/exchange/services/2006/messages");
4603
4604 xmlXPathRegisterNs (
4605 xpctx,
4606 (xmlChar *) "t",
4607 (xmlChar *) "http://schemas.microsoft.com/exchange/services/2006/types");
4608
4609 result = xpath_eval (xpctx, path);
4610
4611 if (result == NULL)
4612 goto exit;
4613
4614 if (!xmlXPathNodeSetGetLength (result->nodesetval))
4615 goto exit;
4616
4617 nodeset = result->nodesetval;
4618 node = nodeset->nodeTab[0];
4619 if (!node->children)
4620 goto exit;
4621
4622 ret = TRUE;
4623
4624 exit:
4625 xmlXPathFreeObject (result);
4626 xmlXPathFreeContext (xpctx);
4627 return ret;
4628 }
4629
4630 gboolean
4631 e_ews_connection_update_items_sync (EEwsConnection *cnc,
4632 gint pri,
4633 const gchar *conflict_res,
4634 const gchar *msg_disposition,
4635 const gchar *send_invites,
4636 const gchar *folder_id,
4637 EEwsRequestCreationCallback create_cb,
4638 gpointer create_user_data,
4639 GSList **out_items,
4640 GCancellable *cancellable,
4641 GError **error)
4642 {
4643 ESoapRequest *request;
4644 ESoapResponse *response;
4645 GSList *items = NULL;
4646 gboolean success;
4647
4648 g_return_val_if_fail (cnc != NULL, FALSE);
4649
4650 request = e_ews_request_new_with_header (
4651 cnc->priv->uri,
4652 cnc->priv->impersonate_user,
4653 "UpdateItem",
4654 NULL,
4655 NULL,
4656 cnc->priv->version,
4657 E_EWS_EXCHANGE_2007_SP1,
4658 FALSE,
4659 error);
4660
4661 if (!request)
4662 return FALSE;
4663
4664 if (conflict_res)
4665 e_soap_request_add_attribute (request, "ConflictResolution", conflict_res, NULL, NULL);
4666 if (msg_disposition)
4667 e_soap_request_add_attribute (request, "MessageDisposition", msg_disposition, NULL, NULL);
4668 if (send_invites)
4669 e_soap_request_add_attribute (request, "SendMeetingInvitationsOrCancellations", send_invites, NULL, NULL);
4670
4671 if (folder_id) {
4672 e_soap_request_start_element (request, "SavedItemFolderId", "messages", NULL);
4673 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", folder_id);
4674 e_soap_request_end_element (request);
4675 }
4676
4677 e_soap_request_start_element (request, "ItemChanges", "messages", NULL);
4678
4679 if (!create_cb (request, create_user_data, error)) {
4680 g_clear_object (&request);
4681 return FALSE;
4682 }
4683
4684 e_soap_request_end_element (request); /* ItemChanges */
4685
4686 e_ews_request_write_footer (request);
4687
4688 /*
4689 * We need to check for both namespaces, because, the message is being wrote without use the types
4690 * namespace. Maybe it is wrong, but the server doesn't complain about that. But this is the reason
4691 * for the first check. The second one, is related to "how it should be" accord with EWS specifications.
4692 */
4693 if (!element_has_child (request, "/s:Envelope/s:Body/m:UpdateItem/m:ItemChanges/ItemChange/Updates") &&
4694 !element_has_child (request, "/s:Envelope/s:Body/m:UpdateItem/m:ItemChanges/t:ItemChange/t:Updates")) {
4695 g_clear_object (&request);
4696 return TRUE;
4697 }
4698
4699 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4700
4701 if (!response) {
4702 g_clear_object (&request);
4703 return FALSE;
4704 }
4705
4706 success = e_ews_process_get_items_response (cnc, response, &items, error);
4707
4708 g_clear_object (&request);
4709 g_clear_object (&response);
4710
4711 if (success && out_items)
4712 *out_items = items;
4713 else
4714 g_slist_free_full (items, g_object_unref);
4715
4716 return success;
4717 }
4718
4719 gboolean
4720 e_ews_connection_create_items_sync (EEwsConnection *cnc,
4721 gint pri,
4722 const gchar *msg_disposition,
4723 const gchar *send_invites,
4724 const EwsFolderId *fid,
4725 EEwsRequestCreationCallback create_cb,
4726 gpointer create_user_data,
4727 GSList **out_items,
4728 GCancellable *cancellable,
4729 GError **error)
4730 {
4731 ESoapRequest *request;
4732 ESoapResponse *response;
4733 GSList *items = NULL;
4734 gboolean success;
4735
4736 g_return_val_if_fail (cnc != NULL, FALSE);
4737
4738 request = e_ews_request_new_with_header (
4739 cnc->priv->uri,
4740 cnc->priv->impersonate_user,
4741 "CreateItem",
4742 NULL,
4743 NULL,
4744 cnc->priv->version,
4745 E_EWS_EXCHANGE_2007_SP1,
4746 FALSE,
4747 error);
4748
4749 if (!request)
4750 return FALSE;
4751
4752 if (msg_disposition)
4753 e_soap_request_add_attribute (request, "MessageDisposition", msg_disposition, NULL, NULL);
4754 if (send_invites)
4755 e_soap_request_add_attribute (request, "SendMeetingInvitations", send_invites, NULL, NULL);
4756
4757 if (fid) {
4758 e_soap_request_start_element (request, "SavedItemFolderId", "messages", NULL);
4759 e_ews_folder_id_append_to_request (request, cnc->priv->email, fid);
4760 e_soap_request_end_element (request);
4761 }
4762
4763 e_soap_request_start_element (request, "Items", "messages", NULL);
4764
4765 if (!create_cb (request, create_user_data, error)) {
4766 g_clear_object (&request);
4767 return FALSE;
4768 }
4769
4770 e_soap_request_end_element (request); /* Items */
4771
4772 e_ews_request_write_footer (request);
4773
4774 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4775
4776 if (!response) {
4777 g_clear_object (&request);
4778 return FALSE;
4779 }
4780
4781 success = e_ews_process_get_items_response (cnc, response, &items, error);
4782
4783 g_clear_object (&request);
4784 g_clear_object (&response);
4785
4786 if (success && out_items)
4787 *out_items = items;
4788 else
4789 g_slist_free_full (items, g_object_unref);
4790
4791 return success;
4792 }
4793
4794 static const gchar *
4795 get_search_scope_str (EwsContactsSearchScope scope)
4796 {
4797 switch (scope) {
4798 case EWS_SEARCH_AD:
4799 return "ActiveDirectory";
4800 case EWS_SEARCH_AD_CONTACTS:
4801 return "ActiveDirectoryContacts";
4802 case EWS_SEARCH_CONTACTS:
4803 return "Contacts";
4804 case EWS_SEARCH_CONTACTS_AD:
4805 return "ContactsActiveDirectory";
4806 default:
4807 g_warn_if_reached ();
4808 return NULL;
4809
4810 }
4811 }
4812
4813 static gboolean
4814 e_ews_process_resolve_names_response (EEwsConnection *cnc,
4815 ESoapResponse *response,
4816 gboolean *out_includes_last_item,
4817 GSList **out_mailboxes,
4818 GSList **out_contact_items,
4819 GError **error)
4820 {
4821 ESoapParameter *param;
4822 ESoapParameter *subparam;
4823 GError *local_error = NULL;
4824
4825 *out_includes_last_item = TRUE;
4826 *out_contact_items = NULL;
4827 *out_mailboxes = NULL;
4828
4829 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
4830
4831 /* Sanity check */
4832 g_return_val_if_fail (
4833 (param != NULL && local_error == NULL) ||
4834 (param == NULL && local_error != NULL), FALSE);
4835
4836 if (local_error != NULL) {
4837 g_propagate_error (error, local_error);
4838 return FALSE;
4839 }
4840
4841 subparam = e_soap_parameter_get_first_child (param);
4842
4843 while (subparam != NULL) {
4844 const gchar *name = (const gchar *) subparam->name;
4845
4846 if (!ews_get_response_status (subparam, error)) {
4847 return FALSE;
4848 }
4849
4850 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "ResolveNamesResponseMessage")) {
4851 ESoapParameter *node;
4852 gchar *prop;
4853
4854 subparam = e_soap_parameter_get_first_child_by_name (subparam, "ResolutionSet");
4855 prop = e_soap_parameter_get_property (subparam, "IncludesLastItemInRange");
4856 /*
4857 * Set the includes_last_item to TRUE as default.
4858 * It can avoid an infinite loop in caller, when, for some reason,
4859 * we don't receive the last_tag property from the server.
4860 */
4861 *out_includes_last_item = g_strcmp0 (prop, "false") != 0;
4862 g_free (prop);
4863
4864 for (subparam = e_soap_parameter_get_first_child_by_name (subparam, "Resolution");
4865 subparam != NULL;
4866 subparam = e_soap_parameter_get_next_child_by_name (subparam, "Resolution")) {
4867 EwsMailbox *mb;
4868
4869 node = e_soap_parameter_get_first_child_by_name (subparam, "Mailbox");
4870 mb = e_ews_item_mailbox_from_soap_param (node);
4871 if (mb) {
4872 EEwsItem *contact_item;
4873
4874 *out_mailboxes = g_slist_prepend (*out_mailboxes, mb);
4875
4876 /* 'mailboxes' and 'contact_items' match 1:1, but if the contact information
4877 * wasn't found, then NULL is stored in the corresponding position */
4878 node = e_soap_parameter_get_first_child_by_name (subparam, "Contact");
4879 if (node) {
4880 contact_item = e_ews_item_new_from_soap_parameter (node);
4881 *out_contact_items = g_slist_prepend (*out_contact_items, contact_item);
4882 } else {
4883 *out_contact_items = g_slist_prepend (*out_contact_items, NULL);
4884 }
4885 }
4886 }
4887
4888 break;
4889 }
4890
4891 subparam = e_soap_parameter_get_next_child (subparam);
4892 }
4893
4894 return TRUE;
4895 }
4896
4897 gboolean
4898 e_ews_connection_resolve_names_sync (EEwsConnection *cnc,
4899 gint pri,
4900 const gchar *resolve_name,
4901 EwsContactsSearchScope scope,
4902 GSList *parent_folder_ids,
4903 gboolean fetch_contact_data,
4904 gboolean *out_includes_last_item,
4905 GSList **out_mailboxes,
4906 GSList **out_contact_items,
4907 GCancellable *cancellable,
4908 GError **error)
4909 {
4910 ESoapRequest *request;
4911 ESoapResponse *response;
4912 gboolean includes_last_item = TRUE;
4913 GSList *mailboxes = NULL, *contact_items = NULL;
4914 gboolean success;
4915
4916 g_return_val_if_fail (cnc != NULL, FALSE);
4917
4918 request = e_ews_request_new_with_header (
4919 cnc->priv->uri,
4920 cnc->priv->impersonate_user,
4921 "ResolveNames",
4922 NULL,
4923 NULL,
4924 cnc->priv->version,
4925 E_EWS_EXCHANGE_2007_SP1,
4926 FALSE,
4927 error);
4928
4929 if (!request)
4930 return FALSE;
4931
4932 e_soap_request_add_attribute (request, "SearchScope", get_search_scope_str (scope), NULL, NULL);
4933
4934 if (fetch_contact_data) {
4935 e_soap_request_add_attribute (request, "ReturnFullContactData", "true", NULL, NULL);
4936
4937 if (e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2010_SP2))
4938 e_soap_request_add_attribute (request, "ContactDataShape", "AllProperties", NULL, NULL);
4939 } else {
4940 e_soap_request_add_attribute (request, "ReturnFullContactData", "false", NULL, NULL);
4941 }
4942
4943 if (parent_folder_ids) {
4944 e_soap_request_start_element (request, "ParentFolderIds", "messages", NULL);
4945 ews_append_folder_ids_to_msg (request, cnc->priv->email, parent_folder_ids);
4946 e_soap_request_end_element (request);
4947 }
4948
4949 e_ews_request_write_string_parameter (request, "UnresolvedEntry", "messages", resolve_name);
4950
4951 e_ews_request_write_footer (request);
4952
4953 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
4954
4955 if (!response) {
4956 g_clear_object (&request);
4957 return FALSE;
4958 }
4959
4960 success = e_ews_process_resolve_names_response (cnc, response, &includes_last_item, &mailboxes, &contact_items, error);
4961
4962 g_clear_object (&request);
4963 g_clear_object (&response);
4964
4965 if (success && out_includes_last_item)
4966 *out_includes_last_item = includes_last_item;
4967
4968 if (success && out_mailboxes)
4969 *out_mailboxes = g_slist_reverse (mailboxes);
4970 else
4971 g_slist_free_full (mailboxes, (GDestroyNotify) e_ews_mailbox_free);
4972
4973 if (success && out_contact_items)
4974 *out_contact_items = g_slist_reverse (contact_items);
4975 else
4976 e_util_free_nullable_object_slist (contact_items);
4977
4978 return success;
4979 }
4980
4981 static void
4982 ews_connection_resolve_by_name (EEwsConnection *cnc,
4983 gint pri,
4984 const gchar *usename,
4985 gboolean is_user_name,
4986 gchar **smtp_address,
4987 GCancellable *cancellable)
4988 {
4989 GSList *mailboxes = NULL;
4990 GSList *contacts = NULL;
4991 gboolean includes_last_item = FALSE;
4992 GSList *miter;
4993 gint len;
4994
4995 g_return_if_fail (cnc != NULL);
4996 g_return_if_fail (usename != NULL);
4997 g_return_if_fail (smtp_address != NULL);
4998
4999 if (!*usename)
5000 return;
5001
5002 len = strlen (usename);
5003 mailboxes = NULL;
5004 contacts = NULL;
5005
5006 /* use the first error, not the guess-part error */
5007 e_ews_connection_resolve_names_sync (
5008 cnc, pri, usename,
5009 EWS_SEARCH_AD_CONTACTS, NULL, TRUE, &includes_last_item, &mailboxes, &contacts,
5010 cancellable, NULL);
5011
5012 for (miter = mailboxes; miter; miter = miter->next) {
5013 const EwsMailbox *mailbox = miter->data;
5014 if (mailbox->email && *mailbox->email && g_strcmp0 (mailbox->routing_type, "EX") != 0
5015 && ((!is_user_name && g_str_has_prefix (mailbox->email, usename) && mailbox->email[len] == '@') ||
5016 (is_user_name && g_str_equal (usename, mailbox->name)))) {
5017 *smtp_address = g_strdup (mailbox->email);
5018 break;
5019 } else if (contacts && !contacts->next && contacts->data &&
5020 e_ews_item_get_item_type (contacts->data) == E_EWS_ITEM_TYPE_CONTACT) {
5021 EEwsItem *contact_item = contacts->data;
5022 GHashTable *addresses_hash = e_ews_item_get_email_addresses (contact_item);
5023 GList *emails = addresses_hash ? g_hash_table_get_values (addresses_hash) : NULL, *iter;
5024 const gchar *display_name;
5025 gboolean found = FALSE;
5026
5027 display_name = e_ews_item_get_display_name (contact_item);
5028 if (!display_name || !*display_name)
5029 display_name = e_ews_item_get_fileas (contact_item);
5030
5031 for (iter = emails; iter && !found; iter = iter->next) {
5032 const gchar *it_email = iter->data;
5033
5034 if (it_email && g_str_has_prefix (it_email, "SMTP:")
5035 && ((!is_user_name && g_str_has_prefix (it_email, usename) && it_email[len] == '@') ||
5036 (is_user_name && display_name && g_str_equal (usename, display_name)))) {
5037 found = TRUE;
5038 break;
5039 }
5040 }
5041
5042 g_list_free (emails);
5043
5044 if (found) {
5045 gint ii;
5046
5047 for (ii = 0; ii < g_hash_table_size (addresses_hash); ii++) {
5048 gchar *key, *value;
5049
5050 key = g_strdup_printf ("EmailAddress%d", ii + 1);
5051 value = g_hash_table_lookup (addresses_hash, key);
5052 g_free (key);
5053
5054 if (value && g_str_has_prefix (value, "SMTP:")) {
5055 /* pick the first available SMTP address */
5056 *smtp_address = g_strdup (value + 5);
5057 break;
5058 }
5059 }
5060 break;
5061 }
5062 }
5063 }
5064
5065 g_slist_free_full (mailboxes, (GDestroyNotify) e_ews_mailbox_free);
5066 e_util_free_nullable_object_slist (contacts);
5067 }
5068
5069 gboolean
5070 e_ews_connection_ex_to_smtp_sync (EEwsConnection *cnc,
5071 gint pri,
5072 const gchar *name,
5073 const gchar *ex_address,
5074 gchar **smtp_address,
5075 GCancellable *cancellable,
5076 GError **error)
5077 {
5078 GSList *mailboxes = NULL;
5079 GSList *contacts = NULL;
5080 gboolean includes_last_item = FALSE;
5081
5082 g_return_val_if_fail (cnc != NULL, FALSE);
5083 g_return_val_if_fail (ex_address != NULL, FALSE);
5084 g_return_val_if_fail (smtp_address != NULL, FALSE);
5085
5086 *smtp_address = NULL;
5087
5088 e_ews_connection_resolve_names_sync (
5089 cnc, pri, ex_address,
5090 EWS_SEARCH_AD_CONTACTS, NULL, TRUE, &includes_last_item, &mailboxes, &contacts,
5091 cancellable, error);
5092
5093 /* only one mailbox matches */
5094 if (mailboxes && !mailboxes->next && mailboxes->data) {
5095 const EwsMailbox *mailbox = mailboxes->data;
5096 if (mailbox->email && *mailbox->email && g_strcmp0 (mailbox->routing_type, "EX") != 0) {
5097 *smtp_address = g_strdup (mailbox->email);
5098 } else if (contacts && !contacts->next && contacts->data &&
5099 e_ews_item_get_item_type (contacts->data) == E_EWS_ITEM_TYPE_CONTACT) {
5100 EEwsItem *contact_item = contacts->data;
5101 GHashTable *addresses = e_ews_item_get_email_addresses (contact_item);
5102 gint ii;
5103
5104 for (ii = 0; ii < (addresses ? g_hash_table_size (addresses) : 0); ii++) {
5105 gchar *key, *value;
5106
5107 key = g_strdup_printf ("EmailAddress%d", ii + 1);
5108 value = g_hash_table_lookup (addresses, key);
5109 g_free (key);
5110
5111 if (value && g_str_has_prefix (value, "SMTP:")) {
5112 /* pick the first available SMTP address */
5113 *smtp_address = g_strdup (value + 5);
5114 break;
5115 }
5116 }
5117 }
5118 }
5119
5120 g_slist_free_full (mailboxes, (GDestroyNotify) e_ews_mailbox_free);
5121 e_util_free_nullable_object_slist (contacts);
5122
5123 if (!*smtp_address) {
5124 const gchar *usename;
5125
5126 usename = strrchr (ex_address, '/');
5127 if (usename && g_ascii_strncasecmp (usename, "/cn=", 4) == 0) {
5128 usename += 4;
5129
5130 /* try to guess from common name of the EX address */
5131 ews_connection_resolve_by_name (cnc, pri, usename, FALSE, smtp_address, cancellable);
5132 }
5133
5134 if (!*smtp_address && name && *name) {
5135 /* try to guess from mailbox name */
5136 ews_connection_resolve_by_name (cnc, pri, name, TRUE, smtp_address, cancellable);
5137 }
5138 }
5139
5140 if (*smtp_address)
5141 g_clear_error (error);
5142
5143 return *smtp_address != NULL;
5144 }
5145
5146 static gboolean
5147 e_ews_process_expand_dl_response (EEwsConnection *cnc,
5148 ESoapResponse *response,
5149 gboolean *out_includes_last_item,
5150 GSList **out_mailboxes,
5151 GError **error)
5152 {
5153 ESoapParameter *param;
5154 ESoapParameter *subparam;
5155 GError *local_error = NULL;
5156
5157 *out_includes_last_item = TRUE;
5158 *out_mailboxes = NULL;
5159
5160 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
5161
5162 /* Sanity check */
5163 g_return_val_if_fail (
5164 (param != NULL && local_error == NULL) ||
5165 (param == NULL && local_error != NULL), FALSE);
5166
5167 if (local_error) {
5168 g_propagate_error (error, local_error);
5169 return FALSE;
5170 }
5171
5172 subparam = e_soap_parameter_get_first_child (param);
5173
5174 while (subparam != NULL) {
5175 const gchar *name = (const gchar *) subparam->name;
5176
5177 if (!ews_get_response_status (subparam, error))
5178 return FALSE;
5179
5180 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "ExpandDLResponseMessage")) {
5181 gchar *prop;
5182
5183 subparam = e_soap_parameter_get_first_child_by_name (subparam, "DLExpansion");
5184 prop = e_soap_parameter_get_property (subparam, "IncludesLastItemInRange");
5185 /*
5186 * Set the includes_last_item to TRUE as default.
5187 * It can avoid an infinite loop in caller, when, for some reason,
5188 * we don't receive the last_tag property from the server.
5189 */
5190 *out_includes_last_item = g_strcmp0 (prop, "false") != 0;
5191 g_free (prop);
5192
5193 for (subparam = e_soap_parameter_get_first_child_by_name (subparam, "Mailbox");
5194 subparam != NULL;
5195 subparam = e_soap_parameter_get_next_child_by_name (subparam, "Mailbox")) {
5196 EwsMailbox *mb;
5197
5198 mb = e_ews_item_mailbox_from_soap_param (subparam);
5199 if (mb)
5200 *out_mailboxes = g_slist_prepend (*out_mailboxes, mb);
5201 }
5202
5203 break;
5204 }
5205
5206 subparam = e_soap_parameter_get_next_child (subparam);
5207 }
5208
5209 return TRUE;
5210 }
5211
5212 gboolean
5213 e_ews_connection_expand_dl_sync (EEwsConnection *cnc,
5214 gint pri,
5215 const EwsMailbox *mb,
5216 gboolean *out_includes_last_item,
5217 GSList **out_mailboxes,
5218 GCancellable *cancellable,
5219 GError **error)
5220 {
5221 ESoapRequest *request;
5222 ESoapResponse *response;
5223 gboolean includes_last_item = TRUE;
5224 GSList *mailboxes = NULL;
5225 gboolean success;
5226
5227 g_return_val_if_fail (cnc != NULL, FALSE);
5228
5229 request = e_ews_request_new_with_header (
5230 cnc->priv->uri,
5231 cnc->priv->impersonate_user,
5232 "ExpandDL",
5233 NULL,
5234 NULL,
5235 cnc->priv->version,
5236 E_EWS_EXCHANGE_2007_SP1,
5237 FALSE,
5238 error);
5239
5240 if (!request)
5241 return FALSE;
5242
5243 e_soap_request_start_element (request, "Mailbox", "messages", NULL);
5244
5245 if (mb->item_id) {
5246 e_soap_request_start_element (request, "ItemId", NULL, NULL);
5247
5248 e_soap_request_add_attribute (request, "Id", mb->item_id->id, NULL, NULL);
5249 e_soap_request_add_attribute (request, "ChangeKey", mb->item_id->change_key, NULL, NULL);
5250
5251 e_soap_request_end_element (request); /* Mailbox */
5252
5253 } else if (mb->email)
5254 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, mb->email);
5255
5256 e_soap_request_end_element (request); /* Mailbox */
5257
5258 e_ews_request_write_footer (request);
5259
5260 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5261
5262 if (!response) {
5263 g_clear_object (&request);
5264 return FALSE;
5265 }
5266
5267 success = e_ews_process_expand_dl_response (cnc, response, &includes_last_item, &mailboxes, error);
5268
5269 g_clear_object (&request);
5270 g_clear_object (&response);
5271
5272 if (success && out_includes_last_item)
5273 *out_includes_last_item = includes_last_item;
5274
5275 if (success && out_mailboxes)
5276 *out_mailboxes = g_slist_reverse (mailboxes);
5277 else
5278 g_slist_free_full (mailboxes, (GDestroyNotify) e_ews_mailbox_free);
5279
5280 return success;
5281 }
5282
5283 gboolean
5284 e_ews_connection_update_folder_sync (EEwsConnection *cnc,
5285 gint pri,
5286 EEwsRequestCreationCallback create_cb,
5287 gpointer create_user_data,
5288 GCancellable *cancellable,
5289 GError **error)
5290 {
5291 ESoapRequest *request;
5292 ESoapResponse *response;
5293 gboolean success;
5294
5295 g_return_val_if_fail (cnc != NULL, FALSE);
5296 g_return_val_if_fail (create_cb != NULL, FALSE);
5297
5298 request = e_ews_request_new_with_header (
5299 cnc->priv->uri,
5300 cnc->priv->impersonate_user,
5301 "UpdateFolder",
5302 NULL,
5303 NULL,
5304 cnc->priv->version,
5305 E_EWS_EXCHANGE_2007_SP1,
5306 FALSE,
5307 error);
5308
5309 if (!request)
5310 return FALSE;
5311
5312 e_soap_request_start_element (request, "FolderChanges", "messages", NULL);
5313
5314 if (!create_cb (request, create_user_data, error)) {
5315 g_clear_object (&request);
5316 return FALSE;
5317 }
5318
5319 e_soap_request_end_element (request); /* FolderChanges */
5320
5321 e_ews_request_write_footer (request);
5322
5323 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5324
5325 if (!response) {
5326 g_clear_object (&request);
5327 return FALSE;
5328 }
5329
5330 success = e_ews_process_generic_response (cnc, response, error);
5331
5332 g_clear_object (&request);
5333 g_clear_object (&response);
5334
5335 return success;
5336 }
5337
5338 gboolean
5339 e_ews_connection_move_folder_sync (EEwsConnection *cnc,
5340 gint pri,
5341 const gchar *to_folder,
5342 const gchar *folder,
5343 GCancellable *cancellable,
5344 GError **error)
5345 {
5346 ESoapRequest *request;
5347 ESoapResponse *response;
5348 gboolean success;
5349
5350 g_return_val_if_fail (cnc != NULL, FALSE);
5351
5352 request = e_ews_request_new_with_header (
5353 cnc->priv->uri,
5354 cnc->priv->impersonate_user,
5355 "MoveFolder",
5356 NULL,
5357 NULL,
5358 cnc->priv->version,
5359 E_EWS_EXCHANGE_2007_SP1,
5360 FALSE,
5361 error);
5362
5363 if (!request)
5364 return FALSE;
5365
5366 e_soap_request_start_element (request, "ToFolderId", "messages", NULL);
5367 if (to_folder)
5368 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", to_folder);
5369 else
5370 e_ews_request_write_string_parameter_with_attribute (request, "DistinguishedFolderId", NULL, NULL, "Id", "msgfolderroot");
5371
5372 e_soap_request_end_element (request);
5373
5374 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
5375 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", folder);
5376 e_soap_request_end_element (request);
5377
5378 e_ews_request_write_footer (request);
5379
5380 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5381
5382 if (!response) {
5383 g_clear_object (&request);
5384 return FALSE;
5385 }
5386
5387 success = e_ews_process_generic_response (cnc, response, error);
5388
5389 g_clear_object (&request);
5390 g_clear_object (&response);
5391
5392 return success;
5393 }
5394
5395 static gboolean
5396 e_ews_process_get_folder_response (EEwsConnection *cnc,
5397 ESoapResponse *response,
5398 GSList **out_folders, /* EEwsFolder * */
5399 GError **error)
5400 {
5401 ESoapParameter *param;
5402 ESoapParameter *subparam;
5403 GError *local_error = NULL;
5404
5405 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
5406
5407 /* Sanity check */
5408 g_return_val_if_fail (
5409 (param != NULL && local_error == NULL) ||
5410 (param == NULL && local_error != NULL), FALSE);
5411
5412 if (local_error != NULL) {
5413 g_propagate_error (error, local_error);
5414 return FALSE;
5415 }
5416
5417 subparam = e_soap_parameter_get_first_child (param);
5418
5419 while (subparam != NULL) {
5420 const gchar *name = (const gchar *) subparam->name;
5421
5422 if (!ews_get_response_status (subparam, &local_error)) {
5423 if (g_strcmp0 (name, "GetFolderResponseMessage") == 0) {
5424 if (out_folders)
5425 *out_folders = g_slist_prepend (*out_folders, e_ews_folder_new_from_error (local_error));
5426 g_clear_error (&local_error);
5427 } else {
5428 g_propagate_error (error, local_error);
5429 return FALSE;
5430 }
5431 } else if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "GetFolderResponseMessage") && out_folders) {
5432 ESoapParameter *node;
5433 EEwsFolder *folder;
5434
5435 for (node = e_soap_parameter_get_first_child_by_name (subparam, "Folders");
5436 node;
5437 node = e_soap_parameter_get_next_child_by_name (subparam, "Folders")) {
5438 folder = e_ews_folder_new_from_soap_parameter (node);
5439 if (!folder)
5440 continue;
5441 *out_folders = g_slist_prepend (*out_folders, folder);
5442 }
5443 }
5444
5445 subparam = e_soap_parameter_get_next_child (subparam);
5446 }
5447
5448 return TRUE;
5449 }
5450
5451 gboolean
5452 e_ews_connection_get_folder_sync (EEwsConnection *cnc,
5453 gint pri,
5454 const gchar *folder_shape,
5455 const EEwsAdditionalProps *add_props,
5456 GSList *folder_ids,
5457 GSList **out_folders,
5458 GCancellable *cancellable,
5459 GError **error)
5460 {
5461 ESoapRequest *request;
5462 ESoapResponse *response;
5463 gboolean success;
5464
5465 g_return_val_if_fail (cnc != NULL, FALSE);
5466
5467 request = e_ews_request_new_with_header (
5468 cnc->priv->uri,
5469 cnc->priv->impersonate_user,
5470 "GetFolder",
5471 NULL,
5472 NULL,
5473 cnc->priv->version,
5474 E_EWS_EXCHANGE_2007_SP1,
5475 TRUE,
5476 error);
5477
5478 if (!request)
5479 return FALSE;
5480
5481 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
5482 e_ews_request_write_string_parameter (request, "BaseShape", NULL, folder_shape);
5483
5484 ews_append_additional_props_to_msg (request, add_props);
5485 e_soap_request_end_element (request);
5486
5487 if (folder_ids) {
5488 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
5489 ews_append_folder_ids_to_msg (request, cnc->priv->email, folder_ids);
5490 e_soap_request_end_element (request);
5491 }
5492
5493 e_ews_request_write_footer (request);
5494
5495 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5496
5497 if (!response) {
5498 g_clear_object (&request);
5499 return FALSE;
5500 }
5501
5502 if (out_folders)
5503 *out_folders = NULL;
5504
5505 success = e_ews_process_get_folder_response (cnc, response, out_folders, error);
5506
5507 g_clear_object (&request);
5508 g_clear_object (&response);
5509
5510 if (success && out_folders) {
5511 *out_folders = g_slist_reverse (*out_folders);
5512 } else if (out_folders) {
5513 g_slist_free_full (*out_folders, g_object_unref);
5514 *out_folders = NULL;
5515 }
5516
5517 return success;
5518 }
5519
5520 static gboolean
5521 e_ews_process_create_folder_response (EEwsConnection *cnc,
5522 ESoapResponse *response,
5523 EEwsFolderType folder_type,
5524 GSList **out_folder_ids, /* EwsFolderId * */
5525 GError **error)
5526 {
5527 ESoapParameter *param;
5528 ESoapParameter *subparam;
5529 GError *local_error = NULL;
5530
5531 *out_folder_ids = NULL;
5532
5533 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
5534
5535 /* Sanity check */
5536 g_return_val_if_fail (
5537 (param != NULL && local_error == NULL) ||
5538 (param == NULL && local_error != NULL), FALSE);
5539
5540 if (local_error) {
5541 g_propagate_error (error, local_error);
5542 return FALSE;
5543 }
5544
5545 subparam = e_soap_parameter_get_first_child (param);
5546
5547 while (subparam != NULL) {
5548 const gchar *name = (const gchar *) subparam->name;
5549
5550 if (!ews_get_response_status (subparam, error))
5551 return FALSE;
5552
5553 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "CreateFolderResponseMessage")) {
5554 ESoapParameter *node;
5555 EwsFolderId *fid = NULL;
5556 const gchar *folder_element;
5557
5558 switch (folder_type) {
5559 case E_EWS_FOLDER_TYPE_MAILBOX:
5560 case E_EWS_FOLDER_TYPE_MEMOS:
5561 folder_element = "Folder";
5562 break;
5563 case E_EWS_FOLDER_TYPE_CALENDAR:
5564 folder_element = "CalendarFolder";
5565 break;
5566 case E_EWS_FOLDER_TYPE_CONTACTS:
5567 folder_element = "ContactsFolder";
5568 break;
5569 case E_EWS_FOLDER_TYPE_SEARCH:
5570 folder_element = "SearchFolder";
5571 break;
5572 case E_EWS_FOLDER_TYPE_TASKS:
5573 folder_element = "TasksFolder";
5574 break;
5575 default:
5576 g_warn_if_reached ();
5577 folder_element = "Folder";
5578 break;
5579 }
5580
5581 node = e_soap_parameter_get_first_child_by_name (subparam, "Folders");
5582 node = e_soap_parameter_get_first_child_by_name (node, folder_element);
5583 param = e_soap_parameter_get_first_child_by_name (node, "FolderId");
5584
5585 fid = g_new0 (EwsFolderId, 1);
5586 fid->id = e_soap_parameter_get_property (param, "Id");
5587 fid->change_key = e_soap_parameter_get_property (param, "ChangeKey");
5588 *out_folder_ids = g_slist_prepend (*out_folder_ids, fid);
5589 }
5590
5591 subparam = e_soap_parameter_get_next_child (subparam);
5592 }
5593
5594 return *out_folder_ids != NULL;
5595 }
5596
5597 gboolean
5598 e_ews_connection_create_folder_sync (EEwsConnection *cnc,
5599 gint pri,
5600 const gchar *parent_folder_id,
5601 gboolean is_distinguished_id,
5602 const gchar *folder_name,
5603 EEwsFolderType folder_type,
5604 EwsFolderId **out_folder_id,
5605 GCancellable *cancellable,
5606 GError **error)
5607 {
5608 ESoapRequest *request;
5609 ESoapResponse *response;
5610 GSList *folder_ids = NULL;
5611 const gchar *folder_element;
5612 const gchar *folder_class = NULL;
5613 gboolean success;
5614
5615 g_return_val_if_fail (cnc != NULL, FALSE);
5616
5617 request = e_ews_request_new_with_header (
5618 cnc->priv->uri,
5619 cnc->priv->impersonate_user,
5620 "CreateFolder",
5621 NULL,
5622 NULL,
5623 cnc->priv->version,
5624 E_EWS_EXCHANGE_2007_SP1,
5625 FALSE,
5626 error);
5627
5628 if (!request)
5629 return FALSE;
5630
5631 e_soap_request_start_element (request, "ParentFolderId", "messages", NULL);
5632
5633 /* If NULL passed for parent_folder_id, use "msgfolderroot" */
5634 if (is_distinguished_id || !parent_folder_id) {
5635 e_soap_request_start_element (request, "DistinguishedFolderId", NULL, NULL);
5636 e_soap_request_add_attribute (request, "Id", parent_folder_id ? parent_folder_id : "msgfolderroot", NULL, NULL);
5637 if (is_distinguished_id && cnc->priv->email) {
5638 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
5639 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, cnc->priv->email);
5640 e_soap_request_end_element (request);
5641 }
5642 e_soap_request_end_element (request);
5643 } else {
5644 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", parent_folder_id);
5645 }
5646
5647 e_soap_request_end_element (request);
5648
5649 switch (folder_type) {
5650 default:
5651 g_warn_if_reached ();
5652 /* fall through */
5653 case E_EWS_FOLDER_TYPE_MAILBOX:
5654 folder_element = "Folder";
5655 folder_class = "IPF.Note";
5656 break;
5657 case E_EWS_FOLDER_TYPE_CALENDAR:
5658 folder_element = "CalendarFolder";
5659 break;
5660 case E_EWS_FOLDER_TYPE_CONTACTS:
5661 folder_element = "ContactsFolder";
5662 break;
5663 case E_EWS_FOLDER_TYPE_SEARCH:
5664 folder_element = "SearchFolder";
5665 break;
5666 case E_EWS_FOLDER_TYPE_TASKS:
5667 folder_element = "TasksFolder";
5668 break;
5669 case E_EWS_FOLDER_TYPE_MEMOS:
5670 folder_element = "Folder";
5671 folder_class = "IPF.StickyNote";
5672 break;
5673 }
5674
5675 e_soap_request_start_element (request, "Folders", "messages", NULL);
5676 e_soap_request_start_element (request, folder_element, NULL, NULL);
5677 if (folder_class)
5678 e_ews_request_write_string_parameter (request, "FolderClass", NULL, folder_class);
5679 e_ews_request_write_string_parameter (request, "DisplayName", NULL, folder_name);
5680
5681 e_soap_request_end_element (request);
5682 e_soap_request_end_element (request);
5683
5684 e_ews_request_write_footer (request);
5685
5686 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5687
5688 if (!response) {
5689 g_clear_object (&request);
5690 return FALSE;
5691 }
5692
5693 success = e_ews_process_create_folder_response (cnc, response, folder_type, &folder_ids, error);
5694
5695 g_clear_object (&request);
5696 g_clear_object (&response);
5697
5698 if (success) {
5699 folder_ids = g_slist_reverse (folder_ids);
5700 g_warn_if_fail (g_slist_length (folder_ids) <= 1);
5701
5702 if (out_folder_id)
5703 *out_folder_id = folder_ids ? folder_ids->data : NULL;
5704
5705 if (folder_ids && out_folder_id)
5706 folder_ids->data = NULL;
5707 }
5708
5709 g_slist_free_full (folder_ids, (GDestroyNotify) e_ews_folder_id_free);
5710
5711 return success;
5712 }
5713
5714 gboolean
5715 e_ews_connection_move_items_sync (EEwsConnection *cnc,
5716 gint pri,
5717 const gchar *folder_id,
5718 gboolean docopy,
5719 const GSList *ids,
5720 GSList **out_items,
5721 GCancellable *cancellable,
5722 GError **error)
5723 {
5724 ESoapRequest *request;
5725 ESoapResponse *response;
5726 const GSList *link;
5727 GSList *items = NULL;
5728 gboolean success;
5729
5730 g_return_val_if_fail (cnc != NULL, FALSE);
5731
5732 if (docopy)
5733 request = e_ews_request_new_with_header (
5734 cnc->priv->uri,
5735 cnc->priv->impersonate_user,
5736 "CopyItem",
5737 NULL,
5738 NULL,
5739 cnc->priv->version,
5740 E_EWS_EXCHANGE_2007_SP1,
5741 FALSE,
5742 error);
5743 else
5744 request = e_ews_request_new_with_header (
5745 cnc->priv->uri,
5746 cnc->priv->impersonate_user,
5747 "MoveItem",
5748 NULL,
5749 NULL,
5750 cnc->priv->version,
5751 E_EWS_EXCHANGE_2007_SP1,
5752 FALSE,
5753 error);
5754
5755 if (!request)
5756 return FALSE;
5757
5758 e_soap_request_start_element (request, "ToFolderId", "messages", NULL);
5759 e_soap_request_start_element (request, "FolderId", NULL, NULL);
5760 e_soap_request_add_attribute (request, "Id", folder_id, NULL, NULL);
5761 e_soap_request_end_element (request); /* FolderId */
5762 e_soap_request_end_element (request); /* ToFolderId */
5763
5764 e_soap_request_start_element (request, "ItemIds", "messages", NULL);
5765 for (link = ids; link; link = g_slist_next (link)) {
5766 e_ews_request_write_string_parameter_with_attribute (request, "ItemId", NULL, NULL, "Id", link->data);
5767 }
5768 e_soap_request_end_element (request); /* ItemIds */
5769
5770 e_ews_request_write_footer (request);
5771
5772 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5773
5774 if (!response) {
5775 g_clear_object (&request);
5776 return FALSE;
5777 }
5778
5779 success = e_ews_process_get_items_response (cnc, response, &items, error);
5780
5781 g_clear_object (&request);
5782 g_clear_object (&response);
5783
5784 if (success && out_items)
5785 *out_items = items;
5786 else
5787 g_slist_free_full (items, g_object_unref);
5788
5789 return success;
5790 }
5791
5792 gboolean
5793 e_ews_connection_move_items_in_chunks_sync (EEwsConnection *cnc,
5794 gint pri,
5795 const gchar *folder_id,
5796 gboolean docopy,
5797 const GSList *ids,
5798 GSList **items,
5799 GCancellable *cancellable,
5800 GError **error)
5801 {
5802 const GSList *iter;
5803 guint total_ids = 0, done_ids = 0;
5804 gboolean success = TRUE;
5805
5806 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
5807 g_return_val_if_fail (items != NULL, FALSE);
5808
5809 g_object_ref (cnc);
5810
5811 *items = NULL;
5812 iter = ids;
5813
5814 while (success && iter) {
5815 guint n_ids;
5816 const GSList *tmp_iter;
5817 GSList *processed_items = NULL;
5818
5819 for (tmp_iter = iter, n_ids = 0; tmp_iter && n_ids < EWS_MOVE_ITEMS_CHUNK_SIZE; tmp_iter = g_slist_next (tmp_iter), n_ids++) {
5820 /* Only check bounds first, to avoid unnecessary allocations */
5821 }
5822
5823 if (tmp_iter) {
5824 GSList *shorter = NULL;
5825
5826 if (total_ids == 0)
5827 total_ids = g_slist_length ((GSList *) ids);
5828
5829 for (n_ids = 0; iter && n_ids < EWS_MOVE_ITEMS_CHUNK_SIZE; iter = g_slist_next (iter), n_ids++) {
5830 shorter = g_slist_prepend (shorter, iter->data);
5831 }
5832
5833 shorter = g_slist_reverse (shorter);
5834
5835 success = e_ews_connection_move_items_sync (cnc, pri, folder_id, docopy,
5836 shorter, &processed_items, cancellable, error);
5837
5838 g_slist_free (shorter);
5839
5840 done_ids += n_ids;
5841 } else {
5842 success = e_ews_connection_move_items_sync (cnc, pri, folder_id, docopy,
5843 iter, &processed_items, cancellable, error);
5844
5845 iter = NULL;
5846 done_ids = total_ids;
5847 }
5848
5849 if (processed_items)
5850 *items = g_slist_concat (*items, processed_items);
5851
5852 if (total_ids > 0)
5853 camel_operation_progress (cancellable, 100 * (gdouble) done_ids / (gdouble) total_ids);
5854 }
5855
5856 g_object_unref (cnc);
5857
5858 return success;
5859 }
5860
5861 gboolean
5862 e_ews_connection_delete_folder_sync (EEwsConnection *cnc,
5863 gint pri,
5864 const gchar *folder_id,
5865 gboolean is_distinguished_id,
5866 const gchar *delete_type,
5867 GCancellable *cancellable,
5868 GError **error)
5869 {
5870 ESoapRequest *request;
5871 ESoapResponse *response;
5872 gboolean success;
5873
5874 g_return_val_if_fail (cnc != NULL, FALSE);
5875
5876 request = e_ews_request_new_with_header (
5877 cnc->priv->uri,
5878 cnc->priv->impersonate_user,
5879 "DeleteFolder",
5880 "DeleteType",
5881 delete_type,
5882 cnc->priv->version,
5883 E_EWS_EXCHANGE_2007_SP1,
5884 FALSE,
5885 error);
5886
5887 if (!request)
5888 return FALSE;
5889
5890 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
5891
5892 e_soap_request_start_element (request,
5893 is_distinguished_id ? "DistinguishedFolderId" : "FolderId",
5894 NULL,
5895 NULL);
5896 e_soap_request_add_attribute (request, "Id", folder_id, NULL, NULL);
5897
5898 /* This element is required for delegate access */
5899 if (is_distinguished_id && cnc->priv->email) {
5900 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
5901 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, cnc->priv->email);
5902 e_soap_request_end_element (request);
5903 }
5904
5905 e_soap_request_end_element (request); /* </DistinguishedFolderId> || </FolderId> */
5906
5907 e_soap_request_end_element (request); /* </FolderIds> */
5908
5909 e_ews_request_write_footer (request);
5910
5911 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5912
5913 if (!response) {
5914 g_clear_object (&request);
5915 return FALSE;
5916 }
5917
5918 success = e_ews_process_generic_response (cnc, response, error);
5919
5920 g_clear_object (&request);
5921 g_clear_object (&response);
5922
5923 return success;
5924 }
5925
5926 gboolean
5927 e_ews_connection_empty_folder_sync (EEwsConnection *cnc,
5928 gint pri,
5929 const gchar *folder_id,
5930 gboolean is_distinguished_id,
5931 const gchar *delete_type,
5932 gboolean delete_subfolders,
5933 GCancellable *cancellable,
5934 GError **error)
5935 {
5936 ESoapRequest *request;
5937 ESoapResponse *response;
5938 gboolean success;
5939
5940 g_return_val_if_fail (cnc != NULL, FALSE);
5941
5942 request = e_ews_request_new_with_header (
5943 cnc->priv->uri,
5944 cnc->priv->impersonate_user,
5945 "EmptyFolder",
5946 "DeleteType",
5947 delete_type,
5948 cnc->priv->version,
5949 E_EWS_EXCHANGE_2010,
5950 FALSE,
5951 error);
5952
5953 if (!request)
5954 return FALSE;
5955
5956 e_soap_request_add_attribute (request, "DeleteSubFolders", delete_subfolders ? "true" : "false", NULL, NULL);
5957
5958 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
5959
5960 e_soap_request_start_element (request,
5961 is_distinguished_id ? "DistinguishedFolderId" : "FolderId",
5962 NULL,
5963 NULL);
5964 e_soap_request_add_attribute (request, "Id", folder_id, NULL, NULL);
5965
5966 /* This element is required for delegate access */
5967 if (is_distinguished_id && cnc->priv->email) {
5968 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
5969 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, cnc->priv->email);
5970 e_soap_request_end_element (request);
5971 }
5972
5973 e_soap_request_end_element (request); /* </DistinguishedFolderId> || </FolderId> */
5974
5975 e_soap_request_end_element (request); /* </FolderIds> */
5976
5977 e_ews_request_write_footer (request);
5978
5979 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
5980
5981 if (!response) {
5982 g_clear_object (&request);
5983 return FALSE;
5984 }
5985
5986 success = e_ews_process_generic_response (cnc, response, error);
5987
5988 g_clear_object (&request);
5989 g_clear_object (&response);
5990
5991 return success;
5992 }
5993
5994 static gboolean
5995 e_ews_process_create_attachments_response (EEwsConnection *cnc,
5996 ESoapResponse *response,
5997 gchar **out_change_key,
5998 GSList **out_attachments_ids,
5999 GError **error)
6000 {
6001 ESoapParameter *param;
6002 ESoapParameter *subparam;
6003 GError *local_error = NULL;
6004
6005 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
6006
6007 /* Sanity check */
6008 g_return_val_if_fail (
6009 (param != NULL && local_error == NULL) ||
6010 (param == NULL && local_error != NULL), FALSE);
6011
6012 if (local_error) {
6013 g_propagate_error (error, local_error);
6014 return FALSE;
6015 }
6016
6017 subparam = e_soap_parameter_get_first_child (param);
6018
6019 while (subparam != NULL) {
6020 const gchar *name = (const gchar *) subparam->name;
6021
6022 if (!ews_get_response_status (subparam, error))
6023 return FALSE;
6024
6025 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "CreateAttachmentResponseMessage")) {
6026 /* http://msdn.microsoft.com/en-us/library/aa565877%28v=EXCHG.80%29.aspx */
6027 ESoapParameter *attsubparam, *attspara, *last_relevant = NULL, *attparam;
6028
6029 attspara = e_soap_parameter_get_first_child_by_name (param, "Attachments");
6030
6031 for (attsubparam = e_soap_parameter_get_first_child (attspara); attsubparam != NULL; attsubparam = e_soap_parameter_get_next_child (attsubparam)) {
6032 if (!g_ascii_strcasecmp (e_soap_parameter_get_name (attsubparam), "FileAttachment")) {
6033 attparam = e_soap_parameter_get_first_child (attsubparam);
6034 last_relevant = attparam;
6035
6036 if (out_attachments_ids)
6037 *out_attachments_ids = g_slist_prepend (*out_attachments_ids, e_soap_parameter_get_property (attparam, "Id"));
6038 }
6039 }
6040
6041 if (last_relevant != NULL && out_change_key) {
6042 g_free (*out_change_key);
6043 *out_change_key = e_soap_parameter_get_property (last_relevant, "RootItemChangeKey");
6044 }
6045 }
6046
6047 subparam = e_soap_parameter_get_next_child (subparam);
6048 }
6049
6050 return TRUE;
6051 }
6052
6053 static gboolean
6054 e_ews_connection_attach_file (ESoapRequest *request,
6055 EEwsAttachmentInfo *info,
6056 gboolean contact_photo,
6057 GError **error)
6058 {
6059 EEwsAttachmentInfoType type = e_ews_attachment_info_get_type (info);
6060 gchar *filename = NULL, *buffer = NULL;
6061 const gchar *content = NULL, *prefer_filename;
6062 gsize length;
6063
6064 switch (type) {
6065 case E_EWS_ATTACHMENT_INFO_TYPE_URI: {
6066 /* TODO - handle a situation where the file isnt accessible/other problem with it */
6067 /* TODO - This is a naive implementation that just uploads the whole content into */
6068 /* memory, ie very inefficient */
6069 const gchar *uri;
6070 gchar *filepath;
6071 GError *local_error = NULL;
6072
6073 uri = e_ews_attachment_info_get_uri (info);
6074
6075 /* convert uri to actual file path */
6076 filepath = g_filename_from_uri (uri, NULL, &local_error);
6077 if (local_error != NULL) {
6078 g_propagate_error (error, local_error);
6079 return FALSE;
6080 }
6081
6082 g_file_get_contents (filepath, &buffer, &length, &local_error);
6083 if (local_error != NULL) {
6084 g_free (filepath);
6085 g_propagate_error (error, local_error);
6086 return FALSE;
6087 }
6088
6089 content = buffer;
6090
6091 filename = strrchr (filepath, G_DIR_SEPARATOR);
6092 filename = filename ? g_strdup (++filename) : g_strdup (filepath);
6093
6094 g_free (filepath);
6095 break;
6096 }
6097 case E_EWS_ATTACHMENT_INFO_TYPE_INLINED:
6098 content = e_ews_attachment_info_get_inlined_data (info, &length);
6099 filename = g_strdup (e_ews_attachment_info_get_filename (info));
6100 break;
6101 default:
6102 g_warning ("Unknown EwsAttachmentInfoType %d", type);
6103 return FALSE;
6104 }
6105
6106 e_soap_request_start_element (request, "FileAttachment", NULL, NULL);
6107
6108 prefer_filename = e_ews_attachment_info_get_prefer_filename (info);
6109 e_ews_request_write_string_parameter (request, "Name", NULL, prefer_filename ? prefer_filename : filename);
6110 if (contact_photo)
6111 e_ews_request_write_string_parameter (request, "IsContactPhoto", NULL, "true");
6112 e_soap_request_start_element (request, "Content", NULL, NULL);
6113 e_soap_request_write_base64 (request, content, length);
6114 e_soap_request_end_element (request); /* "Content" */
6115 e_soap_request_end_element (request); /* "FileAttachment" */
6116
6117 g_free (filename);
6118 g_free (buffer);
6119
6120 return TRUE;
6121 }
6122
6123 gboolean
6124 e_ews_connection_create_attachments_sync (EEwsConnection *cnc,
6125 gint pri,
6126 const EwsId *parent,
6127 const GSList *files,
6128 gboolean is_contact_photo,
6129 gchar **out_change_key,
6130 GSList **out_attachments_ids,
6131 GCancellable *cancellable,
6132 GError **error)
6133 {
6134 ESoapRequest *request;
6135 ESoapResponse *response;
6136 const GSList *link;
6137 gboolean success;
6138
6139 g_return_val_if_fail (cnc != NULL, FALSE);
6140 g_return_val_if_fail (parent != NULL, FALSE);
6141
6142 if (out_change_key)
6143 *out_change_key = NULL;
6144
6145 if (out_attachments_ids)
6146 *out_attachments_ids = NULL;
6147
6148 request = e_ews_request_new_with_header (
6149 cnc->priv->uri,
6150 cnc->priv->impersonate_user,
6151 "CreateAttachment",
6152 NULL,
6153 NULL,
6154 cnc->priv->version,
6155 E_EWS_EXCHANGE_2007_SP1,
6156 FALSE,
6157 error);
6158
6159 if (!request)
6160 return FALSE;
6161
6162 e_soap_request_start_element (request, "ParentItemId", "messages", NULL);
6163 e_soap_request_add_attribute (request, "Id", parent->id, NULL, NULL);
6164 if (parent->change_key)
6165 e_soap_request_add_attribute (request, "ChangeKey", parent->change_key, NULL, NULL);
6166 e_soap_request_end_element (request);
6167
6168 /* start interation over all items to get the attachemnts */
6169 e_soap_request_start_element (request, "Attachments", "messages", NULL);
6170
6171 for (link = files; link; link = g_slist_next (link)) {
6172 if (!e_ews_connection_attach_file (request, link->data, is_contact_photo, error)) {
6173 g_clear_object (&request);
6174 return FALSE;
6175 }
6176 }
6177
6178 e_soap_request_end_element (request); /* "Attachments" */
6179
6180 e_ews_request_write_footer (request);
6181
6182 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
6183
6184 if (!response) {
6185 g_clear_object (&request);
6186 return FALSE;
6187 }
6188
6189 success = e_ews_process_create_attachments_response (cnc, response, out_change_key, out_attachments_ids, error);
6190
6191 g_clear_object (&request);
6192 g_clear_object (&response);
6193
6194 if (success) {
6195 if (out_attachments_ids)
6196 *out_attachments_ids = g_slist_reverse (*out_attachments_ids);
6197 } else {
6198 if (out_change_key)
6199 g_clear_pointer (out_change_key, g_free);
6200
6201 if (out_attachments_ids) {
6202 g_slist_free_full (*out_attachments_ids, g_free);
6203 *out_attachments_ids = NULL;
6204 }
6205 }
6206
6207 return success;
6208 }
6209
6210 static gboolean
6211 e_ews_process_delete_attachments_response (EEwsConnection *cnc,
6212 ESoapResponse *response,
6213 gchar **out_new_change_key,
6214 GError **error)
6215 {
6216 ESoapParameter *param;
6217 ESoapParameter *subparam;
6218 GError *local_error = NULL;
6219
6220 if (out_new_change_key)
6221 *out_new_change_key = NULL;
6222
6223 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
6224
6225 /* Sanity check */
6226 g_return_val_if_fail (
6227 (param != NULL && local_error == NULL) ||
6228 (param == NULL && local_error != NULL), FALSE);
6229
6230 if (local_error) {
6231 g_propagate_error (error, local_error);
6232 return FALSE;
6233 }
6234
6235 subparam = e_soap_parameter_get_first_child (param);
6236
6237 while (subparam != NULL) {
6238 const gchar *name = (const gchar *) subparam->name;
6239
6240 if (!ews_get_response_status (subparam, error))
6241 return FALSE;
6242
6243 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "DeleteAttachmentResponseMessage")) {
6244 /* http://msdn.microsoft.com/en-us/library/aa580782%28v=EXCHG.80%29.aspx */
6245 ESoapParameter *attspara;
6246
6247 attspara = e_soap_parameter_get_first_child_by_name (subparam, "RootItemId");
6248
6249 if (attspara != NULL && out_new_change_key)
6250 *out_new_change_key = e_soap_parameter_get_property (attspara, "RootItemChangeKey");
6251 }
6252
6253 subparam = e_soap_parameter_get_next_child (subparam);
6254 }
6255
6256 return TRUE;
6257 }
6258
6259 gboolean
6260 e_ews_connection_delete_attachments_sync (EEwsConnection *cnc,
6261 gint pri,
6262 const GSList *attachments_ids,
6263 gchar **out_new_change_key,
6264 GCancellable *cancellable,
6265 GError **error)
6266 {
6267 ESoapRequest *request;
6268 ESoapResponse *response;
6269 const GSList *link;
6270 gboolean success;
6271
6272 g_return_val_if_fail (cnc != NULL, FALSE);
6273
6274 request = e_ews_request_new_with_header (
6275 cnc->priv->uri,
6276 cnc->priv->impersonate_user,
6277 "DeleteAttachment",
6278 NULL,
6279 NULL,
6280 cnc->priv->version,
6281 E_EWS_EXCHANGE_2007_SP1,
6282 FALSE,
6283 error);
6284
6285 if (!request)
6286 return FALSE;
6287
6288 /* start interation over all items to get the attachemnts */
6289 e_soap_request_start_element (request, "AttachmentIds", "messages", NULL);
6290
6291 for (link = attachments_ids; link; link = g_slist_next (link)) {
6292 e_ews_request_write_string_parameter_with_attribute (request, "AttachmentId", NULL, NULL, "Id", link->data);
6293 }
6294
6295 e_soap_request_end_element (request); /* "AttachmentIds" */
6296
6297 e_ews_request_write_footer (request);
6298
6299 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
6300
6301 if (!response) {
6302 g_clear_object (&request);
6303 return FALSE;
6304 }
6305
6306 success = e_ews_process_delete_attachments_response (cnc, response, out_new_change_key, error);
6307
6308 g_clear_object (&request);
6309 g_clear_object (&response);
6310
6311 if (!success && out_new_change_key)
6312 g_clear_pointer (out_new_change_key, g_free);
6313
6314 return success;
6315 }
6316
6317 static gboolean
6318 e_ews_process_get_attachments_response (EEwsConnection *cnc,
6319 ESoapResponse *response,
6320 const gchar *uid,
6321 const gchar *cache_directory,
6322 GSList **out_attachments,
6323 GError **error)
6324 {
6325 ESoapParameter *param;
6326 ESoapParameter *subparam;
6327 GError *local_error = NULL;
6328
6329 if (out_attachments)
6330 *out_attachments = NULL;
6331
6332 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
6333
6334 /* Sanity check */
6335 g_return_val_if_fail (
6336 (param != NULL && local_error == NULL) ||
6337 (param == NULL && local_error != NULL), FALSE);
6338
6339 if (local_error) {
6340 g_propagate_error (error, local_error);
6341 return FALSE;
6342 }
6343
6344 subparam = e_soap_parameter_get_first_child (param);
6345
6346 while (subparam != NULL) {
6347 const gchar *name = (const gchar *) subparam->name;
6348
6349 if (!ews_get_response_status (subparam, error))
6350 return FALSE;
6351
6352 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "GetAttachmentResponseMessage") && out_attachments) {
6353 ESoapParameter *subattsparam, *attspara;
6354 EEwsAttachmentInfo *info = NULL;
6355 EEwsItem *item;
6356
6357 attspara = e_soap_parameter_get_first_child_by_name (subparam, "Attachments");
6358
6359 for (subattsparam = e_soap_parameter_get_first_child (attspara);
6360 subattsparam;
6361 subattsparam = e_soap_parameter_get_next_child (subattsparam)) {
6362 name = e_soap_parameter_get_name (subattsparam);
6363
6364 if (!g_ascii_strcasecmp (name, "ItemAttachment")) {
6365 item = e_ews_item_new_from_soap_parameter (subattsparam);
6366 info = e_ews_item_dump_mime_content (item, cache_directory);
6367 g_clear_object (&item);
6368 } else if (!g_ascii_strcasecmp (name, "FileAttachment")) {
6369 info = e_ews_dump_file_attachment_from_soap_parameter (subattsparam, cache_directory, uid);
6370 }
6371
6372 if (info)
6373 *out_attachments = g_slist_prepend (*out_attachments, info);
6374
6375 info = NULL;
6376 }
6377 }
6378
6379 subparam = e_soap_parameter_get_next_child (subparam);
6380 }
6381
6382 return TRUE;
6383 }
6384
6385 gboolean
6386 e_ews_connection_get_attachments_sync (EEwsConnection *cnc,
6387 gint pri,
6388 const gchar *uid,
6389 const GSList *ids,
6390 const gchar *cache_directory,
6391 gboolean include_mime,
6392 GSList **out_attachments,
6393 ESoapResponseProgressFn progress_fn,
6394 gpointer progress_data,
6395 GCancellable *cancellable,
6396 GError **error)
6397 {
6398 ESoapRequest *request;
6399 ESoapResponse *response;
6400 const GSList *link;
6401 gboolean success;
6402
6403 g_return_val_if_fail (cnc != NULL, FALSE);
6404 g_return_val_if_fail (out_attachments != NULL, FALSE);
6405
6406 *out_attachments = NULL;
6407
6408 request = e_ews_request_new_with_header (
6409 cnc->priv->uri,
6410 cnc->priv->impersonate_user,
6411 "GetAttachment",
6412 NULL,
6413 NULL,
6414 cnc->priv->version,
6415 E_EWS_EXCHANGE_2007_SP1,
6416 FALSE,
6417 error);
6418
6419 if (!request)
6420 return FALSE;
6421
6422 /* not sure why I need it, need to check */
6423 if (progress_fn && progress_data)
6424 e_soap_request_set_progress_fn (request, progress_fn, progress_data);
6425
6426 if (cache_directory)
6427 e_soap_request_set_store_node_data (request, "MimeContent Content", cache_directory, TRUE);
6428
6429 /* write empty attachments shape, need to discover maybe usefull in some cases */
6430 e_soap_request_start_element (request, "AttachmentShape", "messages", NULL);
6431 e_ews_request_write_string_parameter (request, "IncludeMimeContent", NULL, "true");
6432 e_soap_request_end_element (request);
6433
6434 /* start interation over all items to get the attachemnts */
6435 e_soap_request_start_element (request, "AttachmentIds", "messages", NULL);
6436
6437 for (link = ids; link; link = g_slist_next (link)) {
6438 e_ews_request_write_string_parameter_with_attribute (request, "AttachmentId", NULL, NULL, "Id", link->data);
6439 }
6440
6441 e_soap_request_end_element (request);
6442
6443 e_ews_request_write_footer (request);
6444
6445 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
6446
6447 if (!response) {
6448 g_clear_object (&request);
6449 return FALSE;
6450 }
6451
6452 success = e_ews_process_get_attachments_response (cnc, response, uid, cache_directory, out_attachments, error);
6453
6454 g_clear_object (&request);
6455 g_clear_object (&response);
6456
6457 if (out_attachments && success) {
6458 *out_attachments = g_slist_reverse (*out_attachments);
6459 } else if (out_attachments) {
6460 g_slist_free_full (*out_attachments, (GDestroyNotify) e_ews_attachment_info_free);
6461 *out_attachments = NULL;
6462 }
6463
6464 return success;
6465 }
6466
6467 static void
6468 ews_handle_free_busy_view (ESoapParameter *param,
6469 GSList **out_components)
6470 {
6471 /*parse the response to create a free_busy data
6472 http://msdn.microsoft.com / en - us / library / aa564001 % 28v = EXCHG.140 % 29.aspx */
6473 ICalComponent *vfb;
6474 ICalProperty *prop = NULL;
6475 ICalTimezone *utc_zone = i_cal_timezone_get_utc_timezone ();
6476 ESoapParameter *viewparam, *eventarray, *event_param, *subparam;
6477 GTimeVal t_val;
6478 const gchar *name;
6479 gchar *value, *new_val = NULL, *summary = NULL, *location = NULL, *id = NULL;
6480
6481 viewparam = e_soap_parameter_get_first_child_by_name (param, "FreeBusyView");
6482 if (!viewparam)
6483 return;
6484
6485 vfb = i_cal_component_new_vfreebusy ();
6486 eventarray = e_soap_parameter_get_first_child_by_name (viewparam, "CalendarEventArray");
6487 for (event_param = eventarray ? e_soap_parameter_get_first_child (eventarray) : NULL;
6488 event_param != NULL;
6489 event_param = e_soap_parameter_get_next_child (event_param)) {
6490 ICalPeriod *ipt;
6491 gboolean is_recurring = FALSE;
6492
6493 ipt = i_cal_period_new_null_period ();
6494
6495 for (subparam = e_soap_parameter_get_first_child (event_param); subparam != NULL; subparam = e_soap_parameter_get_next_child (subparam)) {
6496 name = e_soap_parameter_get_name (subparam);
6497
6498 if (!g_ascii_strcasecmp (name, "StartTime")) {
6499 ICalTime *itt;
6500
6501 value = e_soap_parameter_get_string_value (subparam);
6502 /*We are sending UTC timezone and expect server to return in same*/
6503
6504 /*Remove leading and trailing whitespace*/
6505 g_strstrip (value);
6506
6507 if (g_utf8_strlen (value, -1) == 19) {
6508 /*If server returns time without zone add Z to treat it in UTC*/
6509 new_val = g_strdup_printf ("%sZ", value);
6510 g_free (value);
6511 } else
6512 new_val = value;
6513
6514 g_time_val_from_iso8601 (new_val, &t_val);
6515 g_free (new_val);
6516
6517 itt = i_cal_time_new_from_timet_with_zone (t_val.tv_sec, 0, utc_zone);
6518 i_cal_period_set_start (ipt, itt);
6519 g_clear_object (&itt);
6520
6521 } else if (!g_ascii_strcasecmp (name, "EndTime")) {
6522 ICalTime *itt;
6523
6524 value = e_soap_parameter_get_string_value (subparam);
6525 /*We are sending UTC timezone and expect server to return in same*/
6526
6527 /*Remove leading and trailing whitespace*/
6528 g_strstrip (value);
6529
6530 if (g_utf8_strlen (value, -1) == 19) {
6531 /*If server returns time without zone add Z to treat it in UTC*/
6532 new_val = g_strdup_printf ("%sZ", value);
6533 g_free (value);
6534 } else
6535 new_val = value;
6536
6537 g_time_val_from_iso8601 (new_val, &t_val);
6538 g_free (new_val);
6539
6540 itt = i_cal_time_new_from_timet_with_zone (t_val.tv_sec, 0, utc_zone);
6541 i_cal_period_set_end (ipt, itt);
6542 g_clear_object (&itt);
6543
6544 prop = i_cal_property_new_freebusy (ipt);
6545 } else if (!g_ascii_strcasecmp (name, "BusyType")) {
6546 value = e_soap_parameter_get_string_value (subparam);
6547 if (!strcmp (value, "Busy"))
6548 i_cal_property_set_parameter_from_string (prop, "FBTYPE", "BUSY");
6549 else if (!strcmp (value, "Tentative"))
6550 i_cal_property_set_parameter_from_string (prop, "FBTYPE", "BUSY-TENTATIVE");
6551 else if (!strcmp (value, "OOF"))
6552 i_cal_property_set_parameter_from_string (prop, "FBTYPE", "BUSY-UNAVAILABLE");
6553 else if (!strcmp (value, "Free"))
6554 i_cal_property_set_parameter_from_string (prop, "FBTYPE", "FREE");
6555 g_free (value);
6556 } else if (!g_ascii_strcasecmp (name, "CalendarEventDetails")) {
6557 ESoapParameter *dparam;
6558
6559 dparam = e_soap_parameter_get_first_child_by_name (subparam, "ID");
6560 if (dparam) {
6561 g_clear_pointer (&id, g_free);
6562 id = e_soap_parameter_get_string_value (dparam);
6563 }
6564
6565 dparam = e_soap_parameter_get_first_child_by_name (subparam, "Subject");
6566 if (dparam) {
6567 g_clear_pointer (&summary, g_free);
6568 summary = e_soap_parameter_get_string_value (dparam);
6569 }
6570
6571 dparam = e_soap_parameter_get_first_child_by_name (subparam, "Location");
6572 if (dparam) {
6573 g_clear_pointer (&location, g_free);
6574 location = e_soap_parameter_get_string_value (dparam);
6575 }
6576
6577 dparam = e_soap_parameter_get_first_child_by_name (subparam, "IsRecurring");
6578 if (dparam) {
6579 value = e_soap_parameter_get_string_value (dparam);
6580 is_recurring = g_strcmp0 (value, "true") == 0;
6581 g_free (value);
6582 }
6583 }
6584 }
6585
6586 if (prop) {
6587 if (id) {
6588 /* Unique-ize the ID for the recurring events, otherwise the ID clashes when
6589 more items are from the same series/event. */
6590 if (is_recurring) {
6591 ICalTime *itt;
6592
6593 itt = i_cal_period_get_start (ipt);
6594 if (itt) {
6595 gchar *itt_str, *tmp;
6596
6597 itt_str = i_cal_time_as_ical_string (itt);
6598 tmp = g_strconcat (id, "-", itt_str, NULL);
6599
6600 g_free (id);
6601 g_free (itt_str);
6602
6603 id = tmp;
6604 }
6605 g_clear_object (&itt);
6606 }
6607
6608 i_cal_property_set_parameter_from_string (prop, "X-EWS-ID", id);
6609 }
6610 if (summary)
6611 i_cal_property_set_parameter_from_string (prop, "X-SUMMARY", summary);
6612 if (location)
6613 i_cal_property_set_parameter_from_string (prop, "X-LOCATION", location);
6614 i_cal_component_take_property (vfb, prop);
6615 prop = NULL;
6616 }
6617
6618 g_clear_pointer (&summary, g_free);
6619 g_clear_pointer (&location, g_free);
6620 g_clear_pointer (&id, g_free);
6621 g_clear_object (&ipt);
6622 }
6623
6624 *out_components = g_slist_prepend (*out_components, vfb);
6625 }
6626
6627 static gboolean
6628 e_ews_process_get_free_busy_response (EEwsConnection *cnc,
6629 ESoapResponse *response,
6630 GSList **out_components,
6631 GError **error)
6632 {
6633 ESoapParameter *param;
6634 ESoapParameter *subparam;
6635 GError *local_error = NULL;
6636
6637 param = e_soap_response_get_first_parameter_by_name (response, "FreeBusyResponseArray", &local_error);
6638
6639 /* Sanity check */
6640 g_return_val_if_fail (
6641 (param != NULL && local_error == NULL) ||
6642 (param == NULL && local_error != NULL), FALSE);
6643
6644 if (local_error) {
6645 g_propagate_error (error, local_error);
6646 return FALSE;
6647 }
6648
6649 subparam = e_soap_parameter_get_first_child (param);
6650
6651 while (subparam != NULL) {
6652 ESoapParameter *subsubparam;
6653
6654 subsubparam = e_soap_parameter_get_first_child_by_name (
6655 subparam, "ResponseMessage");
6656
6657 if (subsubparam) {
6658 if (!ews_get_response_status (subsubparam, error))
6659 return FALSE;
6660
6661 if (out_components)
6662 ews_handle_free_busy_view (subparam, out_components);
6663 }
6664
6665 subparam = e_soap_parameter_get_next_child (subparam);
6666 }
6667
6668 return TRUE;
6669 }
6670
6671 gboolean
6672 e_ews_connection_get_free_busy_sync (EEwsConnection *cnc,
6673 gint pri,
6674 EEwsRequestCreationCallback free_busy_cb,
6675 gpointer free_busy_user_data,
6676 GSList **out_free_busy, /* ICalComponent * */
6677 GCancellable *cancellable,
6678 GError **error)
6679 {
6680 ESoapRequest *request;
6681 ESoapResponse *response;
6682 gboolean success;
6683
6684 g_return_val_if_fail (cnc != NULL, FALSE);
6685 g_return_val_if_fail (out_free_busy != NULL, FALSE);
6686
6687 *out_free_busy = NULL;
6688
6689 request = e_ews_request_new_with_header (
6690 cnc->priv->uri,
6691 cnc->priv->impersonate_user,
6692 "GetUserAvailabilityRequest",
6693 NULL,
6694 NULL,
6695 cnc->priv->version,
6696 E_EWS_EXCHANGE_2007_SP1,
6697 FALSE,
6698 error);
6699
6700 if (!request)
6701 return FALSE;
6702
6703 if (!free_busy_cb (request, free_busy_user_data, error)) {
6704 g_clear_object (&request);
6705 return FALSE;
6706 }
6707
6708 e_ews_request_write_footer (request);
6709
6710 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
6711
6712 if (!response) {
6713 g_clear_object (&request);
6714 return FALSE;
6715 }
6716
6717 success = e_ews_process_get_free_busy_response (cnc, response, out_free_busy, error);
6718
6719 g_clear_object (&request);
6720 g_clear_object (&response);
6721
6722 if (success && out_free_busy) {
6723 *out_free_busy = g_slist_reverse (*out_free_busy);
6724 } else if (out_free_busy) {
6725 g_slist_free_full (*out_free_busy, g_object_unref);
6726 *out_free_busy = NULL;
6727 }
6728
6729 return success;
6730 }
6731
6732 static EwsPermissionLevel
6733 get_permission_from_string (const gchar *permission)
6734 {
6735 g_return_val_if_fail (permission != NULL, EwsPermissionLevel_Unknown);
6736
6737 if (!g_ascii_strcasecmp (permission, "Editor"))
6738 return EwsPermissionLevel_Editor;
6739 else if (!g_ascii_strcasecmp (permission, "Author"))
6740 return EwsPermissionLevel_Author;
6741 else if (!g_ascii_strcasecmp (permission, "Reviewer"))
6742 return EwsPermissionLevel_Reviewer;
6743 else if (!g_ascii_strcasecmp (permission, "Custom"))
6744 return EwsPermissionLevel_Custom;
6745 else
6746 return EwsPermissionLevel_None;
6747
6748 }
6749
6750 static void
6751 ews_handle_delegate_user_param (ESoapParameter *param,
6752 GSList **out_delegates)
6753 {
6754 ESoapParameter *subparam, *node, *child;
6755 EwsDelegateInfo *data;
6756 gchar *value;
6757
6758 node = e_soap_parameter_get_first_child_by_name (param, "DelegateUser");
6759 if (!node)
6760 return;
6761
6762 subparam = e_soap_parameter_get_first_child_by_name (node, "UserId");
6763 if (!subparam)
6764 return;
6765
6766 data = g_new0 (EwsDelegateInfo, 1);
6767 data->user_id = g_new0 (EwsUserId, 1);
6768
6769 /*Parse User Id*/
6770
6771 child = e_soap_parameter_get_first_child_by_name (subparam, "SID");
6772 data->user_id->sid = e_soap_parameter_get_string_value (child);
6773
6774 child = e_soap_parameter_get_first_child_by_name (subparam, "PrimarySmtpAddress");
6775 data->user_id->primary_smtp = e_soap_parameter_get_string_value (child);
6776
6777 child = e_soap_parameter_get_first_child_by_name (subparam, "DisplayName");
6778 data->user_id->display_name = e_soap_parameter_get_string_value (child);
6779
6780 subparam = e_soap_parameter_get_first_child_by_name (node, "DelegatePermissions");
6781
6782 /*Parse Delegate Permissions*/
6783 child = e_soap_parameter_get_first_child_by_name (subparam, "CalendarFolderPermissionLevel");
6784 if (child) {
6785 value = e_soap_parameter_get_string_value (child);
6786 data->calendar = get_permission_from_string (value);
6787 g_free (value);
6788 }
6789
6790 child = e_soap_parameter_get_first_child_by_name (subparam, "ContactsFolderPermissionLevel");
6791 if (child) {
6792 value = e_soap_parameter_get_string_value (child);
6793 data->contacts = get_permission_from_string (value);
6794 g_free (value);
6795 }
6796
6797 child = e_soap_parameter_get_first_child_by_name (subparam, "InboxFolderPermissionLevel");
6798 if (child) {
6799 value = e_soap_parameter_get_string_value (child);
6800 data->inbox = get_permission_from_string (value);
6801 g_free (value);
6802 }
6803
6804 child = e_soap_parameter_get_first_child_by_name (subparam, "TasksFolderPermissionLevel");
6805 if (child) {
6806 value = e_soap_parameter_get_string_value (child);
6807 data->tasks = get_permission_from_string (value);
6808 g_free (value);
6809 }
6810
6811 child = e_soap_parameter_get_first_child_by_name (subparam, "NotesFolderPermissionLevel");
6812 if (child) {
6813 value = e_soap_parameter_get_string_value (child);
6814 data->notes = get_permission_from_string (value);
6815 g_free (value);
6816 }
6817
6818 child = e_soap_parameter_get_first_child_by_name (subparam, "JournalFolderPermissionLevel");
6819 if (child) {
6820 value = e_soap_parameter_get_string_value (child);
6821 data->journal = get_permission_from_string (value);
6822 g_free (value);
6823 }
6824
6825 subparam = e_soap_parameter_get_first_child_by_name (node, "ReceiveCopiesOfMeetingMessages");
6826 if (subparam) {
6827 value = e_soap_parameter_get_string_value (subparam);
6828 data->meetingcopies = g_strcmp0 (value, "true") == 0;
6829 g_free (value);
6830 }
6831
6832 subparam = e_soap_parameter_get_first_child_by_name (node, "ViewPrivateItems");
6833 if (subparam) {
6834 value = e_soap_parameter_get_string_value (subparam);
6835 data->view_priv_items = g_strcmp0 (value, "true") == 0;
6836 g_free (value);
6837 }
6838
6839 *out_delegates = g_slist_prepend (*out_delegates, data);
6840 }
6841
6842 static gboolean
6843 e_ews_process_get_delegate_response (EEwsConnection *cnc,
6844 ESoapResponse *response,
6845 EwsDelegateDeliver *out_deliver_to,
6846 GSList **out_delegates,
6847 GError **error)
6848 {
6849 ESoapParameter *param;
6850 ESoapParameter *subparam;
6851 GError *local_error = NULL;
6852
6853 if (ews_get_response_status (e_soap_response_get_parameter (response), &local_error))
6854 param = e_soap_response_get_first_parameter_by_name (response, "DeliverMeetingRequests", &local_error);
6855 else
6856 param = NULL;
6857
6858 /* Sanity check */
6859 g_return_val_if_fail (
6860 (param != NULL && local_error == NULL) ||
6861 (param == NULL && local_error != NULL), FALSE);
6862
6863 if (local_error) {
6864 g_propagate_error (error, local_error);
6865 return FALSE;
6866 }
6867
6868 if (out_deliver_to) {
6869 gchar *value;
6870
6871 value = e_soap_parameter_get_string_value (param);
6872
6873 if (g_strcmp0 (value, "DelegatesOnly") == 0)
6874 *out_deliver_to = EwsDelegateDeliver_DelegatesOnly;
6875 else if (g_strcmp0 (value, "DelegatesAndMe") == 0)
6876 *out_deliver_to = EwsDelegateDeliver_DelegatesAndMe;
6877 else if (g_strcmp0 (value, "DelegatesAndSendInformationToMe") == 0)
6878 *out_deliver_to = EwsDelegateDeliver_DelegatesAndSendInformationToMe;
6879 else {
6880 g_message ("%s: Unknown deliver-to value '%s'", G_STRFUNC, value ? value : "[null]");
6881 *out_deliver_to = EwsDelegateDeliver_DelegatesAndSendInformationToMe;
6882 }
6883
6884 g_free (value);
6885 }
6886
6887 param = e_soap_response_get_first_parameter_by_name (
6888 response, "ResponseMessages", NULL);
6889
6890 /* it's OK to not have set any delegate */
6891 if (!param)
6892 return TRUE;
6893
6894 subparam = e_soap_parameter_get_first_child (param);
6895
6896 while (subparam != NULL) {
6897 const gchar *name = (const gchar *) subparam->name;
6898
6899 if (!ews_get_response_status (subparam, error))
6900 return FALSE;
6901
6902 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "DelegateUserResponseMessageType")) {
6903 ews_handle_delegate_user_param (subparam, out_delegates);
6904 }
6905
6906 subparam = e_soap_parameter_get_next_child (subparam);
6907 }
6908
6909 return TRUE;
6910 }
6911
6912 gboolean
6913 e_ews_connection_get_delegate_sync (EEwsConnection *cnc,
6914 gint pri,
6915 const gchar *mail_id,
6916 gboolean include_permissions,
6917 EwsDelegateDeliver *out_deliver_to,
6918 GSList **out_delegates, /* EwsDelegateInfo * */
6919 GCancellable *cancellable,
6920 GError **error)
6921 {
6922 ESoapRequest *request;
6923 ESoapResponse *response;
6924 gboolean success;
6925
6926 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
6927 g_return_val_if_fail (out_deliver_to != NULL, FALSE);
6928 g_return_val_if_fail (out_delegates != NULL, FALSE);
6929
6930 *out_delegates = NULL;
6931
6932 request = e_ews_request_new_with_header (
6933 cnc->priv->uri,
6934 cnc->priv->impersonate_user,
6935 "GetDelegate",
6936 "IncludePermissions",
6937 include_permissions ? "true" : "false",
6938 cnc->priv->version,
6939 E_EWS_EXCHANGE_2007_SP1,
6940 FALSE,
6941 error);
6942
6943 if (!request)
6944 return FALSE;
6945
6946 e_soap_request_start_element (request, "Mailbox", "messages", NULL);
6947
6948 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, mail_id ? mail_id : cnc->priv->email);
6949
6950 e_soap_request_end_element (request);
6951
6952 e_ews_request_write_footer (request);
6953
6954 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
6955
6956 if (!response) {
6957 g_clear_object (&request);
6958 return FALSE;
6959 }
6960
6961 success = e_ews_process_get_delegate_response (cnc, response, out_deliver_to, out_delegates, error);
6962
6963 g_clear_object (&request);
6964 g_clear_object (&response);
6965
6966 if (success) {
6967 *out_delegates = g_slist_reverse (*out_delegates);
6968 } else {
6969 g_slist_free_full (*out_delegates, (GDestroyNotify) ews_delegate_info_free);
6970 *out_delegates = NULL;
6971 }
6972
6973 return success;
6974 }
6975
6976 static gboolean
6977 e_ews_process_update_delegate_response (EEwsConnection *cnc,
6978 ESoapResponse *response,
6979 GError **error)
6980 {
6981 ESoapParameter *param;
6982 ESoapParameter *subparam;
6983 GError *local_error = NULL;
6984
6985 if (ews_get_response_status (e_soap_response_get_parameter (response), &local_error)) {
6986 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", NULL);
6987 /* that's OK to not receive any ResponseMessages here */
6988 if (!param)
6989 return TRUE;
6990 } else {
6991 param = NULL;
6992 }
6993
6994 /* Sanity check */
6995 g_return_val_if_fail (
6996 (param != NULL && local_error == NULL) ||
6997 (param == NULL && local_error != NULL), FALSE);
6998
6999 if (local_error) {
7000 g_propagate_error (error, local_error);
7001 return FALSE;
7002 }
7003
7004 subparam = e_soap_parameter_get_first_child (param);
7005
7006 while (subparam != NULL) {
7007 if (!ews_get_response_status (subparam, error))
7008 return FALSE;
7009
7010 subparam = e_soap_parameter_get_next_child (param);
7011 }
7012
7013 return TRUE;
7014 }
7015
7016 static void
7017 set_delegate_permission (ESoapRequest *request,
7018 const gchar *elem_name,
7019 EwsPermissionLevel perm_level)
7020 {
7021 const gchar *level_name = NULL;
7022
7023 if (perm_level == EwsPermissionLevel_None)
7024 level_name = "None";
7025 else if (perm_level == EwsPermissionLevel_Reviewer)
7026 level_name = "Reviewer";
7027 else if (perm_level == EwsPermissionLevel_Author)
7028 level_name = "Author";
7029 else if (perm_level == EwsPermissionLevel_Editor)
7030 level_name = "Editor";
7031
7032 if (!level_name)
7033 return;
7034
7035 e_ews_request_write_string_parameter (request, elem_name, NULL, level_name);
7036 }
7037
7038 gboolean
7039 e_ews_connection_add_delegate_sync (EEwsConnection *cnc,
7040 gint pri,
7041 const gchar *mail_id,
7042 const GSList *delegates, /* EwsDelegateInfo * */
7043 GCancellable *cancellable,
7044 GError **error)
7045 {
7046 ESoapRequest *request;
7047 ESoapResponse *response;
7048 const GSList *link;
7049 gboolean success;
7050
7051 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7052 g_return_val_if_fail (delegates != NULL, FALSE);
7053
7054 request = e_ews_request_new_with_header (
7055 cnc->priv->uri,
7056 cnc->priv->impersonate_user,
7057 "AddDelegate",
7058 NULL,
7059 NULL,
7060 cnc->priv->version,
7061 E_EWS_EXCHANGE_2007_SP1,
7062 FALSE,
7063 error);
7064
7065 if (!request)
7066 return FALSE;
7067
7068 e_soap_request_start_element (request, "Mailbox", "messages", NULL);
7069 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, mail_id ? mail_id : cnc->priv->email);
7070 e_soap_request_end_element (request);
7071
7072 e_soap_request_start_element (request, "DelegateUsers", "messages", NULL);
7073 for (link = delegates; link; link = g_slist_next (link)) {
7074 const EwsDelegateInfo *di = link->data;
7075
7076 if (!di)
7077 continue;
7078
7079 e_soap_request_start_element (request, "DelegateUser", NULL, NULL);
7080
7081 e_soap_request_start_element (request, "UserId", NULL, NULL);
7082 e_ews_request_write_string_parameter (request, "PrimarySmtpAddress", NULL, di->user_id->primary_smtp);
7083 e_soap_request_end_element (request); /* UserId */
7084
7085 e_soap_request_start_element (request, "DelegatePermissions", NULL, NULL);
7086 set_delegate_permission (request, "CalendarFolderPermissionLevel", di->calendar);
7087 set_delegate_permission (request, "TasksFolderPermissionLevel", di->tasks);
7088 set_delegate_permission (request, "InboxFolderPermissionLevel", di->inbox);
7089 set_delegate_permission (request, "ContactsFolderPermissionLevel", di->contacts);
7090 set_delegate_permission (request, "NotesFolderPermissionLevel", di->notes);
7091 set_delegate_permission (request, "JournalFolderPermissionLevel", di->journal);
7092 e_soap_request_end_element (request); /* DelegatePermissions */
7093
7094 e_ews_request_write_string_parameter (request, "ReceiveCopiesOfMeetingMessages", NULL, di->meetingcopies ? "true" : "false");
7095 e_ews_request_write_string_parameter (request, "ViewPrivateItems", NULL, di->view_priv_items ? "true" : "false");
7096
7097 e_soap_request_end_element (request); /* DelegateUser */
7098 }
7099
7100 e_soap_request_end_element (request); /* DelegateUsers */
7101
7102 e_ews_request_write_footer (request);
7103
7104 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7105
7106 if (!response) {
7107 g_clear_object (&request);
7108 return FALSE;
7109 }
7110
7111 success = e_ews_process_update_delegate_response (cnc, response, error);
7112
7113 g_clear_object (&request);
7114 g_clear_object (&response);
7115
7116 return success;
7117 }
7118
7119 gboolean
7120 e_ews_connection_remove_delegate_sync (EEwsConnection *cnc,
7121 gint pri,
7122 const gchar *mail_id,
7123 const GSList *delegate_ids, /* EwsUserId * */
7124 GCancellable *cancellable,
7125 GError **error)
7126 {
7127 ESoapRequest *request;
7128 ESoapResponse *response;
7129 const GSList *link;
7130 gboolean success;
7131
7132 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7133 g_return_val_if_fail (delegate_ids != NULL, FALSE);
7134
7135 request = e_ews_request_new_with_header (
7136 cnc->priv->uri,
7137 cnc->priv->impersonate_user,
7138 "RemoveDelegate",
7139 NULL,
7140 NULL,
7141 cnc->priv->version,
7142 E_EWS_EXCHANGE_2007_SP1,
7143 FALSE,
7144 error);
7145
7146 if (!request)
7147 return FALSE;
7148
7149 e_soap_request_start_element (request, "Mailbox", "messages", NULL);
7150 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, mail_id ? mail_id : cnc->priv->email);
7151 e_soap_request_end_element (request);
7152
7153 e_soap_request_start_element (request, "UserIds", "messages", NULL);
7154
7155 for (link = delegate_ids; link; link = g_slist_next (link)) {
7156 const EwsUserId *user_id = link->data;
7157
7158 if (!user_id)
7159 continue;
7160
7161 e_soap_request_start_element (request, "UserId", NULL, NULL);
7162 e_ews_request_write_string_parameter (request, "PrimarySmtpAddress", NULL, user_id->primary_smtp);
7163 e_soap_request_end_element (request);
7164 }
7165
7166 e_soap_request_end_element (request); /* UserIds */
7167
7168 e_ews_request_write_footer (request);
7169
7170 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7171
7172 if (!response) {
7173 g_clear_object (&request);
7174 return FALSE;
7175 }
7176
7177 success = e_ews_process_update_delegate_response (cnc, response, error);
7178
7179 g_clear_object (&request);
7180 g_clear_object (&response);
7181
7182 return success;
7183 }
7184
7185 gboolean
7186 e_ews_connection_update_delegate_sync (EEwsConnection *cnc,
7187 gint pri,
7188 const gchar *mail_id,
7189 EwsDelegateDeliver deliver_to,
7190 const GSList *delegates, /* EwsDelegateInfo * */
7191 GCancellable *cancellable,
7192 GError **error)
7193 {
7194 ESoapRequest *request;
7195 ESoapResponse *response;
7196 const GSList *link;
7197 gboolean success;
7198
7199 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7200
7201 request = e_ews_request_new_with_header (
7202 cnc->priv->uri,
7203 cnc->priv->impersonate_user,
7204 "UpdateDelegate",
7205 NULL,
7206 NULL,
7207 cnc->priv->version,
7208 E_EWS_EXCHANGE_2007_SP1,
7209 FALSE,
7210 error);
7211
7212 if (!request)
7213 return FALSE;
7214
7215 e_soap_request_start_element (request, "Mailbox", "messages", NULL);
7216 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, mail_id ? mail_id : cnc->priv->email);
7217 e_soap_request_end_element (request);
7218
7219 if (delegates) {
7220 e_soap_request_start_element (request, "DelegateUsers", "messages", NULL);
7221
7222 for (link = delegates; link; link = g_slist_next (link)) {
7223 const EwsDelegateInfo *di = link->data;
7224
7225 if (!di)
7226 continue;
7227
7228 e_soap_request_start_element (request, "DelegateUser", NULL, NULL);
7229
7230 e_soap_request_start_element (request, "UserId", NULL, NULL);
7231 e_ews_request_write_string_parameter (request, "PrimarySmtpAddress", NULL, di->user_id->primary_smtp);
7232 e_soap_request_end_element (request); /* UserId */
7233
7234 e_soap_request_start_element (request, "DelegatePermissions", NULL, NULL);
7235 set_delegate_permission (request, "CalendarFolderPermissionLevel", di->calendar);
7236 set_delegate_permission (request, "TasksFolderPermissionLevel", di->tasks);
7237 set_delegate_permission (request, "InboxFolderPermissionLevel", di->inbox);
7238 set_delegate_permission (request, "ContactsFolderPermissionLevel", di->contacts);
7239 set_delegate_permission (request, "NotesFolderPermissionLevel", di->notes);
7240 set_delegate_permission (request, "JournalFolderPermissionLevel", di->journal);
7241 e_soap_request_end_element (request); /* DelegatePermissions */
7242
7243 e_ews_request_write_string_parameter (request, "ReceiveCopiesOfMeetingMessages", NULL, di->meetingcopies ? "true" : "false");
7244 e_ews_request_write_string_parameter (request, "ViewPrivateItems", NULL, di->view_priv_items ? "true" : "false");
7245
7246 e_soap_request_end_element (request); /* DelegateUser */
7247 }
7248
7249 e_soap_request_end_element (request); /* DelegateUsers */
7250 }
7251
7252 e_ews_request_write_string_parameter (request, "DeliverMeetingRequests", "messages",
7253 deliver_to == EwsDelegateDeliver_DelegatesOnly ? "DelegatesOnly" :
7254 deliver_to == EwsDelegateDeliver_DelegatesAndMe ? "DelegatesAndMe" :
7255 "DelegatesAndSendInformationToMe");
7256
7257 e_ews_request_write_footer (request);
7258
7259 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7260
7261 if (!response) {
7262 g_clear_object (&request);
7263 return FALSE;
7264 }
7265
7266 success = e_ews_process_update_delegate_response (cnc, response, error);
7267
7268 g_clear_object (&request);
7269 g_clear_object (&response);
7270
7271 return success;
7272 }
7273
7274 static gboolean
7275 e_ews_process_get_folder_permissions_response (EEwsConnection *cnc,
7276 ESoapResponse *response,
7277 GSList **out_permissions,
7278 GError **error)
7279 {
7280 ESoapParameter *param;
7281 ESoapParameter *subparam;
7282 GError *local_error = NULL;
7283
7284 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
7285
7286 /* Sanity check */
7287 g_return_val_if_fail (
7288 (param != NULL && local_error == NULL) ||
7289 (param == NULL && local_error != NULL), FALSE);
7290
7291 if (local_error) {
7292 g_propagate_error (error, local_error);
7293 return FALSE;
7294 }
7295
7296 subparam = e_soap_parameter_get_first_child (param);
7297
7298 while (subparam != NULL) {
7299 const gchar *name = (const gchar *) subparam->name;
7300
7301 if (!ews_get_response_status (subparam, error))
7302 return FALSE;
7303
7304 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "GetFolderResponseMessage")) {
7305 ESoapParameter *node;
7306
7307 node = e_soap_parameter_get_first_child_by_name (subparam, "Folders");
7308 if (node) {
7309 subparam = node;
7310
7311 node = e_soap_parameter_get_first_child (subparam);
7312 if (node && node->name && g_str_has_suffix ((const gchar *) node->name, "Folder")) {
7313 node = e_soap_parameter_get_first_child_by_name (node, "PermissionSet");
7314 if (node) {
7315 *out_permissions = e_ews_permissions_from_soap_param (node);
7316 }
7317 }
7318 }
7319
7320 break;
7321 }
7322
7323 subparam = e_soap_parameter_get_next_child (subparam);
7324 }
7325
7326 return TRUE;
7327 }
7328
7329 /* free permissions with e_ews_permissions_free() */
7330 gboolean
7331 e_ews_connection_get_folder_permissions_sync (EEwsConnection *cnc,
7332 gint pri,
7333 EwsFolderId *folder_id,
7334 GSList **out_permissions,
7335 GCancellable *cancellable,
7336 GError **error)
7337 {
7338 ESoapRequest *request;
7339 ESoapResponse *response;
7340 gboolean success;
7341
7342 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7343 g_return_val_if_fail (folder_id != NULL, FALSE);
7344 g_return_val_if_fail (out_permissions != NULL, FALSE);
7345
7346 *out_permissions = NULL;
7347
7348 request = e_ews_request_new_with_header (
7349 cnc->priv->uri,
7350 cnc->priv->impersonate_user,
7351 "GetFolder",
7352 NULL,
7353 NULL,
7354 cnc->priv->version,
7355 E_EWS_EXCHANGE_2007_SP1,
7356 FALSE,
7357 error);
7358
7359 if (!request)
7360 return FALSE;
7361
7362 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
7363 e_ews_request_write_string_parameter (request, "BaseShape", NULL, "IdOnly");
7364 e_soap_request_start_element (request, "AdditionalProperties", NULL, NULL);
7365 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:PermissionSet");
7366 e_soap_request_end_element (request); /* AdditionalProperties */
7367 e_soap_request_end_element (request); /* FolderShape */
7368
7369 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
7370 e_ews_folder_id_append_to_request (request, cnc->priv->email, folder_id);
7371 e_soap_request_end_element (request);
7372
7373 e_ews_request_write_footer (request);
7374
7375 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7376
7377 if (!response) {
7378 g_clear_object (&request);
7379 return FALSE;
7380 }
7381
7382 success = e_ews_process_get_folder_permissions_response (cnc, response, out_permissions, error);
7383
7384 g_clear_object (&request);
7385 g_clear_object (&response);
7386
7387 if (!success) {
7388 e_ews_permissions_free (*out_permissions);
7389 *out_permissions = NULL;
7390 }
7391
7392 return success;
7393 }
7394
7395 gboolean
7396 e_ews_connection_set_folder_permissions_sync (EEwsConnection *cnc,
7397 gint pri,
7398 EwsFolderId *folder_id,
7399 EEwsFolderType folder_type,
7400 const GSList *permissions,
7401 GCancellable *cancellable,
7402 GError **error)
7403 {
7404 ESoapRequest *request;
7405 ESoapResponse *response;
7406 const GSList *link;
7407 gboolean success;
7408
7409 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7410 g_return_val_if_fail (folder_id != NULL, FALSE);
7411 g_return_val_if_fail (permissions != NULL, FALSE);
7412
7413 request = e_ews_request_new_with_header (
7414 cnc->priv->uri,
7415 cnc->priv->impersonate_user,
7416 "UpdateFolder",
7417 NULL,
7418 NULL,
7419 cnc->priv->version,
7420 E_EWS_EXCHANGE_2007_SP1,
7421 FALSE,
7422 error);
7423
7424 if (!request)
7425 return FALSE;
7426
7427 e_soap_request_start_element (request, "FolderChanges", "messages", NULL);
7428 e_ews_request_start_folder_change (request, cnc->priv->email, folder_id);
7429
7430 e_soap_request_start_element (request, "SetFolderField", NULL, NULL);
7431 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:PermissionSet");
7432
7433 switch (folder_type) {
7434 default:
7435 case E_EWS_FOLDER_TYPE_MAILBOX:
7436 e_soap_request_start_element (request, "Folder", NULL, NULL);
7437 break;
7438 case E_EWS_FOLDER_TYPE_CALENDAR:
7439 e_soap_request_start_element (request, "CalendarFolder", NULL, NULL);
7440 break;
7441 case E_EWS_FOLDER_TYPE_CONTACTS:
7442 e_soap_request_start_element (request, "ContactsFolder", NULL, NULL);
7443 break;
7444 case E_EWS_FOLDER_TYPE_SEARCH:
7445 e_soap_request_start_element (request, "SearchFolder", NULL, NULL);
7446 break;
7447 case E_EWS_FOLDER_TYPE_TASKS:
7448 e_soap_request_start_element (request, "TasksFolder", NULL, NULL);
7449 break;
7450 }
7451
7452 e_soap_request_start_element (request, "PermissionSet", NULL, NULL);
7453 if (folder_type == E_EWS_FOLDER_TYPE_CALENDAR)
7454 e_soap_request_start_element (request, "CalendarPermissions", NULL, NULL);
7455 else
7456 e_soap_request_start_element (request, "Permissions", NULL, NULL);
7457
7458 for (link = permissions; link; link = g_slist_next (link)) {
7459 EEwsPermission *perm = link->data;
7460 const gchar *perm_level_name;
7461
7462 if (!perm)
7463 continue;
7464
7465 if (folder_type == E_EWS_FOLDER_TYPE_CALENDAR)
7466 e_soap_request_start_element (request, "CalendarPermission", NULL, NULL);
7467 else
7468 e_soap_request_start_element (request, "Permission", NULL, NULL);
7469
7470 e_soap_request_start_element (request, "UserId", NULL, NULL);
7471
7472 switch (perm->user_type) {
7473 case E_EWS_PERMISSION_USER_TYPE_NONE:
7474 g_warn_if_reached ();
7475 break;
7476 case E_EWS_PERMISSION_USER_TYPE_ANONYMOUS:
7477 e_ews_request_write_string_parameter (request, "DistinguishedUser", NULL, "Anonymous");
7478 break;
7479 case E_EWS_PERMISSION_USER_TYPE_DEFAULT:
7480 e_ews_request_write_string_parameter (request, "DistinguishedUser", NULL, "Default");
7481 break;
7482 case E_EWS_PERMISSION_USER_TYPE_REGULAR:
7483 e_ews_request_write_string_parameter (request, "PrimarySmtpAddress", NULL, perm->primary_smtp);
7484 break;
7485 }
7486
7487 e_soap_request_end_element (request); /* UserId */
7488
7489 e_ews_permission_rights_to_level_name (perm->rights);
7490
7491 perm_level_name = e_ews_permission_rights_to_level_name (perm->rights);
7492
7493 if (g_strcmp0 (perm_level_name, "Custom") == 0) {
7494 e_ews_request_write_string_parameter (request, "CanCreateItems", NULL,
7495 (perm->rights & E_EWS_PERMISSION_BIT_CREATE) != 0 ? "true" : "false");
7496 e_ews_request_write_string_parameter (request, "CanCreateSubFolders", NULL,
7497 (perm->rights & E_EWS_PERMISSION_BIT_CREATE_SUBFOLDER) != 0 ? "true" : "false");
7498 e_ews_request_write_string_parameter (request, "IsFolderOwner", NULL,
7499 (perm->rights & E_EWS_PERMISSION_BIT_FOLDER_OWNER) != 0 ? "true" : "false");
7500 e_ews_request_write_string_parameter (request, "IsFolderVisible", NULL,
7501 (perm->rights & E_EWS_PERMISSION_BIT_FOLDER_VISIBLE) != 0 ? "true" : "false");
7502 e_ews_request_write_string_parameter (request, "IsFolderContact", NULL,
7503 (perm->rights & E_EWS_PERMISSION_BIT_FOLDER_CONTACT) != 0 ? "true" : "false");
7504 e_ews_request_write_string_parameter (request, "EditItems", NULL,
7505 (perm->rights & E_EWS_PERMISSION_BIT_EDIT_ANY) != 0 ? "All" :
7506 (perm->rights & E_EWS_PERMISSION_BIT_EDIT_OWNED) != 0 ? "Owned" : "None");
7507 e_ews_request_write_string_parameter (request, "DeleteItems", NULL,
7508 (perm->rights & E_EWS_PERMISSION_BIT_DELETE_ANY) != 0 ? "All" :
7509 (perm->rights & E_EWS_PERMISSION_BIT_DELETE_OWNED) != 0 ? "Owned" : "None");
7510 if (folder_type == E_EWS_FOLDER_TYPE_CALENDAR)
7511 e_ews_request_write_string_parameter (request, "ReadItems", NULL,
7512 (perm->rights & E_EWS_PERMISSION_BIT_READ_ANY) != 0 ? "FullDetails" :
7513 (perm->rights & E_EWS_PERMISSION_BIT_FREE_BUSY_DETAILED) != 0 ? "TimeAndSubjectAndLocation" :
7514 (perm->rights & E_EWS_PERMISSION_BIT_FREE_BUSY_SIMPLE) != 0 ? "TimeOnly" : "None");
7515 else
7516 e_ews_request_write_string_parameter (request, "ReadItems", NULL,
7517 (perm->rights & E_EWS_PERMISSION_BIT_READ_ANY) != 0 ? "FullDetails" : "None");
7518 }
7519
7520 e_ews_request_write_string_parameter (request,
7521 folder_type == E_EWS_FOLDER_TYPE_CALENDAR ? "CalendarPermissionLevel" : "PermissionLevel", NULL,
7522 perm_level_name);
7523
7524 e_soap_request_end_element (request); /* Permission/CalendarPermission */
7525 }
7526
7527 e_soap_request_end_element (request); /* Permissions */
7528 e_soap_request_end_element (request); /* PermissionSet */
7529 e_soap_request_end_element (request); /* Folder/CalendarFolder/... */
7530 e_soap_request_end_element (request); /* SetFolderField */
7531
7532 e_ews_request_end_item_change (request);
7533
7534 e_ews_request_write_footer (request);
7535
7536 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7537
7538 if (!response) {
7539 g_clear_object (&request);
7540 return FALSE;
7541 }
7542
7543 success = e_ews_process_generic_response (cnc, response, error);
7544
7545 g_clear_object (&request);
7546 g_clear_object (&response);
7547
7548 return success;
7549 }
7550
7551 static gboolean
7552 e_ews_process_get_password_expiration_response (EEwsConnection *cnc,
7553 ESoapResponse *response,
7554 gchar **out_exp_date,
7555 GError **error)
7556 {
7557 ESoapParameter *param;
7558 GError *local_error = NULL;
7559
7560 param = e_soap_response_get_first_parameter_by_name (response, "PasswordExpirationDate", &local_error);
7561
7562 /* Sanity check */
7563 g_return_val_if_fail (
7564 (param != NULL && local_error == NULL) ||
7565 (param == NULL && local_error != NULL), FALSE);
7566
7567 if (local_error) {
7568 g_propagate_error (error, local_error);
7569 return FALSE;
7570 }
7571
7572 if (out_exp_date)
7573 *out_exp_date = e_soap_parameter_get_string_value (param);
7574
7575 return TRUE;
7576 }
7577
7578 gboolean
7579 e_ews_connection_get_password_expiration_sync (EEwsConnection *cnc,
7580 gint pri,
7581 const gchar *mail_id,
7582 gchar **out_exp_date,
7583 GCancellable *cancellable,
7584 GError **error)
7585 {
7586 ESoapRequest *request;
7587 ESoapResponse *response;
7588 gboolean success;
7589
7590 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7591 g_return_val_if_fail (out_exp_date != NULL, FALSE);
7592
7593 *out_exp_date = NULL;
7594
7595 request = e_ews_request_new_with_header (
7596 cnc->priv->uri,
7597 cnc->priv->impersonate_user,
7598 "GetPasswordExpirationDate",
7599 NULL,
7600 NULL,
7601 cnc->priv->version,
7602 E_EWS_EXCHANGE_2010_SP2,
7603 FALSE,
7604 error);
7605
7606 if (!request)
7607 return FALSE;
7608
7609 e_ews_request_write_string_parameter (request, "MailboxSmtpAddress", NULL, mail_id ? mail_id : cnc->priv->email);
7610
7611 e_ews_request_write_footer (request);
7612
7613 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7614
7615 if (!response) {
7616 g_clear_object (&request);
7617 return FALSE;
7618 }
7619
7620 success = e_ews_process_get_password_expiration_response (cnc, response, out_exp_date, error);
7621
7622 g_clear_object (&request);
7623 g_clear_object (&response);
7624
7625 if (!success)
7626 g_clear_pointer (out_exp_date, g_free);
7627
7628 return success;
7629 }
7630
7631 static gboolean
7632 e_ews_process_get_folder_info_response (EEwsConnection *cnc,
7633 ESoapResponse *response,
7634 EEwsFolder **out_folder,
7635 GError **error)
7636 {
7637 ESoapParameter *param;
7638 ESoapParameter *subparam;
7639 GError *local_error = NULL;
7640
7641 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
7642
7643 /* Sanity check */
7644 g_return_val_if_fail (
7645 (param != NULL && local_error == NULL) ||
7646 (param == NULL && local_error != NULL), FALSE);
7647
7648 if (local_error) {
7649 g_propagate_error (error, local_error);
7650 return FALSE;
7651 }
7652
7653 subparam = e_soap_parameter_get_first_child (param);
7654
7655 while (subparam != NULL) {
7656 const gchar *name = (const gchar *) subparam->name;
7657
7658 if (!ews_get_response_status (subparam, error))
7659 return FALSE;
7660
7661 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "GetFolderResponseMessage")) {
7662 ESoapParameter *node;
7663
7664 node = e_soap_parameter_get_first_child_by_name (subparam, "Folders");
7665 if (node && out_folder)
7666 *out_folder = e_ews_folder_new_from_soap_parameter (node);
7667
7668 break;
7669 }
7670
7671 subparam = e_soap_parameter_get_next_child (subparam);
7672 }
7673
7674 return TRUE;
7675 }
7676
7677 gboolean
7678 e_ews_connection_get_folder_info_sync (EEwsConnection *cnc,
7679 gint pri,
7680 const gchar *mail_id,
7681 const EwsFolderId *folder_id,
7682 EEwsFolder **out_folder,
7683 GCancellable *cancellable,
7684 GError **error)
7685 {
7686 ESoapRequest *request;
7687 ESoapResponse *response;
7688 gboolean success;
7689
7690 g_return_val_if_fail (E_IS_EWS_CONNECTION (cnc), FALSE);
7691 g_return_val_if_fail (folder_id != NULL, FALSE);
7692 g_return_val_if_fail (out_folder != NULL, FALSE);
7693
7694 *out_folder = NULL;
7695
7696 request = e_ews_request_new_with_header (
7697 cnc->priv->uri,
7698 cnc->priv->impersonate_user,
7699 "GetFolder",
7700 NULL,
7701 NULL,
7702 cnc->priv->version,
7703 E_EWS_EXCHANGE_2007_SP1,
7704 FALSE,
7705 error);
7706
7707 if (!request)
7708 return FALSE;
7709
7710 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
7711 e_ews_request_write_string_parameter (request, "BaseShape", NULL, "Default");
7712 e_soap_request_start_element (request, "AdditionalProperties", NULL, NULL);
7713 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:FolderClass");
7714 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:ParentFolderId");
7715 e_soap_request_end_element (request); /* AdditionalProperties */
7716 e_soap_request_end_element (request); /* FolderShape */
7717
7718 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
7719 e_ews_folder_id_append_to_request (request, mail_id, folder_id);
7720 e_soap_request_end_element (request);
7721
7722 e_ews_request_write_footer (request);
7723
7724 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7725
7726 if (!response) {
7727 g_clear_object (&request);
7728 return FALSE;
7729 }
7730
7731 success = e_ews_process_get_folder_info_response (cnc, response, out_folder, error);
7732
7733 g_clear_object (&request);
7734 g_clear_object (&response);
7735
7736 if (success && !*out_folder)
7737 success = FALSE;
7738
7739 if (!success && *out_folder)
7740 g_clear_object (out_folder);
7741
7742 return success;
7743 }
7744
7745 static gboolean
7746 e_ews_process_find_folder_response (EEwsConnection *cnc,
7747 ESoapResponse *response,
7748 gboolean *out_includes_last_item,
7749 GSList **out_folders,
7750 GError **error)
7751 {
7752 ESoapParameter *param;
7753 ESoapParameter *subparam;
7754 GError *local_error = NULL;
7755
7756 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
7757
7758 /* Sanity check */
7759 g_return_val_if_fail (
7760 (param != NULL && local_error == NULL) ||
7761 (param == NULL && local_error != NULL), FALSE);
7762
7763 if (local_error) {
7764 g_propagate_error (error, local_error);
7765 return FALSE;
7766 }
7767
7768 subparam = e_soap_parameter_get_first_child (param);
7769
7770 while (subparam != NULL) {
7771 const gchar *name = (const gchar *) subparam->name;
7772
7773 if (!ews_get_response_status (subparam, error))
7774 return FALSE;
7775
7776 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "FindFolderResponseMessage")) {
7777 ESoapParameter *node, *subparam1;
7778 gchar *last;
7779 EEwsFolder *folder;
7780 gboolean includes_last_item;
7781
7782 node = e_soap_parameter_get_first_child_by_name (subparam, "RootFolder");
7783 last = e_soap_parameter_get_property (node, "IncludesLastItemInRange");
7784 /*
7785 * Set the includes_last_item to TRUE as default.
7786 * It can avoid an infinite loop in caller, when, for some reason,
7787 * we don't receive the last_tag property from the server.
7788 */
7789 includes_last_item = g_strcmp0 (last, "false") != 0;
7790 g_free (last);
7791
7792 node = e_soap_parameter_get_first_child_by_name (node, "Folders");
7793 for (subparam1 = e_soap_parameter_get_first_child (node);
7794 subparam1 && out_folders;
7795 subparam1 = e_soap_parameter_get_next_child (subparam1)) {
7796 folder = e_ews_folder_new_from_soap_parameter (subparam1);
7797 if (folder)
7798 *out_folders = g_slist_prepend (*out_folders, folder);
7799 }
7800
7801 if (out_includes_last_item)
7802 *out_includes_last_item = includes_last_item;
7803 }
7804
7805 subparam = e_soap_parameter_get_next_child (subparam);
7806 }
7807
7808 return TRUE;
7809 }
7810
7811 gboolean
7812 e_ews_connection_find_folder_sync (EEwsConnection *cnc,
7813 gint pri,
7814 const EwsFolderId *fid,
7815 gboolean *out_includes_last_item,
7816 GSList **out_folders,
7817 GCancellable *cancellable,
7818 GError **error)
7819 {
7820 ESoapRequest *request;
7821 ESoapResponse *response;
7822 gboolean success;
7823
7824 g_return_val_if_fail (cnc != NULL, FALSE);
7825 g_return_val_if_fail (out_folders != NULL, FALSE);
7826
7827 *out_folders = NULL;
7828
7829 request = e_ews_request_new_with_header (
7830 cnc->priv->uri,
7831 cnc->priv->impersonate_user,
7832 "FindFolder",
7833 "Traversal",
7834 "Shallow",
7835 cnc->priv->version,
7836 E_EWS_EXCHANGE_2007_SP1,
7837 FALSE,
7838 error);
7839
7840 if (!request)
7841 return FALSE;
7842
7843 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
7844 e_ews_request_write_string_parameter (request, "BaseShape", NULL, "Default");
7845 e_soap_request_start_element (request, "AdditionalProperties", NULL, NULL);
7846 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:FolderClass");
7847 e_ews_request_write_string_parameter_with_attribute (request, "FieldURI", NULL, NULL, "FieldURI", "folder:ChildFolderCount");
7848 e_soap_request_end_element (request); /* AdditionalProperties */
7849 e_soap_request_end_element (request);
7850
7851 e_soap_request_start_element (request, "ParentFolderIds", "messages", NULL);
7852
7853 if (fid->is_distinguished_id)
7854 e_ews_request_write_string_parameter_with_attribute (request, "DistinguishedFolderId", NULL, NULL, "Id", fid->id);
7855 else
7856 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", fid->id);
7857
7858 e_soap_request_end_element (request);
7859
7860 e_ews_request_write_footer (request);
7861
7862 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
7863
7864 if (!response) {
7865 g_clear_object (&request);
7866 return FALSE;
7867 }
7868
7869 success = e_ews_process_find_folder_response (cnc, response, out_includes_last_item, out_folders, error);
7870
7871 g_clear_object (&request);
7872 g_clear_object (&response);
7873
7874 if (success) {
7875 *out_folders = g_slist_reverse (*out_folders);
7876 } else {
7877 g_slist_free_full (*out_folders, g_object_unref);
7878 *out_folders = NULL;
7879 }
7880
7881 return success;
7882 }
7883
7884 typedef struct _AuthMethodsData {
7885 GCancellable *cancellable;
7886 GSList **out_auth_methods;
7887 } AuthMethodsData;
7888
7889 static void
7890 e_ews_auth_methods_got_headers_cb (SoupMessage *message,
7891 gpointer user_data)
7892 {
7893 AuthMethodsData *amd = user_data;
7894 const gchar *auths_lst;
7895 gboolean has_bearer = FALSE;
7896 gchar **auths;
7897 gint ii;
7898
7899 g_return_if_fail (amd != NULL);
7900
7901 auths_lst = soup_message_headers_get_list (soup_message_get_response_headers (message), "WWW-Authenticate");
7902
7903 if (auths_lst) {
7904 auths = g_strsplit (auths_lst, ",", -1);
7905
7906 for (ii = 0; auths && auths[ii]; ii++) {
7907 gchar *auth, *space;
7908
7909 auth = g_strstrip (g_strdup (auths[ii]));
7910
7911 if (auth && *auth) {
7912 space = strchr (auth, ' ');
7913 if (space)
7914 *space = '\0';
7915
7916 has_bearer = has_bearer || g_ascii_strcasecmp (auth, "Bearer") == 0;
7917 *(amd->out_auth_methods) = g_slist_prepend (*(amd->out_auth_methods), auth);
7918 } else {
7919 g_free (auth);
7920 }
7921 }
7922
7923 g_strfreev (auths);
7924
7925 if (!has_bearer) {
7926 /* Special-case Office365 OAuth2, because outlook.office365.com doesn't advertise Bearer */
7927 *(amd->out_auth_methods) = g_slist_prepend (*(amd->out_auth_methods), g_strdup ("Bearer"));
7928 }
7929 }
7930
7931 g_cancellable_cancel (amd->cancellable);
7932 }
7933
7934 gboolean
7935 e_ews_connection_query_auth_methods_sync (EEwsConnection *cnc,
7936 gint pri,
7937 GSList **out_auth_methods,
7938 GCancellable *cancellable,
7939 GError **error)
7940 {
7941 AuthMethodsData amd;
7942 CamelEwsSettings *settings;
7943 ESoapRequest *request;
7944 ESoupSession *session;
7945 SoupMessage *message;
7946 GInputStream *stream;
7947 gulong cancelled_id = 0;
7948 gboolean success;
7949 GError *local_error = NULL;
7950
7951 g_return_val_if_fail (cnc != NULL, FALSE);
7952 g_return_val_if_fail (out_auth_methods != NULL, FALSE);
7953
7954 *out_auth_methods = NULL;
7955
7956 /* use some simple operation to get WWW-Authenticate headers from the server */
7957 request = e_ews_request_new_with_header (
7958 cnc->priv->uri,
7959 cnc->priv->impersonate_user,
7960 "GetFolder",
7961 NULL,
7962 NULL,
7963 cnc->priv->version,
7964 E_EWS_EXCHANGE_2007_SP1,
7965 TRUE,
7966 error);
7967
7968 if (!request)
7969 return FALSE;
7970
7971 e_soap_request_start_element (request, "FolderShape", "messages", NULL);
7972 e_ews_request_write_string_parameter (request, "BaseShape", NULL, "IdOnly");
7973 e_soap_request_end_element (request);
7974
7975 e_soap_request_start_element (request, "FolderIds", "messages", NULL);
7976 e_ews_request_write_string_parameter_with_attribute (request, "DistinguishedFolderId", NULL, NULL, "Id", "inbox");
7977 e_soap_request_end_element (request);
7978
7979 e_ews_request_write_footer (request);
7980
7981 session = e_ews_connection_create_soup_session (cnc);
7982
7983 settings = e_ews_connection_ref_settings (cnc);
7984 message = e_soap_request_persist (request, session, settings, error);
7985 g_clear_object (&settings);
7986
7987 if (!message) {
7988 g_clear_object (&session);
7989 g_clear_object (&request);
7990 return FALSE;
7991 }
7992
7993 e_ews_connection_maybe_prepare_message_for_testing_sources (cnc, message);
7994
7995 amd.cancellable = g_cancellable_new ();
7996 amd.out_auth_methods = out_auth_methods;
7997
7998 g_signal_connect (message, "got-headers",
7999 G_CALLBACK (e_ews_auth_methods_got_headers_cb), &amd);
8000
8001 if (cancellable)
8002 cancelled_id = g_cancellable_connect (cancellable, G_CALLBACK (e_ews_cancel_cancellable_cb), amd.cancellable, NULL);
8003
8004 stream = e_soup_session_send_message_sync (session, message, amd.cancellable, &local_error);
8005
8006 /* The request should be cancelled in the got-headers handler */
8007 g_clear_object (&stream);
8008
8009 if (local_error && !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
8010 success = FALSE;
8011 g_propagate_error (error, local_error);
8012 g_slist_free_full (*out_auth_methods, g_free);
8013 *out_auth_methods = NULL;
8014 } else {
8015 success = TRUE;
8016 *out_auth_methods = g_slist_reverse (*out_auth_methods);
8017 }
8018
8019 if (cancelled_id)
8020 g_cancellable_disconnect (cancellable, cancelled_id);
8021
8022 g_clear_object (&amd.cancellable);
8023 g_clear_object (&message);
8024 g_clear_object (&session);
8025 g_clear_object (&request);
8026
8027 if (success && g_cancellable_set_error_if_cancelled (cancellable, error)) {
8028 g_slist_free_full (*out_auth_methods, g_free);
8029 *out_auth_methods = NULL;
8030 success = FALSE;
8031 }
8032
8033 return success;
8034 }
8035
8036 static void
8037 ews_connection_build_subscribed_folders_list (gpointer key,
8038 gpointer value,
8039 gpointer user_data)
8040 {
8041 GSList *folders = value, *l;
8042 EEwsConnection *cnc = user_data;
8043
8044 for (l = folders; l != NULL; l = l->next) {
8045 if (g_slist_find_custom (cnc->priv->subscribed_folders, l->data, (GCompareFunc) g_strcmp0) == NULL) {
8046 cnc->priv->subscribed_folders =
8047 g_slist_prepend (cnc->priv->subscribed_folders, g_strdup (l->data));
8048 }
8049 }
8050 }
8051
8052 static void
8053 ews_connection_subscription_id_changed_cb (EEwsNotification *notification,
8054 const gchar *subscription_id,
8055 gpointer user_data)
8056 {
8057 EEwsConnection *cnc = user_data;
8058
8059 g_return_if_fail (E_IS_EWS_CONNECTION (cnc));
8060
8061 NOTIFICATION_LOCK (cnc);
8062
8063 if (cnc->priv->notification == notification)
8064 g_signal_emit (cnc, signals[SUBSCRIPTION_ID_CHANGED], 0, subscription_id, NULL);
8065
8066 NOTIFICATION_UNLOCK (cnc);
8067 }
8068
8069 static gpointer
8070 ews_connection_notification_start_thread (gpointer user_data)
8071 {
8072 GWeakRef *weakref = user_data;
8073 EEwsConnection *cnc;
8074
8075 g_return_val_if_fail (weakref != NULL, NULL);
8076
8077 cnc = g_weak_ref_get (weakref);
8078
8079 if (cnc && !e_ews_connection_get_disconnected_flag (cnc)) {
8080 gchar *last_subscription_id = e_ews_connection_dup_last_subscription_id (cnc);
8081
8082 NOTIFICATION_LOCK (cnc);
8083
8084 if (cnc->priv->subscribed_folders) {
8085 g_clear_object (&cnc->priv->notification);
8086
8087 cnc->priv->notification = e_ews_notification_new (cnc, last_subscription_id);
8088
8089 /* The 'notification' assumes ownership of the 'last_subscription_id' */
8090 last_subscription_id = NULL;
8091
8092 g_signal_connect_object (cnc->priv->notification, "subscription-id-changed",
8093 G_CALLBACK (ews_connection_subscription_id_changed_cb), cnc, 0);
8094
8095 e_ews_notification_start_listening_sync (cnc->priv->notification, cnc->priv->subscribed_folders);
8096 }
8097
8098 NOTIFICATION_UNLOCK (cnc);
8099
8100 g_free (last_subscription_id);
8101 }
8102
8103 g_clear_object (&cnc);
8104 e_weak_ref_free (weakref);
8105
8106 return NULL;
8107 }
8108
8109 static gboolean
8110 ews_connection_notification_delay_cb (gpointer user_data)
8111 {
8112 GWeakRef *weakref = user_data;
8113 EEwsConnection *cnc;
8114
8115 if (g_source_is_destroyed (g_main_current_source ()))
8116 return FALSE;
8117
8118 g_return_val_if_fail (weakref != NULL, FALSE);
8119
8120 cnc = g_weak_ref_get (weakref);
8121
8122 if (cnc) {
8123 NOTIFICATION_LOCK (cnc);
8124
8125 if (cnc->priv->notification_delay_id == g_source_get_id (g_main_current_source ())) {
8126 cnc->priv->notification_delay_id = 0;
8127
8128 if (cnc->priv->subscribed_folders) {
8129 g_thread_unref (g_thread_new (NULL, ews_connection_notification_start_thread,
8130 e_weak_ref_new (cnc)));
8131 }
8132 }
8133
8134 NOTIFICATION_UNLOCK (cnc);
8135
8136 g_object_unref (cnc);
8137 }
8138
8139 return FALSE;
8140 }
8141
8142 static void
8143 e_ews_connection_maybe_start_notifications_locked (EEwsConnection *cnc)
8144 {
8145 if (camel_ews_settings_get_listen_notifications (cnc->priv->settings)) {
8146 e_ews_debug_print ("Start notifications for cnc:%p\n", cnc);
8147
8148 if (cnc->priv->notification_delay_id)
8149 g_source_remove (cnc->priv->notification_delay_id);
8150
8151 cnc->priv->notification_delay_id = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, 5,
8152 ews_connection_notification_delay_cb, e_weak_ref_new (cnc), (GDestroyNotify) e_weak_ref_free);
8153 }
8154 }
8155
8156 /*
8157 * Enables server notification on a folder (or a set of folders).
8158 * The events we are listen for notifications are: Copied, Created, Deleted, Modified and Moved.
8159 *
8160 * As we have only one subscription per connection, for every enable_notifications_sync() call,
8161 * we do:
8162 * - Check if we already are subscribed
8163 * - If we are already subscribed:
8164 * - Stop to send events regards to the already subscribed folders' list
8165 * - Unsubscribe the already subscribed folders' list
8166 * - Add the user folders' lst to the hash table if subscribed folders
8167 * - Create a new list of the folders to subscribe for, based in the hash table of subscribed folders
8168 * - Subscribed to listen notifications for the folders
8169 * - Start to send events regards to the newly subscribed folders' list
8170 *
8171 * Pair function for this one is e_ews_connection_disable_notifications_sync() and we do
8172 * something really similar for every disable_notifications_sync() call.
8173 *
8174 * The notification is received to the caller with the "server-notification" signal.
8175 * Note that the signal is used for each notification, without distinction on the
8176 * enabled object.
8177 */
8178 void
8179 e_ews_connection_enable_notifications_sync (EEwsConnection *cnc,
8180 GSList *folders,
8181 guint *subscription_key)
8182 {
8183 GSList *new_folders = NULL, *l, *flink;
8184 gint subscriptions_size;
8185
8186 g_return_if_fail (cnc != NULL);
8187 g_return_if_fail (cnc->priv != NULL);
8188 g_return_if_fail (cnc->priv->version >= E_EWS_EXCHANGE_2010_SP1);
8189 g_return_if_fail (folders != NULL);
8190
8191 NOTIFICATION_LOCK (cnc);
8192 subscriptions_size = g_hash_table_size (cnc->priv->subscriptions);
8193
8194 if (subscriptions_size == G_MAXUINT - 1)
8195 goto exit;
8196
8197 for (flink = folders; flink; flink = g_slist_next (flink)) {
8198 for (l = cnc->priv->subscribed_folders; l; l = g_slist_next (l)) {
8199 if (g_strcmp0 (l->data, flink->data) == 0)
8200 break;
8201 }
8202
8203 if (!l)
8204 break;
8205 }
8206
8207 /* All requested folders are already subscribed */
8208 if (!flink && cnc->priv->notification)
8209 goto exit;
8210
8211 if (subscriptions_size > 0) {
8212 if (cnc->priv->notification) {
8213 e_ews_notification_stop_listening_sync (cnc->priv->notification);
8214 g_clear_object (&cnc->priv->notification);
8215 }
8216
8217 g_slist_free_full (cnc->priv->subscribed_folders, g_free);
8218 cnc->priv->subscribed_folders = NULL;
8219 }
8220
8221 while (g_hash_table_contains (cnc->priv->subscriptions, GINT_TO_POINTER (notification_key))) {
8222 notification_key++;
8223 if (notification_key == 0)
8224 notification_key++;
8225 }
8226
8227 for (l = folders; l != NULL; l = l->next)
8228 new_folders = g_slist_prepend (new_folders, g_strdup (l->data));
8229
8230 g_hash_table_insert (cnc->priv->subscriptions, GINT_TO_POINTER (notification_key), new_folders);
8231 new_folders = NULL;
8232
8233 g_hash_table_foreach (cnc->priv->subscriptions, ews_connection_build_subscribed_folders_list, cnc);
8234
8235 e_ews_connection_maybe_start_notifications_locked (cnc);
8236
8237 exit:
8238 *subscription_key = notification_key;
8239 notification_key++;
8240 if (notification_key == 0)
8241 notification_key++;
8242
8243 NOTIFICATION_UNLOCK (cnc);
8244 }
8245
8246 void
8247 e_ews_connection_disable_notifications_sync (EEwsConnection *cnc,
8248 guint subscription_key)
8249 {
8250 g_return_if_fail (cnc != NULL);
8251 g_return_if_fail (cnc->priv != NULL);
8252
8253 NOTIFICATION_LOCK (cnc);
8254 if (cnc->priv->notification == NULL)
8255 goto exit;
8256
8257 if (!g_hash_table_remove (cnc->priv->subscriptions, GINT_TO_POINTER (subscription_key)))
8258 goto exit;
8259
8260 e_ews_notification_stop_listening_sync (cnc->priv->notification);
8261
8262 g_slist_free_full (cnc->priv->subscribed_folders, g_free);
8263 cnc->priv->subscribed_folders = NULL;
8264
8265 g_hash_table_foreach (cnc->priv->subscriptions, ews_connection_build_subscribed_folders_list, cnc);
8266 if (cnc->priv->subscribed_folders != NULL && !e_ews_connection_get_disconnected_flag (cnc)) {
8267 e_ews_connection_maybe_start_notifications_locked (cnc);
8268 } else {
8269 g_clear_object (&cnc->priv->notification);
8270 }
8271
8272 exit:
8273 NOTIFICATION_UNLOCK (cnc);
8274 }
8275
8276 static EEwsCalendarTo *
8277 ews_get_to (ESoapParameter *node)
8278 {
8279 EEwsCalendarTo *to = NULL;
8280 ESoapParameter *param;
8281 gchar *kind = NULL;
8282 gchar *value = NULL;
8283 gboolean success = FALSE;
8284
8285 param = e_soap_parameter_get_first_child_by_name (node, "To");
8286 if (param == NULL)
8287 goto exit;
8288
8289 kind = e_soap_parameter_get_property (param, "Kind");
8290 if (kind == NULL)
8291 goto exit;
8292
8293 value = e_soap_parameter_get_string_value (param);
8294 if (value == NULL)
8295 goto exit;
8296
8297 success = TRUE;
8298
8299 exit:
8300 if (success) {
8301 to = e_ews_calendar_to_new ();
8302 to->kind = kind;
8303 to->value = value;
8304 } else {
8305 g_free (kind);
8306 g_free (value);
8307 }
8308
8309 return to;
8310 }
8311
8312 static EEwsCalendarPeriod *
8313 ews_get_period (ESoapParameter *node)
8314 {
8315 EEwsCalendarPeriod *period = NULL;
8316 gchar *bias = NULL;
8317 gchar *name = NULL;
8318 gchar *id = NULL;
8319
8320 bias = e_soap_parameter_get_property (node, "Bias");
8321 name = e_soap_parameter_get_property (node, "Name");
8322 id = e_soap_parameter_get_property (node, "Id");
8323
8324 if (bias == NULL || name == NULL || id == NULL) {
8325 g_free (bias);
8326 g_free (name);
8327 g_free (id);
8328
8329 return NULL;
8330 }
8331
8332 period = e_ews_calendar_period_new ();
8333 period->bias = bias;
8334 period->name = name;
8335 period->id = id;
8336
8337 return period;
8338 }
8339
8340 static GSList * /* EEwsCalendarPeriod * */
8341 ews_get_periods_list (ESoapParameter *node)
8342 {
8343 ESoapParameter *param;
8344 GSList *periods = NULL;
8345
8346 for (param = e_soap_parameter_get_first_child_by_name (node, "Period");
8347 param != NULL;
8348 param = e_soap_parameter_get_next_child_by_name (param, "Period")) {
8349 EEwsCalendarPeriod *period;
8350
8351 period = ews_get_period (param);
8352 if (period != NULL) {
8353 periods = g_slist_prepend (periods, period);
8354 } else {
8355 g_slist_free_full (periods, (GDestroyNotify) e_ews_calendar_period_free);
8356 return NULL;
8357 }
8358 }
8359
8360 periods = g_slist_reverse (periods);
8361 return periods;
8362 }
8363
8364 static EEwsCalendarAbsoluteDateTransition *
8365 ews_get_absolute_date_transition (ESoapParameter *node)
8366 {
8367 ESoapParameter *param;
8368 EEwsCalendarAbsoluteDateTransition *absolute_date_transition = NULL;
8369 EEwsCalendarTo *to = NULL;
8370 gchar *date_time = NULL;
8371 gboolean success = FALSE;
8372
8373 param = e_soap_parameter_get_first_child_by_name (node, "To");
8374 if (param != NULL)
8375 to = ews_get_to (param);
8376
8377 if (to == NULL)
8378 goto exit;
8379
8380 param = e_soap_parameter_get_first_child_by_name (node, "DateTime");
8381 if (param != NULL)
8382 date_time = e_soap_parameter_get_string_value (param);
8383
8384 if (date_time == NULL)
8385 goto exit;
8386
8387 success = TRUE;
8388
8389 exit:
8390 if (success) {
8391 absolute_date_transition = e_ews_calendar_absolute_date_transition_new ();
8392 absolute_date_transition->to = to;
8393 absolute_date_transition->date_time = date_time;
8394 } else {
8395 e_ews_calendar_to_free (to);
8396 g_free (date_time);
8397 }
8398
8399 return absolute_date_transition;
8400 }
8401
8402 static EEwsCalendarRecurringDateTransition *
8403 ews_get_recurring_date_transition (ESoapParameter *node)
8404 {
8405 ESoapParameter *param;
8406 EEwsCalendarRecurringDateTransition *recurring_date_transition = NULL;
8407 EEwsCalendarTo *to = NULL;
8408 gchar *time_offset = NULL;
8409 gchar *month = NULL;
8410 gchar *day = NULL;
8411 gboolean success = FALSE;
8412
8413 to = ews_get_to (node);
8414 if (to == NULL)
8415 goto exit;
8416
8417 param = e_soap_parameter_get_first_child_by_name (node, "TimeOffset");
8418 if (param != NULL)
8419 time_offset = e_soap_parameter_get_string_value (param);
8420
8421 if (time_offset == NULL)
8422 goto exit;
8423
8424 param = e_soap_parameter_get_first_child_by_name (node, "Month");
8425 if (param != NULL)
8426 month = e_soap_parameter_get_string_value (param);
8427
8428 if (month == NULL)
8429 goto exit;
8430
8431 param = e_soap_parameter_get_first_child_by_name (node, "Day");
8432 if (param != NULL)
8433 day = e_soap_parameter_get_string_value (param);
8434
8435 if (day == NULL)
8436 goto exit;
8437
8438 success = TRUE;
8439
8440 exit:
8441 if (success) {
8442 recurring_date_transition = e_ews_calendar_recurring_date_transition_new ();
8443 recurring_date_transition->to = to;
8444 recurring_date_transition->time_offset = time_offset;
8445 recurring_date_transition->month = month;
8446 recurring_date_transition->day = day;
8447 } else {
8448 e_ews_calendar_to_free (to);
8449 g_free (time_offset);
8450 g_free (month);
8451 g_free (day);
8452 }
8453
8454 return recurring_date_transition;
8455 }
8456
8457 static EEwsCalendarRecurringDayTransition *
8458 ews_get_recurring_day_transition (ESoapParameter *node)
8459 {
8460 ESoapParameter *param;
8461 EEwsCalendarRecurringDayTransition *recurring_day_transition = NULL;
8462 EEwsCalendarTo *to = NULL;
8463 gchar *time_offset = NULL;
8464 gchar *month = NULL;
8465 gchar *day_of_week = NULL;
8466 gchar *occurrence = NULL;
8467 gboolean success = FALSE;
8468
8469 to = ews_get_to (node);
8470 if (to == NULL)
8471 goto exit;
8472
8473 param = e_soap_parameter_get_first_child_by_name (node, "TimeOffset");
8474 if (param != NULL)
8475 time_offset = e_soap_parameter_get_string_value (param);
8476
8477 if (time_offset == NULL)
8478 goto exit;
8479
8480 param = e_soap_parameter_get_first_child_by_name (node, "Month");
8481 if (param != NULL)
8482 month = e_soap_parameter_get_string_value (param);
8483
8484 if (month == NULL)
8485 goto exit;
8486
8487 param = e_soap_parameter_get_first_child_by_name (node, "DayOfWeek");
8488 if (param != NULL)
8489 day_of_week = e_soap_parameter_get_string_value (param);
8490
8491 if (day_of_week == NULL)
8492 goto exit;
8493
8494 param = e_soap_parameter_get_first_child_by_name (node, "Occurrence");
8495 if (param != NULL)
8496 occurrence = e_soap_parameter_get_string_value (param);
8497
8498 if (occurrence == NULL)
8499 goto exit;
8500
8501 success = TRUE;
8502
8503 exit:
8504 if (success) {
8505 recurring_day_transition = e_ews_calendar_recurring_day_transition_new ();
8506 recurring_day_transition->to = to;
8507 recurring_day_transition->time_offset = time_offset;
8508 recurring_day_transition->month = month;
8509 recurring_day_transition->day_of_week = day_of_week;
8510 recurring_day_transition->occurrence = occurrence;
8511 } else {
8512 e_ews_calendar_to_free (to);
8513 g_free (time_offset);
8514 g_free (month);
8515 g_free (day_of_week);
8516 g_free (occurrence);
8517 }
8518
8519 return recurring_day_transition;
8520 }
8521
8522 static GSList * /* EEwsCalendarAbsoluteDateTransition * */
8523 ews_get_absolute_date_transitions_list (ESoapParameter *node)
8524 {
8525 ESoapParameter *param;
8526 GSList *absolute_date_transitions = NULL;
8527
8528 for (param = e_soap_parameter_get_first_child_by_name (node, "AbsoluteDateTransition");
8529 param != NULL;
8530 param = e_soap_parameter_get_next_child_by_name (param, "AbsoluteDateTransition")) {
8531 EEwsCalendarAbsoluteDateTransition *absolute_date_transition;
8532
8533 absolute_date_transition = ews_get_absolute_date_transition (param);
8534 if (absolute_date_transition != NULL) {
8535 absolute_date_transitions =
8536 g_slist_prepend (absolute_date_transitions, absolute_date_transition);
8537 } else {
8538 g_slist_free_full (
8539 absolute_date_transitions,
8540 (GDestroyNotify) e_ews_calendar_absolute_date_transition_free);
8541 return NULL;
8542 }
8543 }
8544
8545 absolute_date_transitions = g_slist_reverse (absolute_date_transitions);
8546 return absolute_date_transitions;
8547 }
8548
8549 static GSList * /* EEwsCalendarRecurringDayTransition * */
8550 ews_get_recurring_day_transitions_list (ESoapParameter *node)
8551 {
8552 ESoapParameter *param;
8553 GSList *recurring_day_transitions = NULL;
8554
8555 for (param = e_soap_parameter_get_first_child_by_name (node, "RecurringDayTransition");
8556 param != NULL;
8557 param = e_soap_parameter_get_next_child_by_name (param, "RecurringDayTransition")) {
8558 EEwsCalendarRecurringDayTransition *recurring_day_transition;
8559
8560 recurring_day_transition = ews_get_recurring_day_transition (param);
8561 if (recurring_day_transition != NULL) {
8562 recurring_day_transitions =
8563 g_slist_prepend (recurring_day_transitions, recurring_day_transition);
8564 } else {
8565 g_slist_free_full (
8566 recurring_day_transitions,
8567 (GDestroyNotify) e_ews_calendar_recurring_day_transition_free);
8568 return NULL;
8569 }
8570 }
8571
8572 recurring_day_transitions = g_slist_reverse (recurring_day_transitions);
8573 return recurring_day_transitions;
8574 }
8575
8576 static GSList * /* EEwsCalendarRecurringDateTransition * */
8577 ews_get_recurring_date_transitions_list (ESoapParameter *node)
8578 {
8579 ESoapParameter *param;
8580 GSList *recurring_date_transitions = NULL;
8581
8582 for (param = e_soap_parameter_get_first_child_by_name (node, "RecurringDateTransition");
8583 param != NULL;
8584 param = e_soap_parameter_get_next_child_by_name (param, "RecurringDateTransition")) {
8585 EEwsCalendarRecurringDateTransition *recurring_date_transition;
8586
8587 recurring_date_transition = ews_get_recurring_date_transition (param);
8588 if (recurring_date_transition != NULL) {
8589 recurring_date_transitions =
8590 g_slist_prepend (recurring_date_transitions, recurring_date_transition);
8591 } else {
8592 g_slist_free_full (
8593 recurring_date_transitions,
8594 (GDestroyNotify) e_ews_calendar_recurring_date_transition_free);
8595 return NULL;
8596 }
8597 }
8598
8599 recurring_date_transitions = g_slist_reverse (recurring_date_transitions);
8600 return recurring_date_transitions;
8601 }
8602
8603 static EEwsCalendarTransitionsGroup *
8604 ews_get_transitions_group (ESoapParameter *node)
8605 {
8606 EEwsCalendarTransitionsGroup *tg = NULL;
8607 EEwsCalendarTo *transition = NULL;
8608 ESoapParameter *param = NULL;
8609 gchar *id = NULL;
8610 GSList *absolute_date_transitions = NULL;
8611 GSList *recurring_date_transitions = NULL;
8612 GSList *recurring_day_transitions = NULL;
8613
8614 id = e_soap_parameter_get_property (node, "Id");
8615 if (id == NULL)
8616 return NULL;
8617
8618 param = e_soap_parameter_get_first_child_by_name (node, "Transition");
8619 if (param != NULL)
8620 transition = ews_get_to (param);
8621
8622 absolute_date_transitions = ews_get_absolute_date_transitions_list (node);
8623 recurring_date_transitions = ews_get_recurring_date_transitions_list (node);
8624 recurring_day_transitions = ews_get_recurring_day_transitions_list (node);
8625
8626 tg = e_ews_calendar_transitions_group_new ();
8627 tg->id = id;
8628 tg->transition = transition;
8629 tg->absolute_date_transitions = absolute_date_transitions;
8630 tg->recurring_date_transitions = recurring_date_transitions;
8631 tg->recurring_day_transitions = recurring_day_transitions;
8632
8633 return tg;
8634 }
8635
8636 static GSList * /* EEwsCalendarTransitionsGroup * */
8637 ews_get_transitions_groups_list (ESoapParameter *node)
8638 {
8639 ESoapParameter *param;
8640 GSList *transitions_groups = NULL;
8641
8642 for (param = e_soap_parameter_get_first_child_by_name (node, "TransitionsGroup");
8643 param != NULL;
8644 param = e_soap_parameter_get_next_child_by_name (param, "TransitionsGroup")) {
8645 EEwsCalendarTransitionsGroup *tg;
8646
8647 tg = ews_get_transitions_group (param);
8648 if (tg != NULL) {
8649 transitions_groups = g_slist_prepend (transitions_groups, tg);
8650 } else {
8651 g_slist_free_full (transitions_groups, (GDestroyNotify) e_ews_calendar_transitions_group_free);
8652 return NULL;
8653 }
8654 }
8655
8656 transitions_groups = g_slist_reverse (transitions_groups);
8657 return transitions_groups;
8658 }
8659
8660 static EEwsCalendarTransitions *
8661 ews_get_transitions (ESoapParameter *node)
8662 {
8663 ESoapParameter *param;
8664 EEwsCalendarTransitions *transitions = NULL;
8665 EEwsCalendarTo *transition = NULL;
8666 GSList *absolute_date_transitions = NULL;
8667 GSList *recurring_date_transitions = NULL;
8668 GSList *recurring_day_transitions = NULL;
8669
8670 param = e_soap_parameter_get_first_child_by_name (node, "Transition");
8671 if (param != NULL)
8672 transition = ews_get_to (param);
8673
8674 if (transition == NULL)
8675 return NULL;
8676
8677 absolute_date_transitions = ews_get_absolute_date_transitions_list (node);
8678 recurring_day_transitions = ews_get_recurring_day_transitions_list (node);
8679 recurring_date_transitions = ews_get_recurring_date_transitions_list (node);
8680
8681 transitions = e_ews_calendar_transitions_new ();
8682 transitions->transition = transition;
8683 transitions->absolute_date_transitions = absolute_date_transitions;
8684 transitions->recurring_day_transitions = recurring_day_transitions;
8685 transitions->recurring_date_transitions = recurring_date_transitions;
8686
8687 return transitions;
8688 }
8689
8690 static EEwsCalendarTimeZoneDefinition *
8691 ews_get_time_zone_definition (ESoapParameter *node)
8692 {
8693 ESoapParameter *param;
8694 gchar *name = NULL;
8695 gchar *id = NULL;
8696 GSList *periods = NULL;
8697 GSList *transitions_groups = NULL;
8698 EEwsCalendarTransitions *transitions = NULL;
8699 EEwsCalendarTimeZoneDefinition *tzd = NULL;
8700 gboolean success = FALSE;
8701
8702 name = e_soap_parameter_get_property (node, "Name");
8703 if (name == NULL)
8704 goto exit;
8705
8706 id = e_soap_parameter_get_property (node, "Id");
8707 if (id == NULL)
8708 goto exit;
8709
8710 param = e_soap_parameter_get_first_child_by_name (node, "Periods");
8711 if (param != NULL)
8712 periods = ews_get_periods_list (param);
8713 if (periods == NULL)
8714 goto exit;
8715
8716 param = e_soap_parameter_get_first_child_by_name (node, "TransitionsGroups");
8717 if (param != NULL)
8718 transitions_groups = ews_get_transitions_groups_list (param);
8719 if (transitions_groups == NULL)
8720 goto exit;
8721
8722 param = e_soap_parameter_get_first_child_by_name (node, "Transitions");
8723 if (param != NULL)
8724 transitions = ews_get_transitions (param);
8725 if (transitions == NULL)
8726 goto exit;
8727
8728 success = TRUE;
8729
8730 exit:
8731 if (success) {
8732 tzd = e_ews_calendar_time_zone_definition_new ();
8733 tzd->name = name;
8734 tzd->id = id;
8735 tzd->periods = periods;
8736 tzd->transitions_groups = transitions_groups;
8737 tzd->transitions = transitions;
8738 } else {
8739 g_free (name);
8740 g_free (id);
8741 g_slist_free_full (periods, (GDestroyNotify) e_ews_calendar_period_free);
8742 g_slist_free_full (transitions_groups, (GDestroyNotify) e_ews_calendar_transitions_group_free);
8743 e_ews_calendar_transitions_free (transitions);
8744 }
8745
8746 return tzd;
8747 }
8748
8749 static gboolean
8750 e_ews_process_get_server_time_zones_response (EEwsConnection *cnc,
8751 ESoapResponse *response,
8752 GSList **out_tzds,
8753 GError **error)
8754 {
8755 ESoapParameter *param;
8756 ESoapParameter *subparam;
8757 GError *local_error = NULL;
8758
8759 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
8760
8761 /* Sanity check */
8762 g_return_val_if_fail (
8763 (param != NULL && local_error == NULL) ||
8764 (param == NULL && local_error != NULL), FALSE);
8765
8766 if (local_error) {
8767 g_propagate_error (error, local_error);
8768 return FALSE;
8769 }
8770
8771 subparam = e_soap_parameter_get_first_child (param);
8772
8773 while (subparam != NULL) {
8774 const gchar *name = (const gchar *) subparam->name;
8775
8776 if (!ews_get_response_status (subparam, error))
8777 return FALSE;
8778
8779 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "GetServerTimeZonesResponseMessage") && out_tzds) {
8780 ESoapParameter *node, *node2;
8781
8782 node = e_soap_parameter_get_first_child_by_name (subparam, "TimeZoneDefinitions");
8783 if (node != NULL) {
8784 node2 = e_soap_parameter_get_first_child_by_name (node, "TimeZoneDefinition");
8785 if (node2 != NULL) {
8786 EEwsCalendarTimeZoneDefinition *tzd;
8787
8788 tzd = ews_get_time_zone_definition (node2);
8789 if (tzd != NULL)
8790 *out_tzds = g_slist_prepend (*out_tzds, tzd);
8791 }
8792 }
8793 }
8794
8795 subparam = e_soap_parameter_get_next_child (subparam);
8796 }
8797
8798 if (out_tzds)
8799 *out_tzds = g_slist_reverse (*out_tzds);
8800
8801 return TRUE;
8802 }
8803
8804 gboolean
8805 e_ews_connection_get_server_time_zones_sync (EEwsConnection *cnc,
8806 gint pri,
8807 const GSList *msdn_locations,
8808 GSList **out_tzds, /* EEwsCalendarTimeZoneDefinition */
8809 GCancellable *cancellable,
8810 GError **error)
8811 {
8812 ESoapRequest *request;
8813 ESoapResponse *response;
8814 const GSList *link;
8815 gboolean success;
8816
8817 g_return_val_if_fail (cnc != NULL, FALSE);
8818 g_return_val_if_fail (out_tzds != NULL, FALSE);
8819
8820 *out_tzds = NULL;
8821
8822 /*
8823 * EWS server version earlier than 2010 doesn't have support to "GetServerTimeZones".
8824 * So, if the API is called with an older Exchange's version, let's just "fail" silently.
8825 */
8826 if (!e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2010_SP1)) {
8827 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Requires at least Microsoft Exchange 2010 SP1 server"));
8828 return FALSE;
8829 }
8830
8831 request = e_ews_request_new_with_header (
8832 cnc->priv->uri,
8833 cnc->priv->impersonate_user,
8834 "GetServerTimeZones",
8835 "ReturnFullTimeZoneData",
8836 "true",
8837 cnc->priv->version,
8838 E_EWS_EXCHANGE_2010,
8839 FALSE,
8840 error);
8841
8842 if (!request)
8843 return FALSE;
8844
8845 e_soap_request_start_element (request, "Ids", "messages", NULL);
8846 for (link = msdn_locations; link; link = g_slist_next (link)) {
8847 e_ews_request_write_string_parameter_with_attribute (request, "Id", NULL, link->data, NULL, NULL);
8848 }
8849 e_soap_request_end_element (request); /* Ids */
8850
8851 e_ews_request_write_footer (request);
8852
8853 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
8854
8855 if (!response) {
8856 g_clear_object (&request);
8857 return FALSE;
8858 }
8859
8860 success = e_ews_process_get_server_time_zones_response (cnc, response, out_tzds, error);
8861
8862 g_clear_object (&request);
8863 g_clear_object (&response);
8864
8865 if (!success) {
8866 g_slist_free_full (*out_tzds, (GDestroyNotify) e_ews_calendar_time_zone_definition_free);
8867 *out_tzds = NULL;
8868 }
8869
8870 if (!*out_tzds)
8871 success = FALSE;
8872
8873 return success;
8874 }
8875
8876 static gboolean
8877 e_ews_process_get_user_photo_response (EEwsConnection *cnc,
8878 ESoapResponse *response,
8879 gchar **out_picture_data,
8880 GError **error)
8881 {
8882 ESoapParameter *param;
8883 GError *local_error = NULL;
8884
8885 param = e_soap_response_get_first_parameter_by_name (response, "PictureData", &local_error);
8886
8887 /* Sanity check */
8888 g_return_val_if_fail (
8889 (param != NULL && local_error == NULL) ||
8890 (param == NULL && local_error != NULL), FALSE);
8891
8892 if (local_error) {
8893 g_propagate_error (error, local_error);
8894 return FALSE;
8895 }
8896
8897 *out_picture_data = e_soap_parameter_get_string_value (param);
8898
8899 if (*out_picture_data && !**out_picture_data)
8900 g_clear_pointer (out_picture_data, g_free);
8901
8902 return TRUE;
8903 }
8904
8905 gboolean
8906 e_ews_connection_get_user_photo_sync (EEwsConnection *cnc,
8907 gint pri,
8908 const gchar *email,
8909 EEwsSizeRequested size_requested,
8910 gchar **out_picture_data, /* base64-encoded */
8911 GCancellable *cancellable,
8912 GError **error)
8913 {
8914 ESoapRequest *request;
8915 ESoapResponse *response;
8916 gchar *tmp;
8917 gboolean success;
8918
8919 g_return_val_if_fail (cnc != NULL, FALSE);
8920 g_return_val_if_fail (out_picture_data != NULL, FALSE);
8921
8922 *out_picture_data = NULL;
8923
8924 /*
8925 * EWS server version earlier than 2013 doesn't have support to "GetUserPhoto".
8926 */
8927 if (!e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2013)) {
8928 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Requires at least Microsoft Exchange 2013 server"));
8929 return FALSE;
8930 }
8931
8932 request = e_ews_request_new_with_header (
8933 cnc->priv->uri,
8934 cnc->priv->impersonate_user,
8935 "GetUserPhoto",
8936 NULL,
8937 NULL,
8938 cnc->priv->version,
8939 E_EWS_EXCHANGE_2013,
8940 FALSE,
8941 error);
8942
8943 if (!request)
8944 return FALSE;
8945
8946 e_soap_request_start_element (request, "Email", "messages", NULL);
8947 e_soap_request_write_string (request, email);
8948 e_soap_request_end_element (request); /* Email */
8949
8950 e_soap_request_start_element (request, "SizeRequested", "messages", NULL);
8951 tmp = g_strdup_printf ("HR%dx%d", (gint) size_requested, size_requested);
8952 e_soap_request_write_string (request, tmp);
8953 g_free (tmp);
8954 e_soap_request_end_element (request); /* SizeRequested */
8955
8956 e_ews_request_write_footer (request);
8957
8958 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
8959
8960 if (!response) {
8961 g_clear_object (&request);
8962 return FALSE;
8963 }
8964
8965 success = e_ews_process_get_user_photo_response (cnc, response, out_picture_data, error);
8966
8967 g_clear_object (&request);
8968 g_clear_object (&response);
8969
8970 if (!*out_picture_data)
8971 success = FALSE;
8972 else if (!success)
8973 g_clear_pointer (out_picture_data, g_free);
8974
8975 return success;
8976 }
8977
8978 static gboolean
8979 e_ews_process_get_user_configuration_response (EEwsConnection *cnc,
8980 ESoapResponse *response,
8981 gchar **out_properties,
8982 GError **error)
8983 {
8984 ESoapParameter *param, *subparam;
8985 GError *local_error = NULL;
8986
8987 *out_properties = NULL;
8988
8989 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
8990
8991 if (param) {
8992 param = e_soap_parameter_get_first_child_by_name (param, "GetUserConfigurationResponseMessage");
8993 if (!param) {
8994 g_set_error (&local_error, G_IO_ERROR, G_IO_ERROR_FAILED,
8995 "Missing <%s> in SOAP response", "GetUserConfigurationResponseMessage");
8996 }
8997 }
8998
8999 if (param) {
9000 param = e_soap_parameter_get_first_child_by_name (param, "UserConfiguration");
9001 if (!param) {
9002 g_set_error (&local_error, G_IO_ERROR, G_IO_ERROR_FAILED,
9003 "Missing <%s> in SOAP response", "UserConfiguration");
9004 }
9005 }
9006
9007 /* Sanity check */
9008 g_return_val_if_fail (
9009 (param != NULL && local_error == NULL) ||
9010 (param == NULL && local_error != NULL), FALSE);
9011
9012 if (local_error) {
9013 g_propagate_error (error, local_error);
9014 return FALSE;
9015 }
9016
9017 subparam = e_soap_parameter_get_first_child_by_name (param, "ItemId");
9018 if (subparam) {
9019 gchar *id, *changekey;
9020
9021 id = e_soap_parameter_get_property (subparam, "Id");
9022 changekey = e_soap_parameter_get_property (subparam, "ChangeKey");
9023
9024 /* Encoded as: Id + "\n" + ChangeKey */
9025 *out_properties = g_strconcat (id ? id : "", "\n", changekey, NULL);
9026
9027 g_free (changekey);
9028 g_free (id);
9029 }
9030
9031 if (!subparam) {
9032 subparam = e_soap_parameter_get_first_child_by_name (param, "Dictionary");
9033 if (subparam)
9034 *out_properties = e_soap_response_dump_parameter (response, subparam);
9035 }
9036
9037 if (!subparam) {
9038 subparam = e_soap_parameter_get_first_child_by_name (param, "XmlData");
9039 if (subparam) {
9040 *out_properties = e_soap_parameter_get_string_value (subparam);
9041 }
9042 }
9043
9044 if (!subparam) {
9045 subparam = e_soap_parameter_get_first_child_by_name (param, "BinaryData");
9046 if (subparam) {
9047 *out_properties = e_soap_parameter_get_string_value (subparam);
9048 }
9049 }
9050
9051 if (*out_properties && !**out_properties) {
9052 g_free (*out_properties);
9053 *out_properties = NULL;
9054 }
9055
9056 return *out_properties != NULL;
9057 }
9058
9059 gboolean
9060 e_ews_connection_get_user_configuration_sync (EEwsConnection *cnc,
9061 gint pri,
9062 const EwsFolderId *fid,
9063 const gchar *config_name,
9064 EEwsUserConfigurationProperties props,
9065 gchar **out_properties,
9066 GCancellable *cancellable,
9067 GError **error)
9068 {
9069 ESoapRequest *request;
9070 ESoapResponse *response;
9071 EwsFolderId local_fid;
9072 gboolean success;
9073
9074 g_return_val_if_fail (cnc != NULL, FALSE);
9075 g_return_val_if_fail (out_properties != NULL, FALSE);
9076
9077 *out_properties = NULL;
9078
9079 /* EWS server version earlier than 2010 doesn't support it. */
9080 if (!e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2010)) {
9081 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Requires at least Microsoft Exchange 2010 server"));
9082 return FALSE;
9083 }
9084
9085 local_fid = *fid;
9086 local_fid.change_key = NULL;
9087
9088 request = e_ews_request_new_with_header (
9089 cnc->priv->uri,
9090 cnc->priv->impersonate_user,
9091 "GetUserConfiguration",
9092 NULL,
9093 NULL,
9094 cnc->priv->version,
9095 E_EWS_EXCHANGE_2010,
9096 FALSE,
9097 error);
9098
9099 if (!request)
9100 return FALSE;
9101
9102 e_soap_request_start_element (request, "UserConfigurationName", "messages", NULL);
9103 e_soap_request_add_attribute (request, "Name", config_name, NULL, NULL);
9104
9105 e_ews_folder_id_append_to_request (request, cnc->priv->email, &local_fid);
9106
9107 e_soap_request_end_element (request); /* UserConfigurationName */
9108
9109 e_soap_request_start_element (request, "UserConfigurationProperties", "messages", NULL);
9110
9111 switch (props) {
9112 case E_EWS_USER_CONFIGURATION_PROPERTIES_ID:
9113 e_soap_request_write_string (request, "Id");
9114 break;
9115 case E_EWS_USER_CONFIGURATION_PROPERTIES_DICTIONARY:
9116 e_soap_request_write_string (request, "Dictionary");
9117 break;
9118 case E_EWS_USER_CONFIGURATION_PROPERTIES_XMLDATA:
9119 e_soap_request_write_string (request, "XmlData");
9120 break;
9121 case E_EWS_USER_CONFIGURATION_PROPERTIES_BINARYDATA:
9122 e_soap_request_write_string (request, "BinaryData");
9123 break;
9124 /* case E_EWS_USER_CONFIGURATION_PROPERTIES_ALL:
9125 e_soap_request_write_string (request, "All");
9126 break; */
9127 default:
9128 e_soap_request_write_string (request, "Unknown");
9129 break;
9130 }
9131
9132 e_soap_request_end_element (request); /* UserConfigurationProperties */
9133
9134 e_ews_request_write_footer (request);
9135
9136 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9137
9138 if (!response) {
9139 g_clear_object (&request);
9140 return FALSE;
9141 }
9142
9143 success = e_ews_process_get_user_configuration_response (cnc, response, out_properties, error);
9144
9145 g_clear_object (&request);
9146 g_clear_object (&response);
9147
9148 if (!success)
9149 g_clear_pointer (out_properties, g_free);
9150
9151 return success;
9152 }
9153
9154 static gboolean
9155 e_ews_process_convert_id_response (EEwsConnection *cnc,
9156 ESoapResponse *response,
9157 gchar **out_converted_id,
9158 GError **error)
9159 {
9160 ESoapParameter *param;
9161 GError *local_error = NULL;
9162
9163 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
9164
9165 if (param) {
9166 param = e_soap_parameter_get_first_child_by_name (param, "ConvertIdResponseMessage");
9167 if (!param) {
9168 g_set_error (&local_error, G_IO_ERROR, G_IO_ERROR_FAILED,
9169 "Missing <%s> in SOAP response", "ConvertIdResponseMessage");
9170 }
9171 }
9172
9173 if (param) {
9174 param = e_soap_parameter_get_first_child_by_name (param, "AlternateId");
9175 if (!param) {
9176 g_set_error (&local_error, G_IO_ERROR, G_IO_ERROR_FAILED,
9177 "Missing <%s> in SOAP response", "AlternateId");
9178 }
9179 }
9180
9181 /* Sanity check */
9182 g_return_val_if_fail (
9183 (param != NULL && local_error == NULL) ||
9184 (param == NULL && local_error != NULL), FALSE);
9185
9186 if (local_error) {
9187 g_propagate_error (error, local_error);
9188 return FALSE;
9189 }
9190
9191 *out_converted_id = e_soap_parameter_get_property (param, "Id");
9192
9193 return TRUE;
9194 }
9195
9196 gboolean
9197 e_ews_connection_convert_id_sync (EEwsConnection *cnc,
9198 gint pri,
9199 const gchar *email,
9200 const gchar *folder_id,
9201 const gchar *from_format,
9202 const gchar *to_format,
9203 gchar **out_converted_id,
9204 GCancellable *cancellable,
9205 GError **error)
9206 {
9207 ESoapRequest *request;
9208 ESoapResponse *response;
9209 gboolean success;
9210
9211 g_return_val_if_fail (cnc != NULL, FALSE);
9212 g_return_val_if_fail (folder_id != NULL, FALSE);
9213 g_return_val_if_fail (from_format != NULL, FALSE);
9214 g_return_val_if_fail (to_format != NULL, FALSE);
9215 g_return_val_if_fail (out_converted_id != NULL, FALSE);
9216
9217 *out_converted_id = NULL;
9218
9219 /* EWS server version earlier than 2007 SP1 doesn't support it. */
9220 if (!e_ews_connection_satisfies_server_version (cnc, E_EWS_EXCHANGE_2007_SP1)) {
9221 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("Requires at least Microsoft Exchange 2007 SP1 server"));
9222 return FALSE;
9223 }
9224
9225 request = e_ews_request_new_with_header (
9226 cnc->priv->uri,
9227 cnc->priv->impersonate_user,
9228 "ConvertId",
9229 "DestinationFormat",
9230 to_format,
9231 cnc->priv->version,
9232 E_EWS_EXCHANGE_2007_SP1,
9233 FALSE,
9234 error);
9235
9236 if (!request)
9237 return FALSE;
9238
9239 e_soap_request_start_element (request, "SourceIds", "messages", NULL);
9240 e_soap_request_start_element (request, "AlternateId", NULL, NULL);
9241
9242 e_soap_request_add_attribute (request, "Id", folder_id, NULL, NULL);
9243 e_soap_request_add_attribute (request, "Format", from_format, NULL, NULL);
9244 e_soap_request_add_attribute (request, "Mailbox", email, NULL, NULL);
9245
9246 e_soap_request_end_element (request); /* AlternateId */
9247 e_soap_request_end_element (request); /* SourceIds */
9248
9249 e_ews_request_write_footer (request);
9250
9251 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9252
9253 if (!response) {
9254 g_clear_object (&request);
9255 return FALSE;
9256 }
9257
9258 success = e_ews_process_convert_id_response (cnc, response, out_converted_id, error);
9259
9260 g_clear_object (&request);
9261 g_clear_object (&response);
9262
9263 if (!success)
9264 g_clear_pointer (out_converted_id, g_free);
9265
9266 return success;
9267 }
9268
9269 static GDateTime *
9270 ews_oof_settings_string_to_date_time (const gchar *string)
9271 {
9272 GDateTime *date_time = NULL;
9273
9274 if (string) {
9275 GTimeZone *utc = g_time_zone_new_utc ();
9276
9277 date_time = g_date_time_new_from_iso8601 (string, utc);
9278
9279 g_time_zone_unref (utc);
9280 }
9281
9282 return date_time;
9283 }
9284
9285 static gchar *
9286 ews_oof_settings_text_from_html (gchar *html_text)
9287 {
9288 gsize haystack_len;
9289 gchar *plain_text;
9290 gchar *start, *end;
9291 gchar *ii, *jj;
9292
9293 g_return_val_if_fail (html_text != NULL, NULL);
9294
9295 haystack_len = strlen (html_text);
9296 start = g_strstr_len (html_text, haystack_len, "<body");
9297 end = g_strstr_len (html_text, haystack_len, "</body>");
9298
9299 /* Parse the status set by Outlook Web Access. */
9300 if (g_strrstr (html_text, "BodyFragment") != NULL && start == NULL) {
9301 start = html_text;
9302 end = html_text + haystack_len;
9303 }
9304
9305 /* Strip HTML tags. */
9306 plain_text = jj = g_malloc (end - start);
9307 for (ii = start; ii < end; ii++) {
9308 if (*ii == '<') {
9309 while (*ii != '>')
9310 ii++;
9311 } else {
9312 *jj++ = *ii;
9313 }
9314 }
9315 *jj = '\0';
9316
9317 return plain_text;
9318 }
9319
9320 static gboolean
9321 e_ews_process_get_user_oof_settings_response (EEwsConnection *cnc,
9322 ESoapResponse *response,
9323 EEwsOofSettings *oof_settings,
9324 GError **error)
9325 {
9326 ESoapParameter *param;
9327 ESoapParameter *subparam;
9328 ESoapParameter *subsubparam;
9329 GDateTime *date_time;
9330 gchar *string;
9331 gchar *text;
9332 GError *local_error = NULL;
9333
9334 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessage", &local_error);
9335
9336 /* Sanity check */
9337 g_return_val_if_fail (
9338 (param != NULL && local_error == NULL) ||
9339 (param == NULL && local_error != NULL), FALSE);
9340
9341 if (local_error) {
9342 g_propagate_error (error, local_error);
9343 return FALSE;
9344 }
9345
9346 if (!ews_get_response_status (param, error))
9347 return FALSE;
9348
9349 param = e_soap_response_get_first_parameter_by_name (response, "OofSettings", &local_error);
9350
9351 /* Sanity check */
9352 g_return_val_if_fail (
9353 (param != NULL && local_error == NULL) ||
9354 (param == NULL && local_error != NULL), FALSE);
9355
9356 if (local_error) {
9357 g_propagate_error (error, local_error);
9358 return FALSE;
9359 }
9360
9361 subparam = e_soap_parameter_get_first_child_by_name (param, "OofState");
9362 string = e_soap_parameter_get_string_value (subparam);
9363 if (g_strcmp0 (string, "Disabled") == 0)
9364 e_ews_oof_settings_set_state (oof_settings, E_EWS_OOF_STATE_DISABLED);
9365 else if (g_strcmp0 (string, "Enabled") == 0)
9366 e_ews_oof_settings_set_state (oof_settings, E_EWS_OOF_STATE_ENABLED);
9367 else if (g_strcmp0 (string, "Scheduled") == 0)
9368 e_ews_oof_settings_set_state (oof_settings, E_EWS_OOF_STATE_SCHEDULED);
9369 g_free (string);
9370
9371 subparam = e_soap_parameter_get_first_child_by_name (param, "ExternalAudience");
9372 string = e_soap_parameter_get_string_value (subparam);
9373 if (g_strcmp0 (string, "None") == 0)
9374 e_ews_oof_settings_set_external_audience (oof_settings, E_EWS_EXTERNAL_AUDIENCE_NONE);
9375 else if (g_strcmp0 (string, "Known") == 0)
9376 e_ews_oof_settings_set_external_audience (oof_settings, E_EWS_EXTERNAL_AUDIENCE_KNOWN);
9377 else if (g_strcmp0 (string, "All") == 0)
9378 e_ews_oof_settings_set_external_audience (oof_settings, E_EWS_EXTERNAL_AUDIENCE_ALL);
9379 g_free (string);
9380
9381 subparam = e_soap_parameter_get_first_child_by_name (param, "Duration");
9382 subsubparam = e_soap_parameter_get_first_child_by_name (subparam, "StartTime");
9383 string = e_soap_parameter_get_string_value (subsubparam);
9384 date_time = ews_oof_settings_string_to_date_time (string);
9385 if (date_time != NULL) {
9386 e_ews_oof_settings_set_start_time (oof_settings, date_time);
9387 g_date_time_unref (date_time);
9388 }
9389 g_free (string);
9390
9391 subsubparam = e_soap_parameter_get_first_child_by_name (subparam, "EndTime");
9392 string = e_soap_parameter_get_string_value (subsubparam);
9393 date_time = ews_oof_settings_string_to_date_time (string);
9394 if (date_time != NULL) {
9395 e_ews_oof_settings_set_end_time (oof_settings, date_time);
9396 g_date_time_unref (date_time);
9397 }
9398 g_free (string);
9399
9400 subparam = e_soap_parameter_get_first_child_by_name (param, "InternalReply");
9401 subsubparam = e_soap_parameter_get_first_child_by_name (subparam, "Message");
9402 string = e_soap_parameter_get_string_value (subsubparam);
9403 if (string == NULL)
9404 text = NULL;
9405 else if (g_strrstr (string, "</body>") != NULL)
9406 text = ews_oof_settings_text_from_html (string);
9407 else if (g_strrstr (string, "BodyFragment") != NULL)
9408 text = ews_oof_settings_text_from_html (string);
9409 else
9410 text = g_strdup (string);
9411 e_ews_oof_settings_set_internal_reply (oof_settings, text ? text : "");
9412 g_free (string);
9413 g_free (text);
9414
9415 subparam = e_soap_parameter_get_first_child_by_name (param, "ExternalReply");
9416 subsubparam = e_soap_parameter_get_first_child_by_name (subparam, "Message");
9417 string = e_soap_parameter_get_string_value (subsubparam);
9418 if (string == NULL)
9419 text = NULL;
9420 else if (g_strrstr (string, "</body>") != NULL)
9421 text = ews_oof_settings_text_from_html (string);
9422 else if (g_strrstr (string, "BodyFragment") != NULL)
9423 text = ews_oof_settings_text_from_html (string);
9424 else
9425 text = g_strdup (string);
9426 e_ews_oof_settings_set_external_reply (oof_settings, text ? text : "");
9427 g_free (string);
9428 g_free (text);
9429
9430 return TRUE;
9431 }
9432
9433 gboolean
9434 e_ews_connection_get_user_oof_settings_sync (EEwsConnection *cnc,
9435 gint pri,
9436 EEwsOofSettings *inout_oof_settings,
9437 GCancellable *cancellable,
9438 GError **error)
9439 {
9440 ESoapRequest *request;
9441 ESoapResponse *response;
9442 gboolean success;
9443
9444 g_return_val_if_fail (cnc != NULL, FALSE);
9445 g_return_val_if_fail (inout_oof_settings != NULL, FALSE);
9446
9447 request = e_ews_request_new_with_header (
9448 cnc->priv->uri,
9449 cnc->priv->impersonate_user,
9450 "GetUserOofSettingsRequest",
9451 NULL,
9452 NULL,
9453 cnc->priv->version,
9454 E_EWS_EXCHANGE_2007_SP1,
9455 FALSE,
9456 error);
9457
9458 if (!request)
9459 return FALSE;
9460
9461 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
9462 e_ews_request_write_string_parameter (request, "Address", NULL, e_ews_connection_get_mailbox (cnc));
9463 e_soap_request_end_element (request);
9464
9465 e_ews_request_write_footer (request);
9466
9467 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9468
9469 if (!response) {
9470 g_clear_object (&request);
9471 return FALSE;
9472 }
9473
9474 success = e_ews_process_get_user_oof_settings_response (cnc, response, inout_oof_settings, error);
9475
9476 g_clear_object (&request);
9477 g_clear_object (&response);
9478
9479 return success;
9480 }
9481
9482 static gchar *
9483 ews_oof_settings_date_time_to_string (const GDateTime *date_time)
9484 {
9485 gchar *string = NULL;
9486
9487 if (date_time)
9488 string = g_date_time_format_iso8601 ((GDateTime *) date_time);
9489
9490 return string;
9491 }
9492
9493 static gboolean
9494 e_ews_process_set_user_oof_settings_response (EEwsConnection *cnc,
9495 ESoapResponse *response,
9496 GError **error)
9497 {
9498 ESoapParameter *param;
9499 GError *local_error = NULL;
9500
9501 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessage", &local_error);
9502
9503 /* Sanity check */
9504 g_return_val_if_fail (
9505 (param != NULL && local_error == NULL) ||
9506 (param == NULL && local_error != NULL), FALSE);
9507
9508 if (local_error) {
9509 g_propagate_error (error, local_error);
9510 return FALSE;
9511 }
9512
9513 return ews_get_response_status (param, error);
9514 }
9515
9516 gboolean
9517 e_ews_connection_set_user_oof_settings_sync (EEwsConnection *cnc,
9518 gint pri,
9519 EEwsOofState state,
9520 EEwsExternalAudience external_audience,
9521 const GDateTime *start_date,
9522 const GDateTime *end_date,
9523 const gchar *internal_reply,
9524 const gchar *external_reply,
9525 GCancellable *cancellable,
9526 GError **error)
9527 {
9528 ESoapRequest *request;
9529 ESoapResponse *response;
9530 gchar *start_time;
9531 gchar *end_time;
9532 const gchar *string;
9533 gboolean success;
9534
9535 g_return_val_if_fail (cnc != NULL, FALSE);
9536
9537 request = e_ews_request_new_with_header (
9538 cnc->priv->uri,
9539 cnc->priv->impersonate_user,
9540 "SetUserOofSettingsRequest",
9541 NULL,
9542 NULL,
9543 cnc->priv->version,
9544 E_EWS_EXCHANGE_2007_SP1,
9545 FALSE,
9546 error);
9547
9548 if (!request)
9549 return FALSE;
9550
9551 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
9552 e_ews_request_write_string_parameter (request, "Address", NULL, e_ews_connection_get_mailbox (cnc));
9553 e_soap_request_end_element (request);
9554
9555 e_soap_request_start_element (request, "UserOofSettings", NULL, NULL);
9556
9557 switch (state) {
9558 default:
9559 g_warn_if_reached ();
9560 /* fall through */
9561 case E_EWS_OOF_STATE_DISABLED:
9562 string = "Disabled";
9563 break;
9564 case E_EWS_OOF_STATE_ENABLED:
9565 string = "Enabled";
9566 break;
9567 case E_EWS_OOF_STATE_SCHEDULED:
9568 string = "Scheduled";
9569 break;
9570 }
9571
9572 e_ews_request_write_string_parameter (request, "OofState", NULL, string);
9573
9574 switch (external_audience) {
9575 default:
9576 g_warn_if_reached ();
9577 /* fall through */
9578 case E_EWS_EXTERNAL_AUDIENCE_NONE:
9579 string = "None";
9580 break;
9581 case E_EWS_EXTERNAL_AUDIENCE_KNOWN:
9582 string = "Known";
9583 break;
9584 case E_EWS_EXTERNAL_AUDIENCE_ALL:
9585 string = "All";
9586 break;
9587 }
9588
9589 e_ews_request_write_string_parameter (request, "ExternalAudience", NULL, string);
9590
9591 start_time = ews_oof_settings_date_time_to_string (start_date);
9592 end_time = ews_oof_settings_date_time_to_string (end_date);
9593
9594 e_soap_request_start_element (request, "Duration", NULL, NULL);
9595 e_ews_request_write_string_parameter (request, "StartTime", NULL, start_time);
9596 e_ews_request_write_string_parameter (request, "EndTime", NULL, end_time);
9597 e_soap_request_end_element (request);
9598
9599 g_free (start_time);
9600 g_free (end_time);
9601
9602 e_soap_request_start_element (request, "InternalReply", NULL, NULL);
9603 e_ews_request_write_string_parameter (request, "Message", NULL, internal_reply);
9604 e_soap_request_end_element (request);
9605
9606 e_soap_request_start_element (request, "ExternalReply", NULL, NULL);
9607 e_ews_request_write_string_parameter (request, "Message", NULL, external_reply);
9608 e_soap_request_end_element (request);
9609
9610 e_soap_request_end_element (request); /* UserOofSettings */
9611
9612 e_ews_request_write_footer (request);
9613
9614 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9615
9616 if (!response) {
9617 g_clear_object (&request);
9618 return FALSE;
9619 }
9620
9621 success = e_ews_process_set_user_oof_settings_response (cnc, response, error);
9622
9623 g_clear_object (&request);
9624 g_clear_object (&response);
9625
9626 return success;
9627 }
9628
9629 static gboolean
9630 e_ews_process_subscribe_response (EEwsConnection *cnc,
9631 ESoapResponse *response,
9632 gchar **out_subscription_id,
9633 GError **error)
9634 {
9635 ESoapParameter *param, *subparam;
9636 GError *local_error = NULL;
9637
9638 param = e_soap_response_get_first_parameter_by_name (response, "ResponseMessages", &local_error);
9639
9640 /* Sanity check */
9641 g_return_val_if_fail (
9642 (param != NULL && local_error == NULL) ||
9643 (param == NULL && local_error != NULL), FALSE);
9644
9645 if (local_error) {
9646 g_propagate_error (error, local_error);
9647 return FALSE;
9648 }
9649
9650 subparam = e_soap_parameter_get_first_child (param);
9651
9652 while (subparam != NULL) {
9653 const gchar *name = (const gchar *) subparam->name;
9654
9655 if (!ews_get_response_status (subparam, error))
9656 return FALSE;
9657
9658 if (E_EWS_CONNECTION_UTILS_CHECK_ELEMENT (name, "SubscribeResponseMessage")) {
9659 ESoapParameter *node;
9660
9661 node = e_soap_parameter_get_first_child_by_name (subparam, "SubscriptionId");
9662 *out_subscription_id = e_soap_parameter_get_string_value (node);
9663
9664 break;
9665 }
9666
9667 subparam = e_soap_parameter_get_next_child (subparam);
9668 }
9669
9670 return *out_subscription_id != NULL;
9671 }
9672
9673 gboolean
9674 e_ews_connection_subscribe_sync (EEwsConnection *cnc,
9675 gint pri,
9676 const GSList *folder_ids, /* gchar * */
9677 gchar **out_subscription_id,
9678 GCancellable *cancellable,
9679 GError **error)
9680 {
9681 ESoapRequest *request;
9682 ESoapResponse *response;
9683 const GSList *link;
9684 const gchar * const *event_names;
9685 gint event_type;
9686 gboolean success;
9687
9688 g_return_val_if_fail (cnc != NULL, FALSE);
9689 g_return_val_if_fail (out_subscription_id != NULL, FALSE);
9690
9691 *out_subscription_id = NULL;
9692
9693 request = e_ews_request_new_with_header (
9694 cnc->priv->uri,
9695 cnc->priv->impersonate_user,
9696 "Subscribe",
9697 NULL,
9698 NULL,
9699 cnc->priv->version,
9700 E_EWS_EXCHANGE_2010_SP1,
9701 FALSE,
9702 error);
9703
9704 if (!request)
9705 return FALSE;
9706
9707 e_soap_request_start_element (request, "StreamingSubscriptionRequest", "messages", NULL);
9708
9709 e_soap_request_start_element (request, "FolderIds", NULL, NULL);
9710 for (link = folder_ids; link; link = g_slist_next (link)) {
9711 e_ews_request_write_string_parameter_with_attribute (request, "FolderId", NULL, NULL, "Id", link->data);
9712 }
9713 e_soap_request_end_element (request); /* FolderIds */
9714
9715 event_names = e_ews_notification_get_event_names ();
9716
9717 e_soap_request_start_element (request, "EventTypes", NULL, NULL);
9718 for (event_type = 0; event_names[event_type] != NULL; event_type++) {
9719 if (g_strcmp0 (event_names[event_type], "StatusEvent") == 0)
9720 continue;
9721
9722 e_ews_request_write_string_parameter_with_attribute (request, "EventType", NULL, event_names[event_type], NULL, NULL);
9723 }
9724 e_soap_request_end_element (request); /* EventTypes */
9725
9726 e_soap_request_end_element (request); /* StreamingSubscriptionRequest */
9727
9728 e_ews_request_write_footer (request);
9729
9730 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9731
9732 if (!response) {
9733 g_clear_object (&request);
9734 return FALSE;
9735 }
9736
9737 success = e_ews_process_subscribe_response (cnc, response, out_subscription_id, error);
9738
9739 g_clear_object (&request);
9740 g_clear_object (&response);
9741
9742 return success;
9743 }
9744
9745 gboolean
9746 e_ews_connection_unsubscribe_sync (EEwsConnection *cnc,
9747 gint pri,
9748 const gchar *subscription_id,
9749 GCancellable *cancellable,
9750 GError **error)
9751 {
9752 ESoapRequest *request;
9753 ESoapResponse *response;
9754 gboolean success;
9755
9756 g_return_val_if_fail (cnc != NULL, FALSE);
9757 g_return_val_if_fail (subscription_id != NULL, FALSE);
9758
9759 request = e_ews_request_new_with_header (
9760 cnc->priv->uri,
9761 cnc->priv->impersonate_user,
9762 "Unsubscribe",
9763 NULL,
9764 NULL,
9765 cnc->priv->version,
9766 E_EWS_EXCHANGE_2010_SP1,
9767 FALSE,
9768 error);
9769
9770 if (!request)
9771 return FALSE;
9772
9773 e_ews_request_write_string_parameter_with_attribute (request, "SubscriptionId", "messages", subscription_id, NULL, NULL);
9774
9775 e_ews_request_write_footer (request);
9776
9777 response = e_ews_connection_send_request_sync (cnc, request, cancellable, error);
9778
9779 if (!response) {
9780 g_clear_object (&request);
9781 return FALSE;
9782 }
9783
9784 success = e_ews_process_generic_response (cnc, response, error);
9785
9786 g_clear_object (&request);
9787 g_clear_object (&response);
9788
9789 return success;
9790 }
9791
9792 GInputStream *
9793 e_ews_connection_prepare_streaming_events_sync (EEwsConnection *cnc,
9794 gint pri,
9795 const gchar *subscription_id,
9796 ESoupSession **out_session,
9797 SoupMessage **out_message,
9798 GCancellable *cancellable,
9799 GError **error)
9800 {
9801 ESoapRequest *request;
9802 CamelEwsSettings *settings;
9803 GInputStream *input_stream;
9804
9805 g_return_val_if_fail (cnc != NULL, NULL);
9806 g_return_val_if_fail (subscription_id != NULL, NULL);
9807 g_return_val_if_fail (out_session != NULL, NULL);
9808 g_return_val_if_fail (out_message != NULL, NULL);
9809
9810 request = e_ews_request_new_with_header (
9811 cnc->priv->uri,
9812 cnc->priv->impersonate_user,
9813 "GetStreamingEvents",
9814 NULL,
9815 NULL,
9816 cnc->priv->version,
9817 E_EWS_EXCHANGE_2010_SP1,
9818 FALSE,
9819 error);
9820
9821 if (!request)
9822 return NULL;
9823
9824 e_soap_request_start_element (request, "SubscriptionIds", "messages", NULL);
9825 e_ews_request_write_string_parameter_with_attribute (request, "SubscriptionId", NULL, subscription_id, NULL, NULL);
9826 e_soap_request_end_element (request);
9827
9828 e_ews_request_write_string_parameter_with_attribute (request, "ConnectionTimeout", "messages", "10", NULL, NULL);
9829
9830 e_ews_request_write_footer (request);
9831
9832 settings = e_ews_connection_ref_settings (cnc);
9833
9834 *out_session = e_ews_connection_create_soup_session (cnc);
9835 *out_message = e_soap_request_persist (request, *out_session, settings, error);
9836
9837 g_clear_object (&settings);
9838
9839 if (!*out_message) {
9840 g_clear_object (out_session);
9841 g_clear_object (&request);
9842 return NULL;
9843 }
9844
9845 e_ews_connection_maybe_prepare_message_for_testing_sources (cnc, *out_message);
9846
9847 g_mutex_lock (&cnc->priv->property_lock);
9848 e_soup_session_set_credentials (*out_session, cnc->priv->credentials);
9849 g_mutex_unlock (&cnc->priv->property_lock);
9850
9851 input_stream = e_soup_session_send_message_sync (*out_session, *out_message, cancellable, error);
9852
9853 g_clear_object (&request);
9854
9855 if (!input_stream) {
9856 g_clear_object (out_message);
9857 g_clear_object (out_session);
9858 }
9859
9860 return input_stream;
9861 }