Fix modest_tny_msg_header_get_all_recipients_list (in case from is empty)
[modest] / src / modest-utils.c
index bb66e34..c6e50e7 100644 (file)
@@ -54,6 +54,7 @@
 #ifdef MODEST_TOOLKIT_HILDON2
 #include "modest-header-window.h"
 #endif
+#include <langinfo.h>
 
 GQuark
 modest_utils_get_supported_secure_authentication_error_quark (void)
@@ -133,13 +134,13 @@ modest_utils_create_temp_stream (const gchar *orig_name, const gchar *hash_base,
                           __FUNCTION__, orig_name);
                return NULL;
        }
-       
+
        if (g_strstr_len (orig_name, strlen(orig_name), "/") != NULL) {
                g_warning ("%s: filename contains '/' character(s) (%s)",
                           __FUNCTION__, orig_name);
                return NULL;
        }
-               
+
        /* make a random subdir under /tmp or /var/tmp */
        if (hash_base != NULL) {
                hash_number = g_str_hash (hash_base);
@@ -155,6 +156,12 @@ modest_utils_create_temp_stream (const gchar *orig_name, const gchar *hash_base,
        }
 
        filepath = g_strconcat (tmpdir, "/", orig_name, NULL);
+
+       /* if file exists, first we try to remove it */
+       if (modest_utils_file_exists (filepath)) {
+               g_unlink (filepath);
+       }
+
        /* don't overwrite if it already exists, even if it is writable */
        if (modest_utils_file_exists (filepath)) {
                if (path!=NULL) {
@@ -169,7 +176,7 @@ modest_utils_create_temp_stream (const gchar *orig_name, const gchar *hash_base,
                fd = g_open (filepath, O_CREAT|O_WRONLY|O_TRUNC, 0644);
                if (fd == -1) {
                        g_warning ("%s: failed to create '%s': %s",
-                                       __FUNCTION__, filepath, g_strerror(errno));                     
+                                       __FUNCTION__, filepath, g_strerror(errno));
                        g_free (filepath);
                        g_free (tmpdir);
                        return NULL;
@@ -180,45 +187,37 @@ modest_utils_create_temp_stream (const gchar *orig_name, const gchar *hash_base,
 
        if (path)
                *path = filepath;
+       else
+               g_free (filepath);
 
        return TNY_FS_STREAM (tny_fs_stream_new (fd));
 }
 
 typedef struct 
 {
-       gboolean cancel;
-       GList *result;
+       GList **result;
        GtkWidget* dialog;
        GtkWidget* progress;
-       GError* error;
 } ModestGetSupportedAuthInfo;
 
-static void on_camel_account_get_supported_secure_authentication_status (
-       GObject *self, TnyStatus *status, gpointer user_data)
-{
-       /*ModestGetSupportedAuthInfo* info = (ModestGetSupportedAuthInfo*) user_data;*/
-}
-
 static gboolean
 on_idle_secure_auth_finished (gpointer user_data)
 {
-       ModestGetSupportedAuthInfo *info = (ModestGetSupportedAuthInfo*)user_data;
        /* Operation has finished, close the dialog. Control continues after
         * gtk_dialog_run in modest_utils_get_supported_secure_authentication_methods() */
-
-       /* This is a GDK lock because we are an idle callback and
-        * the code below is or does Gtk+ code */
-
        gdk_threads_enter(); /* CHECKED */
-       gtk_dialog_response (GTK_DIALOG (info->dialog), GTK_RESPONSE_ACCEPT);
+       gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_ACCEPT);
        gdk_threads_leave(); /* CHECKED */
 
        return FALSE;
 }
 
 static void
-on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gboolean cancelled,
-       TnyList *auth_types, GError *err, gpointer user_data)
+on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self,
+                                                     gboolean cancelled,
+                                                     TnyList *auth_types,
+                                                     GError *err,
+                                                     gpointer user_data)
 {
        ModestPairList *pairs;
        GList *result;
@@ -229,22 +228,17 @@ on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gbo
        g_return_if_fail (user_data);
        g_return_if_fail (TNY_IS_CAMEL_ACCOUNT(self));
        g_return_if_fail (TNY_IS_LIST(auth_types));
-       
+
        info = (ModestGetSupportedAuthInfo *) user_data;
 
        /* Free everything if the actual action was canceled */
-       if (info->cancel) {
-               info->cancel = TRUE;
+       if (cancelled) {
                g_debug ("%s: operation canceled\n", __FUNCTION__);
                goto close_dialog;
        }
 
        if (err) {
-               if (info->error) {
-                       g_error_free (info->error);
-                       info->error = NULL;
-               }                       
-               info->error = g_error_copy (err);
+               g_debug ("%s: error getting the supported auth methods\n", __FUNCTION__);
                goto close_dialog;
        }
 
@@ -260,7 +254,7 @@ on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gbo
 
        protocol_registry = modest_runtime_get_protocol_registry ();
        pairs = modest_protocol_registry_get_pair_list_by_tag (protocol_registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS);
-  
+
        /* Get the enum value for the strings: */
        result = NULL;
        iter = tny_list_create_iterator(auth_types);
@@ -268,7 +262,7 @@ on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gbo
                TnyPair *pair;
                const gchar *auth_name;
                ModestProtocolType protocol_type;
-               
+
                pair = TNY_PAIR(tny_iterator_get_current(iter));
                auth_name = NULL;
                if (pair) {
@@ -276,43 +270,33 @@ on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gbo
                        g_object_unref (pair);
                        pair = NULL;
                }
-               
+
                g_debug ("%s: auth_name=%s\n", __FUNCTION__, auth_name);
-               
+
                protocol_type = modest_protocol_get_type_id (modest_protocol_registry_get_protocol_by_name (protocol_registry,
                                                                                                            MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
                                                                                                            auth_name));
-               
+
                if (modest_protocol_registry_protocol_type_is_secure (protocol_registry, protocol_type))
                        result = g_list_prepend(result, GINT_TO_POINTER(protocol_type));
-               
+
                tny_iterator_next(iter);
        }
        g_object_unref (iter);
 
        modest_pair_list_free (pairs);
-       info->result = result;
+       *(info->result) = result;
 
  close_dialog:
        /* Close the dialog in a main thread */
-       g_idle_add(on_idle_secure_auth_finished, info);
-}
+       g_idle_add(on_idle_secure_auth_finished, info->dialog);
 
-static void
-on_secure_auth_cancel(GtkWidget* dialog, int response, gpointer user_data)
-{
-       g_return_if_fail (GTK_IS_WIDGET(dialog));
-       
-       if(response == GTK_RESPONSE_REJECT || response == GTK_RESPONSE_DELETE_EVENT) {
-               ModestGetSupportedAuthInfo *info = (ModestGetSupportedAuthInfo*)user_data;
-               g_return_if_fail(info);
-               /* This gives the ownership of the info to the worker thread. */
-               info->result = NULL;
-               info->cancel = TRUE;
-       }
+       /* Free the info */
+       g_slice_free (ModestGetSupportedAuthInfo, info);
 }
+
 typedef struct {
-       GtkProgressBar *progress;
+       GtkWidget *progress;
        gboolean not_finished;
 } KeepPulsing;
 
@@ -320,38 +304,42 @@ static gboolean
 keep_pulsing (gpointer user_data)
 {
        KeepPulsing *info = (KeepPulsing *) user_data;
-       
-       gtk_progress_bar_pulse (info->progress);
 
        if (!info->not_finished) {
-               g_object_unref (info->progress);
                g_slice_free (KeepPulsing, info);
                return FALSE;
        }
-       
+
+       gtk_progress_bar_pulse (GTK_PROGRESS_BAR (info->progress));
        return TRUE;
 }
 
 GList*
-modest_utils_get_supported_secure_authentication_methods (ModestProtocolType protocol_type, 
-       const gchar* hostname, gint port, const gchar* username, GtkWindow *parent_window, GError** error)
+modest_utils_get_supported_secure_authentication_methods (ModestProtocolType protocol_type,
+                                                         const gchar* hostname,
+                                                         gint port,
+                                                         const gchar* username,
+                                                         GtkWindow *parent_window,
+                                                         GError** error)
 {
        TnyAccount * tny_account = NULL;
        ModestProtocolRegistry *protocol_registry;
-       ModestProtocol *protocol;
+       GtkWidget *dialog;
+       gint retval;
+       ModestTnyAccountStore *account_store;
+       TnySessionCamel *session = NULL;
+       ModestProtocol *protocol = NULL;
+       GList *result = NULL;
+       GtkWidget *progress;
 
        g_return_val_if_fail (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID, NULL);
 
        protocol_registry = modest_runtime_get_protocol_registry ();
-       
+
        /* We need a connection to get the capabilities; */
        if (!modest_platform_connect_and_wait (GTK_WINDOW (parent_window), NULL))
                return NULL;
-        
-       /*
-       result = g_list_append (result, GINT_TO_POINTER (MODEST_PROTOCOL_AUTH_CRAMMD5));
-       */
-       
+
        /* Create a TnyCamelAccount so we can use 
         * tny_camel_account_get_supported_secure_authentication(): */
        protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type);
@@ -359,121 +347,86 @@ modest_utils_get_supported_secure_authentication_methods (ModestProtocolType pro
        if (MODEST_IS_ACCOUNT_PROTOCOL (protocol)) {
                tny_account = modest_account_protocol_create_account (MODEST_ACCOUNT_PROTOCOL (protocol));
        }
-       
+
        if (!tny_account) {
                g_printerr ("%s could not create tny account.", __FUNCTION__);
                return NULL;
        }
-       
-       /* Set proto, so that the prepare_func() vfunc will work when we call 
-        * set_session(): */
-        /* TODO: Why isn't this done in account_new()? */
-       tny_account_set_proto (tny_account,
-                              modest_protocol_get_name (modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type)));
 
+       /* Set proto, so that the prepare_func() vfunc will work when
+        * we call set_session(): */
+       protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type);
+       tny_account_set_id (tny_account, "temp_account");
+       tny_account_set_proto (tny_account, modest_protocol_get_name (protocol));
        tny_account_set_hostname (tny_account, hostname);
-       /* Required for POP, at least */
        tny_account_set_user (tny_account, username);
-                              
+
        if(port > 0)
                tny_account_set_port (tny_account, port);
-               
+
        /* Set the session for the account, so we can use it: */
-       ModestTnyAccountStore *account_store = modest_runtime_get_account_store ();
-       TnySessionCamel *session = 
-               modest_tny_account_store_get_session (TNY_ACCOUNT_STORE (account_store));
+       account_store = modest_runtime_get_account_store ();
+       session = modest_tny_account_store_get_session (TNY_ACCOUNT_STORE (account_store));
        g_return_val_if_fail (session, NULL);
        tny_camel_account_set_session (TNY_CAMEL_ACCOUNT(tny_account), session);
-       
-       
+
+       dialog = gtk_dialog_new_with_buttons(" ",
+                                            parent_window,
+                                            GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+                                            _("mcen_bd_dialog_cancel"),
+                                            GTK_RESPONSE_REJECT,
+                                            NULL);
+
        /* Ask camel to ask the server, asynchronously: */
        ModestGetSupportedAuthInfo *info = g_slice_new (ModestGetSupportedAuthInfo);
-       info->result = NULL;
-       info->cancel = FALSE;
-       info->error = NULL;
-       info->progress = gtk_progress_bar_new();
-
-       info->dialog = gtk_dialog_new_with_buttons(" ", 
-                                                  parent_window, GTK_DIALOG_MODAL,
-                                                  _("mcen_bd_dialog_cancel"),
-                                                  GTK_RESPONSE_REJECT,
-                                                  NULL);
-       
-       g_signal_connect(G_OBJECT(info->dialog), "response", G_CALLBACK(on_secure_auth_cancel), info);
-       
+       info->result = &result;
+       info->dialog = dialog;
+
        gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox),
                          gtk_label_new(_("emev_ni_checking_supported_auth_methods")));
-       gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), info->progress);
+       progress = gtk_progress_bar_new();
+       gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), progress);
        gtk_widget_show_all(info->dialog);
 
        KeepPulsing *pi = g_slice_new (KeepPulsing);
-       pi->progress = (GtkProgressBar *) g_object_ref (info->progress);
+       pi->progress = progress;
        pi->not_finished = TRUE;
-       
+
        /* Starts the pulsing of the progressbar */
        g_timeout_add (500, keep_pulsing, pi);
-       
-       tny_camel_account_get_supported_secure_authentication (
-               TNY_CAMEL_ACCOUNT (tny_account),
-               on_camel_account_get_supported_secure_authentication,
-               on_camel_account_get_supported_secure_authentication_status,
-               info);
 
-       gtk_dialog_run (GTK_DIALOG (info->dialog));
-       
+       tny_camel_account_get_supported_secure_authentication (TNY_CAMEL_ACCOUNT (tny_account),
+                                                              on_camel_account_get_supported_secure_authentication,
+                                                              NULL,
+                                                              info);
+
+       retval = gtk_dialog_run (GTK_DIALOG (info->dialog));
+
        pi->not_finished = FALSE;
        /* pi is freed in the timeout itself to avoid a GCond here */
-       
-       gtk_widget_destroy(info->dialog);
-       info->dialog = NULL;
-                       
-       GList *result = info->result;
-       if (!info->cancel) {
-               if (info->error) {
-                       gchar * debug_url_string = tny_account_get_url_string  (tny_account);
-                       g_warning ("%s:\n  error: %s\n  account url: %s", __FUNCTION__, info->error->message, 
-                                  debug_url_string);
-                       g_free (debug_url_string);
-                       
-                       g_propagate_error(error, info->error);
-                       info->error = NULL;
-               }
-       } else {
-               // Tell the caller that the operation was canceled so it can
-               // make a difference
-               g_set_error(error,
-                           modest_utils_get_supported_secure_authentication_error_quark(),
-                           MODEST_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED,
-                           "User has canceled query");
-       }
 
-       /* Free the info */
-       if (info->error)
-               g_free (info->error);
-       if (info->result)
-               g_list_free (info->result);
-       if (info->dialog)
-               gtk_widget_destroy (info->dialog);
-       if (info->progress)
-               gtk_widget_destroy (info->progress);
-       g_slice_free (ModestGetSupportedAuthInfo, info);
+       gtk_widget_destroy(dialog);
+
+       /* Frees */
+       tny_account_cancel (tny_account);
+       g_object_unref (tny_account);
 
        return result;
 }
 
-void 
-modest_utils_show_dialog_and_forget (GtkWindow *parent_window, 
+void
+modest_utils_show_dialog_and_forget (GtkWindow *parent_window,
                                     GtkDialog *dialog)
 {
        g_return_if_fail (GTK_IS_WINDOW(parent_window));
        g_return_if_fail (GTK_IS_DIALOG(dialog));
 
        gtk_window_set_transient_for (GTK_WINDOW (dialog), parent_window);
-       
+
        /* Destroy the dialog when it is closed: */
-       g_signal_connect_swapped (dialog, 
-                                 "response", 
-                                 G_CALLBACK (gtk_widget_destroy), 
+       g_signal_connect_swapped (dialog,
+                                 "response",
+                                 G_CALLBACK (gtk_widget_destroy),
                                  dialog);
 
        gtk_widget_show (GTK_WIDGET (dialog));
@@ -665,8 +618,7 @@ launch_sort_headers_dialog (GtkWindow *parent_window,
        sort_ids[sort_key] = TNY_HEADER_FLAG_PRIORITY_MASK;
        priority_sort_id = sort_key;
        
-       sortable = GTK_TREE_SORTABLE (gtk_tree_model_filter_get_model
-                                     (GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)))));
+       sortable = GTK_TREE_SORTABLE (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
        /* Launch dialogs */
        if (!gtk_tree_sortable_get_sort_column_id (sortable,
                                                   &current_sort_colid, &current_sort_type)) {
@@ -727,7 +679,7 @@ launch_sort_headers_dialog (GtkWindow *parent_window,
 
 void
 modest_utils_run_sort_dialog (GtkWindow *parent_window,
-                                ModestSortDialogType type)
+                             ModestSortDialogType type)
 {
        GtkWidget *dialog = NULL;
 
@@ -768,20 +720,67 @@ modest_images_cache_get_id (const gchar *account, const gchar *uri)
 }
 
 gchar *
-modest_utils_get_account_name_from_recipient (const gchar *from_header)
+modest_utils_get_account_name_from_recipient (const gchar *from_header, gchar **mailbox)
 {
        gchar *account_name = NULL;
        ModestAccountMgr *mgr = NULL;
        GSList *accounts = NULL, *node = NULL;
 
+       if (mailbox)
+               *mailbox = NULL;
        g_return_val_if_fail (from_header, NULL);
 
        mgr = modest_runtime_get_account_mgr ();
        accounts = modest_account_mgr_account_names (mgr, TRUE);
                
        for (node = accounts; node != NULL; node = g_slist_next (node)) {
-               gchar *from = 
-                       modest_account_mgr_get_from_string (mgr, node->data);
+               gchar *from;
+               gchar *transport_account;
+
+               if (!strcmp (from_header, node->data)) {
+                       account_name = g_strdup (node->data);
+                       break;
+               }
+
+               transport_account = modest_account_mgr_get_server_account_name (modest_runtime_get_account_mgr (),
+                                                                               (const gchar *) node->data,
+                                                                               TNY_ACCOUNT_TYPE_TRANSPORT);
+               if (transport_account) {
+                       gchar *proto;
+                       proto = modest_account_mgr_get_string (mgr, transport_account, MODEST_ACCOUNT_PROTO, TRUE);
+
+                       if (proto != NULL) {
+                               ModestProtocol *protocol = 
+                                       modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
+                                                                                      MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
+                                                                                      proto);
+                               if (protocol && MODEST_IS_ACCOUNT_PROTOCOL (protocol)) {
+                                       ModestPairList *pair_list;
+                                       ModestPair *pair;
+                                       gchar *from_header_email =
+                                               modest_text_utils_get_email_address (from_header);
+                                       pair_list = modest_account_protocol_get_from_list (MODEST_ACCOUNT_PROTOCOL (protocol),
+                                                                                          node->data);
+                                       
+                                       pair = modest_pair_list_find_by_first_as_string (pair_list, from_header_email);
+                                       if (pair != NULL) {
+                                               account_name = g_strdup (node->data);
+                                               if (mailbox)
+                                                       *mailbox = g_strdup (from_header_email);
+                                       }
+                                       
+                                       modest_pair_list_free (pair_list);
+                                       
+                               }
+                               g_free (proto);
+                       }
+                       g_free (transport_account);
+               }
+               if (mailbox && *mailbox)
+                       break;
+
+               from = 
+                       modest_account_mgr_get_from_string (mgr, node->data, NULL);
                        
                if (from) {
                        gchar *from_email = 
@@ -801,6 +800,8 @@ modest_utils_get_account_name_from_recipient (const gchar *from_header)
                        g_free (from_header_email);
                        g_free (from);
                }
+
+                       
        }
        g_slist_foreach (accounts, (GFunc) g_free, NULL);
        g_slist_free (accounts);
@@ -826,3 +827,316 @@ modest_utils_on_entry_invalid_character (ModestValidatingEntry *self,
        modest_platform_information_banner (GTK_WIDGET (self), NULL, message);
        g_free (message);
 }
+
+FILE*
+modest_utils_open_mcc_mapping_file (gboolean from_lc_messages, gboolean *translated)
+{
+       FILE* result = NULL;
+       const gchar* path;
+       const gchar *env_list;
+       gchar **parts, **node;
+
+       if (from_lc_messages) {
+               env_list = getenv ("LC_MESSAGES");
+       } else {
+               env_list = getenv ("LANG");
+       }
+       parts = g_strsplit (env_list, ":", 0);
+       gchar *path1 = NULL;
+       const gchar* path2 = MODEST_MCC_MAPPING;
+
+       if (translated)
+               *translated = TRUE;
+
+       path = NULL;
+       for (node = parts; path == NULL && node != NULL && *node != NULL && **node != '\0'; node++) {
+               path1 = g_strdup_printf ("%s.%s", MODEST_OPERATOR_WIZARD_MCC_MAPPING, *node);
+               if (access (path1, R_OK) == 0) {
+                       path = path1;
+                       break;
+               } else {
+                       g_free (path1);
+                       path1 = NULL;
+               }
+       }
+       g_strfreev (parts);
+
+       if (path == NULL) {
+               if (access (MODEST_OPERATOR_WIZARD_MCC_MAPPING, R_OK) == 0) {
+                       path = MODEST_OPERATOR_WIZARD_MCC_MAPPING;
+                       if (translated)
+                               *translated = FALSE;
+               } else if (access (path2, R_OK) == 0) {
+                       path = path2;
+               } else {
+                       g_warning ("%s: neither '%s' nor '%s' is a readable mapping file",
+                                  __FUNCTION__, path1, path2);
+                       goto end;
+               }
+       }
+
+       result = fopen (path, "r");
+       if (!result) {
+               g_warning ("%s: error opening mapping file '%s': %s",
+                          __FUNCTION__, path, strerror(errno));
+               goto end;
+       }
+ end:
+       g_free (path1);
+       return result;
+}
+
+/* cluster mcc's, based on the list
+ * http://en.wikipedia.org/wiki/Mobile_country_code
+ */
+static int
+effective_mcc (gint mcc)
+{
+       switch (mcc) {
+       case 405: return 404; /* india */
+       case 441: return 440; /* japan */       
+       case 235: return 234; /* united kingdom */
+       case 311:
+       case 312:
+       case 313:
+       case 314:
+       case 315:
+       case 316: return 310; /* united states */
+       default:  return mcc;
+       }
+}
+
+/* each line is of the form:
+   xxx    logical_id
+
+  NOTE: this function is NOT re-entrant, the out-param country
+  are static strings that should NOT be freed. and will change when
+  calling this function again
+
+  also note, this function will return the "effective mcc", which
+  is the normalized mcc for a country - ie. even if the there
+  are multiple entries for the United States with various mccs,
+  this function will always return 310, even if the real mcc parsed
+  would be 314. see the 'effective_mcc' function above.
+*/
+static int
+parse_mcc_mapping_line (const char* line,  char** country)
+{
+       char mcc[4];  /* the mcc code, always 3 bytes*/
+       gchar *iter, *tab, *final;
+
+       if (!line) {
+               *country = NULL;
+               return 0;
+       }
+
+       /* Go to the first tab (Country separator) */
+       tab = g_utf8_strrchr (line, -1, '\t');
+       if (!tab)
+               return 0;
+
+       *country = g_utf8_find_next_char (tab, NULL);
+
+       /* Replace by end of string. We need to use strlen, because
+          g_utf8_strrchr expects bytes and not UTF8 characters  */
+       final = g_utf8_strrchr (tab, strlen (tab) + 1, '\n');
+       if (G_LIKELY (final))
+               *final = '\0';
+       else
+               tab[strlen(tab) - 1] = '\0';
+
+       /* Get MCC code */
+       mcc[0] = g_utf8_get_char (line);
+       iter = g_utf8_find_next_char (line, NULL);
+       mcc[1] = g_utf8_get_char (iter);
+       iter = g_utf8_find_next_char (iter, NULL);
+       mcc[2] = g_utf8_get_char (iter);
+       mcc[3] = '\0';
+
+       return effective_mcc ((int) strtol ((const char*)mcc, NULL, 10));
+}
+
+#define MCC_FILE_MAX_LINE_LEN 128 /* max length of a line in MCC file */
+
+/** Note that the mcc_mapping file is installed 
+ * by the operator-wizard-settings package.
+ */
+GtkTreeModel *
+modest_utils_create_country_model (void)
+{
+       GtkTreeModel *model;
+
+       model = GTK_TREE_MODEL (gtk_list_store_new (2,  G_TYPE_STRING, G_TYPE_INT));
+
+       return model;
+}
+
+void
+modest_utils_fill_country_model (GtkTreeModel *model, gint *locale_mcc)
+{
+       gboolean translated;
+       char line[MCC_FILE_MAX_LINE_LEN];
+       guint previous_mcc = 0;
+       gchar *territory;
+       GHashTable *country_hash;
+       FILE *file;
+
+       /* First we need to know our current region */
+       file = modest_utils_open_mcc_mapping_file (FALSE, &translated);
+       if (!file) {
+               g_warning ("Could not open mcc_mapping file");
+               return;
+       }
+
+       /* Get the territory specified for the current locale */
+       territory = nl_langinfo (_NL_ADDRESS_COUNTRY_NAME);
+
+       while (fgets (line, MCC_FILE_MAX_LINE_LEN, file) != NULL) {
+               int mcc;
+               char *country = NULL;
+
+               mcc = parse_mcc_mapping_line (line, &country);
+               if (!country || mcc == 0) {
+                       g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
+                       continue;
+               }
+
+               if (mcc == previous_mcc) {
+                       /* g_warning ("already seen: %s", line); */
+                       continue;
+               }
+               previous_mcc = mcc;
+
+               if (!(*locale_mcc)) {
+                       if (translated) {
+                               if (!g_utf8_collate (country, territory))
+                                       *locale_mcc = mcc;
+                       } else {
+                               gchar *translation = dgettext ("osso-countries", country);
+                               if (!g_utf8_collate (translation, territory))
+                                       *locale_mcc = mcc;
+                       }
+               }
+       }
+       fclose (file);
+
+       /* Now we fill the model */
+       file = modest_utils_open_mcc_mapping_file (TRUE, &translated);
+       if (!file) {
+               g_warning ("Could not open mcc_mapping file");
+               return;
+       }
+
+       country_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+       while (fgets (line, MCC_FILE_MAX_LINE_LEN, file) != NULL) {
+
+               int mcc;
+               char *country = NULL;
+               GtkTreeIter iter;
+               const gchar *name_translated;
+
+               mcc = parse_mcc_mapping_line (line, &country);
+               if (!country || mcc == 0) {
+                       g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
+                       continue;
+               }
+
+               if (mcc == previous_mcc ||
+                   g_hash_table_lookup (country_hash, country)) {
+                       g_debug ("already seen: '%s' %d", country, mcc);
+                       continue;
+               }
+               previous_mcc = mcc;
+
+               g_hash_table_insert (country_hash, g_strdup (country), GINT_TO_POINTER (mcc));
+
+               name_translated = dgettext ("osso-countries", country);
+
+               /* Add the row to the model: */
+               gtk_list_store_append (GTK_LIST_STORE (model), &iter);
+               gtk_list_store_set(GTK_LIST_STORE (model), &iter, 
+                                  MODEST_UTILS_COUNTRY_MODEL_COLUMN_MCC, mcc, 
+                                  MODEST_UTILS_COUNTRY_MODEL_COLUMN_NAME, name_translated, 
+                                  -1);
+       }
+
+
+       g_hash_table_unref (country_hash);
+       fclose (file);
+
+       /* Fallback to Finland */
+       if (!(*locale_mcc))
+               *locale_mcc = 244;
+
+       /* Sort the items: */
+       gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), 
+                                             MODEST_UTILS_COUNTRY_MODEL_COLUMN_NAME, GTK_SORT_ASCENDING);
+}
+
+GList *
+modest_utils_create_notification_list_from_header_list (TnyList *header_list)
+{
+       GList *new_headers_list;
+       TnyIterator *iter;
+
+       g_return_val_if_fail (TNY_IS_LIST (header_list), NULL);
+       g_return_val_if_fail (tny_list_get_length (header_list) > 0, NULL);
+
+       new_headers_list = NULL;
+       iter = tny_list_create_iterator (header_list);
+       while (!tny_iterator_is_done (iter)) {
+               ModestMsgNotificationData *data;
+               TnyHeader *header;
+               TnyFolder *folder;
+
+               header = (TnyHeader *) tny_iterator_get_current (iter);
+               if (header) {
+                       folder = tny_header_get_folder (header);
+
+                       if (folder) {
+                               gchar *uri, *uid;
+
+                               uid = tny_header_dup_uid (header);
+                               uri = g_strdup_printf ("%s/%s",
+                                                      tny_folder_get_url_string (folder),
+                                                      uid);
+                               g_free (uid);
+
+                               /* Create data & add to list */
+                               data = g_slice_new0 (ModestMsgNotificationData);
+                               data->subject = tny_header_dup_subject (header);
+                               data->from = tny_header_dup_from (header);
+                               data->uri = uri;
+
+                               new_headers_list = g_list_append (new_headers_list, data);
+
+                               g_object_unref (folder);
+                       }
+                       g_object_unref (header);
+               }
+               tny_iterator_next (iter);
+       }
+       g_object_unref (iter);
+
+       return new_headers_list;
+}
+
+static void
+free_notification_data (gpointer data,
+                       gpointer user_data)
+{
+       ModestMsgNotificationData *notification_data  = (ModestMsgNotificationData *) data;
+
+       g_free (notification_data->from);
+       g_free (notification_data->subject);
+       g_free (notification_data->uri);
+}
+
+void
+modest_utils_free_notification_list (GList *notification_list)
+{
+       g_return_if_fail (g_list_length (notification_list) > 0);
+
+       g_list_foreach (notification_list, free_notification_data, NULL);
+       g_list_free (notification_list);
+}