/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* * Copyright © 2012 – 2018 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General * Public License along with this library; if not, see . */ /* Based on code by the Evolution team. * * This was originally written as a part of evolution-ews: * evolution-ews/src/server/e-ews-connection.c */ #include "config.h" #include #include #include #include #include "goaewsclient.h" #include "goautils.h" struct _GoaEwsClient { GObject parent_instance; }; G_DEFINE_TYPE (GoaEwsClient, goa_ews_client, G_TYPE_OBJECT); /* ---------------------------------------------------------------------------------------------------- */ static void goa_ews_client_init (GoaEwsClient *self) { } static void goa_ews_client_class_init (GoaEwsClientClass *self) { } /* ---------------------------------------------------------------------------------------------------- */ GoaEwsClient * goa_ews_client_new (void) { return GOA_EWS_CLIENT (g_object_new (GOA_TYPE_EWS_CLIENT, NULL)); } /* ---------------------------------------------------------------------------------------------------- */ typedef struct { gchar *password; gchar *username; } AutodiscoverAuthData; typedef struct { GCancellable *cancellable; GCancellable *req_cancellable; GError *error; SoupMessage *msgs[2]; SoupSession *session; gboolean accept_ssl_errors; guint pending; gulong cancellable_id; xmlOutputBuffer *buf; AutodiscoverAuthData *auth; } AutodiscoverData; static void ews_client_autodiscover_auth_data_free (AutodiscoverAuthData *auth) { g_free (auth->password); g_free (auth->username); g_slice_free (AutodiscoverAuthData, auth); } static void ews_client_autodiscover_data_free (gpointer user_data) { AutodiscoverData *data = user_data; if (data->cancellable_id > 0) { g_cancellable_disconnect (data->cancellable, data->cancellable_id); g_object_unref (data->cancellable); } g_clear_object (&data->req_cancellable); g_clear_error (&data->error); xmlOutputBufferClose (data->buf); g_clear_pointer (&data->auth, ews_client_autodiscover_auth_data_free); g_object_unref (data->session); g_slice_free (AutodiscoverData, data); } static gboolean ews_client_check_node (const xmlNode *node, const gchar *name) { g_return_val_if_fail (node != NULL, FALSE); return node->type == XML_ELEMENT_NODE && !g_strcmp0 ((gchar *) node->name, name); } static gboolean ews_client_authenticate (SoupMessage *msg, SoupAuth *auth, gboolean retrying, gpointer user_data) { AutodiscoverAuthData *data = user_data; if (retrying) return FALSE; soup_auth_authenticate (auth, data->username, data->password); return TRUE; } static gboolean ews_client_accept_certificate (SoupMessage *msg, GTlsCertificate *cert, GTlsCertificateFlags cert_flags, gpointer user_data) { AutodiscoverData *data; GTask *task = G_TASK (user_data); g_debug ("goa_ews_client_autodiscover(): accept certificate for request (%p)", msg); data = (AutodiscoverData *) g_task_get_task_data (task); if (data->accept_ssl_errors || cert_flags == 0) return TRUE; if (data->error == NULL) { goa_utils_set_error_ssl (&data->error, cert_flags); /* The callback will be invoked after we have returned to the * main loop. */ soup_session_abort (data->session); } return FALSE; } static void ews_client_autodiscover_cancelled_cb (GCancellable *cancellable, gpointer user_data) { AutodiscoverData *data; GTask *task = G_TASK (user_data); g_debug ("goa_ews_client_autodiscover(): cancelled"); data = (AutodiscoverData *) g_task_get_task_data (task); /* The callback will be invoked after we have returned to the main * loop. */ soup_session_abort (data->session); } static gboolean ews_client_autodiscover_parse_protocol (xmlNode *node) { for (node = node->children; node; node = node->next) { if (ews_client_check_node (node, "ASUrl")) return TRUE; } return FALSE; } static gboolean ews_client_autodiscover_complete_idle_cb (gpointer user_data) { GTask *task = user_data; AutodiscoverData *data = g_task_get_task_data (task); if (data->error != NULL) g_task_return_error (task, g_steal_pointer (&data->error)); else g_task_return_boolean (task, TRUE); return G_SOURCE_REMOVE; } static void ews_client_autodiscover_response_cb (SoupSession *session, GAsyncResult *result, gpointer user_data) { SoupMessage *msg; GBytes *body = NULL; GError *error = NULL; AutodiscoverData *data; GTask *task = G_TASK (user_data); gboolean op_res = FALSE; guint idx; guint status; gsize size; xmlDoc *doc = NULL; xmlNode *node; msg = soup_session_get_async_result_message (session, result); g_debug ("goa_ews_client_autodiscover(): response (%p, %u)", msg, soup_message_get_status (msg)); body = soup_session_send_and_read_finish (session, result, &error); data = (AutodiscoverData *) g_task_get_task_data (task); size = sizeof (data->msgs) / sizeof (data->msgs[0]); for (idx = 0; idx < size; idx++) { if (data->msgs[idx] == msg) break; } if (idx == size || data->pending == 0) { g_bytes_unref (body); g_clear_error (&error); g_object_unref (task); return; } data->msgs[idx] = NULL; /* G_IO_ERROR_CANCELLED, if we are being aborted by the * GCancellable, an SSL error or another message that was * successful. */ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { /* If we are being aborted by the GCancellable, then the * GTask is responsible for setting the GError automatically. * * If a previous autodiscover attempt for the same GAsyncResult * was successful then no additional attempts are required and * we should use the result from the earlier attempt. */ goto out; } status = soup_message_get_status (msg); if (status != SOUP_STATUS_OK || error) { g_warning ("goa_ews_client_autodiscover() failed: %u — %s", status, soup_message_get_reason_phrase (msg)); g_return_if_fail (data->error == NULL); if (!error) goa_utils_set_error_soup (&error, msg); goto out; } g_debug ("The response headers"); g_debug ("==================="); g_debug ("%s", (char *)g_bytes_get_data (body, NULL)); doc = xmlReadMemory (g_bytes_get_data (body, NULL), g_bytes_get_size (body), "autodiscover.xml", NULL, 0); if (doc == NULL) { g_set_error (&error, GOA_ERROR, GOA_ERROR_FAILED, /* TODO: more specific */ _("Failed to parse autodiscover response XML")); goto out; } node = xmlDocGetRootElement (doc); if (g_strcmp0 ((gchar *) node->name, "Autodiscover")) { g_set_error (&error, GOA_ERROR, GOA_ERROR_FAILED, /* TODO: more specific */ /* Translators: the parameter is an XML element name. */ _("Failed to find “%s” element"), "Autodiscover"); goto out; } for (node = node->children; node; node = node->next) { if (ews_client_check_node (node, "Response")) break; } if (node == NULL) { g_set_error (&error, GOA_ERROR, GOA_ERROR_FAILED, /* TODO: more specific */ /* Translators: the parameter is an XML element name. */ _("Failed to find “%s” element"), "Response"); goto out; } for (node = node->children; node; node = node->next) { if (ews_client_check_node (node, "Account")) break; } if (node == NULL) { g_set_error (&error, GOA_ERROR, GOA_ERROR_FAILED, /* TODO: more specific */ /* Translators: the parameter is an XML element name. */ _("Failed to find “%s” element"), "Account"); goto out; } for (node = node->children; node; node = node->next) { if (ews_client_check_node (node, "Protocol")) { op_res = ews_client_autodiscover_parse_protocol (node); /* Since the server may send back multiple nodes * don't break unless we found the one we want. */ if (op_res) break; } } if (!op_res) { g_set_error (&error, GOA_ERROR, GOA_ERROR_FAILED, /* TODO: more specific*/ _("Failed to find ASUrl in autodiscover response")); goto out; } /* This autodiscover attempt was successful. Save the result now so * that it won't get lost when we hear from another autodiscover * attempt for the same GAsyncResult. */ for (idx = 0; idx < size; idx++) { if (data->msgs[idx] != NULL) { /* The callback (ie. this function) will be invoked after we * have returned to the main loop. */ g_cancellable_cancel (data->req_cancellable); } } out: /* op_res == FALSE, if we are being aborted by the GCancellable, an * SSL error, another message that was successful or an error * encountered while parsing this response. */ if (!op_res) { /* There's another request outstanding. * Hope that it has better luck. */ if (data->pending > 1) g_clear_error (&error); if (error != NULL && data->error == NULL) { g_propagate_error (&data->error, error); error = NULL; } } data->pending--; if (data->pending == 0) { /* This is required, to not free the SoupSession under its hands (as this callback is called under it) */ GSource *idle_source = g_idle_source_new (); g_source_set_callback (idle_source, ews_client_autodiscover_complete_idle_cb, g_object_ref (task), g_object_unref); g_source_attach (idle_source, g_task_get_context (task)); } g_clear_pointer (&body, g_bytes_unref); g_clear_pointer (&doc, xmlFreeDoc); g_clear_error (&error); g_object_unref (task); } static xmlDoc * ews_client_create_autodiscover_xml (const gchar *email) { xmlDoc *doc; xmlNode *node; xmlNs *ns; doc = xmlNewDoc ((xmlChar *) "1.0"); node = xmlNewDocNode (doc, NULL, (xmlChar *) "Autodiscover", NULL); xmlDocSetRootElement (doc, node); ns = xmlNewNs (node, (xmlChar *) "http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006", NULL); node = xmlNewChild (node, ns, (xmlChar *) "Request", NULL); xmlNewChild (node, ns, (xmlChar *) "EMailAddress", (xmlChar *) email); xmlNewChild (node, ns, (xmlChar *) "AcceptableResponseSchema", (xmlChar *) "http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a"); return doc; } static void ews_client_post_restarted_cb (SoupMessage *msg, gpointer data) { xmlOutputBuffer *buf = data; GBytes *body; /* In violation of RFC2616, libsoup will change a POST request to * a GET on receiving a 302 redirect. */ g_debug ("Working around libsoup bug with redirect"); g_object_set (msg, "method", "POST", NULL); #ifdef LIBXML2_NEW_BUFFER body = g_bytes_new (xmlOutputBufferGetContent (buf), xmlOutputBufferGetSize (buf)); #else body = g_bytes_new (buf->buffer->content, buf->buffer->use); #endif soup_message_set_request_body_from_bytes (msg, "text/xml; charset=utf-8", body); g_bytes_unref (body); } static SoupMessage * ews_client_create_msg_for_url (const gchar *url, xmlOutputBuffer *buf, AutodiscoverAuthData *auth, GTask *task) { SoupMessage *msg; GBytes *body = NULL; msg = soup_message_new (buf != NULL ? "POST" : "GET", url); soup_message_headers_append (soup_message_get_request_headers (msg), "User-Agent", "libews/0.1"); g_signal_connect (msg, "authenticate", G_CALLBACK (ews_client_authenticate), auth); g_signal_connect (msg, "accept-certificate", G_CALLBACK (ews_client_accept_certificate), task); if (buf != NULL) { #ifdef LIBXML2_NEW_BUFFER body = g_bytes_new (xmlOutputBufferGetContent (buf), xmlOutputBufferGetSize (buf)); #else body = g_bytes_new (buf->buffer->content, buf->buffer->use); #endif soup_message_set_request_body_from_bytes (msg, "text/xml; charset=utf-8", body); g_signal_connect (msg, "restarted", G_CALLBACK (ews_client_post_restarted_cb), buf); } g_debug ("The request headers"); g_debug ("==================="); g_debug ("%*.s", body ? (int) g_bytes_get_size (body) : 0, body ? (char *)g_bytes_get_data (body, NULL) : ""); if (body) g_bytes_unref (body); return msg; } void goa_ews_client_autodiscover (GoaEwsClient *self, const gchar *email, const gchar *password, const gchar *username, const gchar *server, gboolean accept_ssl_errors, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { AutodiscoverData *data; AutodiscoverAuthData *auth; GTask *task = NULL; gchar *url1; gchar *url2; xmlDoc *doc; xmlOutputBuffer *buf; g_return_if_fail (GOA_IS_EWS_CLIENT (self)); g_return_if_fail (email != NULL && email[0] != '\0'); g_return_if_fail (password != NULL && password[0] != '\0'); g_return_if_fail (username != NULL && username[0] != '\0'); g_return_if_fail (server != NULL && server[0] != '\0'); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, goa_ews_client_autodiscover); data = g_slice_new0 (AutodiscoverData); g_task_set_task_data (task, data, ews_client_autodiscover_data_free); doc = ews_client_create_autodiscover_xml (email); buf = xmlAllocOutputBuffer (NULL); xmlNodeDumpOutput (buf, doc, xmlDocGetRootElement (doc), 0, 1, NULL); xmlOutputBufferFlush (buf); url1 = g_strdup_printf ("https://%s/autodiscover/autodiscover.xml", server); url2 = g_strdup_printf ("https://autodiscover.%s/autodiscover/autodiscover.xml", server); /* http://msdn.microsoft.com/en-us/library/ee332364.aspx says we are * supposed to try $domain and then autodiscover.$domain. But some * people have broken firewalls on the former which drop packets * instead of rejecting connections, and make the request take ages * to time out. So run both queries in parallel and let the fastest * (successful) one win. */ auth = g_slice_new0 (AutodiscoverAuthData); auth->username = g_strdup (username); auth->password = g_strdup (password); data->auth = auth; data->buf = buf; data->msgs[0] = ews_client_create_msg_for_url (url1, buf, auth, task); data->msgs[1] = ews_client_create_msg_for_url (url2, buf, auth, task); data->pending = sizeof (data->msgs) / sizeof (data->msgs[0]); data->session = soup_session_new (); soup_session_add_feature_by_type (data->session, SOUP_TYPE_AUTH_NTLM); data->accept_ssl_errors = accept_ssl_errors; data->req_cancellable = g_cancellable_new (); if (cancellable != NULL) { data->cancellable = g_object_ref (cancellable); data->cancellable_id = g_cancellable_connect (cancellable, G_CALLBACK (ews_client_autodiscover_cancelled_cb), task, NULL); } soup_session_send_and_read_async (data->session, data->msgs[0], G_PRIORITY_DEFAULT, data->req_cancellable, (GAsyncReadyCallback)ews_client_autodiscover_response_cb, g_object_ref (task)); soup_session_send_and_read_async (data->session, data->msgs[1], G_PRIORITY_DEFAULT, data->req_cancellable, (GAsyncReadyCallback)ews_client_autodiscover_response_cb, g_object_ref (task)); g_free (url2); g_free (url1); g_object_unref (task); xmlFreeDoc (doc); } gboolean goa_ews_client_autodiscover_finish (GoaEwsClient *self, GAsyncResult *res, GError **error) { GTask *task; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); g_return_val_if_fail (g_task_is_valid (res, self), FALSE); task = G_TASK (res); g_return_val_if_fail (g_task_get_source_tag (task) == goa_ews_client_autodiscover, FALSE); return g_task_propagate_boolean (task, error); } /* ---------------------------------------------------------------------------------------------------- */ typedef struct { GError **error; GMainLoop *loop; gboolean op_res; } AutodiscoverSyncData; static void ews_client_autodiscover_sync_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { AutodiscoverSyncData *data = user_data; data->op_res = goa_ews_client_autodiscover_finish (GOA_EWS_CLIENT (source_object), res, data->error); g_main_loop_quit (data->loop); } gboolean goa_ews_client_autodiscover_sync (GoaEwsClient *self, const gchar *email, const gchar *password, const gchar *username, const gchar *server, gboolean accept_ssl_errors, GCancellable *cancellable, GError **error) { AutodiscoverSyncData data; GMainContext *context = NULL; data.error = error; context = g_main_context_new (); g_main_context_push_thread_default (context); data.loop = g_main_loop_new (context, FALSE); goa_ews_client_autodiscover (self, email, password, username, server, accept_ssl_errors, cancellable, ews_client_autodiscover_sync_cb, &data); g_main_loop_run (data.loop); g_main_loop_unref (data.loop); g_main_context_pop_thread_default (context); g_main_context_unref (context); return data.op_res; }