/* * This program 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) version 3. * * This program 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 the program; if not, see * * * Authors: * Jeffrey Stedfast * * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #ifdef G_OS_WIN32 /* Work around namespace clobbage in */ #define DATADIR windows_DATADIR #include #undef DATADIR #undef interface #endif #include #include #include "em-filter-editor.h" #include #include #include "mail-mt.h" #include "mail-ops.h" #include "mail-tools.h" #include "e-mail-tag-editor.h" #include #include #include #include "e-util/e-util.h" #include "e-util/e-util-private.h" #include "e-util/e-mktemp.h" #include "e-util/e-account-utils.h" #include "e-util/e-dialog-utils.h" #include "e-util/e-alert-dialog.h" #include "shell/e-shell.h" #include "widgets/misc/e-attachment.h" #include "em-utils.h" #include "em-composer-utils.h" #include "em-format-quote.h" #include "e-mail-folder-utils.h" #include "e-mail-local.h" #include "e-mail-session.h" /* XXX This is a dirty hack on a dirty hack. We really need * to rework or get rid of the functions that use this. */ extern const gchar *shell_builtin_backend; /* How many is too many? */ /* Used in em_util_ask_open_many() */ #define TOO_MANY 10 #define d(x) static void free_account_sort_order_cache (void); gboolean em_utils_ask_open_many (GtkWindow *parent, gint how_many) { gchar *string; gboolean proceed; if (how_many < TOO_MANY) return TRUE; string = g_strdup_printf (ngettext ( /* Translators: This message is shown only for ten or more * messages to be opened. The %d is replaced with the actual * count of messages. If you need a '%' in your text, then * write it doubled, like '%%'. */ "Are you sure you want to open %d message at once?", "Are you sure you want to open %d messages at once?", how_many), how_many); proceed = em_utils_prompt_user ( parent, "/apps/evolution/mail/prompts/open_many", "mail:ask-open-many", string, NULL); g_free (string); return proceed; } /** * em_utils_prompt_user: * @parent: parent window * @promptkey: gconf key to check if we should prompt the user or not. * @tag: e_alert tag. * * Convenience function to query the user with a Yes/No dialog and a * "Do not show this dialog again" checkbox. If the user checks that * checkbox, then @promptkey is set to %FALSE, otherwise it is set to * %TRUE. * * Returns %TRUE if the user clicks Yes or %FALSE otherwise. **/ gboolean em_utils_prompt_user (GtkWindow *parent, const gchar *promptkey, const gchar *tag, ...) { GtkWidget *dialog; GtkWidget *check = NULL; GtkWidget *container; va_list ap; gint button; GConfClient *client; EAlert *alert = NULL; client = gconf_client_get_default (); if (promptkey && !gconf_client_get_bool (client, promptkey, NULL)) { g_object_unref (client); return TRUE; } va_start (ap, tag); alert = e_alert_new_valist (tag, ap); va_end (ap); dialog = e_alert_dialog_new (parent, alert); g_object_unref (alert); container = e_alert_dialog_get_content_area (E_ALERT_DIALOG (dialog)); if (promptkey) { check = gtk_check_button_new_with_mnemonic ( _("_Do not show this message again")); gtk_box_pack_start ( GTK_BOX (container), check, FALSE, FALSE, 0); gtk_widget_show (check); } button = gtk_dialog_run (GTK_DIALOG (dialog)); if (promptkey) gconf_client_set_bool ( client, promptkey, !gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (check)), NULL); gtk_widget_destroy (dialog); g_object_unref (client); return button == GTK_RESPONSE_YES; } /** * em_utils_uids_copy: * @uids: array of uids * * Duplicates the array of uids held by @uids into a new * GPtrArray. Use em_utils_uids_free() to free the resultant uid * array. * * Returns a duplicate copy of @uids. **/ GPtrArray * em_utils_uids_copy (GPtrArray *uids) { GPtrArray *copy; gint i; copy = g_ptr_array_new (); g_ptr_array_set_size (copy, uids->len); for (i = 0; i < uids->len; i++) copy->pdata[i] = g_strdup (uids->pdata[i]); return copy; } /** * em_utils_uids_free: * @uids: array of uids * * Frees the array of uids pointed to by @uids back to the system. **/ void em_utils_uids_free (GPtrArray *uids) { gint i; for (i = 0; i < uids->len; i++) g_free (uids->pdata[i]); g_ptr_array_free (uids, TRUE); } /** * em_utils_check_user_can_send_mail: * * Returns %TRUE if the user has an account configured (to send mail) * or %FALSE otherwise. **/ gboolean em_utils_check_user_can_send_mail (void) { EAccountList *account_list; EAccount *account; account_list = e_get_account_list (); if (e_list_length (E_LIST (account_list)) == 0) return FALSE; if (!(account = e_get_default_account ())) return FALSE; /* Check for a transport */ if (!account->transport->url) return FALSE; return TRUE; } /* Editing Filters/Search Folders... */ static GtkWidget *filter_editor = NULL; static void em_filter_editor_response (GtkWidget *dialog, gint button, gpointer user_data) { EMFilterContext *fc; if (button == GTK_RESPONSE_OK) { const gchar *config_dir; gchar *user; config_dir = mail_session_get_config_dir (); fc = g_object_get_data ((GObject *) dialog, "context"); user = g_build_filename (config_dir, "filters.xml", NULL); e_rule_context_save ((ERuleContext *) fc, user); g_free (user); } gtk_widget_destroy (dialog); filter_editor = NULL; } static EMFilterSource em_filter_source_element_names[] = { { "incoming", }, { "outgoing", }, { NULL } }; /** * em_utils_edit_filters: * @parent: parent window * @backend: an #EMailBAckend * * Opens or raises the filters editor dialog so that the user may edit * his/her filters. If @parent is non-NULL, then the dialog will be * created as a child window of @parent's toplevel window. **/ void em_utils_edit_filters (GtkWidget *parent, EMailBackend *backend) { const gchar *config_dir; gchar *user, *system; EMFilterContext *fc; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); if (filter_editor) { gtk_window_present (GTK_WINDOW (filter_editor)); return; } config_dir = mail_session_get_config_dir (); fc = em_filter_context_new (backend); user = g_build_filename (config_dir, "filters.xml", NULL); system = g_build_filename (EVOLUTION_PRIVDATADIR, "filtertypes.xml", NULL); e_rule_context_load ((ERuleContext *) fc, system, user); g_free (user); g_free (system); if (((ERuleContext *) fc)->error) { e_mail_backend_submit_alert ( backend, "mail:filter-load-error", ((ERuleContext *) fc)->error, NULL); return; } if (em_filter_source_element_names[0].name == NULL) { em_filter_source_element_names[0].name = _("Incoming"); em_filter_source_element_names[1].name = _("Outgoing"); } filter_editor = (GtkWidget *) em_filter_editor_new ( fc, em_filter_source_element_names); if (parent != NULL) gtk_window_set_transient_for ( GTK_WINDOW (filter_editor), GTK_WINDOW (parent)); gtk_window_set_title ( GTK_WINDOW (filter_editor), _("Message Filters")); g_object_set_data_full ( G_OBJECT (filter_editor), "context", fc, (GDestroyNotify) g_object_unref); g_signal_connect ( filter_editor, "response", G_CALLBACK (em_filter_editor_response), NULL); gtk_widget_show (GTK_WIDGET (filter_editor)); } /* * Picked this from e-d-s/libedataserver/e-data. * But it allows more characters to occur in filenames, especially * when saving attachment. */ void em_filename_make_safe (gchar *string) { gchar *p, *ts; gunichar c; #ifdef G_OS_WIN32 const gchar *unsafe_chars = "/\":*?<>|\\#"; #else const gchar *unsafe_chars = "/#"; #endif g_return_if_fail (string != NULL); p = string; while (p && *p) { c = g_utf8_get_char (p); ts = p; p = g_utf8_next_char (p); /* I wonder what this code is supposed to actually * achieve, and whether it does that as currently * written? */ if (!g_unichar_isprint (c) || ( c < 0xff && strchr (unsafe_chars, c&0xff ))) { while (ts < p) *ts++ = '_'; } } } /* ********************************************************************** */ /* Flag-for-Followup... */ /** * em_utils_flag_for_followup: * @reader: an #EMailReader * @folder: folder containing messages to flag * @uids: uids of messages to flag * * Open the Flag-for-Followup editor for the messages specified by * @folder and @uids. **/ void em_utils_flag_for_followup (EMailReader *reader, CamelFolder *folder, GPtrArray *uids) { EShell *shell; EMailBackend *backend; EShellSettings *shell_settings; EShellBackend *shell_backend; EMFormatHTML *formatter; GtkWidget *editor; GtkWindow *window; CamelTag *tags; gint i; g_return_if_fail (E_IS_MAIL_READER (reader)); g_return_if_fail (CAMEL_IS_FOLDER (folder)); g_return_if_fail (uids != NULL); window = e_mail_reader_get_window (reader); backend = e_mail_reader_get_backend (reader); editor = e_mail_tag_editor_new (); gtk_window_set_transient_for (GTK_WINDOW (editor), window); shell_backend = E_SHELL_BACKEND (backend); shell = e_shell_backend_get_shell (shell_backend); shell_settings = e_shell_get_shell_settings (shell); /* These settings come from the calendar module. */ g_object_bind_property ( shell_settings, "cal-use-24-hour-format", editor, "use-24-hour-format", G_BINDING_SYNC_CREATE); g_object_bind_property ( shell_settings, "cal-week-start-day", editor, "week-start-day", G_BINDING_SYNC_CREATE); for (i = 0; i < uids->len; i++) { CamelMessageInfo *info; info = camel_folder_get_message_info (folder, uids->pdata[i]); if (info == NULL) continue; e_mail_tag_editor_add_message ( E_MAIL_TAG_EDITOR (editor), camel_message_info_from (info), camel_message_info_subject (info)); camel_folder_free_message_info (folder, info); } /* special-case... */ if (uids->len == 1) { CamelMessageInfo *info; const gchar *message_uid; message_uid = g_ptr_array_index (uids, 0); info = camel_folder_get_message_info (folder, message_uid); if (info) { tags = (CamelTag *) camel_message_info_user_tags (info); if (tags) e_mail_tag_editor_set_tag_list ( E_MAIL_TAG_EDITOR (editor), tags); camel_folder_free_message_info (folder, info); } } if (gtk_dialog_run (GTK_DIALOG (editor)) != GTK_RESPONSE_OK) goto exit; tags = e_mail_tag_editor_get_tag_list (E_MAIL_TAG_EDITOR (editor)); if (tags == NULL) goto exit; camel_folder_freeze (folder); for (i = 0; i < uids->len; i++) { CamelMessageInfo *info; CamelTag *iter; info = camel_folder_get_message_info (folder, uids->pdata[i]); if (info == NULL) continue; for (iter = tags; iter != NULL; iter = iter->next) camel_message_info_set_user_tag ( info, iter->name, iter->value); camel_folder_free_message_info (folder, info); } camel_folder_thaw (folder); camel_tag_list_free (&tags); formatter = e_mail_reader_get_formatter (reader); em_format_queue_redraw (EM_FORMAT (formatter)); exit: /* XXX We shouldn't be freeing this. */ em_utils_uids_free (uids); gtk_widget_destroy (GTK_WIDGET (editor)); } /** * em_utils_flag_for_followup_clear: * @parent: parent window * @folder: folder containing messages to unflag * @uids: uids of messages to unflag * * Clears the Flag-for-Followup flag on the messages referenced by * @folder and @uids. **/ void em_utils_flag_for_followup_clear (GtkWindow *parent, CamelFolder *folder, GPtrArray *uids) { gint i; g_return_if_fail (GTK_IS_WINDOW (parent)); g_return_if_fail (CAMEL_IS_FOLDER (folder)); g_return_if_fail (uids != NULL); camel_folder_freeze (folder); for (i = 0; i < uids->len; i++) { CamelMessageInfo *mi = camel_folder_get_message_info (folder, uids->pdata[i]); if (mi) { camel_message_info_set_user_tag(mi, "follow-up", NULL); camel_message_info_set_user_tag(mi, "due-by", NULL); camel_message_info_set_user_tag(mi, "completed-on", NULL); camel_folder_free_message_info (folder, mi); } } camel_folder_thaw (folder); em_utils_uids_free (uids); } /** * em_utils_flag_for_followup_completed: * @parent: parent window * @folder: folder containing messages to 'complete' * @uids: uids of messages to 'complete' * * Sets the completed state (and date/time) for each message * referenced by @folder and @uids that is marked for * Flag-for-Followup. **/ void em_utils_flag_for_followup_completed (GtkWindow *parent, CamelFolder *folder, GPtrArray *uids) { gchar *now; gint i; g_return_if_fail (GTK_IS_WINDOW (parent)); g_return_if_fail (CAMEL_IS_FOLDER (folder)); g_return_if_fail (uids != NULL); now = camel_header_format_date (time (NULL), 0); camel_folder_freeze (folder); for (i = 0; i < uids->len; i++) { const gchar *tag; CamelMessageInfo *mi = camel_folder_get_message_info (folder, uids->pdata[i]); if (mi) { tag = camel_message_info_user_tag(mi, "follow-up"); if (tag && tag[0]) camel_message_info_set_user_tag(mi, "completed-on", now); camel_folder_free_message_info (folder, mi); } } camel_folder_thaw (folder); g_free (now); em_utils_uids_free (uids); } /* This kind of sucks, because for various reasons most callers need to run * synchronously in the gui thread, however this could take a long, blocking * time to run. */ static gint em_utils_write_messages_to_stream (CamelFolder *folder, GPtrArray *uids, CamelStream *stream) { CamelStream *filtered_stream; CamelMimeFilter *from_filter; gint i, res = 0; from_filter = camel_mime_filter_from_new (); filtered_stream = camel_stream_filter_new (stream); camel_stream_filter_add ( CAMEL_STREAM_FILTER (filtered_stream), from_filter); g_object_unref (from_filter); for (i = 0; i < uids->len; i++) { CamelMimeMessage *message; gchar *from; /* FIXME camel_folder_get_message_sync() may block. */ message = camel_folder_get_message_sync ( folder, uids->pdata[i], NULL, NULL); if (message == NULL) { res = -1; break; } /* We need to flush after each stream write since we are * writing to the same stream. */ from = camel_mime_message_build_mbox_from (message); if (camel_stream_write_string (stream, from, NULL, NULL) == -1 || camel_stream_flush (stream, NULL, NULL) == -1 || camel_data_wrapper_write_to_stream_sync ( (CamelDataWrapper *) message, (CamelStream *) filtered_stream, NULL, NULL) == -1 || camel_stream_flush ( (CamelStream *) filtered_stream, NULL, NULL) == -1) res = -1; g_free (from); g_object_unref (message); if (res == -1) break; } g_object_unref (filtered_stream); return res; } /* This kind of sucks, because for various reasons most callers need to run * synchronously in the gui thread, however this could take a long, blocking * time to run. */ static gint em_utils_read_messages_from_stream (CamelFolder *folder, CamelStream *stream) { CamelMimeParser *mp = camel_mime_parser_new (); gboolean success = TRUE; camel_mime_parser_scan_from (mp, TRUE); camel_mime_parser_init_with_stream (mp, stream, NULL); while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM) { CamelMimeMessage *msg; gboolean success; /* NB: de-from filter, once written */ msg = camel_mime_message_new (); if (!camel_mime_part_construct_from_parser_sync ( (CamelMimePart *) msg, mp, NULL, NULL)) { g_object_unref (msg); break; } /* FIXME camel_folder_append_message_sync() may block. */ success = camel_folder_append_message_sync ( folder, msg, NULL, NULL, NULL, NULL); g_object_unref (msg); if (!success) break; camel_mime_parser_step (mp, NULL, NULL); } g_object_unref (mp); return success ? 0 : -1; } /** * em_utils_selection_set_mailbox: * @data: selection data * @folder: folder containign messages to copy into the selection * @uids: uids of the messages to copy into the selection * * Creates a mailbox-format selection. * Warning: Could be BIG! * Warning: This could block the ui for an extended period. **/ void em_utils_selection_set_mailbox (GtkSelectionData *data, CamelFolder *folder, GPtrArray *uids) { GByteArray *byte_array; CamelStream *stream; GdkAtom target; target = gtk_selection_data_get_target (data); byte_array = g_byte_array_new (); stream = camel_stream_mem_new_with_byte_array (byte_array); if (em_utils_write_messages_to_stream (folder, uids, stream) == 0) gtk_selection_data_set ( data, target, 8, byte_array->data, byte_array->len); g_object_unref (stream); } /** * em_utils_selection_get_mailbox: * @selection_data: selection data * @folder: * * Receive a mailbox selection/dnd * Warning: Could be BIG! * Warning: This could block the ui for an extended period. * FIXME: Exceptions? **/ void em_utils_selection_get_mailbox (GtkSelectionData *selection_data, CamelFolder *folder) { CamelStream *stream; const guchar *data; gint length; data = gtk_selection_data_get_data (selection_data); length = gtk_selection_data_get_length (selection_data); if (data == NULL || length == -1) return; /* TODO: a stream mem with read-only access to existing data? */ /* NB: Although copying would let us run this async ... which it should */ stream = (CamelStream *) camel_stream_mem_new_with_buffer ((gchar *) data, length); em_utils_read_messages_from_stream (folder, stream); g_object_unref (stream); } /** * em_utils_selection_get_message: * @selection_data: * @folder: * * get a message/rfc822 data. **/ void em_utils_selection_get_message (GtkSelectionData *selection_data, CamelFolder *folder) { CamelStream *stream; CamelMimeMessage *msg; const guchar *data; gint length; data = gtk_selection_data_get_data (selection_data); length = gtk_selection_data_get_length (selection_data); if (data == NULL || length == -1) return; stream = (CamelStream *) camel_stream_mem_new_with_buffer ((gchar *) data, length); msg = camel_mime_message_new (); if (camel_data_wrapper_construct_from_stream_sync ( (CamelDataWrapper *) msg, stream, NULL, NULL)) /* FIXME camel_folder_append_message_sync() may block. */ camel_folder_append_message_sync ( folder, msg, NULL, NULL, NULL, NULL); g_object_unref (msg); g_object_unref (stream); } /** * em_utils_selection_set_uidlist: * @selection_data: selection data * @folder: * @uids: * * Sets a "x-uid-list" format selection data. **/ void em_utils_selection_set_uidlist (GtkSelectionData *selection_data, CamelFolder *folder, GPtrArray *uids) { GByteArray *array = g_byte_array_new (); GdkAtom target; gchar *folder_uri; gint i; /* format: "uri\0uid1\0uid2\0uid3\0...\0uidn\0" */ folder_uri = e_mail_folder_uri_from_folder (folder); g_byte_array_append ( array, (guchar *) folder_uri, strlen (folder_uri) + 1); for (i = 0; i < uids->len; i++) g_byte_array_append (array, uids->pdata[i], strlen (uids->pdata[i]) + 1); target = gtk_selection_data_get_target (selection_data); gtk_selection_data_set ( selection_data, target, 8, array->data, array->len); g_byte_array_free (array, TRUE); g_free (folder_uri); } /** * em_utils_selection_get_uidlist: * @data: selection data * @session: an #EMailSession * @move: do we delete the messages. * * Convert a uid list into a copy/move operation. * * Warning: Could take some time to run. **/ void em_utils_selection_get_uidlist (GtkSelectionData *selection_data, EMailSession *session, CamelFolder *dest, gint move, GCancellable *cancellable, GError **error) { /* format: "uri\0uid1\0uid2\0uid3\0...\0uidn" */ gchar *inptr, *inend; GPtrArray *uids; CamelFolder *folder; const guchar *data; gint length; g_return_if_fail (selection_data != NULL); g_return_if_fail (E_IS_MAIL_SESSION (session)); data = gtk_selection_data_get_data (selection_data); length = gtk_selection_data_get_length (selection_data); if (data == NULL || length == -1) return; uids = g_ptr_array_new (); inptr = (gchar *) data; inend = (gchar *) (data + length); while (inptr < inend) { gchar *start = inptr; while (inptr < inend && *inptr) inptr++; if (start > (gchar *) data) g_ptr_array_add (uids, g_strndup (start, inptr - start)); inptr++; } if (uids->len == 0) { g_ptr_array_free (uids, TRUE); return; } /* FIXME e_mail_session_uri_to_folder_sync() may block. */ folder = e_mail_session_uri_to_folder_sync ( session, (gchar *) data, 0, cancellable, error); if (folder) { /* FIXME camel_folder_transfer_messages_to_sync() may block. */ camel_folder_transfer_messages_to_sync ( folder, uids, dest, move, NULL, cancellable, error); g_object_unref (folder); } em_utils_uids_free (uids); } /** * em_utils_selection_set_urilist: * @data: * @folder: * @uids: * * Set the selection data @data to a uri which points to a file, which is * a berkely mailbox format mailbox. The file is automatically cleaned * up when the application quits. **/ void em_utils_selection_set_urilist (GtkSelectionData *data, CamelFolder *folder, GPtrArray *uids) { gchar *tmpdir; CamelStream *fstream; gchar *uri, *file = NULL, *tmpfile; gint fd; CamelMessageInfo *info; tmpdir = e_mkdtemp("drag-n-drop-XXXXXX"); if (tmpdir == NULL) return; /* Try to get the drop filename from the message or folder */ if (uids->len == 1) { const gchar *message_uid; message_uid = g_ptr_array_index (uids, 0); info = camel_folder_get_message_info (folder, message_uid); if (info) { file = g_strdup (camel_message_info_subject (info)); camel_folder_free_message_info (folder, info); } } /* TODO: Handle conflicts? */ if (file == NULL) { /* Drop filename for messages from a mailbox */ file = g_strdup_printf ( _("Messages from %s"), camel_folder_get_display_name (folder)); } e_filename_make_safe (file); tmpfile = g_build_filename (tmpdir, file, NULL); g_free (tmpdir); g_free (file); fd = g_open (tmpfile, O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0666); if (fd == -1) { g_free (tmpfile); return; } uri = g_filename_to_uri (tmpfile, NULL, NULL); g_free (tmpfile); fstream = camel_stream_fs_new_with_fd (fd); if (fstream) { if (em_utils_write_messages_to_stream (folder, uids, fstream) == 0) { /* terminate with \r\n to be compliant with the spec */ gchar *uri_crlf = g_strconcat(uri, "\r\n", NULL); GdkAtom target; target = gtk_selection_data_get_target (data); gtk_selection_data_set ( data, target, 8, (guchar *) uri_crlf, strlen (uri_crlf)); g_free (uri_crlf); } g_object_unref (fstream); } else close (fd); g_free (uri); } /** * em_utils_selection_set_urilist: * @data: * @folder: * @uids: * * Get the selection data @data from a uri list which points to a * file, which is a berkely mailbox format mailbox. The file is * automatically cleaned up when the application quits. **/ void em_utils_selection_get_urilist (GtkSelectionData *selection_data, CamelFolder *folder) { CamelStream *stream; CamelURL *url; gint fd, i, res = 0; gchar **uris; d(printf(" * drop uri list\n")); uris = gtk_selection_data_get_uris (selection_data); for (i = 0; res == 0 && uris[i]; i++) { g_strstrip (uris[i]); if (uris[i][0] == '#') continue; url = camel_url_new (uris[i], NULL); if (url == NULL) continue; if (strcmp(url->protocol, "file") == 0 && (fd = g_open (url->path, O_RDONLY | O_BINARY, 0)) != -1) { stream = camel_stream_fs_new_with_fd (fd); if (stream) { res = em_utils_read_messages_from_stream (folder, stream); g_object_unref (stream); } else close (fd); } camel_url_free (url); } g_strfreev (uris); } /** * em_utils_folder_is_templates: * @folder: a #CamelFolder * * Decides if @folder is a Templates folder. * * Returns %TRUE if this is a Templates folder or %FALSE otherwise. **/ gboolean em_utils_folder_is_templates (CamelFolder *folder) { CamelFolder *local_templates_folder; CamelSession *session; CamelStore *store; EAccountList *account_list; EIterator *iterator; gchar *folder_uri; gboolean is_templates = FALSE; g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); local_templates_folder = e_mail_local_get_folder (E_MAIL_LOCAL_FOLDER_TEMPLATES); if (folder == local_templates_folder) return TRUE; folder_uri = e_mail_folder_uri_from_folder (folder); store = camel_folder_get_parent_store (folder); session = camel_service_get_session (CAMEL_SERVICE (store)); account_list = e_get_account_list (); iterator = e_list_get_iterator (E_LIST (account_list)); while (!is_templates && e_iterator_is_valid (iterator)) { EAccount *account; /* XXX EIterator misuses const. */ account = (EAccount *) e_iterator_get (iterator); if (account->templates_folder_uri != NULL) is_templates = e_mail_folder_uri_equal ( session, folder_uri, account->templates_folder_uri); e_iterator_next (iterator); } g_object_unref (iterator); g_free (folder_uri); return is_templates; } /** * em_utils_folder_is_drafts: * @folder: a #CamelFolder * * Decides if @folder is a Drafts folder. * * Returns %TRUE if this is a Drafts folder or %FALSE otherwise. **/ gboolean em_utils_folder_is_drafts (CamelFolder *folder) { CamelFolder *local_drafts_folder; CamelSession *session; CamelStore *store; EAccountList *account_list; EIterator *iterator; gchar *folder_uri; gboolean is_drafts = FALSE; g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); local_drafts_folder = e_mail_local_get_folder (E_MAIL_LOCAL_FOLDER_DRAFTS); if (folder == local_drafts_folder) return TRUE; folder_uri = e_mail_folder_uri_from_folder (folder); store = camel_folder_get_parent_store (folder); session = camel_service_get_session (CAMEL_SERVICE (store)); account_list = e_get_account_list (); iterator = e_list_get_iterator (E_LIST (account_list)); while (!is_drafts && e_iterator_is_valid (iterator)) { EAccount *account; /* XXX EIterator misuses const. */ account = (EAccount *) e_iterator_get (iterator); if (account->drafts_folder_uri != NULL) is_drafts = e_mail_folder_uri_equal ( session, folder_uri, account->drafts_folder_uri); e_iterator_next (iterator); } g_object_unref (iterator); g_free (folder_uri); return is_drafts; } /** * em_utils_folder_is_sent: * @folder: a #CamelFolder * * Decides if @folder is a Sent folder. * * Returns %TRUE if this is a Sent folder or %FALSE otherwise. **/ gboolean em_utils_folder_is_sent (CamelFolder *folder) { CamelFolder *local_sent_folder; CamelSession *session; CamelStore *store; EAccountList *account_list; EIterator *iterator; gchar *folder_uri; gboolean is_sent = FALSE; g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); local_sent_folder = e_mail_local_get_folder (E_MAIL_LOCAL_FOLDER_SENT); if (folder == local_sent_folder) return TRUE; folder_uri = e_mail_folder_uri_from_folder (folder); store = camel_folder_get_parent_store (folder); session = camel_service_get_session (CAMEL_SERVICE (store)); account_list = e_get_account_list (); iterator = e_list_get_iterator (E_LIST (account_list)); while (!is_sent && e_iterator_is_valid (iterator)) { EAccount *account; /* XXX EIterator misuses const. */ account = (EAccount *) e_iterator_get (iterator); if (account->sent_folder_uri != NULL) is_sent = e_mail_folder_uri_equal ( session, folder_uri, account->sent_folder_uri); e_iterator_next (iterator); } g_object_unref (iterator); g_free (folder_uri); return is_sent; } /** * em_utils_folder_is_outbox: * @folder: a #CamelFolder * * Decides if @folder is an Outbox folder. * * Returns %TRUE if this is an Outbox folder or %FALSE otherwise. **/ gboolean em_utils_folder_is_outbox (CamelFolder *folder) { CamelFolder *local_outbox_folder; g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE); local_outbox_folder = e_mail_local_get_folder (E_MAIL_LOCAL_FOLDER_OUTBOX); return (folder == local_outbox_folder); } /* ********************************************************************** */ static EProxy *emu_proxy = NULL; static GStaticMutex emu_proxy_lock = G_STATIC_MUTEX_INIT; static gpointer emu_proxy_setup (gpointer data) { if (!emu_proxy) { emu_proxy = e_proxy_new (); e_proxy_setup_proxy (emu_proxy); /* not necessary to listen for changes here */ } return NULL; } EProxy * em_utils_get_proxy (void) { g_static_mutex_lock (&emu_proxy_lock); if (!emu_proxy) { mail_call_main (MAIL_CALL_p_p, (MailMainFunc) emu_proxy_setup, NULL); } g_static_mutex_unlock (&emu_proxy_lock); return emu_proxy; } /** * em_utils_message_to_html: * @message: * @credits: * @flags: EMFormatQuote flags * @source: * @append: Text to append, can be NULL. * @validity_found: if not NULL, then here will be set what validities * had been found during message conversion. Value is a bit OR * of EM_FORMAT_VALIDITY_FOUND_* constants. * * Convert a message to html, quoting if the @credits attribution * string is given. * * Return value: The html version as a NULL terminated string. **/ gchar * em_utils_message_to_html (CamelMimeMessage *message, const gchar *credits, guint32 flags, EMFormat *source, const gchar *append, guint32 *validity_found) { EMFormatQuote *emfq; CamelStream *mem; GByteArray *buf; buf = g_byte_array_new (); mem = camel_stream_mem_new (); camel_stream_mem_set_byte_array (CAMEL_STREAM_MEM (mem), buf); emfq = em_format_quote_new (credits, mem, flags); ((EMFormat *) emfq)->composer = TRUE; if (!source) { GConfClient *gconf; gchar *charset; /* FIXME We should be getting this from the * current view, not the global setting. */ gconf = gconf_client_get_default (); charset = gconf_client_get_string ( gconf, "/apps/evolution/mail/display/charset", NULL); em_format_set_default_charset ((EMFormat *) emfq, charset); g_object_unref (gconf); g_free (charset); } /* FIXME Not passing a GCancellable here. */ em_format_format_clone ( EM_FORMAT (emfq), NULL, NULL, message, source, NULL); if (validity_found) *validity_found = ((EMFormat *)emfq)->validity_found; g_object_unref (emfq); if (append && *append) camel_stream_write_string (mem, append, NULL, NULL); camel_stream_write(mem, "", 1, NULL, NULL); g_object_unref (mem); return (gchar *) g_byte_array_free (buf, FALSE); } /* ********************************************************************** */ /** * em_utils_expunge_folder: * @parent: parent window * @backend: #EMailBackend * @folder: folder to expunge * * Expunges @folder. **/ void em_utils_expunge_folder (GtkWidget *parent, EMailBackend *backend, CamelFolder *folder) { const gchar *description; description = camel_folder_get_description (folder); if (!em_utils_prompt_user ( GTK_WINDOW (parent), "/apps/evolution/mail/prompts/expunge", "mail:ask-expunge", description, NULL)) return; mail_expunge_folder (backend, folder); } /** * em_utils_empty_trash: * @parent: parent window * @backend: an #EMailBackend * * Empties all Trash folders. **/ void em_utils_empty_trash (GtkWidget *parent, EMailBackend *backend) { EMailSession *session; GList *list, *iter; g_return_if_fail (E_IS_MAIL_BACKEND (backend)); if (!em_utils_prompt_user ((GtkWindow *) parent, "/apps/evolution/mail/prompts/empty_trash", "mail:ask-empty-trash", NULL)) return; session = e_mail_backend_get_session (backend); list = camel_session_list_services (CAMEL_SESSION (session)); for (iter = list; iter != NULL; iter = g_list_next (iter)) { EAccount *account; CamelProvider *provider; CamelService *service; const gchar *uid; service = CAMEL_SERVICE (iter->data); provider = camel_service_get_provider (service); uid = camel_service_get_uid (service); if (!CAMEL_IS_STORE (service)) continue; if ((provider->flags & CAMEL_PROVIDER_IS_STORAGE) == 0) continue; account = e_get_account_by_uid (uid); /* The local store has no corresponding * EAccount, so skip the enabled check. */ if (account != NULL) { if (!account->enabled) continue; } mail_empty_trash (backend, CAMEL_STORE (service)); } g_list_free (list); } /* ********************************************************************** */ /* runs sync, in main thread */ static gpointer emu_addr_setup (gpointer user_data) { GError *err = NULL; ESourceList **psource_list = user_data; if (!e_book_client_get_sources (psource_list, &err)) g_error_free (err); return NULL; } static void emu_addr_cancel_stop (gpointer data) { gboolean *stop = data; g_return_if_fail (stop != NULL); *stop = TRUE; } static void emu_addr_cancel_cancellable (gpointer data) { GCancellable *cancellable = data; g_return_if_fail (cancellable != NULL); g_cancellable_cancel (cancellable); } struct TryOpenEBookStruct { GError **error; EFlag *flag; gboolean result; }; static void try_open_book_client_cb (GObject *source_object, GAsyncResult *result, gpointer closure) { EBookClient *book_client = E_BOOK_CLIENT (source_object); struct TryOpenEBookStruct *data = (struct TryOpenEBookStruct *) closure; GError *error = NULL; if (!data) return; e_client_open_finish (E_CLIENT (book_client), result, &error); data->result = error == NULL; if (!data->result) { g_clear_error (data->error); g_propagate_error (data->error, error); } e_flag_set (data->flag); } /* * try_open_book_client: * Tries to open address book asynchronously, but acts as synchronous. * The advantage is it checks periodically whether the camel_operation * has been canceled or not, and if so, then stops immediately, with * result FALSE. Otherwise returns same as e_client_open() */ static gboolean try_open_book_client (EBookClient *book_client, gboolean only_if_exists, GCancellable *cancellable, GError **error) { struct TryOpenEBookStruct data; gboolean canceled = FALSE; EFlag *flag = e_flag_new (); data.error = error; data.flag = flag; data.result = FALSE; e_client_open ( E_CLIENT (book_client), only_if_exists, cancellable, try_open_book_client_cb, &data); while (canceled = camel_operation_cancel_check (NULL), !canceled && !e_flag_is_set (flag)) { GTimeVal wait; g_get_current_time (&wait); g_time_val_add (&wait, 250000); /* waits 250ms */ e_flag_timed_wait (flag, &wait); } if (canceled) { g_cancellable_cancel (cancellable); g_clear_error (error); g_propagate_error ( error, e_client_error_create ( E_CLIENT_ERROR_CANCELLED, NULL)); } e_flag_wait (flag); e_flag_free (flag); return data.result && (!error || !*error); } #define NOT_FOUND_BOOK (GINT_TO_POINTER (1)) G_LOCK_DEFINE_STATIC (contact_cache); /* key is lowercased contact email; value is EBook pointer * (just for comparison) where it comes from */ static GHashTable *contact_cache = NULL; /* key is source ID; value is pointer to EBook */ static GHashTable *emu_books_hash = NULL; /* key is source ID; value is same pointer as key; this is hash of * broken books, which failed to open for some reason */ static GHashTable *emu_broken_books_hash = NULL; static ESourceList *emu_books_source_list = NULL; static gboolean search_address_in_addressbooks (const gchar *address, gboolean local_only, gboolean (*check_contact) (EContact *contact, gpointer user_data), gpointer user_data) { gboolean found = FALSE, stop = FALSE, found_any = FALSE; gchar *lowercase_addr; gpointer ptr; EBookQuery *book_query; gchar *query; GSList *s, *g, *addr_sources = NULL; GHook *hook_cancellable; GCancellable *cancellable; if (!address || !*address) return FALSE; G_LOCK (contact_cache); if (!emu_books_source_list) { mail_call_main ( MAIL_CALL_p_p, (MailMainFunc) emu_addr_setup, &emu_books_source_list); emu_books_hash = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, g_object_unref); emu_broken_books_hash = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL); contact_cache = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL); } if (!emu_books_source_list) { G_UNLOCK (contact_cache); return FALSE; } lowercase_addr = g_utf8_strdown (address, -1); ptr = g_hash_table_lookup (contact_cache, lowercase_addr); if (ptr != NULL && (check_contact == NULL || ptr == NOT_FOUND_BOOK)) { g_free (lowercase_addr); G_UNLOCK (contact_cache); return ptr != NOT_FOUND_BOOK; } book_query = e_book_query_field_test (E_CONTACT_EMAIL, E_BOOK_QUERY_IS, address); query = e_book_query_to_string (book_query); e_book_query_unref (book_query); for (g = e_source_list_peek_groups (emu_books_source_list); g; g = g_slist_next (g)) { ESourceGroup *group = g->data; if (!group) continue; if (local_only && !(e_source_group_peek_base_uri (group) && g_str_has_prefix ( e_source_group_peek_base_uri (group), "local:"))) continue; for (s = e_source_group_peek_sources (group); s; s = g_slist_next (s)) { ESource *source = s->data; const gchar *completion = e_source_get_property (source, "completion"); if (completion && g_ascii_strcasecmp (completion, "true") == 0) { addr_sources = g_slist_prepend (addr_sources, g_object_ref (source)); } } } cancellable = g_cancellable_new (); hook_cancellable = mail_cancel_hook_add (emu_addr_cancel_cancellable, cancellable); for (s = addr_sources; !stop && !found && s; s = g_slist_next (s)) { ESource *source = s->data; GSList *contacts; EBookClient *book_client = NULL; GHook *hook_stop; gboolean cached_book = FALSE; GError *err = NULL; /* failed to load this book last time, skip it now */ if (g_hash_table_lookup (emu_broken_books_hash, e_source_peek_uid (source)) != NULL) { d(printf ("%s: skipping broken book '%s'\n", G_STRFUNC, e_source_peek_name (source))); continue; } d(printf(" checking '%s'\n", e_source_get_uri(source))); hook_stop = mail_cancel_hook_add (emu_addr_cancel_stop, &stop); book_client = g_hash_table_lookup (emu_books_hash, e_source_peek_uid (source)); if (!book_client) { book_client = e_book_client_new (source, &err); if (book_client == NULL) { if (err && (g_error_matches (err, E_CLIENT_ERROR, E_CLIENT_ERROR_CANCELLED) || g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED))) { stop = TRUE; } else if (err) { gchar *source_uid; source_uid = g_strdup ( e_source_peek_uid (source)); g_hash_table_insert ( emu_broken_books_hash, source_uid, source_uid); g_warning ( "%s: Unable to create addressbook '%s': %s", G_STRFUNC, e_source_peek_name (source), err->message); } g_clear_error (&err); } else if (!stop && !try_open_book_client (book_client, TRUE, cancellable, &err)) { g_object_unref (book_client); book_client = NULL; if (err && (g_error_matches (err, E_CLIENT_ERROR, E_CLIENT_ERROR_CANCELLED) || g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED))) { stop = TRUE; } else if (err) { gchar *source_uid; source_uid = g_strdup ( e_source_peek_uid (source)); g_hash_table_insert ( emu_broken_books_hash, source_uid, source_uid); g_warning ( "%s: Unable to open addressbook '%s': %s", G_STRFUNC, e_source_peek_name (source), err->message); } g_clear_error (&err); } } else { cached_book = TRUE; } if (book_client && !stop && e_book_client_get_contacts_sync (book_client, query, &contacts, cancellable, &err)) { if (contacts != NULL) { if (!found_any) { g_hash_table_insert (contact_cache, g_strdup (lowercase_addr), book_client); } found_any = TRUE; if (check_contact) { GSList *l; for (l = contacts; l && !found; l = l->next) { EContact *contact = l->data; found = check_contact (contact, user_data); } } else { found = TRUE; } g_slist_foreach (contacts, (GFunc) g_object_unref, NULL); g_slist_free (contacts); } } else if (book_client) { stop = stop || (err && (g_error_matches (err, E_CLIENT_ERROR, E_CLIENT_ERROR_CANCELLED) || g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED))); if (err && !stop) { gchar *source_uid = g_strdup (e_source_peek_uid (source)); g_hash_table_insert (emu_broken_books_hash, source_uid, source_uid); g_warning ( "%s: Can't get contacts from '%s': %s", G_STRFUNC, e_source_peek_name (source), err->message); } g_clear_error (&err); } mail_cancel_hook_remove (hook_stop); stop = stop || camel_operation_cancel_check (NULL); if (stop && !cached_book && book_client) { g_object_unref (book_client); } else if (!stop && book_client && !cached_book) { g_hash_table_insert ( emu_books_hash, g_strdup ( e_source_peek_uid (source)), book_client); } } mail_cancel_hook_remove (hook_cancellable); g_object_unref (cancellable); g_slist_foreach (addr_sources, (GFunc) g_object_unref, NULL); g_slist_free (addr_sources); g_free (query); if (!found_any) { g_hash_table_insert (contact_cache, lowercase_addr, NOT_FOUND_BOOK); lowercase_addr = NULL; } G_UNLOCK (contact_cache); g_free (lowercase_addr); return found_any; } gboolean em_utils_in_addressbook (CamelInternetAddress *iaddr, gboolean local_only) { const gchar *addr; /* TODO: check all addresses? */ if (iaddr == NULL || !camel_internet_address_get (iaddr, 0, NULL, &addr)) return FALSE; return search_address_in_addressbooks (addr, local_only, NULL, NULL); } static gboolean extract_photo_data (EContact *contact, gpointer user_data) { EContactPhoto **photo = user_data; g_return_val_if_fail (contact != NULL, FALSE); g_return_val_if_fail (user_data != NULL, FALSE); *photo = e_contact_get (contact, E_CONTACT_PHOTO); if (!*photo) *photo = e_contact_get (contact, E_CONTACT_LOGO); return *photo != NULL; } typedef struct _PhotoInfo { gchar *address; EContactPhoto *photo; } PhotoInfo; static void emu_free_photo_info (PhotoInfo *pi) { if (!pi) return; if (pi->address) g_free (pi->address); if (pi->photo) e_contact_photo_free (pi->photo); g_free (pi); } G_LOCK_DEFINE_STATIC (photos_cache); static GSList *photos_cache = NULL; /* list of PhotoInfo-s */ CamelMimePart * em_utils_contact_photo (CamelInternetAddress *cia, gboolean local_only) { const gchar *addr = NULL; CamelMimePart *part = NULL; EContactPhoto *photo = NULL; GSList *p, *first_not_null = NULL; gint count_not_null = 0; if (cia == NULL || !camel_internet_address_get (cia, 0, NULL, &addr) || !addr) { return NULL; } G_LOCK (photos_cache); /* search a cache first */ for (p = photos_cache; p; p = p->next) { PhotoInfo *pi = p->data; if (!pi) continue; if (pi->photo) { if (!first_not_null) first_not_null = p; count_not_null++; } if (g_ascii_strcasecmp (addr, pi->address) == 0) { photo = pi->photo; break; } } /* !p means the address had not been found in the cache */ if (!p && search_address_in_addressbooks ( addr, local_only, extract_photo_data, &photo)) { PhotoInfo *pi; if (photo && photo->type != E_CONTACT_PHOTO_TYPE_INLINED) { e_contact_photo_free (photo); photo = NULL; } /* keep only up to 10 photos in memory */ if (photo && count_not_null >= 10 && first_not_null) { pi = first_not_null->data; photos_cache = g_slist_remove (photos_cache, pi); emu_free_photo_info (pi); } pi = g_new0 (PhotoInfo, 1); pi->address = g_strdup (addr); pi->photo = photo; photos_cache = g_slist_append (photos_cache, pi); } /* some photo found, use it */ if (photo) { /* Form a mime part out of the photo */ part = camel_mime_part_new (); camel_mime_part_set_content (part, (const gchar *) photo->data.inlined.data, photo->data.inlined.length, "image/jpeg"); } G_UNLOCK (photos_cache); return part; } /* list of email addresses (strings) to remove from local cache of photos and * contacts, but only if the photo doesn't exist or is an not-found contact */ void emu_remove_from_mail_cache (const GSList *addresses) { const GSList *a; GSList *p; CamelInternetAddress *cia; cia = camel_internet_address_new (); for (a = addresses; a; a = a->next) { const gchar *addr = NULL; if (!a->data) continue; if (camel_address_decode ((CamelAddress *) cia, a->data) != -1 && camel_internet_address_get (cia, 0, NULL, &addr) && addr) { gchar *lowercase_addr = g_utf8_strdown (addr, -1); G_LOCK (contact_cache); if (g_hash_table_lookup (contact_cache, lowercase_addr) == NOT_FOUND_BOOK) g_hash_table_remove (contact_cache, lowercase_addr); G_UNLOCK (contact_cache); g_free (lowercase_addr); G_LOCK (photos_cache); for (p = photos_cache; p; p = p->next) { PhotoInfo *pi = p->data; if (pi && !pi->photo && g_ascii_strcasecmp (pi->address, addr) == 0) { photos_cache = g_slist_remove (photos_cache, pi); emu_free_photo_info (pi); break; } } G_UNLOCK (photos_cache); } } g_object_unref (cia); } void emu_remove_from_mail_cache_1 (const gchar *address) { GSList *l; g_return_if_fail (address != NULL); l = g_slist_append (NULL, (gpointer) address); emu_remove_from_mail_cache (l); g_slist_free (l); } /* frees all data created by call of em_utils_in_addressbook() or * em_utils_contact_photo() */ void emu_free_mail_cache (void) { G_LOCK (contact_cache); if (emu_books_hash) { g_hash_table_destroy (emu_books_hash); emu_books_hash = NULL; } if (emu_broken_books_hash) { g_hash_table_destroy (emu_broken_books_hash); emu_broken_books_hash = NULL; } if (emu_books_source_list) { g_object_unref (emu_books_source_list); emu_books_source_list = NULL; } if (contact_cache) { g_hash_table_destroy (contact_cache); contact_cache = NULL; } G_UNLOCK (contact_cache); G_LOCK (photos_cache); g_slist_foreach (photos_cache, (GFunc) emu_free_photo_info, NULL); g_slist_free (photos_cache); photos_cache = NULL; G_UNLOCK (photos_cache); free_account_sort_order_cache (); } void em_utils_clear_get_password_canceled_accounts_flag (void) { EAccountList *account_list; EIterator *iterator; account_list = e_get_account_list (); for (iterator = e_list_get_iterator (E_LIST (account_list)); e_iterator_is_valid (iterator); e_iterator_next (iterator)) { EAccount *account = (EAccount *) e_iterator_get (iterator); if (account && account->source) account->source->get_password_canceled = FALSE; if (account && account->transport) account->transport->get_password_canceled = FALSE; } g_object_unref (iterator); } gchar * em_utils_url_unescape_amp (const gchar *url) { gchar *buff; gint i, j, amps; if (!url) return NULL; amps = 0; for (i = 0; url[i]; i++) { if (url [i] == '&' && strncmp (url + i, "&", 5) == 0) amps++; } buff = g_strdup (url); if (!amps) return buff; for (i = 0, j = 0; url[i]; i++, j++) { buff[j] = url[i]; if (url [i] == '&' && strncmp (url + i, "&", 5) == 0) i += 4; } buff[j] = 0; return buff; } static EAccount * guess_account_from_folder (CamelFolder *folder) { CamelStore *store; const gchar *uid; store = camel_folder_get_parent_store (folder); uid = camel_service_get_uid (CAMEL_SERVICE (store)); return e_get_account_by_uid (uid); } static EAccount * guess_account_from_message (CamelMimeMessage *message) { const gchar *uid; uid = camel_mime_message_get_source (message); return (uid != NULL) ? e_get_account_by_uid (uid) : NULL; } GHashTable * em_utils_generate_account_hash (void) { GHashTable *account_hash; EAccount *account, *def; EAccountList *account_list; EIterator *iterator; account_list = e_get_account_list (); account_hash = g_hash_table_new (camel_strcase_hash, camel_strcase_equal); def = e_get_default_account (); iterator = e_list_get_iterator (E_LIST (account_list)); while (e_iterator_is_valid (iterator)) { account = (EAccount *) e_iterator_get (iterator); if (account->id->address) { EAccount *acnt; /* Accounts with identical email addresses that are * enabled take precedence over the accounts that * aren't. If all accounts with matching email * addresses are disabled, then the first one in * the list takes precedence. The default account * always takes precedence no matter what. */ acnt = g_hash_table_lookup ( account_hash, account->id->address); if (acnt && acnt != def && !acnt->enabled && account->enabled) { g_hash_table_remove ( account_hash, acnt->id->address); acnt = NULL; } if (!acnt) g_hash_table_insert ( account_hash, (gchar *) account->id->address, (gpointer) account); } e_iterator_next (iterator); } g_object_unref (iterator); /* The default account has to be there if none * of the enabled accounts are present. */ if (g_hash_table_size (account_hash) == 0 && def && def->id->address) g_hash_table_insert ( account_hash, (gchar *) def->id->address, (gpointer) def); return account_hash; } EAccount * em_utils_guess_account (CamelMimeMessage *message, CamelFolder *folder) { EAccount *account = NULL; g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL); if (folder != NULL) g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL); /* check for newsgroup header */ if (folder != NULL && camel_medium_get_header (CAMEL_MEDIUM (message), "Newsgroups")) account = guess_account_from_folder (folder); /* check for source folder */ if (account == NULL && folder != NULL) account = guess_account_from_folder (folder); /* then message source */ if (account == NULL) account = guess_account_from_message (message); return account; } EAccount * em_utils_guess_account_with_recipients (CamelMimeMessage *message, CamelFolder *folder) { EAccount *account = NULL; EAccountList *account_list; GHashTable *recipients; EIterator *iterator; CamelInternetAddress *addr; const gchar *type; const gchar *key; /* This policy is subject to debate and tweaking, * but please also document the rational here. */ g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL); /* Build a set of email addresses in which to test for membership. * Only the keys matter here; the values just need to be non-NULL. */ recipients = g_hash_table_new (g_str_hash, g_str_equal); type = CAMEL_RECIPIENT_TYPE_TO; addr = camel_mime_message_get_recipients (message, type); if (addr != NULL) { gint index = 0; while (camel_internet_address_get (addr, index++, NULL, &key)) g_hash_table_insert ( recipients, (gpointer) key, GINT_TO_POINTER (1)); } type = CAMEL_RECIPIENT_TYPE_CC; addr = camel_mime_message_get_recipients (message, type); if (addr != NULL) { gint index = 0; while (camel_internet_address_get (addr, index++, NULL, &key)) g_hash_table_insert ( recipients, (gpointer) key, GINT_TO_POINTER (1)); } /* First Preference: We were given a folder that maps to an * enabled account, and that account's email address appears * in the list of To: or Cc: recipients. */ if (folder != NULL) account = guess_account_from_folder (folder); if (account == NULL || !account->enabled) goto second_preference; if ((key = account->id->address) == NULL) goto second_preference; if (g_hash_table_lookup (recipients, key) != NULL) goto exit; second_preference: /* Second Preference: Choose any enabled account whose email * address appears in the list to To: or Cc: recipients. */ account_list = e_get_account_list (); iterator = e_list_get_iterator (E_LIST (account_list)); while (e_iterator_is_valid (iterator)) { account = (EAccount *) e_iterator_get (iterator); e_iterator_next (iterator); if (account == NULL || !account->enabled) continue; if ((key = account->id->address) == NULL) continue; if (g_hash_table_lookup (recipients, key) != NULL) { g_object_unref (iterator); goto exit; } } g_object_unref (iterator); /* Last Preference: Defer to em_utils_guess_account(). */ account = em_utils_guess_account (message, folder); exit: g_hash_table_destroy (recipients); return account; } void emu_restore_folder_tree_state (EMFolderTree *folder_tree) { EShell *shell; EShellBackend *backend; GKeyFile *key_file; const gchar *config_dir; gchar *filename; g_return_if_fail (folder_tree != NULL); g_return_if_fail (EM_IS_FOLDER_TREE (folder_tree)); shell = e_shell_get_default (); backend = e_shell_get_backend_by_name (shell, "mail"); g_return_if_fail (backend != NULL); config_dir = e_shell_backend_get_config_dir (backend); g_return_if_fail (config_dir != NULL); filename = g_build_filename (config_dir, "state.ini", NULL); key_file = g_key_file_new (); g_key_file_load_from_file (key_file, filename, 0, NULL); g_free (filename); em_folder_tree_restore_state (folder_tree, key_file); g_key_file_free (key_file); } /* Returns TRUE if CamelURL points to a local mbox file. */ gboolean em_utils_is_local_delivery_mbox_file (CamelURL *url) { g_return_val_if_fail (url != NULL, FALSE); return g_str_equal (url->protocol, "mbox") && (url->path != NULL) && g_file_test (url->path, G_FILE_TEST_EXISTS) && !g_file_test (url->path, G_FILE_TEST_IS_DIR); } static void cancel_service_connect_cb (GCancellable *cancellable, CamelService *service) { g_return_if_fail (CAMEL_IS_SERVICE (service)); camel_service_cancel_connect (service); } gboolean em_utils_connect_service_sync (CamelService *service, GCancellable *cancellable, GError **error) { gboolean res; gulong handler_id = 0; g_return_val_if_fail (CAMEL_IS_SERVICE (service), FALSE); if (cancellable != NULL) handler_id = g_cancellable_connect ( cancellable, G_CALLBACK (cancel_service_connect_cb), service, NULL); res = camel_service_connect_sync (service, error); if (handler_id) g_cancellable_disconnect (cancellable, handler_id); return res; } gboolean em_utils_disconnect_service_sync (CamelService *service, gboolean clean, GCancellable *cancellable, GError **error) { gboolean res; gulong handler_id = 0; g_return_val_if_fail (CAMEL_IS_SERVICE (service), FALSE); if (cancellable != NULL) handler_id = g_cancellable_connect ( cancellable, G_CALLBACK (cancel_service_connect_cb), service, NULL); res = camel_service_disconnect_sync (service, clean, error); if (handler_id) g_cancellable_disconnect (cancellable, handler_id); return res; } G_LOCK_DEFINE_STATIC (accounts_sort_order_cache); static GHashTable *accounts_sort_order_cache = NULL; /* account_uid string to sort order uint */ static void free_account_sort_order_cache (void) { G_LOCK (accounts_sort_order_cache); if (accounts_sort_order_cache) { g_hash_table_destroy (accounts_sort_order_cache); accounts_sort_order_cache = NULL; } G_UNLOCK (accounts_sort_order_cache); } static void fill_accounts_sort_order_cache (EMailBackend *backend, gboolean force_reload) { GSList *account_uids; G_LOCK (accounts_sort_order_cache); if (!force_reload && accounts_sort_order_cache) { G_UNLOCK (accounts_sort_order_cache); return; } if (!accounts_sort_order_cache) accounts_sort_order_cache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); else g_hash_table_remove_all (accounts_sort_order_cache); account_uids = em_utils_load_accounts_sort_order (backend); if (account_uids) { GSList *iter; guint index; for (index = 1, iter = account_uids; iter; index++, iter = iter->next) { if (iter->data) g_hash_table_insert (accounts_sort_order_cache, iter->data, GUINT_TO_POINTER (index)); } /* items are stolen into the cache */ /* g_slist_foreach (account_uids, (GFunc) g_free, NULL); */ g_slist_free (account_uids); } G_UNLOCK (accounts_sort_order_cache); } static gchar * emu_get_sort_order_filename (EMailBackend *backend) { g_return_val_if_fail (backend != NULL, NULL); return g_build_filename ( e_shell_backend_get_config_dir (E_SHELL_BACKEND (backend)), "sortorder.ini", NULL); } static GKeyFile * emu_get_sort_order_key_file (EMailBackend *backend) { gchar *filename; GKeyFile *key_file; g_return_val_if_fail (backend != NULL, NULL); filename = emu_get_sort_order_filename (backend); g_return_val_if_fail (filename != NULL, NULL); key_file = g_key_file_new (); g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, NULL); g_free (filename); return key_file; } void em_utils_save_accounts_sort_order (EMailBackend *backend, const GSList *account_uids) { gchar *filename; GKeyFile *key_file; gint ii; gchar key[32]; gchar *content; gsize length = 0; key_file = emu_get_sort_order_key_file (backend); g_return_if_fail (key_file != NULL); filename = emu_get_sort_order_filename (backend); g_return_if_fail (filename != NULL); g_key_file_remove_group (key_file, "accounts", NULL); for (ii = 0; account_uids; ii++, account_uids = account_uids->next) { sprintf (key, "%d", ii); g_key_file_set_string (key_file, "accounts", key, account_uids->data); } content = g_key_file_to_data (key_file, &length, NULL); if (content) g_file_set_contents (filename, content, length, NULL); g_free (content); g_free (filename); g_key_file_free (key_file); fill_accounts_sort_order_cache (backend, TRUE); e_mail_backend_account_sort_order_changed (backend); } GSList * em_utils_load_accounts_sort_order (EMailBackend *backend) { GKeyFile *key_file; GSList *account_uids = NULL; gchar key[32]; gchar *value; gint ii; key_file = emu_get_sort_order_key_file (backend); g_return_val_if_fail (key_file != NULL, NULL); ii = 0; do { sprintf (key, "%d", ii); ii++; value = g_key_file_get_string (key_file, "accounts", key, NULL); if (!value) break; account_uids = g_slist_prepend (account_uids, value); } while (*key); g_key_file_free (key_file); return g_slist_reverse (account_uids); } guint em_utils_get_account_sort_order (EMailBackend *backend, const gchar *account_uid) { guint res; g_return_val_if_fail (backend != NULL, 0); g_return_val_if_fail (account_uid != NULL, 0); fill_accounts_sort_order_cache (backend, FALSE); G_LOCK (accounts_sort_order_cache); res = GPOINTER_TO_UINT (g_hash_table_lookup (accounts_sort_order_cache, account_uid)); G_UNLOCK (accounts_sort_order_cache); return res; }