/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* * Copyright Ā© 2011 – 2017 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 . */ #include "config.h" #include #include #include "goamailconfig.h" #include "goasouplogger.h" #include "goautils.h" #include "goamailclient.h" /* The timeout used for non-IDLE commands */ #define COMMAND_TIMEOUT_SEC 30 /* Mail Autoconfig URIs * * See: * - Mail provider (https://benbucksch.github.io/autoconfig-spec/draft-autoconfig-1.html#section-4.1) * - Central database (https://benbucksch.github.io/autoconfig-spec/draft-autoconfig-1.html#section-4.2) * - MX (https://benbucksch.github.io/autoconfig-spec/draft-autoconfig-1.html#section-4.3) * - Autoconfig Spec issue #7 (https://github.com/benbucksch/autoconfig-spec/issues/7) */ #define AUTOCONFIG_DOMAIN_ADDRESS_FMT "https://autoconfig.%s/.well-known/mail-v1.xml?emailaddress=%s" #define AUTOCONFIG_DOMAIN_ADDRESS_OLD_FMT "https://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s" #define AUTOCONFIG_DOMAIN_FMT "https://%s/.well-known/autoconfig/mail/config-v1.1.xml" #define AUTOCONFIG_DOMAIN_ADDRESS_OLD_FMT "https://autoconfig.%s/mail/config-v1.1.xml?emailaddress=%s" #define AUTOCONFIG_DOMAIN_OLD_FMT "http://autoconfig.%s/mail/config-v1.1.xml" #define AUTOCONFIG_MX_DOMAIN_ADDRESS_FMT AUTOCONFIG_DOMAIN_ADDRESS_FMT #define AUTOCONFIG_DATABASE_ISPDB_FMT "https://v1.ispdb.net/%s" #define AUTOCONFIG_DATABSE_THUNDERBIRD_FMT "https://autoconfig.thunderbird.net/v1.1/%s" #define AUTOCONFIG_SERVER_TYPE_IMAP "imap" #define AUTOCONFIG_SERVER_TYPE_POP3 "pop3" #define AUTOCONFIG_SERVER_TYPE_JMAP "jmap" #define AUTOCONFIG_SERVER_TYPE_SMTP "smtp" #define AUTOCONFIG_SOCKET_TYPE_PLAIN "plain" #define AUTOCONFIG_SOCKET_TYPE_STARTTLS "STARTTLS" #define AUTOCONFIG_SOCKET_TYPE_SSL "SSL" struct _GoaMailClient { /*< private >*/ GObject parent_instance; }; G_DEFINE_TYPE (GoaMailClient, goa_mail_client, G_TYPE_OBJECT); /* ---------------------------------------------------------------------------------------------------- */ static void goa_mail_client_init (GoaMailClient *self) { } static void goa_mail_client_class_init (GoaMailClientClass *klass) { } /* ---------------------------------------------------------------------------------------------------- */ GoaMailClient * goa_mail_client_new (void) { return GOA_MAIL_CLIENT (g_object_new (GOA_TYPE_MAIL_CLIENT, NULL)); } /* ---------------------------------------------------------------------------------------------------- */ typedef struct { GDataInputStream *input; GDataOutputStream *output; GIOStream *tls_conn; GSocket *socket; GSocketClient *sc; GSocketConnection *conn; GTlsCertificateFlags cert_flags; GoaMailAuth *auth; GoaTlsType tls_type; gboolean accept_ssl_errors; gchar *host_and_port; guint16 default_port; } CheckData; static void mail_client_check_data_free (CheckData *data) { g_object_unref (data->sc); g_object_unref (data->auth); g_clear_object (&data->input); g_clear_object (&data->output); g_clear_object (&data->socket); g_clear_object (&data->conn); g_clear_object (&data->tls_conn); g_free (data->host_and_port); g_slice_free (CheckData, data); } static gboolean mail_client_check_accept_certificate_cb (GTlsConnection *conn, GTlsCertificate *peer_cert, GTlsCertificateFlags errors, gpointer user_data) { CheckData *data = user_data; /* Fail the connection if the certificate is invalid. */ data->cert_flags = errors; return FALSE; } static void mail_client_check_event_cb (GSocketClient *sc, GSocketClientEvent event, GSocketConnectable *connectable, GIOStream *connection, gpointer user_data) { CheckData *data = user_data; if (event != G_SOCKET_CLIENT_TLS_HANDSHAKING) return; data->tls_conn = g_object_ref (connection); if (data->accept_ssl_errors) g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (data->tls_conn), 0); g_signal_connect (data->tls_conn, "accept-certificate", G_CALLBACK (mail_client_check_accept_certificate_cb), data); } static void mail_client_check_auth_run_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); CheckData *data; GError *error; data = g_task_get_task_data (task); error = NULL; if (!goa_mail_auth_run_finish (data->auth, res, &error)) { g_warning ("goa_mail_auth_run() failed: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_task_return_error (task, error); goto out; } g_io_stream_close (G_IO_STREAM (data->conn), NULL, NULL); g_task_return_boolean (task, TRUE); out: g_object_unref (G_OBJECT (task)); } static void mail_client_check_tls_conn_handshake_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); CheckData *data; GCancellable *cancellable; GDataInputStream *input; GDataOutputStream *output; GInputStream *base_input; GError *error; GOutputStream *base_output; input = NULL; output = NULL; cancellable = g_task_get_cancellable (task); data = g_task_get_task_data (task); error = NULL; if (!g_tls_connection_handshake_finish (G_TLS_CONNECTION (data->tls_conn), res, &error)) { g_warning ("g_tls_connection_handshake() failed: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); /* GIO sets G_TLS_ERROR_BAD_CERTIFICATE when it should be * setting G_TLS_ERROR_HANDSHAKE. Hence, lets check the * GTlsCertificate flags to accommodate future GIO fixes. */ if (data->cert_flags != 0) { GError *tls_error; tls_error = NULL; goa_utils_set_error_ssl (&tls_error, data->cert_flags); g_task_return_error (task, tls_error); g_error_free (error); } else { error->domain = GOA_ERROR; error->code = GOA_ERROR_FAILED; /* TODO: more specific */ g_task_return_error (task, error); } goto out; } g_clear_object (&data->conn); data->conn = g_tcp_wrapper_connection_new (data->tls_conn, data->socket); base_input = g_io_stream_get_input_stream (G_IO_STREAM (data->conn)); input = g_data_input_stream_new (base_input); g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (input), FALSE); g_data_input_stream_set_newline_type (input, G_DATA_STREAM_NEWLINE_TYPE_CR_LF); goa_mail_auth_set_input (data->auth, input); base_output = g_io_stream_get_output_stream (G_IO_STREAM (data->conn)); output = g_data_output_stream_new (base_output); g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (output), FALSE); goa_mail_auth_set_output (data->auth, output); goa_mail_auth_run (data->auth, cancellable, mail_client_check_auth_run_cb, g_object_ref (task)); out: g_clear_object (&input); g_clear_object (&output); g_object_unref (G_OBJECT (task)); } static void mail_client_check_auth_starttls_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); CheckData *data; GCancellable *cancellable; GSocketConnectable *server_identity; GError *error; server_identity = NULL; cancellable = g_task_get_cancellable (task); data = g_task_get_task_data (task); error = NULL; if (!goa_mail_auth_starttls_finish (data->auth, res, &error)) { g_warning ("goa_mail_auth_starttls() failed: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_task_return_error (task, error); goto out; } error = NULL; server_identity = g_network_address_parse (data->host_and_port, data->default_port, &error); if (server_identity == NULL) { g_task_return_error (task, error); goto out; } error = NULL; data->tls_conn = g_tls_client_connection_new (G_IO_STREAM (data->conn), server_identity, &error); if (data->tls_conn == NULL) { g_task_return_error (task, error); goto out; } if (data->accept_ssl_errors) g_tls_client_connection_set_validation_flags (G_TLS_CLIENT_CONNECTION (data->tls_conn), 0); g_signal_connect (data->tls_conn, "accept-certificate", G_CALLBACK (mail_client_check_accept_certificate_cb), data); g_tls_connection_handshake_async (G_TLS_CONNECTION (data->tls_conn), G_PRIORITY_DEFAULT, cancellable, mail_client_check_tls_conn_handshake_cb, g_object_ref (task)); out: g_clear_object (&server_identity); g_object_unref (G_OBJECT (task)); } static void mail_client_check_connect_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); CheckData *data; GCancellable *cancellable; GDataInputStream *input; GDataOutputStream *output; GInputStream *base_input; GError *error; GOutputStream *base_output; cancellable = g_task_get_cancellable (task); data = g_task_get_task_data (task); error = NULL; data->conn = g_socket_client_connect_to_host_finish (data->sc, res, &error); if (data->conn == NULL) { g_warning ("g_socket_client_connect_to_host() failed: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); /* GIO sets G_TLS_ERROR_BAD_CERTIFICATE when it should be * setting G_TLS_ERROR_HANDSHAKE. Hence, lets check the * GTlsCertificate flags to accommodate future GIO fixes. */ if (data->cert_flags != 0) { GError *tls_error; tls_error = NULL; goa_utils_set_error_ssl (&tls_error, data->cert_flags); g_task_return_error (task, tls_error); g_error_free (error); } else { error->domain = GOA_ERROR; error->code = GOA_ERROR_FAILED; /* TODO: more specific */ g_task_return_error (task, error); } goto out; } /* fail quickly */ data->socket = g_object_ref (g_socket_connection_get_socket (data->conn)); g_socket_set_timeout (data->socket, COMMAND_TIMEOUT_SEC); base_input = g_io_stream_get_input_stream (G_IO_STREAM (data->conn)); input = g_data_input_stream_new (base_input); g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (input), FALSE); g_data_input_stream_set_newline_type (input, G_DATA_STREAM_NEWLINE_TYPE_CR_LF); goa_mail_auth_set_input (data->auth, input); g_object_unref (input); base_output = g_io_stream_get_output_stream (G_IO_STREAM (data->conn)); output = g_data_output_stream_new (base_output); g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (output), FALSE); goa_mail_auth_set_output (data->auth, output); g_object_unref (output); if (data->tls_type == GOA_TLS_TYPE_STARTTLS) goa_mail_auth_starttls (data->auth, cancellable, mail_client_check_auth_starttls_cb, g_object_ref (task)); else goa_mail_auth_run (data->auth, cancellable, mail_client_check_auth_run_cb, g_object_ref (task)); out: g_object_unref (G_OBJECT (task)); } void goa_mail_client_check (GoaMailClient *self, const gchar *host_and_port, GoaTlsType tls_type, gboolean accept_ssl_errors, guint16 default_port, GoaMailAuth *auth, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { CheckData *data; GTask *task; g_return_if_fail (GOA_IS_MAIL_CLIENT (self)); g_return_if_fail (host_and_port != NULL && host_and_port[0] != '\0'); g_return_if_fail (GOA_IS_MAIL_AUTH (auth)); 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_mail_client_check); data = g_slice_new0 (CheckData); g_task_set_task_data (task, data, (GDestroyNotify) mail_client_check_data_free); data->sc = g_socket_client_new (); if (tls_type == GOA_TLS_TYPE_SSL) { g_socket_client_set_tls (data->sc, TRUE); g_signal_connect (data->sc, "event", G_CALLBACK (mail_client_check_event_cb), data); } data->host_and_port = g_strdup (host_and_port); data->tls_type = tls_type; data->accept_ssl_errors = accept_ssl_errors; data->default_port = default_port; data->auth = g_object_ref (auth); g_socket_client_connect_to_host_async (data->sc, data->host_and_port, data->default_port, cancellable, mail_client_check_connect_cb, g_object_ref (task)); g_object_unref (task); } gboolean goa_mail_client_check_finish (GoaMailClient *self, GAsyncResult *res, GError **error) { GTask *task; g_return_val_if_fail (GOA_IS_MAIL_CLIENT (self), FALSE); 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_mail_client_check, FALSE); return g_task_propagate_boolean (task, error); } /* ---------------------------------------------------------------------------------------------------- */ typedef struct { GError **error; GMainLoop *loop; gboolean op_res; } CheckSyncData; static void mail_client_check_sync_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { CheckSyncData *data = user_data; data->op_res = goa_mail_client_check_finish (GOA_MAIL_CLIENT (source_object), res, data->error); g_main_loop_quit (data->loop); } gboolean goa_mail_client_check_sync (GoaMailClient *self, const gchar *host_and_port, GoaTlsType tls_type, gboolean accept_ssl_errors, guint16 default_port, GoaMailAuth *auth, GCancellable *cancellable, GError **error) { CheckSyncData 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_mail_client_check (self, host_and_port, tls_type, accept_ssl_errors, default_port, auth, cancellable, mail_client_check_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; } /* ---------------------------------------------------------------------------------------------------- */ static GoaMailConfig * goa_mail_config_new_from_autoconfig_xml (RestXmlNode *server, const char *email_address, const char *email_localpart, const char *email_domain) { g_autoptr (GoaMailConfig) config = NULL; const char *server_type = NULL; RestXmlNode *username = NULL; RestXmlNode *hostname = NULL; RestXmlNode *port = NULL; RestXmlNode *socket_type = NULL; g_return_val_if_fail (g_str_equal (server->name, "incomingServer") || g_str_equal (server->name, "outgoingServer"), NULL); server_type = rest_xml_node_get_attr (server, "type"); g_return_val_if_fail (server_type != NULL, NULL); config = goa_mail_config_new (server_type); hostname = rest_xml_node_find (server, "hostname"); if (hostname != NULL && hostname->content != NULL) goa_mail_config_set_hostname (GOA_MAIL_CONFIG (config), hostname->content); socket_type = rest_xml_node_find (server, "socketType"); if (socket_type != NULL && socket_type->content != NULL) { if (g_ascii_strcasecmp (socket_type->content, AUTOCONFIG_SOCKET_TYPE_SSL) == 0) goa_mail_config_set_encryption (GOA_MAIL_CONFIG (config), GOA_TLS_TYPE_SSL); else if (g_ascii_strcasecmp (socket_type->content, AUTOCONFIG_SOCKET_TYPE_STARTTLS) == 0) goa_mail_config_set_encryption (GOA_MAIL_CONFIG (config), GOA_TLS_TYPE_STARTTLS); else if (g_ascii_strcasecmp (socket_type->content, AUTOCONFIG_SOCKET_TYPE_PLAIN) == 0) goa_mail_config_set_encryption (GOA_MAIL_CONFIG (config), GOA_TLS_TYPE_NONE); } port = rest_xml_node_find (server, "port"); if (port != NULL && port->content != NULL) { guint64 port_ = g_ascii_strtoull (port->content, NULL, 10); if (port_ > 0 && port_ < UINT16_MAX) goa_mail_config_set_port (GOA_MAIL_CONFIG (config), (uint16_t)port_); } username = rest_xml_node_find (server, "username"); if (username != NULL && username->content != NULL) { if (g_ascii_strcasecmp (username->content, "%EMAILADDRESS%") == 0) goa_mail_config_set_username (GOA_MAIL_CONFIG (config), email_address); else if (g_ascii_strcasecmp (username->content, "%EMAILLOCALPART%") == 0) goa_mail_config_set_username (GOA_MAIL_CONFIG (config), email_localpart); else if (g_ascii_strcasecmp (username->content, "%EMAILDOMAIN%") == 0) goa_mail_config_set_username (GOA_MAIL_CONFIG (config), email_domain); } return g_steal_pointer (&config); } /*< private > * mail_client_parse_autoconfig_xml: * @xml_bytes: Autoconfig XML * @email_address: a valid email address * @error: (nullable): return location for an error * * Parse an autoconfig XML document and return a list of services. * * See: * - https://github.com/benbucksch/autoconfig-spec/ * - https://benbucksch.github.io/autoconfig-spec/draft-autoconfig-1.html * - https://github.com/thunderbird/autoconfig * * Returns: (transfer container) (element-type Goa.MailConfig): a list of discovered services */ static GPtrArray * mail_client_parse_autoconfig_xml (GBytes *xml_bytes, const char *email_address, GError **error) { g_autoptr(GPtrArray) services = NULL; g_autofree char *email_localpart = NULL; g_autofree char *email_domain = NULL; g_autoptr(RestXmlParser) parser = NULL; g_autoptr(RestXmlNode) root_node = NULL; RestXmlNode *email_node = NULL; const char *xml_data = NULL; gsize xml_len = 0; goa_utils_parse_email_address (email_address, &email_localpart, &email_domain); xml_data = g_bytes_get_data (xml_bytes, &xml_len); parser = rest_xml_parser_new (); root_node = rest_xml_parser_parse_from_data (parser, xml_data, xml_len); if (root_node == NULL || g_strcmp0 (root_node->name, "clientConfig") != 0) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Failed to parse Autoconfig XML"); return NULL; } services = g_ptr_array_new_with_free_func (g_object_unref); /* Mail Services */ email_node = rest_xml_node_find (root_node, "emailProvider"); if (email_node != NULL) { RestXmlNode *incoming_server = NULL; RestXmlNode *outgoing_server = NULL; incoming_server = rest_xml_node_find (email_node, "incomingServer"); for (RestXmlNode *node = incoming_server; node != NULL; node = node->next) { GoaMailConfig *server = NULL; server = goa_mail_config_new_from_autoconfig_xml (node, email_address, email_localpart, email_domain); if (server != NULL) g_ptr_array_add (services, g_steal_pointer (&server)); } outgoing_server = rest_xml_node_find (email_node, "outgoingServer"); for (RestXmlNode *node = outgoing_server; node != NULL; node = node->next) { GoaMailConfig *server = NULL; server = goa_mail_config_new_from_autoconfig_xml (node, email_address, email_localpart, email_domain); if (server != NULL) g_ptr_array_add (services, g_steal_pointer (&server)); } } return g_steal_pointer (&services); } /* ---------------------------------------------------------------------------------------------------- */ static int sort_mx_domains (gconstpointer a, gconstpointer b) { GVariant *variant_a = (GVariant *)a; GVariant *variant_b = (GVariant *)b; uint16_t pref_a, pref_b; g_variant_get (variant_a, "(qs)", &pref_a, NULL); g_variant_get (variant_b, "(qs)", &pref_b, NULL); return pref_a > pref_b; } typedef struct { SoupSession *session; char *email_address; GQueue uris; gboolean mx_fallback; } DiscoverData; static void discover_data_free (gpointer user_data) { DiscoverData *data = user_data; g_clear_object (&data->session); g_clear_pointer (&data->email_address, g_free); g_queue_clear_full (&data->uris, g_free); g_free (data); } static void mail_client_discover_iterate (GTask *task); static void goa_mail_client_autoconfig_cb (SoupSession *session, GAsyncResult *result, gpointer user_data) { g_autoptr (GTask) task = G_TASK (user_data); DiscoverData *data = g_task_get_task_data (task); SoupMessage *response = NULL; GPtrArray *services = NULL; g_autoptr (GBytes) body = NULL; g_autoptr (GError) error = NULL; body = soup_session_send_and_read_finish (session, result, &error); if (error != NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_task_return_error (task, g_steal_pointer (&error)); return; } goto next; } response = soup_session_get_async_result_message (session, result); if (soup_message_get_status (response) != SOUP_STATUS_OK) goto next; services = mail_client_parse_autoconfig_xml (body, data->email_address, NULL); if (services != NULL) { g_task_return_pointer (task, g_steal_pointer (&services), (GDestroyNotify) g_ptr_array_unref); return; } next: mail_client_discover_iterate (task); } static void goa_mail_client_mx_domain_cb (GResolver *resolver, GAsyncResult *result, gpointer user_data) { g_autoptr(GTask) task = G_TASK (user_data); DiscoverData *data = g_task_get_task_data (task); const char *mx_raw_domain = NULL; const char *mx_base_domain = NULL; g_autofree char *mx_full_domain = NULL; g_autolist(GVariant) records = NULL; g_autoptr(GError) error = NULL; /* Resolve the highest priority MX domain for %EMAILDOMAIN% */ records = g_resolver_lookup_records_finish (resolver, result, &error); if (records == NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_task_return_error (task, g_steal_pointer (&error)); return; } g_debug ("%s(): %s", G_STRFUNC, error->message); goto out; } records = g_list_sort (records, sort_mx_domains); g_variant_get ((GVariant *)records->data, "(q&s)", NULL, &mx_raw_domain); mx_full_domain = g_utf8_casefold (mx_raw_domain, -1); mx_base_domain = soup_tld_get_base_domain (mx_full_domain, NULL); /* Lookup by the highest priority %MXFULLDOMAIN% and %MXBASEDOMAIN */ g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_MX_DOMAIN_ADDRESS_FMT, mx_full_domain, data->email_address)); if (mx_base_domain != NULL && g_strcmp0 (mx_base_domain, mx_full_domain) != 0) g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_MX_DOMAIN_ADDRESS_FMT, mx_base_domain, data->email_address)); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DATABASE_ISPDB_FMT, mx_full_domain)); if (mx_base_domain != NULL && g_strcmp0 (mx_base_domain, mx_full_domain) != 0) g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DATABASE_ISPDB_FMT, mx_base_domain)); out: mail_client_discover_iterate (task); } static void mail_client_discover_iterate (GTask *task) { DiscoverData *data = g_task_get_task_data (task); if (!g_queue_is_empty (&data->uris)) { g_autoptr(SoupMessage) message = NULL; g_autofree char *uri = NULL; uri = g_queue_pop_head (&data->uris); message = soup_message_new (SOUP_METHOD_GET, uri); if (message != NULL) { soup_session_send_and_read_async (data->session, message, G_PRIORITY_DEFAULT, g_task_get_cancellable (task), (GAsyncReadyCallback)goa_mail_client_autoconfig_cb, g_object_ref (task)); } else { g_warning ("Failed to create message for \"%s\"", uri); mail_client_discover_iterate (task); } } else if (data->mx_fallback) { g_autoptr(GResolver) resolver = NULL; g_autofree char *email_domain = NULL; goa_utils_parse_email_address (data->email_address, NULL, &email_domain); resolver = g_resolver_get_default (); g_resolver_lookup_records_async (resolver, email_domain, G_RESOLVER_RECORD_MX, g_task_get_cancellable (task), (GAsyncReadyCallback)goa_mail_client_mx_domain_cb, g_object_ref (task)); data->mx_fallback = FALSE; } else { g_task_return_new_error (task, GOA_ERROR, GOA_ERROR_FAILED, "Failed to autoconfig '%s'", data->email_address); } } /** * goa_mail_client_discover: * @self: a `GoaMailClient` * @email_address: a well-formed email address * @cancellable: (nullable): a cancellable for the operation * @callback: (scope async): a callback to be invoked when the operation is complete * @user_data: (closure): user supplied data * * Discover IMAP/SMTP configuration for the domain of @email. * * Call [method@Goa.MailClient.discover_finish] to get the result. */ void goa_mail_client_discover (GoaMailClient *self, const char *email_address, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_autoptr(GTask) task = NULL; g_autoptr(SoupLogger) logger = NULL; g_autofree char *email_domain = NULL; DiscoverData *data; g_return_if_fail (GOA_IS_MAIL_CLIENT (self)); g_return_if_fail (email_address != NULL && *email_address != '\0'); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); if (!goa_utils_parse_email_address (email_address, NULL, &email_domain)) { g_task_report_new_error (self, callback, user_data, goa_mail_client_discover, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, _("Invalid email address ā€œ%sā€"), email_address); } data = g_new0 (DiscoverData, 1); data->email_address = g_strdup (email_address); data->mx_fallback = TRUE; data->session = soup_session_new (); logger = goa_soup_logger_new (SOUP_LOGGER_LOG_BODY, -1); soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger)); soup_session_set_timeout (data->session, 15); soup_session_set_user_agent (data->session, "gnome-online-accounts/" PACKAGE_VERSION " "); /* Lookup by %EMAILDOMAIN% */ g_queue_init (&data->uris); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DOMAIN_ADDRESS_FMT, email_domain, email_address)); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DOMAIN_ADDRESS_OLD_FMT, email_domain, email_address)); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DOMAIN_FMT, email_domain)); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DOMAIN_OLD_FMT, email_domain)); g_queue_push_tail (&data->uris, g_strdup_printf (AUTOCONFIG_DATABASE_ISPDB_FMT, email_domain)); task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, goa_mail_client_discover); g_task_set_task_data (task, data, discover_data_free); mail_client_discover_iterate (task); } /** * goa_mail_client_discover_finish: * @self: a `GoaMailClient` * @result: a `GAsyncResult` * @error: (nullable): return location for an error * * Finish an operation started by [method@Goa.MailClient.discover]. * * Returns: (transfer container) (element-type Goa.MailConfig): a list of discovered services, * which may include DAV services, or %NULL with @error set */ GPtrArray * goa_mail_client_discover_finish (GoaMailClient *self, GAsyncResult *result, GError **error) { GTask *task = G_TASK (result); g_return_val_if_fail (GOA_IS_MAIL_CLIENT (self), NULL); g_return_val_if_fail (g_task_is_valid (result, self), NULL); g_return_val_if_fail (g_task_get_source_tag (task) == goa_mail_client_discover, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); return g_task_propagate_pointer (task, error); }