static CamelService *
ref_service_for_source (CamelSession *session,
const gchar *src)
{
CamelService *service = NULL;
/* Source strings are now CamelService UIDs. */
if (src != NULL)
service = camel_session_ref_service (session, src);
/* For backward-compability, also handle CamelService URLs. */
if (service == NULL && src != NULL) {
CamelURL *url;
url = camel_url_new (src, NULL);
if (service == NULL && url != NULL)
service = camel_session_ref_service_by_url (
session, url, CAMEL_PROVIDER_STORE);
if (service == NULL && url != NULL)
service = camel_session_ref_service_by_url (
session, url, CAMEL_PROVIDER_TRANSPORT);
if (url != NULL)
camel_url_free (url);
}
return service;
}
GCancellable *
mail_receive_account (EMailSession *session,
ESource *account)
{
CamelService *service;
service = camel_session_ref_service (
CAMEL_SESSION (session), e_source_get_uid(account));
return mail_receive_service (service);
}
static void
set_transport_service (struct _send_info *info,
const gchar *transport_uid)
{
CamelService *service;
g_static_mutex_lock (&status_lock);
service = camel_session_ref_service ((CamelSession *)info->session, transport_uid);
if (CAMEL_IS_TRANSPORT (service)) {
if (info->service != NULL)
g_object_unref (info->service);
info->service = g_object_ref (service);
}
if (service != NULL)
g_object_unref (service);
g_static_mutex_unlock (&status_lock);
}
static CamelService *
ref_default_transport (EMailSession *session)
{
ESource *source;
CamelService *service;
const gchar *extension_name;
const gchar *uid;
source = e_source_registry_ref_default_mail_identity (source_registry);
if (source == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;
if (e_source_has_extension (source, extension_name)) {
ESourceMailSubmission *extension;
gchar *uid;
extension = e_source_get_extension (source, extension_name);
uid = e_source_mail_submission_dup_transport_uid (extension);
g_object_unref (source);
source = e_source_registry_ref_source (source_registry, uid);
g_free (uid);
} else {
g_object_unref (source);
source = NULL;
}
if (source == NULL)
return NULL;
uid = e_source_get_uid (source);
service = camel_session_ref_service (CAMEL_SESSION (session), uid);
g_object_unref (source);
return service;
}
static gboolean
auto_timeout (gpointer data)
{
EMailSession *session;
struct _auto_data *info = data;
CamelService *service;
const char *uid;
session = info->session;
uid = e_source_get_uid (info->account);
service = camel_session_ref_service (
CAMEL_SESSION (session), uid);
printf("Timeout for %s: %p\n", uid, service);
g_return_val_if_fail (CAMEL_IS_SERVICE (service), TRUE);
if (camel_session_get_online (CAMEL_SESSION (session)))
mail_receive_service (service);
return TRUE;
}
/**
* e_mail_session_ref_transport:
* @session: an #EMailSession
* @transport_uid: the UID of a mail transport
*
* Returns the transport #CamelService instance for @transport_uid,
* verifying first that the @transport_uid is indeed a mail transport and
* that the corresponding #ESource is enabled. If these checks fail, the
* function returns %NULL.
*
* The returned #CamelService is referenced for thread-safety and must be
* unreferenced with g_object_unref() when finished with it.
*
* Returns: a #CamelService, or %NULL
**/
CamelService *
e_mail_session_ref_transport (EMailSession *session,
const gchar *transport_uid)
{
ESourceRegistry *registry;
ESource *source = NULL;
CamelService *transport = NULL;
const gchar *extension_name;
g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
g_return_val_if_fail (transport_uid != NULL, NULL);
registry = e_mail_session_get_registry (session);
extension_name = E_SOURCE_EXTENSION_MAIL_TRANSPORT;
source = e_source_registry_ref_source (registry, transport_uid);
if (source == NULL)
goto exit;
if (!e_source_registry_check_enabled (registry, source))
goto exit;
if (!e_source_has_extension (source, extension_name))
goto exit;
transport = camel_session_ref_service (
CAMEL_SESSION (session), transport_uid);
/* Sanity check. */
if (transport != NULL)
g_warn_if_fail (CAMEL_IS_TRANSPORT (transport));
exit:
g_clear_object (&source);
return transport;
}
gboolean
mail_send_short_message (EGdbusSession *object,
GDBusMethodInvocation *invocation, const char *account_uid,
const char *text, const char **to,
EMailDataSession *msession, GError **ret_error)
{
EAccount *account;
CamelMimeMessage *message;
CamelService *service;
gchar *transport_uid;
CamelInternetAddress *recipients;
CamelMessageInfo *info;
GSimpleAsyncResult *simple;
SendAsyncContext *context;
CamelInternetAddress *from;
GCancellable *ops;
EMailDataOperation *mops;
char *mops_path;
gchar subject[MAX_SUBJECT_LENGTH + 4];
GError *error = NULL;
/* Check params. */
if (account_uid == NULL || *account_uid == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account"));
goto on_error;
}
if (text == NULL || *text == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Text is empty"));
goto on_error;
}
if (to == NULL || *to == 0 || **to == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("No recipient"));
goto on_error;
}
/* Get transport. */
account = e_get_account_by_uid (account_uid);
if (!account) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account %s"),
account_uid);
goto on_error;
}
transport_uid = g_strconcat (account->uid, "-transport", NULL);
service = camel_session_ref_service (CAMEL_SESSION (session),
transport_uid);
if (!CAMEL_IS_TRANSPORT (service)) {
error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account %s"), account_uid);
g_object_unref (account);
g_free (transport_uid);
goto on_error;
}
/* Prepare message. */
message = camel_mime_message_new ();
strncpy (subject, text, MAX_SUBJECT_LENGTH + 1);
if (strlen(text) > MAX_SUBJECT_LENGTH)
strcpy (subject + MAX_SUBJECT_LENGTH, "...");
camel_mime_message_set_subject (message, subject);
from = camel_internet_address_new ();
camel_internet_address_add (from, NULL, "sms");
recipients = camel_internet_address_new ();
while (*to) {
camel_internet_address_add (recipients, NULL, *to);
to++;
}
camel_mime_message_set_from (message, from);
camel_mime_message_set_recipients (message, CAMEL_RECIPIENT_TYPE_TO,
recipients);
camel_mime_message_set_date (message, CAMEL_MESSAGE_DATE_CURRENT, 0);
camel_mime_part_set_content_type (CAMEL_MIME_PART(message),
"text/plain");
camel_mime_part_set_content (CAMEL_MIME_PART(message), text,
strlen(text), "text/plain");
info = camel_message_info_new (NULL);
camel_message_info_set_flags (info, CAMEL_MESSAGE_SEEN, ~0);
/* Return the new operation */
ops = camel_operation_new ();
mops = e_mail_data_operation_new ((CamelOperation *) ops);
mops_path = e_mail_data_operation_register_gdbus_object (mops,
g_dbus_method_invocation_get_connection(invocation),
NULL);
egdbus_session_complete_send_short_message (object, invocation,
mops_path);
/* The rest of the processing happens in a thread. */
context = g_slice_new0 (SendAsyncContext);
context->message = message;
context->io_priority = G_PRIORITY_DEFAULT;
context->from = CAMEL_ADDRESS (from);
context->recipients = CAMEL_ADDRESS (recipients);
context->info = info;
context->transport = service;
context->sent_folder_uri = g_strdup (account->sent_folder_uri);
context->cancellable = ops;
context->ops_path = mops_path;
context->result = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
/* Failure here emits a runtime warning but is non-fatal. */
context->driver = camel_session_get_filter_driver (
CAMEL_SESSION (session), "outgoing", &error);
if (error != NULL) {
g_warn_if_fail (context->driver == NULL);
g_warning ("%s", error->message);
g_error_free (error);
}
/* This gets popped in async_context_free(). */
camel_operation_push_message (context->cancellable,
_("Sending message"));
simple = g_simple_async_result_new (
G_OBJECT (session), mail_send_short_message_completed,
context, mail_send_short_message);
g_simple_async_result_set_op_res_gpointer (
simple, context, (GDestroyNotify) async_context_free);
g_simple_async_result_run_in_thread (
simple,
(GSimpleAsyncThreadFunc) mail_send_short_to_thread,
context->io_priority, context->cancellable);
g_object_unref (simple);
return TRUE;
on_error:
*ret_error = error;
return FALSE;
}
static void
mail_shell_view_execute_search (EShellView *shell_view)
{
EMailShellViewPrivate *priv;
EMailShellContent *mail_shell_content;
EMailShellSidebar *mail_shell_sidebar;
EShellWindow *shell_window;
EShellBackend *shell_backend;
EShellContent *shell_content;
EShellSidebar *shell_sidebar;
EShellSearchbar *searchbar;
EActionComboBox *combo_box;
EMailBackend *backend;
EMailSession *session;
ESourceRegistry *registry;
EMFolderTree *folder_tree;
GtkWidget *message_list;
EFilterRule *rule;
EMailReader *reader;
EMailView *mail_view;
CamelVeeFolder *search_folder;
CamelFolder *folder;
CamelService *service;
CamelStore *store;
GtkAction *action;
EMailLabelListStore *label_store;
GtkTreePath *path;
GtkTreeIter tree_iter;
GString *string;
GList *list, *iter;
GSList *search_strings = NULL;
const gchar *text;
gboolean valid;
gchar *query;
gchar *temp;
gchar *tag;
const gchar *use_tag;
gint value;
priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell_backend = e_shell_view_get_shell_backend (shell_view);
shell_content = e_shell_view_get_shell_content (shell_view);
shell_sidebar = e_shell_view_get_shell_sidebar (shell_view);
backend = E_MAIL_BACKEND (shell_backend);
session = e_mail_backend_get_session (backend);
mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content);
mail_view = e_mail_shell_content_get_mail_view (mail_shell_content);
searchbar = e_mail_shell_content_get_searchbar (mail_shell_content);
mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar);
folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar);
reader = E_MAIL_READER (mail_view);
folder = e_mail_reader_ref_folder (reader);
message_list = e_mail_reader_get_message_list (reader);
registry = e_mail_session_get_registry (session);
label_store = e_mail_ui_session_get_label_store (
E_MAIL_UI_SESSION (session));
action = ACTION (MAIL_SEARCH_SUBJECT_OR_ADDRESSES_CONTAIN);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
text = e_shell_searchbar_get_search_text (searchbar);
if (value == MAIL_SEARCH_ADVANCED || text == NULL || *text == '\0') {
if (value != MAIL_SEARCH_ADVANCED)
e_shell_view_set_search_rule (shell_view, NULL);
query = e_shell_view_get_search_query (shell_view);
if (!query)
query = g_strdup ("");
goto filter;
}
/* Replace variables in the selected rule with the
* current search text and extract a query string. */
g_return_if_fail (value >= 0 && value < MAIL_NUM_SEARCH_RULES);
rule = priv->search_rules[value];
/* Set the search rule in EShellView so that "Create
* Search Folder from Search" works for quick searches. */
e_shell_view_set_search_rule (shell_view, rule);
for (iter = rule->parts; iter != NULL; iter = iter->next) {
EFilterPart *part = iter->data;
EFilterElement *element = NULL;
if (strcmp (part->name, "subject") == 0)
element = e_filter_part_find_element (part, "subject");
else if (strcmp (part->name, "body") == 0)
element = e_filter_part_find_element (part, "word");
else if (strcmp (part->name, "sender") == 0)
element = e_filter_part_find_element (part, "sender");
else if (strcmp (part->name, "to") == 0)
element = e_filter_part_find_element (part, "recipient");
if (strcmp (part->name, "body") == 0) {
struct _camel_search_words *words;
gint ii;
words = camel_search_words_split ((guchar *) text);
for (ii = 0; ii < words->len; ii++)
search_strings = g_slist_prepend (
search_strings, g_strdup (
words->words[ii]->word));
camel_search_words_free (words);
}
if (element != NULL) {
EFilterInput *input = E_FILTER_INPUT (element);
e_filter_input_set_value (input, text);
}
}
string = g_string_sized_new (1024);
e_filter_rule_build_code (rule, string);
query = g_string_free (string, FALSE);
filter:
/* Apply selected filter. */
combo_box = e_shell_searchbar_get_filter_combo_box (searchbar);
value = e_action_combo_box_get_current_value (combo_box);
switch (value) {
case MAIL_FILTER_ALL_MESSAGES:
break;
case MAIL_FILTER_UNREAD_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all (not "
"(system-flag \"Seen\"))))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_NO_LABEL:
string = g_string_sized_new (1024);
g_string_append_printf (
string, "(and %s (and ", query);
valid = gtk_tree_model_get_iter_first (
GTK_TREE_MODEL (label_store), &tree_iter);
while (valid) {
tag = e_mail_label_list_store_get_tag (
label_store, &tree_iter);
use_tag = tag;
if (g_str_has_prefix (use_tag, "$Label"))
use_tag += 6;
g_string_append_printf (
string, " (match-all (not (or "
"(= (user-tag \"label\") \"%s\") "
"(user-flag \"$Label%s\") "
"(user-flag \"%s\"))))",
use_tag, use_tag, use_tag);
g_free (tag);
valid = gtk_tree_model_iter_next (
GTK_TREE_MODEL (label_store),
&tree_iter);
}
g_string_append_len (string, "))", 2);
g_free (query);
query = g_string_free (string, FALSE);
break;
case MAIL_FILTER_READ_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Seen\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_LAST_5_DAYS_MESSAGES:
if (em_utils_folder_is_sent (registry, folder))
temp = g_strdup_printf (
"(and %s (match-all "
"(> (get-sent-date) "
"(- (get-current-date) 432000))))",
query);
else
temp = g_strdup_printf (
"(and %s (match-all "
"(> (get-received-date) "
"(- (get-current-date) 432000))))",
query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_MESSAGES_WITH_ATTACHMENTS:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Attachments\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_IMPORTANT_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Flagged\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_MESSAGES_NOT_JUNK:
temp = g_strdup_printf (
"(and %s (match-all (not "
"(system-flag \"junk\"))))", query);
g_free (query);
query = temp;
break;
default:
/* The action value also serves as a path for
* the label list store. That's why we number
* the label actions from zero. */
path = gtk_tree_path_new_from_indices (value, -1);
gtk_tree_model_get_iter (
GTK_TREE_MODEL (label_store),
&tree_iter, path);
gtk_tree_path_free (path);
tag = e_mail_label_list_store_get_tag (
label_store, &tree_iter);
use_tag = tag;
if (g_str_has_prefix (use_tag, "$Label"))
use_tag += 6;
temp = g_strdup_printf (
"(and %s (match-all (or "
"(= (user-tag \"label\") \"%s\") "
"(user-flag \"$Label%s\") "
"(user-flag \"%s\"))))",
query, use_tag, use_tag, use_tag);
g_free (tag);
g_free (query);
query = temp;
break;
}
/* Apply selected scope. */
combo_box = e_shell_searchbar_get_scope_combo_box (searchbar);
value = e_action_combo_box_get_current_value (combo_box);
switch (value) {
case MAIL_SCOPE_CURRENT_FOLDER:
goto execute;
case MAIL_SCOPE_CURRENT_ACCOUNT:
goto current_account;
case MAIL_SCOPE_ALL_ACCOUNTS:
goto all_accounts;
default:
g_warn_if_reached ();
goto execute;
}
all_accounts:
/* Prepare search folder for all accounts. */
/* If the search text is empty, cancel any
* account-wide searches still in progress. */
text = e_shell_searchbar_get_search_text (searchbar);
if (text == NULL || *text == '\0') {
CamelStore *selected_store = NULL;
gchar *selected_folder_name = NULL;
if (priv->search_account_all != NULL) {
g_object_unref (priv->search_account_all);
priv->search_account_all = NULL;
}
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
/* Reset the message list to the current folder tree
* selection. This needs to happen synchronously to
* avoid search conflicts, so we can't just grab the
* folder URI and let the asynchronous callbacks run
* after we've already kicked off the search. */
em_folder_tree_get_selected (
folder_tree, &selected_store, &selected_folder_name);
if (selected_store != NULL && selected_folder_name != NULL) {
folder = camel_store_get_folder_sync (
selected_store, selected_folder_name,
CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL);
e_mail_reader_set_folder (reader, folder);
g_object_unref (folder);
}
g_clear_object (&selected_store);
g_free (selected_folder_name);
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE);
goto execute;
}
search_folder = priv->search_account_all;
/* Skip the search if we already have the results. */
if (search_folder != NULL) {
const gchar *vf_query;
vf_query = camel_vee_folder_get_expression (search_folder);
if (g_strcmp0 (query, vf_query) == 0)
goto all_accounts_setup;
}
/* Disable the scope combo while search is in progress. */
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE);
/* If we already have a search folder, reuse it. */
if (search_folder != NULL) {
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
camel_vee_folder_set_expression (search_folder, query);
goto all_accounts_setup;
}
/* Create a new search folder. */
/* FIXME Complete lack of error checking here. */
service = camel_session_ref_service (
CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID);
camel_service_connect_sync (service, NULL, NULL);
search_folder = (CamelVeeFolder *) camel_vee_folder_new (
CAMEL_STORE (service),
_("All Account Search"),
CAMEL_STORE_FOLDER_PRIVATE);
priv->search_account_all = search_folder;
g_object_unref (service);
camel_vee_folder_set_expression (search_folder, query);
all_accounts_setup:
list = em_folder_tree_model_list_stores (EM_FOLDER_TREE_MODEL (
gtk_tree_view_get_model (GTK_TREE_VIEW (folder_tree))));
g_list_foreach (list, (GFunc) g_object_ref, NULL);
priv->search_account_cancel = camel_operation_new ();
/* This takes ownership of the stores list. */
mail_shell_view_setup_search_results_folder (
CAMEL_FOLDER (search_folder), list,
priv->search_account_cancel);
mail_shell_view_show_search_results_folder (
E_MAIL_SHELL_VIEW (shell_view),
CAMEL_FOLDER (search_folder));
goto execute;
current_account:
/* Prepare search folder for current account only. */
/* If the search text is empty, cancel any
* account-wide searches still in progress. */
text = e_shell_searchbar_get_search_text (searchbar);
if (text == NULL || *text == '\0') {
CamelStore *selected_store = NULL;
gchar *selected_folder_name = NULL;
if (priv->search_account_current != NULL) {
g_object_unref (priv->search_account_current);
priv->search_account_current = NULL;
}
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
/* Reset the message list to the current folder tree
* selection. This needs to happen synchronously to
* avoid search conflicts, so we can't just grab the
* folder URI and let the asynchronous callbacks run
* after we've already kicked off the search. */
em_folder_tree_get_selected (
folder_tree, &selected_store, &selected_folder_name);
if (selected_store != NULL && selected_folder_name != NULL) {
folder = camel_store_get_folder_sync (
selected_store, selected_folder_name,
CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL);
e_mail_reader_set_folder (reader, folder);
g_object_unref (folder);
}
g_clear_object (&selected_store);
g_free (selected_folder_name);
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE);
goto execute;
}
search_folder = priv->search_account_current;
/* Skip the search if we already have the results. */
if (search_folder != NULL) {
const gchar *vf_query;
vf_query = camel_vee_folder_get_expression (search_folder);
if (g_strcmp0 (query, vf_query) == 0)
goto current_accout_setup;
}
/* Disable the scope combo while search is in progress. */
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE);
/* If we already have a search folder, reuse it. */
if (search_folder != NULL) {
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
camel_vee_folder_set_expression (search_folder, query);
goto current_accout_setup;
}
/* Create a new search folder. */
/* FIXME Complete lack of error checking here. */
service = camel_session_ref_service (
CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID);
camel_service_connect_sync (service, NULL, NULL);
search_folder = (CamelVeeFolder *) camel_vee_folder_new (
CAMEL_STORE (service),
_("Account Search"),
CAMEL_STORE_FOLDER_PRIVATE);
priv->search_account_current = search_folder;
g_object_unref (service);
camel_vee_folder_set_expression (search_folder, query);
current_accout_setup:
if (folder != NULL && folder != CAMEL_FOLDER (search_folder)) {
store = camel_folder_get_parent_store (folder);
if (store != NULL)
g_object_ref (store);
} else {
store = NULL;
em_folder_tree_get_selected (folder_tree, &store, NULL);
}
list = NULL; /* list of CamelStore-s */
if (store != NULL)
list = g_list_append (NULL, store);
priv->search_account_cancel = camel_operation_new ();
/* This takes ownership of the stores list. */
mail_shell_view_setup_search_results_folder (
CAMEL_FOLDER (search_folder), list,
priv->search_account_cancel);
mail_shell_view_show_search_results_folder (
E_MAIL_SHELL_VIEW (shell_view),
CAMEL_FOLDER (search_folder));
execute:
/* Finally, execute the search. */
message_list_set_search (MESSAGE_LIST (message_list), query);
e_mail_view_set_search_strings (mail_view, search_strings);
g_slist_foreach (search_strings, (GFunc) g_free, NULL);
g_slist_free (search_strings);
g_free (query);
g_clear_object (&folder);
}
static struct _send_data *
build_infra (EMailSession *session, gboolean allow_send)
{
struct _send_data *data;
struct _send_info *info;
CamelService *transport = NULL;
GList *link;
GList *list = NULL;
GList *accounts=NULL;
transport = ref_default_transport (session);
accounts = mail_get_all_accounts();
data = setup_send_data (session);
link = accounts;
while (link) {
ESource *source;
CamelService *service;
const gchar *uid;
source = (ESource *)link->data;
if (!e_source_get_enabled(source)) {
link = link->next;
continue;
}
uid = e_source_get_uid (source);
service = camel_session_ref_service (
CAMEL_SESSION (session), uid);
/* see if we have an outstanding download active */
info = g_hash_table_lookup (data->active, uid);
if (info == NULL) {
send_info_t type = SEND_INVALID;
type = get_receive_type (service);
if (type == SEND_INVALID || type == SEND_SEND) {
link = link->next;
continue;
}
info = g_malloc0 (sizeof (*info));
info->type = type;
info->session = g_object_ref (session);
d(printf("adding source %s\n", source->url));
info->service = g_object_ref (service);
info->keep_on_server = mail_get_keep_on_server (service);
info->cancellable = camel_operation_new ();
info->state = allow_send ? SEND_ACTIVE : SEND_COMPLETE;
info->timeout_id = g_timeout_add (
STATUS_TIMEOUT, operation_status_timeout, info);
g_signal_connect (
info->cancellable, "status",
G_CALLBACK (operation_status), info);
g_hash_table_insert (
data->active, g_strdup(uid), info);
list = g_list_prepend (list, info);
} else if (info->timeout_id == 0)
info->timeout_id = g_timeout_add (
STATUS_TIMEOUT, operation_status_timeout, info);
info->data = data;
link = link->next;
}
g_list_free_full (accounts, (GDestroyNotify) g_object_unref);
/* Skip displaying the SMTP row if we've got no outbox,
* outgoing account or unsent mails. */
CamelFolder *local_outbox;
local_outbox =
e_mail_session_get_local_folder (
session, E_MAIL_LOCAL_FOLDER_OUTBOX);
if (allow_send && local_outbox && CAMEL_IS_TRANSPORT (transport)
&& (camel_folder_get_message_count (local_outbox) -
camel_folder_get_deleted_message_count (local_outbox)) != 0) {
info = g_hash_table_lookup (data->active, SEND_URI_KEY);
if (info == NULL) {
info = g_malloc0 (sizeof (*info));
info->type = SEND_SEND;
info->service = g_object_ref (transport);
info->keep_on_server = FALSE;
info->cancellable = camel_operation_new ();
info->state = SEND_ACTIVE;
info->timeout_id = g_timeout_add (
STATUS_TIMEOUT, operation_status_timeout, info);
g_signal_connect (
info->cancellable, "status",
G_CALLBACK (operation_status), info);
g_hash_table_insert (data->active, g_strdup(SEND_URI_KEY), info);
list = g_list_prepend (list, info);
} else if (info->timeout_id == 0)
info->timeout_id = g_timeout_add (
STATUS_TIMEOUT, operation_status_timeout, info);
info->data = data;
}
data->infos = list;
return data;
}
GCancellable *
mail_send (EMailSession *session)
{
CamelFolder *local_outbox;
CamelService *service;
struct _send_info *info;
struct _send_data *data;
send_info_t type = SEND_INVALID;
const gchar *transport_uid;
ESource *account;
const gchar *extension_name;
account = e_source_registry_ref_default_mail_identity (source_registry);
if (account == NULL)
return NULL;
extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;
if (e_source_has_extension (account, extension_name)) {
ESourceMailSubmission *extension;
gchar *uid;
extension = e_source_get_extension (account, extension_name);
uid = e_source_mail_submission_dup_transport_uid (extension);
g_object_unref (account);
account = e_source_registry_ref_source (source_registry, uid);
g_free (uid);
} else {
g_object_unref (account);
account = NULL;
}
if (account == NULL)
return NULL;
transport_uid = e_source_get_uid (account);
data = setup_send_data (session);
info = g_hash_table_lookup (data->active, SEND_URI_KEY);
if (info != NULL) {
info->again++;
d(printf("send of %s still in progress\n", transport_uid));
return info->cancellable;
}
service = camel_session_ref_service (
CAMEL_SESSION (session), transport_uid);
if (!CAMEL_IS_TRANSPORT (service)) {
return NULL;
}
d(printf("starting non-interactive send of '%s'\n", account->transport->url));
type = get_receive_type (service);
if (type == SEND_INVALID) {
return NULL;
}
info = g_malloc0 (sizeof (*info));
info->type = SEND_SEND;
info->session = g_object_ref (session);
info->service = g_object_ref (service);
info->keep_on_server = FALSE;
info->cancellable = camel_operation_new();
info->data = data;
info->state = SEND_ACTIVE;
info->timeout_id = 0;
d(printf("Adding new info %p\n", info));
g_hash_table_insert (data->active, g_strdup(SEND_URI_KEY), info);
/* todo, store the folder in info? */
local_outbox =
e_mail_session_get_local_folder (
session, E_MAIL_LOCAL_FOLDER_OUTBOX);
mail_send_queue (
session, local_outbox,
CAMEL_TRANSPORT (service),
E_FILTER_SOURCE_OUTGOING,
info->cancellable,
receive_get_folder, info,
receive_status, info,
send_done, info);
return info->cancellable;
}
