static CamelNNTPGroupList*
camel_nntp_get_grouplist_from_file (CamelNNTPStore *store, CamelException *ex)
{
gchar *root_dir = camel_nntp_store_get_toplevel_dir(CAMEL_NNTP_STORE(store));
gchar *grouplist_file = g_strdup_printf ("%s/grouplist", root_dir);
CamelNNTPGroupList *list;
FILE *fp;
char buf[300];
unsigned long time;
g_free (root_dir);
fp = g_fopen (grouplist_file, "r");
g_free (grouplist_file);
if (fp == NULL) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unable to load grouplist file for %s: %s"),
CAMEL_SERVICE(store)->url->host,
strerror(errno));
return NULL;
}
/* read the time */
if (!fgets (buf, sizeof (buf), fp)) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unable to load grouplist file for %s: %s"),
CAMEL_SERVICE(store)->url->host,
strerror(errno));
fclose (fp);
return NULL;
}
list = g_new0 (CamelNNTPGroupList, 1);
list->store = store;
sscanf (buf, "%lu", &time);
list->time = time;
while (fgets (buf, sizeof (buf), fp)) {
CamelNNTPGroupListEntry *entry = g_new (CamelNNTPGroupListEntry, 1);
char **split_line = g_strsplit (buf, " ", 4);
entry->group_name = g_strdup (split_line[0]);
entry->high = atoi (split_line[1]);
entry->low = atoi (split_line[2]);
g_strfreev (split_line);
list->group_list = g_list_prepend (list->group_list, entry);
}
fclose (fp);
list->group_list = g_list_reverse(list->group_list);
return list;
}
/**
* camel_offline_store_set_network_state:
* @store: a #CamelOfflineStore object
* @state: the network state
* @ex: a #CamelException
*
* Set the network state to either #CAMEL_OFFLINE_STORE_NETWORK_AVAIL
* or #CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL.
**/
void
camel_offline_store_set_network_state (CamelOfflineStore *store, int state, CamelException *ex)
{
CamelException lex;
CamelService *service = CAMEL_SERVICE (store);
gboolean network_state = camel_session_get_network_state (service->session);
if (store->state == state)
return;
camel_exception_init (&lex);
if (store->state == CAMEL_OFFLINE_STORE_NETWORK_AVAIL) {
/* network available -> network unavailable */
if (network_state) {
if (((CamelStore *) store)->folders) {
GPtrArray *folders;
CamelFolder *folder;
int i, sync;
sync = camel_url_get_param (((CamelService *) store)->url, "sync_offline") != NULL;
folders = camel_object_bag_list (((CamelStore *) store)->folders);
for (i = 0; i < folders->len; i++) {
folder = folders->pdata[i];
if (CAMEL_CHECK_TYPE (folder, CAMEL_OFFLINE_FOLDER_TYPE)
&& (sync || ((CamelOfflineFolder *) folder)->sync_offline)) {
camel_offline_folder_downsync ((CamelOfflineFolder *) folder, NULL, &lex);
camel_exception_clear (&lex);
}
camel_object_unref (folder);
}
g_ptr_array_free (folders, TRUE);
}
camel_store_sync (CAMEL_STORE (store), FALSE, &lex);
camel_exception_clear (&lex);
}
if (!camel_service_disconnect (CAMEL_SERVICE (store), network_state, ex))
return;
} else {
/* network unavailable -> network available */
if (!camel_service_connect (CAMEL_SERVICE (store), ex))
return;
}
store->state = state;
}
int
camel_nntp_auth_authenticate (CamelNNTPStore *store, CamelException *ex)
{
CamelService *service = CAMEL_SERVICE (store);
CamelSession *session = camel_service_get_session (service);
int resp;
if (!service->url->authmech && !service->url->passwd) {
gchar *prompt;
prompt = camel_session_build_password_prompt (
"NNTP", service->url->user, service->url->host);
service->url->passwd = camel_session_get_password (
session, prompt, TRUE, service, "password", ex);
g_free (prompt);
if (!service->url->passwd) {
camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL,
"You didn\'t enter a password.");
resp = 666;
goto done;
}
}
/* first send username */
resp = camel_nntp_command (store, ex, NULL, "AUTHINFO USER %s", service->url->user);
if (resp == NNTP_AUTH_REJECTED) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Server rejected username"));
goto done;
}
else if (resp != NNTP_AUTH_CONTINUE) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Failed to send username to server"));
goto done;
}
/* then send the username if the server asks for it */
resp = camel_nntp_command (store, ex, NULL, "AUTHINFO PASS %s", service->url->passwd);
if (resp == NNTP_AUTH_REJECTED) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Server rejected username/password"));
goto done;
}
done:
if (service->url->passwd) {
/* let's be paranoid */
memset (service->url->passwd, 0, strlen (service->url->passwd));
g_free (service->url->passwd);
service->url->passwd = NULL;
}
return resp;
}
/* Helper for e_mail_store_prepare_for_offline() */
static void
mail_store_prepare_for_offline_thread (GSimpleAsyncResult *simple,
GObject *source_object,
GCancellable *cancellable)
{
CamelService *service;
const gchar *display_name;
GError *local_error = NULL;
service = CAMEL_SERVICE (source_object);
display_name = camel_service_get_display_name (service);
if (display_name == NULL || *display_name == '\0')
display_name = G_OBJECT_TYPE_NAME (service);
camel_operation_push_message (
cancellable, _("Preparing account “%s” for offline"),
display_name);
if (CAMEL_IS_OFFLINE_STORE (service))
camel_offline_store_prepare_for_offline_sync (
CAMEL_OFFLINE_STORE (service),
cancellable, &local_error);
if (local_error != NULL)
g_simple_async_result_take_error (simple, local_error);
camel_operation_pop_message (cancellable);
}
gboolean
e_mail_store_go_online_sync (CamelStore *store,
GCancellable *cancellable,
GError **error)
{
CamelService *service;
const gchar *display_name;
gboolean success = TRUE;
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
service = CAMEL_SERVICE (store);
display_name = camel_service_get_display_name (service);
if (display_name == NULL || *display_name == '\0')
display_name = G_OBJECT_TYPE_NAME (service);
camel_operation_push_message (
cancellable, _("Reconnecting to “%s”"), display_name);
if (CAMEL_IS_OFFLINE_STORE (store))
success = camel_offline_store_set_online_sync (
CAMEL_OFFLINE_STORE (store),
TRUE, cancellable, error);
camel_operation_pop_message (cancellable);
return success;
}
static gchar *
mail_tool_get_local_movemail_path (CamelStore *store,
GError **error)
{
const gchar *uid;
guchar *safe_uid, *c;
const gchar *data_dir;
gchar *path, *full;
struct stat st;
uid = camel_service_get_uid (CAMEL_SERVICE (store));
safe_uid = (guchar *) g_strdup ((const gchar *) uid);
for (c = safe_uid; *c; c++)
if (strchr ("/:;=|%&#!*^()\\, ", *c) || !isprint ((gint) *c))
*c = '_';
data_dir = mail_session_get_data_dir ();
path = g_build_filename (data_dir, "spool", NULL);
if (g_stat (path, &st) == -1 && g_mkdir_with_parents (path, 0700) == -1) {
g_set_error (
error, G_FILE_ERROR,
g_file_error_from_errno (errno),
_("Could not create spool directory '%s': %s"),
path, g_strerror (errno));
g_free (path);
return NULL;
}
full = g_strdup_printf ("%s/movemail.%s", path, safe_uid);
g_free (path);
g_free (safe_uid);
return full;
}
static gchar *
vfolder_adduri_desc (struct _adduri_msg *m)
{
CamelStore *store;
CamelService *service;
EMailSession *session;
const gchar *display_name;
gchar *folder_name;
gchar *description;
gboolean success;
session = e_mail_backend_get_session (m->backend);
success = e_mail_folder_uri_parse (
CAMEL_SESSION (session), m->uri,
&store, &folder_name, NULL);
if (!success)
return NULL;
service = CAMEL_SERVICE (store);
display_name = camel_service_get_display_name (service);
description = g_strdup_printf (
_("Updating Search Folders for '%s' : %s"),
display_name, folder_name);
g_object_unref (store);
g_free (folder_name);
return description;
}
/* resets the current folder. To just free current folder, pass NULL for folder */
void
groupwise_store_set_current_folder (CamelGroupwiseStore *groupwise_store, CamelFolder *folder)
{
camel_service_lock (CAMEL_SERVICE (groupwise_store), CAMEL_SERVICE_REC_CONNECT_LOCK);
if (groupwise_store->current_folder) {
g_object_unref (groupwise_store->current_folder);
groupwise_store->current_folder = NULL;
}
if (folder)
groupwise_store->current_folder = g_object_ref (folder);
camel_service_unlock (CAMEL_SERVICE (groupwise_store), CAMEL_SERVICE_REC_CONNECT_LOCK);
}
static gboolean
special_mail_store_is_enabled (CamelStore *store)
{
CamelService *service;
EShell *shell;
EShellSettings *shell_settings;
const gchar *uid, *prop = NULL;
service = CAMEL_SERVICE (store);
g_return_val_if_fail (service, FALSE);
uid = camel_service_get_uid (service);
if (g_strcmp0 (uid, "local") == 0)
prop = "mail-enable-local-folders";
else if (g_strcmp0 (uid, "vfolder") == 0)
prop = "mail-enable-search-folders";
if (!prop)
return TRUE;
shell = e_shell_get_default ();
shell_settings = e_shell_get_shell_settings (shell);
return e_shell_settings_get_boolean (shell_settings, prop);
}
ESource *
em_utils_ref_mail_identity_for_store (ESourceRegistry *registry,
CamelStore *store)
{
ESourceMailAccount *extension;
ESource *source;
const gchar *extension_name;
const gchar *store_uid;
gchar *identity_uid;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
store_uid = camel_service_get_uid (CAMEL_SERVICE (store));
g_return_val_if_fail (store_uid != NULL, NULL);
source = e_source_registry_ref_source (registry, store_uid);
g_return_val_if_fail (source != NULL, NULL);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (source, extension_name);
identity_uid = e_source_mail_account_dup_identity_uid (extension);
g_object_unref (source);
source = NULL;
if (identity_uid != NULL) {
source = e_source_registry_ref_source (registry, identity_uid);
g_free (identity_uid);
}
return source;
}
static CamelFolder *
diary_decode_folder (CamelDiscoDiary *diary)
{
CamelFolder *folder;
char *name;
if (camel_file_util_decode_string (diary->file, &name) == -1)
return NULL;
folder = g_hash_table_lookup (diary->folders, name);
if (!folder) {
CamelException ex;
char *msg;
camel_exception_init (&ex);
folder = camel_store_get_folder (CAMEL_STORE (diary->store),
name, 0, &ex);
if (folder)
g_hash_table_insert (diary->folders, name, folder);
else {
msg = g_strdup_printf (_("Could not open `%s':\n%s\nChanges made to this folder will not be resynchronized."),
name, camel_exception_get_description (&ex));
camel_exception_clear (&ex);
camel_session_alert_user (camel_service_get_session (CAMEL_SERVICE (diary->store)),
CAMEL_SESSION_ALERT_WARNING,
msg, FALSE);
g_free (msg);
g_free (name);
}
} else
g_free (name);
return folder;
}
/**
* camel_imap_command_continuation:
* @store: the IMAP store
* @cmd: buffer containing the response/request data
* @cmdlen: command length
* @ex: a CamelException
*
* This method is for sending continuing responses to the IMAP server
* after camel_imap_command() or camel_imap_command_response() returns
* a continuation response.
*
* This function assumes you have an exclusive lock on the imap stream.
*
* Return value: as for camel_imap_command(). On failure, the store's
* connect_lock will be released.
**/
CamelImapResponse *
camel_imap_command_continuation (CamelImapStore *store, const char *cmd,
size_t cmdlen, CamelException *ex)
{
if (!camel_imap_store_connected (store, ex))
return NULL;
g_return_val_if_fail(store->ostream!=NULL, NULL);
g_return_val_if_fail(store->istream!=NULL, NULL);
if (camel_stream_write (store->ostream, cmd, cmdlen) == -1 ||
camel_stream_write (store->ostream, "\r\n", 2) == -1) {
if (errno == EINTR)
camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL,
_("Operation cancelled"));
else
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
g_strerror (errno));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
CAMEL_SERVICE_REC_UNLOCK (store, connect_lock);
return NULL;
}
return imap_read_response (store, ex);
}
void
e_mail_store_go_offline (CamelStore *store,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
g_return_if_fail (CAMEL_IS_STORE (store));
/* Cancel any pending connect first so the set_offline_op
* thread won't get queued behind a hung connect op. */
camel_service_cancel_connect (CAMEL_SERVICE (store));
simple = g_simple_async_result_new (
G_OBJECT (store), callback,
user_data, e_mail_store_go_offline);
g_simple_async_result_run_in_thread (
simple, (GSimpleAsyncThreadFunc)
mail_store_go_offline_thread,
io_priority, cancellable);
g_object_unref (simple);
}
/* this is copied from Evolution's libemail-engine/e-mail-folder-utils.c */
static gchar *
mail_folder_uri_build (CamelStore *store,
const gchar *folder_name)
{
const gchar *uid;
gchar *encoded_name;
gchar *encoded_uid;
gchar *uri;
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
g_return_val_if_fail (folder_name != NULL, NULL);
/* Skip the leading slash, if present. */
if (*folder_name == '/')
folder_name++;
uid = camel_service_get_uid (CAMEL_SERVICE (store));
encoded_uid = camel_url_encode (uid, ":;@/");
encoded_name = camel_url_encode (folder_name, "#");
uri = g_strdup_printf ("folder://%s/%s", encoded_uid, encoded_name);
g_free (encoded_uid);
g_free (encoded_name);
return uri;
}
void
e_mail_store_foreach (EMailBackend *backend,
GFunc func,
gpointer user_data)
{
EMailSession *session;
GList *list, *link;
/* XXX This is a silly convenience function.
* Could probably just get rid of it. */
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
g_return_if_fail (func != NULL);
session = e_mail_backend_get_session (backend);
list = camel_session_list_services (CAMEL_SESSION (session));
for (link = list; link != NULL; link = g_list_next (link)) {
CamelService *service = CAMEL_SERVICE (link->data);
if (CAMEL_IS_STORE (service))
func (service, user_data);
}
g_list_free (list);
}
/**
* em_utils_folder_is_drafts:
* @registry: an #ESourceRegistry
* @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 (ESourceRegistry *registry,
CamelFolder *folder)
{
CamelFolder *local_drafts_folder;
CamelSession *session;
CamelStore *store;
GList *list, *iter;
gchar *folder_uri;
gboolean is_drafts = FALSE;
const gchar *extension_name;
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE);
store = camel_folder_get_parent_store (folder);
session = camel_service_ref_session (CAMEL_SERVICE (store));
local_drafts_folder =
e_mail_session_get_local_folder (
E_MAIL_SESSION (session), E_MAIL_LOCAL_FOLDER_DRAFTS);
if (folder == local_drafts_folder) {
is_drafts = TRUE;
goto exit;
}
folder_uri = e_mail_folder_uri_from_folder (folder);
store = camel_folder_get_parent_store (folder);
extension_name = E_SOURCE_EXTENSION_MAIL_COMPOSITION;
list = e_source_registry_list_sources (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceExtension *extension;
const gchar *drafts_folder_uri;
extension = e_source_get_extension (source, extension_name);
drafts_folder_uri =
e_source_mail_composition_get_drafts_folder (
E_SOURCE_MAIL_COMPOSITION (extension));
if (drafts_folder_uri != NULL)
is_drafts = e_mail_folder_uri_equal (
session, folder_uri, drafts_folder_uri);
if (is_drafts)
break;
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
g_free (folder_uri);
exit:
g_object_unref (session);
return is_drafts;
}
void
camel_nntp_grouplist_save (CamelNNTPGroupList *group_list, CamelException *ex)
{
FILE *fp;
gchar *root_dir = camel_nntp_store_get_toplevel_dir(CAMEL_NNTP_STORE(group_list->store));
gchar *grouplist_file = g_strdup_printf ("%s/grouplist", root_dir);
g_free (root_dir);
fp = g_fopen (grouplist_file, "w");
g_free (grouplist_file);
if (fp == NULL) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unable to save grouplist file for %s: %s"),
CAMEL_SERVICE(group_list->store)->url->host,
strerror(errno));
return;
}
fprintf (fp, "%lu\n", (long)group_list->time);
g_list_foreach (group_list->group_list, (GFunc)save_entry, fp);
fclose (fp);
}
static void
mail_store_prepare_for_offline_thread (GSimpleAsyncResult *simple,
CamelStore *store,
GCancellable *cancellable)
{
CamelService *service;
gchar *service_name;
GError *error = NULL;
service = CAMEL_SERVICE (store);
service_name = camel_service_get_name (service, TRUE);
camel_operation_push_message (
cancellable, _("Preparing account '%s' for offline"),
service_name);
g_free (service_name);
if (CAMEL_IS_DISCO_STORE (store))
camel_disco_store_prepare_for_offline (
CAMEL_DISCO_STORE (store), cancellable, &error);
else if (CAMEL_IS_OFFLINE_STORE (store))
camel_offline_store_prepare_for_offline_sync (
CAMEL_OFFLINE_STORE (store), cancellable, &error);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
camel_operation_pop_message (cancellable);
}
static gint
sort_services_cb (gconstpointer service1,
gconstpointer service2,
gpointer account_store)
{
return e_mail_account_store_compare_services (account_store, CAMEL_SERVICE (service1), CAMEL_SERVICE (service2));
}
GtkWidget *
org_gnome_exchange_show_folder_size_factory (EPlugin *epl, EConfigHookItemFactoryData *data)
{
EMConfigTargetFolder *target= (EMConfigTargetFolder *)data->config->target;
CamelFolder *cml_folder = target->folder;
CamelService *service;
CamelProvider *provider;
ExchangeAccount *account;
GtkWidget *lbl_size, *lbl_size_val;
GtkListStore *model;
GtkVBox *vbx;
GtkHBox *hbx_size;
char *folder_name, *folder_size;
int mode;
service = CAMEL_SERVICE (camel_folder_get_parent_store (cml_folder));
if (!service)
return NULL;
provider = camel_service_get_provider (service);
if (!provider)
return NULL;
if (g_ascii_strcasecmp (provider->protocol, "exchange"))
return NULL;
account = exchange_operations_get_exchange_account ();
exchange_account_is_offline (account, &mode);
if (mode == OFFLINE_MODE)
return NULL;
folder_name = (char*) camel_folder_get_name (cml_folder);
if (!folder_name)
folder_name = g_strdup ("name");
model = exchange_account_folder_size_get_model (account);
if (model)
folder_size = g_strdup_printf (_("%s KB"), exchange_folder_size_get_val (model, folder_name));
else
folder_size = g_strdup (_("0 KB"));
hbx_size = (GtkHBox*) gtk_hbox_new (FALSE, 0);
vbx = (GtkVBox *)gtk_notebook_get_nth_page (GTK_NOTEBOOK (data->parent), 0);
lbl_size = gtk_label_new_with_mnemonic (_("Size:"));
lbl_size_val = gtk_label_new_with_mnemonic (_(folder_size));
gtk_widget_show (lbl_size);
gtk_widget_show (lbl_size_val);
gtk_misc_set_alignment (GTK_MISC (lbl_size), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (lbl_size_val), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbx_size), lbl_size, FALSE, TRUE, 12);
gtk_box_pack_start (GTK_BOX (hbx_size), lbl_size_val, FALSE, TRUE, 10);
gtk_widget_show_all (GTK_WIDGET (hbx_size));
gtk_box_pack_start (GTK_BOX (vbx), GTK_WIDGET (hbx_size), FALSE, FALSE, 0);
g_free (folder_size);
return GTK_WIDGET (hbx_size);
}
static gboolean
imap_command_start (CamelImapStore *store, CamelFolder *folder,
const char *cmd, CamelException *ex)
{
ssize_t nwritten;
g_return_val_if_fail(store->ostream!=NULL, FALSE);
g_return_val_if_fail(store->istream!=NULL, FALSE);
/* Check for current folder */
if (folder && folder != store->current_folder) {
CamelImapResponse *response;
CamelException internal_ex;
response = camel_imap_command (store, folder, ex, NULL);
if (!response)
return FALSE;
camel_exception_init (&internal_ex);
camel_imap_folder_selected (folder, response, &internal_ex);
camel_imap_response_free (store, response);
if (camel_exception_is_set (&internal_ex)) {
camel_exception_xfer (ex, &internal_ex);
return FALSE;
}
}
/* Send the command */
if (camel_verbose_debug) {
const char *mask;
if (!strncmp ("LOGIN \"", cmd, 7))
mask = "LOGIN \"xxx\" xxx";
else if (!strncmp ("LOGIN {", cmd, 7))
mask = "LOGIN {N+}\r\nxxx {N+}\r\nxxx";
else if (!strncmp ("LOGIN ", cmd, 6))
mask = "LOGIN xxx xxx";
else
mask = cmd;
fprintf (stderr, "sending : %c%.5u %s\r\n", store->tag_prefix, store->command, mask);
}
nwritten = camel_stream_printf (store->ostream, "%c%.5u %s\r\n",
store->tag_prefix, store->command++, cmd);
if (nwritten == -1) {
if (errno == EINTR)
camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL,
_("Operation cancelled"));
else
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
g_strerror (errno));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
return FALSE;
}
return TRUE;
}
static gboolean
is_in_gw_account (EShellView *shell_view,
gboolean *is_on_store,
gchar **folder_full_name)
{
EShellSidebar *shell_sidebar;
EMFolderTree *folder_tree = NULL;
GtkTreeSelection *selection;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
gboolean is_store = FALSE, res;
CamelStore *store;
CamelProvider *provider;
gchar *full_name = NULL;
if (folder_full_name)
*folder_full_name = NULL;
shell_sidebar = e_shell_view_get_shell_sidebar (shell_view);
g_object_get (shell_sidebar, "folder-tree", &folder_tree, NULL);
g_return_val_if_fail (folder_tree != NULL, FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_tree));
g_return_val_if_fail (selection != NULL, FALSE);
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return FALSE;
gtk_tree_model_get (model, &iter,
COL_STRING_FULL_NAME, &full_name,
COL_POINTER_CAMEL_STORE, &store,
COL_BOOL_IS_STORE, &is_store,
-1);
provider = camel_service_get_provider (CAMEL_SERVICE (store));
res = g_strcmp0 (provider->protocol, "groupwise") == 0;
if (is_on_store)
*is_on_store = is_store;
if (!is_store) {
if (folder_full_name)
*folder_full_name = full_name;
else
g_free (full_name);
} else {
g_free (full_name);
}
return res;
}
static gboolean
is_eex_store_available (EShellView *shell_view)
{
EShellSidebar *shell_sidebar;
EMFolderTree *folder_tree = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
gboolean res = FALSE;
g_return_val_if_fail (shell_view != NULL, FALSE);
shell_sidebar = e_shell_view_get_shell_sidebar (shell_view);
g_object_get (shell_sidebar, "folder-tree", &folder_tree, NULL);
g_return_val_if_fail (folder_tree != NULL, FALSE);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_tree));
g_return_val_if_fail (model != NULL, FALSE);
if (!gtk_tree_model_get_iter_first (model, &iter))
return FALSE;
do {
CamelStore *store;
gboolean is_store;
gboolean is_exchange_store = FALSE;
gtk_tree_model_get (model, &iter,
COL_POINTER_CAMEL_STORE, &store,
COL_BOOL_IS_STORE, &is_store,
-1);
/* XXX Maybe move CamelExchangeStore to /server/lib so
* we can query its GType directly? Would probably
* drag all the other CamelExchange classes with it,
* but maybe that's okay? */
if (CAMEL_IS_STORE (store)) {
CamelService *service;
CamelProvider *provider;
const gchar *protocol;
service = CAMEL_SERVICE (store);
provider = camel_service_get_provider (service);
protocol = (provider != NULL) ? provider->protocol : NULL;
is_exchange_store = (g_strcmp0 (protocol, "exchange") == 0);
}
res = is_store && is_exchange_store;
} while (!res && gtk_tree_model_iter_next (model, &iter));
return res;
}
void
mail_filter_rename_folder (CamelStore *store,
const gchar *old_folder_name,
const gchar *new_folder_name)
{
CamelSession *session;
EMFilterContext *fc;
const gchar *config_dir;
gchar *user, *system;
GList *changed;
gchar *old_uri;
gchar *new_uri;
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (old_folder_name != NULL);
g_return_if_fail (new_folder_name != NULL);
session = camel_service_ref_session (CAMEL_SERVICE (store));
old_uri = e_mail_folder_uri_build (store, old_folder_name);
new_uri = e_mail_folder_uri_build (store, new_folder_name);
fc = em_filter_context_new (E_MAIL_SESSION (session));
config_dir = mail_session_get_config_dir ();
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 (system);
changed = e_rule_context_rename_uri (
(ERuleContext *) fc, old_uri, new_uri, g_str_equal);
if (changed) {
if (e_rule_context_save ((ERuleContext *) fc, user) == -1)
g_warning ("Could not write out changed filter rules\n");
e_rule_context_free_uri_list ((ERuleContext *) fc, changed);
}
g_free (user);
g_object_unref (fc);
g_free (old_uri);
g_free (new_uri);
g_object_unref (session);
}
static void
pop3_store_dispose (GObject *object)
{
CamelPOP3StorePrivate *priv;
priv = CAMEL_POP3_STORE_GET_PRIVATE (object);
/* Force disconnect so we dont have it run
* later, after we've cleaned up some stuff. */
camel_service_disconnect_sync (
CAMEL_SERVICE (object), TRUE, NULL, NULL);
g_clear_object (&priv->cache);
g_clear_object (&priv->engine);
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (camel_pop3_store_parent_class)->dispose (object);
}
static void
mail_store_go_offline_thread (GSimpleAsyncResult *simple,
CamelStore *store,
GCancellable *cancellable)
{
CamelService *service;
gchar *service_name;
GError *error = NULL;
service = CAMEL_SERVICE (store);
service_name = camel_service_get_name (service, TRUE);
camel_operation_push_message (
cancellable, _("Disconnecting from '%s'"), service_name);
g_free (service_name);
if (CAMEL_IS_DISCO_STORE (store)) {
CamelDiscoStore *disco_store;
disco_store = CAMEL_DISCO_STORE (store);
if (camel_disco_store_can_work_offline (disco_store))
camel_disco_store_set_status (
disco_store, CAMEL_DISCO_STORE_OFFLINE,
cancellable, &error);
else
em_utils_disconnect_service_sync (service, TRUE, cancellable, &error);
} else if (CAMEL_IS_OFFLINE_STORE (store)) {
CamelOfflineStore *offline_store;
offline_store = CAMEL_OFFLINE_STORE (store);
camel_offline_store_set_online_sync (
offline_store, FALSE, cancellable, &error);
} else
em_utils_disconnect_service_sync (service, TRUE, cancellable, &error);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
camel_operation_pop_message (cancellable);
}
static gint
exchange_entry_play_delete (CamelOfflineJournal *journal,
CamelExchangeJournalEntry *entry,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
CamelStore *parent_store;
const gchar *full_name;
gboolean success;
folder = CAMEL_FOLDER (journal->folder);
full_name = camel_folder_get_full_name (folder);
parent_store = camel_folder_get_parent_store (folder);
success = camel_exchange_utils_set_message_flags (
CAMEL_SERVICE (parent_store), full_name,
entry->uid, entry->set, entry->flags, error);
return success ? 0 : -1;
}
static ESource *
guess_mail_account_from_folder (ESourceRegistry *registry,
CamelFolder *folder,
const gchar *message_uid)
{
ESource *source;
CamelStore *store;
const gchar *uid;
/* Lookup an ESource by CamelStore UID. */
store = camel_folder_get_parent_store (folder);
if (message_uid && folder && CAMEL_IS_VEE_STORE (store)) {
CamelMessageInfo *mi = camel_folder_get_message_info (folder, message_uid);
if (mi) {
CamelFolder *location;
location = camel_vee_folder_get_location (CAMEL_VEE_FOLDER (folder), (CamelVeeMessageInfo *) mi, NULL);
if (location)
store = camel_folder_get_parent_store (location);
camel_folder_free_message_info (folder, mi);
}
}
uid = camel_service_get_uid (CAMEL_SERVICE (store));
source = e_source_registry_ref_source (registry, uid);
/* If we found an ESource, make sure it's a mail account. */
if (source != NULL) {
const gchar *extension_name;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
source = NULL;
}
}
return source;
}
gboolean
e_mail_session_unsubscribe_folder_sync (EMailSession *session,
const gchar *folder_uri,
GCancellable *cancellable,
GError **error)
{
CamelStore *store = NULL;
gchar *folder_name = NULL;
const gchar *message;
gboolean success = FALSE;
g_return_val_if_fail (E_IS_MAIL_SESSION (session), FALSE);
g_return_val_if_fail (folder_uri != NULL, FALSE);
success = e_mail_folder_uri_parse (
CAMEL_SESSION (session), folder_uri,
&store, &folder_name, error);
if (!success)
return FALSE;
message = _("Unsubscribing from folder '%s'");
camel_operation_push_message (cancellable, message, folder_name);
/* FIXME This should take our GCancellable. */
success =
em_utils_connect_service_sync (
CAMEL_SERVICE (store), cancellable, error) &&
camel_subscribable_unsubscribe_folder_sync (
CAMEL_SUBSCRIBABLE (store),
folder_name, cancellable, error);
camel_operation_pop_message (cancellable);
g_object_unref (store);
g_free (folder_name);
return success;
}
/**
* em_utils_folder_is_outbox:
* @registry: an #ESourceRegistry
* @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 (ESourceRegistry *registry,
CamelFolder *folder)
{
CamelStore *store;
CamelSession *session;
CamelFolder *local_outbox_folder;
gboolean is_outbox;
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE);
store = camel_folder_get_parent_store (folder);
session = camel_service_ref_session (CAMEL_SERVICE (store));
local_outbox_folder =
e_mail_session_get_local_folder (
E_MAIL_SESSION (session), E_MAIL_LOCAL_FOLDER_OUTBOX);
is_outbox = (folder == local_outbox_folder);
g_object_unref (session);
return is_outbox;
}
