/* 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_create_folder (CamelStore *store,
const gchar *full_name,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
AsyncContext *context;
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (full_name != NULL);
context = g_slice_new0 (AsyncContext);
context->full_name = g_strdup (full_name);
simple = g_simple_async_result_new (
G_OBJECT (store), callback, user_data,
e_mail_store_create_folder);
g_simple_async_result_set_op_res_gpointer (
simple, context, (GDestroyNotify) async_context_free);
g_simple_async_result_run_in_thread (
simple, mail_store_create_folder_thread,
io_priority, cancellable);
g_object_unref (simple);
}
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);
}
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);
}
void
e_mail_store_remove_by_account (EMailBackend *backend,
EAccount *account)
{
EMailSession *session;
CamelService *service;
CamelProvider *provider;
const gchar *uid;
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
g_return_if_fail (E_IS_ACCOUNT (account));
uid = account->uid;
session = e_mail_backend_get_session (backend);
service = camel_session_get_service (CAMEL_SESSION (session), uid);
g_return_if_fail (CAMEL_IS_STORE (service));
provider = camel_service_get_provider (service);
g_return_if_fail (provider != NULL);
if (!(provider->flags & CAMEL_PROVIDER_IS_STORAGE))
return;
e_mail_store_remove (backend, CAMEL_STORE (service));
}
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 gpointer
worker (gpointer d)
{
gint i;
CamelStore *store;
CamelService *service;
CamelFolder *folder;
for (i = 0; i < MAX_LOOP; i++) {
gchar *uid;
uid = g_strdup_printf ("test-uid-%d", i);
service = camel_session_add_service (
session, uid, path, CAMEL_PROVIDER_STORE, NULL);
g_free (uid);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
folder = camel_store_get_folder_sync (
store, "testbox",
CAMEL_STORE_FOLDER_CREATE, NULL, NULL);
if (testid == 0) {
g_object_unref (folder);
g_object_unref (store);
} else {
g_object_unref (store);
g_object_unref (folder);
}
}
return NULL;
}
static void
mail_store_add (EMailBackend *backend,
CamelStore *store,
AddStoreCallback callback)
{
EMailSession *session;
EMFolderTreeModel *default_model;
MailFolderCache *folder_cache;
StoreInfo *store_info;
g_return_if_fail (store_table != NULL);
g_return_if_fail (store != NULL);
g_return_if_fail (CAMEL_IS_STORE (store));
session = e_mail_backend_get_session (backend);
default_model = em_folder_tree_model_get_default ();
folder_cache = e_mail_session_get_folder_cache (session);
store_info = store_info_new (store);
store_info->callback = callback;
g_hash_table_insert (store_table, store, store_info);
if (special_mail_store_is_enabled (store))
em_folder_tree_model_add_store (default_model, store);
mail_folder_cache_note_store (
folder_cache, CAMEL_SESSION (session), store, NULL,
mail_store_note_store_cb, store_info_ref (store_info));
}
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;
}
void
e_mail_store_add (EMailBackend *backend,
CamelStore *store)
{
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
g_return_if_fail (CAMEL_IS_STORE (store));
mail_store_add (backend, store, NULL);
}
static void
mail_shell_view_folder_tree_selected_cb (EMailShellView *mail_shell_view,
CamelStore *store,
const gchar *folder_name,
CamelFolderInfoFlags flags,
EMFolderTree *folder_tree)
{
EMailShellContent *mail_shell_content;
EShellView *shell_view;
EMailReader *reader;
EMailView *mail_view;
GCancellable *cancellable;
AsyncContext *context;
EActivity *activity;
shell_view = E_SHELL_VIEW (mail_shell_view);
mail_shell_content = mail_shell_view->priv->mail_shell_content;
mail_view = e_mail_shell_content_get_mail_view (mail_shell_content);
reader = E_MAIL_READER (mail_view);
/* Cancel any unfinished open folder operations. */
if (mail_shell_view->priv->opening_folder != NULL) {
g_cancellable_cancel (mail_shell_view->priv->opening_folder);
g_object_unref (mail_shell_view->priv->opening_folder);
mail_shell_view->priv->opening_folder = NULL;
}
/* If we are to clear the message list, do so immediately. */
if ((flags & CAMEL_FOLDER_NOSELECT) || folder_name == NULL) {
e_mail_reader_set_folder (reader, NULL);
e_shell_view_update_actions_in_idle (shell_view);
return;
}
g_warn_if_fail (CAMEL_IS_STORE (store));
/* Open the selected folder asynchronously. */
activity = e_mail_reader_new_activity (reader);
cancellable = e_activity_get_cancellable (activity);
mail_shell_view->priv->opening_folder = g_object_ref (cancellable);
context = g_slice_new0 (AsyncContext);
context->activity = activity;
context->reader = g_object_ref (reader);
context->shell_view = g_object_ref (shell_view);
camel_store_get_folder (
store, folder_name, 0, G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) mail_shell_view_got_folder_cb, context);
}
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;
}
static gboolean
send_receive_can_use_service (EMailAccountStore *account_store,
CamelService *service,
GtkTreeIter *piter)
{
GtkTreeModel *model;
GtkTreeIter iter;
gboolean found = FALSE, enabled = FALSE, builtin = TRUE;
if (!CAMEL_IS_STORE (service))
return FALSE;
model = GTK_TREE_MODEL (account_store);
if (piter) {
found = TRUE;
iter = *piter;
} else if (gtk_tree_model_get_iter_first (model, &iter)) {
CamelService *adept;
do {
adept = NULL;
gtk_tree_model_get (
model, &iter,
E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, &adept,
-1);
if (service == adept) {
found = TRUE;
g_object_unref (adept);
break;
}
if (adept)
g_object_unref (adept);
} while (gtk_tree_model_iter_next (model, &iter));
}
if (!found)
return FALSE;
gtk_tree_model_get (
model, &iter,
E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED, &enabled,
E_MAIL_ACCOUNT_STORE_COLUMN_BUILTIN, &builtin,
-1);
return enabled && !builtin;
}
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);
}
gboolean
e_mail_store_create_folder_sync (CamelStore *store,
const gchar *full_name,
GCancellable *cancellable,
GError **error)
{
CamelFolderInfo *folder_info;
gchar *copied_full_name;
gchar *display_name;
const gchar *parent;
gboolean success = TRUE;
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
g_return_val_if_fail (full_name != NULL, FALSE);
copied_full_name = g_strdup (full_name);
display_name = strrchr (copied_full_name, '/');
if (display_name == NULL) {
display_name = copied_full_name;
parent = "";
} else {
*display_name++ = '\0';
parent = copied_full_name;
}
folder_info = camel_store_create_folder_sync (
store, parent, display_name, cancellable, error);
g_free (copied_full_name);
if (folder_info == NULL)
return FALSE;
if (CAMEL_IS_SUBSCRIBABLE (store))
success = camel_subscribable_subscribe_folder_sync (
CAMEL_SUBSCRIBABLE (store),
full_name, cancellable, error);
camel_store_free_folder_info (store, folder_info);
return success;
}
void
e_mail_store_prepare_for_offline (CamelStore *store,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
g_return_if_fail (CAMEL_IS_STORE (store));
simple = g_simple_async_result_new (
G_OBJECT (store), callback, user_data,
e_mail_store_prepare_for_offline);
g_simple_async_result_run_in_thread (
simple, (GSimpleAsyncThreadFunc)
mail_store_prepare_for_offline_thread,
io_priority, cancellable);
g_object_unref (simple);
}
static StoreInfo *
store_info_new (CamelStore *store)
{
StoreInfo *store_info;
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
store_info = g_slice_new0 (StoreInfo);
store_info->ref_count = 1;
store_info->store = g_object_ref (store);
/* If these are vfolders then they need to be opened now,
* otherwise they won't keep track of all folders. */
if (store->flags & CAMEL_STORE_VTRASH)
store_info->vtrash =
camel_store_get_trash_folder_sync (store, NULL, NULL);
if (store->flags & CAMEL_STORE_VJUNK)
store_info->vjunk =
camel_store_get_junk_folder_sync (store, NULL, NULL);
return store_info;
}
void
e_mail_store_remove (EMailBackend *backend,
CamelStore *store)
{
EMailSession *session;
MailFolderCache *folder_cache;
EMFolderTreeModel *default_model;
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (store_table != NULL);
session = e_mail_backend_get_session (backend);
/* Because the store table holds a reference to each store used
* as a key in it, none of them will ever be gc'ed, meaning any
* call to camel_session_get_{service,store} with the same URL
* will always return the same object. So this works. */
if (g_hash_table_lookup (store_table, store) == NULL)
return;
g_object_ref (store);
g_hash_table_remove (store_table, store);
folder_cache = e_mail_session_get_folder_cache (session);
mail_folder_cache_note_store_remove (folder_cache, store);
default_model = em_folder_tree_model_get_default ();
em_folder_tree_model_remove_store (default_model, store);
mail_disconnect_store (store);
g_object_unref (store);
}
CamelStore *
e_mail_store_add_by_account (EMailBackend *backend,
EAccount *account)
{
EMailSession *session;
CamelService *service = NULL;
CamelProvider *provider;
CamelURL *url;
gboolean skip = FALSE, transport_only;
GError *error = NULL;
g_return_val_if_fail (E_IS_MAIL_BACKEND (backend), NULL);
g_return_val_if_fail (E_IS_ACCOUNT (account), NULL);
session = e_mail_backend_get_session (backend);
/* check whether it's transport-only accounts */
transport_only = !account->source || !account->source->url || !*account->source->url;
if (transport_only)
goto handle_transport;
/* Load the service, but don't connect. Check its provider,
* and if this belongs in the folder tree model, add it. */
provider = camel_provider_get (account->source->url, &error);
if (provider == NULL) {
/* In case we do not have a provider here, we handle
* the special case of having multiple mail identities
* eg. a dummy account having just SMTP server defined */
goto handle_transport;
}
service = camel_session_add_service (
CAMEL_SESSION (session),
account->uid, account->source->url,
CAMEL_PROVIDER_STORE, &error);
camel_service_set_display_name (service, account->name);
handle_transport:
if (account->transport) {
/* While we're at it, add the account's transport to the
* CamelSession. The transport's UID is a kludge for now.
* We take the EAccount's UID and tack on "-transport". */
gchar *transport_uid;
GError *transport_error = NULL;
transport_uid = g_strconcat (
account->uid, "-transport", NULL);
camel_session_add_service (
CAMEL_SESSION (session),
transport_uid, account->transport->url,
CAMEL_PROVIDER_TRANSPORT, &transport_error);
g_free (transport_uid);
if (transport_error) {
g_warning (
"%s: Failed to add transport service: %s",
G_STRFUNC, transport_error->message);
g_error_free (transport_error);
}
}
if (transport_only)
return NULL;
if (!CAMEL_IS_STORE (service))
goto fail;
/* Do not add local-delivery files,
* but make them ready for later use. */
url = camel_url_new (account->source->url, NULL);
if (url != NULL) {
skip = em_utils_is_local_delivery_mbox_file (url);
camel_url_free (url);
}
if (!skip && (provider->flags & CAMEL_PROVIDER_IS_STORAGE))
e_mail_store_add (backend, CAMEL_STORE (service));
return CAMEL_STORE (service);
fail:
/* FIXME: Show an error dialog. */
g_warning (
"Couldn't get service: %s: %s", account->name,
error ? error->message : "Not a CamelStore");
if (error)
g_error_free (error);
return NULL;
}
gint main (gint argc, gchar **argv)
{
CamelSession *session;
gint i, j, index;
gchar *path;
CamelStore *store;
CamelService *service;
GThread *threads[MAX_THREADS];
struct _threadinfo *info;
CamelFolder *folder;
GPtrArray *uids;
GError *error = NULL;
camel_test_init (argc, argv);
camel_test_provider_init (1, local_drivers);
/* clear out any camel-test data */
system ("/bin/rm -rf /tmp/camel-test");
session = camel_test_session_new ("/tmp/camel-test");
for (j = 0; j < G_N_ELEMENTS (local_providers); j++) {
for (index = 0; index < 2; index++) {
gchar *uid;
path = g_strdup_printf ("method %s %s", local_providers[j], index?"indexed":"nonindexed");
camel_test_start (path);
test_free (path);
push ("trying %s index %d", local_providers[j], index);
uid = g_strdup_printf ("test-uid-%d", j);
path = g_strdup_printf ("%s:///tmp/camel-test/%s", local_providers[j], local_providers[j]);
service = camel_session_add_service (
session, uid, path,
CAMEL_PROVIDER_STORE, &error);
g_free (uid);
check_msg (error == NULL, "%s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
test_free (path);
if (index == 0)
folder = camel_store_get_folder_sync (
store, "testbox",
CAMEL_STORE_FOLDER_CREATE,
NULL, &error);
else
folder = camel_store_get_folder_sync (
store, "testbox",
CAMEL_STORE_FOLDER_CREATE |
CAMEL_STORE_FOLDER_BODY_INDEX,
NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
for (i = 0; i < MAX_THREADS; i++) {
GError *error = NULL;
info = g_malloc (sizeof (*info));
info->id = i * MAX_MESSAGES;
info->folder = folder;
threads[i] = g_thread_try_new (NULL, worker, info, &error);
check_msg (error == NULL, "g_thread_try_new() failed: %s", error->message);
}
for (i = 0; i < MAX_THREADS; i++) {
if (threads[i]) {
info = g_thread_join (threads[i]);
g_free (info);
}
}
pull ();
push ("deleting remaining messages");
uids = camel_folder_get_uids (folder);
for (i = 0; i < uids->len; i++) {
camel_folder_delete_message (folder, uids->pdata[i]);
}
camel_folder_free_uids (folder, uids);
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check_unref (folder, 1);
camel_store_delete_folder_sync (
store, "testbox", NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
check_unref (store, 1);
pull ();
camel_test_end ();
}
}
g_object_unref (session);
return 0;
}
gint main (gint argc, gchar **argv)
{
CamelService *service;
CamelSession *session;
CamelStore *store;
CamelFolder *folder;
CamelMimeMessage *msg;
gint i, j;
CamelStream *mbox;
CamelFilterDriver *driver;
GError *error = NULL;
camel_test_init (argc, argv);
camel_test_provider_init (1, local_drivers);
/* clear out any camel-test data */
system ("/bin/rm -rf /tmp/camel-test");
camel_test_start ("Simple filtering of mbox");
session = camel_test_session_new ("/tmp/camel-test");
/* todo: cross-check everything with folder_info checks as well */
/* todo: work out how to do imap/pop/nntp tests */
push ("getting store");
service = camel_session_add_service (
session, "test-uid", "mbox:///tmp/camel-test/mbox",
CAMEL_PROVIDER_STORE, &error);
check_msg (error == NULL, "getting store: %s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
g_clear_error (&error);
pull ();
push ("Creating output folders");
for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) {
push ("creating %s", mailboxes[i].name);
mailboxes[i].folder = folder = camel_store_get_folder_sync (
store, mailboxes[i].name,
CAMEL_STORE_FOLDER_CREATE, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
/* we need an empty folder for this to work */
test_folder_counts (folder, 0, 0);
g_clear_error (&error);
pull ();
}
pull ();
/* append a bunch of messages with specific content */
push ("creating 100 test message mbox");
mbox = camel_stream_fs_new_with_name ("/tmp/camel-test/inbox", O_WRONLY|O_CREAT|O_EXCL, 0600, NULL);
for (j = 0; j < 100; j++) {
gchar *content, *subject;
push ("creating test message");
msg = test_message_create_simple ();
content = g_strdup_printf ("data%d content\n", j);
test_message_set_content_simple ((CamelMimePart *)msg, 0, "text/plain",
content, strlen (content));
test_free (content);
subject = g_strdup_printf ("Test%d message%d subject", j, 100-j);
camel_mime_message_set_subject (msg, subject);
camel_mime_message_set_date (msg, j * 60 * 24, 0);
pull ();
camel_stream_write_string (mbox, "From \n", NULL, NULL);
check (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), mbox, NULL, NULL) != -1);
#if 0
push ("appending simple message %d", j);
camel_folder_append_message (folder, msg, NULL, ex);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
#endif
test_free (subject);
check_unref (msg, 1);
}
check (camel_stream_close (mbox, NULL, NULL) != -1);
check_unref (mbox, 1);
pull ();
push ("Building filters");
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
for (i = 0; i < G_N_ELEMENTS (rules); i++) {
camel_filter_driver_add_rule (driver, rules[i].name, rules[i].match, rules[i].action);
}
pull ();
push ("Executing filters");
camel_filter_driver_set_default_folder (driver, mailboxes[0].folder);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check_msg (error == NULL, "%s", error->message);
/* now need to check the folder counts/etc */
check_unref (driver, 1);
g_clear_error (&error);
pull ();
/* this tests that invalid rules are caught */
push ("Testing broken match rules");
for (i = 0; i < G_N_ELEMENTS (brokens); i++) {
push ("rule %s", brokens[i].match);
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
camel_filter_driver_add_rule (driver, brokens[i].name, brokens[i].match, brokens[i].action);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check (error != NULL);
check_unref (driver, 1);
g_clear_error (&error);
pull ();
}
pull ();
push ("Testing broken action rules");
for (i = 0; i < G_N_ELEMENTS (brokena); i++) {
push ("rule %s", brokena[i].action);
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
camel_filter_driver_add_rule (driver, brokena[i].name, brokena[i].match, brokena[i].action);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check (error != NULL);
check_unref (driver, 1);
g_clear_error (&error);
pull ();
}
pull ();
for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) {
check_unref (mailboxes[i].folder, 1);
}
check_unref (store, 1);
check_unref (session, 1);
camel_test_end ();
return 0;
}
/* this should probably take a folder instead of a session ... */
void
test_folder_message_ops (CamelSession *session,
const gchar *name,
gint local,
const gchar *mailbox)
{
CamelStore *store;
CamelService *service;
CamelFolder *folder;
CamelMimeMessage *msg;
gint j;
gint indexed, max;
GPtrArray *uids;
CamelMessageInfo *info;
GError *error = NULL;
max = local ? 2 : 1;
for (indexed = 0; indexed < max; indexed++) {
gchar *what = g_strdup_printf ("folder ops: %s %s", name, local ? (indexed?"indexed":"non-indexed"):"");
gint flags;
camel_test_start (what);
test_free (what);
push ("getting store");
service = camel_session_add_service (
session, name, name, CAMEL_PROVIDER_STORE, &error);
check_msg (error == NULL, "adding store: %s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
g_clear_error (&error);
pull ();
push ("creating %sindexed folder", indexed?"":"non-");
if (indexed)
flags = CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_FOLDER_BODY_INDEX;
else
flags = CAMEL_STORE_FOLDER_CREATE;
folder = camel_store_get_folder_sync (
store, mailbox, flags, NULL, &error);
/* we can't create mailbox outside of namespace, since we have no api for it, try
* using inbox namespace, works for courier */
if (folder == NULL) {
gchar *mbox = g_strdup_printf ("INBOX/%s", mailbox);
mailbox = mbox;
g_clear_error (&error);
folder = camel_store_get_folder_sync (
store, mailbox, flags, NULL, &error);
}
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
/* verify empty/can't get nonexistant stuff */
test_folder_counts (folder, 0, 0);
test_folder_not_message (folder, "0");
test_folder_not_message (folder, "");
for (j = 0; j < 10; j++) {
gchar *content, *subject;
push ("creating test message");
msg = test_message_create_simple ();
content = g_strdup_printf ("Test message %d contents\n\n", j);
test_message_set_content_simple (
(CamelMimePart *) msg, 0, "text/plain",
content, strlen (content));
test_free (content);
subject = g_strdup_printf ("Test message %d", j);
camel_mime_message_set_subject (msg, subject);
pull ();
push ("appending simple message %d", j);
camel_folder_append_message_sync (
folder, msg, NULL, NULL, NULL, &error);
check_msg (error == NULL, "%s", error->message);
#if 0
/* sigh, this shouldn't be required, but the imap code is too dumb to do it itself */
if (!local) {
push ("forcing a refresh of folder updates");
camel_folder_refresh_info (folder, ex);
check_msg (error == NULL, "%s", error->message);
pull ();
}
#endif
/*if (!local)
camel_test_nonfatal ("unread counts dont seem right for imap");*/
test_folder_counts (folder, j + 1, j + 1);
/*if (!local)
camel_test_fatal ();*/
push ("checking it is in the right uid slot & exists");
uids = camel_folder_get_uids (folder);
check (uids != NULL);
check (uids->len == j + 1);
if (uids->len > j)
test_folder_message (folder, uids->pdata[j]);
pull ();
push ("checking it is the right message (subject): %s", subject);
if (uids->len > j) {
info = camel_folder_get_message_info (folder, uids->pdata[j]);
check (info != NULL);
check_msg (
strcmp (camel_message_info_get_subject (info), subject) == 0,
"info->subject %s", camel_message_info_get_subject (info));
camel_message_info_unref (info);
}
camel_folder_free_uids (folder, uids);
pull ();
test_free (subject);
/*if (!local)
camel_test_fatal ();*/
check_unref (msg, 1);
pull ();
}
if (local)
check_unref (folder, 1);
else
check_unref (folder, 2);
pull ();
#if 0
push ("deleting test folder, with messages in it");
camel_store_delete_folder (store, mailbox, ex);
check (camel_exception_is_set (ex));
camel_exception_clear (ex);
pull ();
#endif
push ("re-opening folder");
folder = camel_store_get_folder_sync (
store, mailbox, flags, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
g_clear_error (&error);
/* verify counts */
test_folder_counts (folder, 10, 10);
/* re-check uid's, after a reload */
uids = camel_folder_get_uids (folder);
check (uids != NULL);
check (uids->len == 10);
for (j = 0; j < 10; j++) {
gchar *subject = g_strdup_printf ("Test message %d", j);
push ("verify reload of %s", subject);
test_folder_message (folder, uids->pdata[j]);
info = camel_folder_get_message_info (folder, uids->pdata[j]);
check_msg (
strcmp (camel_message_info_get_subject (info), subject) == 0,
"info->subject %s", camel_message_info_get_subject (info));
test_free (subject);
camel_message_info_unref (info);
pull ();
}
push ("deleting first message & expunging");
camel_folder_delete_message (folder, uids->pdata[0]);
test_folder_counts (folder, 10, 9);
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
test_folder_not_message (folder, uids->pdata[0]);
test_folder_counts (folder, 9, 9);
camel_folder_free_uids (folder, uids);
uids = camel_folder_get_uids (folder);
check (uids != NULL);
check (uids->len == 9);
for (j = 0; j < 9; j++) {
gchar *subject = g_strdup_printf ("Test message %d", j + 1);
push ("verify after expunge of %s", subject);
test_folder_message (folder, uids->pdata[j]);
info = camel_folder_get_message_info (folder, uids->pdata[j]);
check_msg (
strcmp (camel_message_info_get_subject (info), subject) == 0,
"info->subject %s", camel_message_info_get_subject (info));
test_free (subject);
camel_message_info_unref (info);
pull ();
}
pull ();
push ("deleting last message & expunging");
camel_folder_delete_message (folder, uids->pdata[8]);
/* sync? */
test_folder_counts (folder, 9, 8);
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
test_folder_not_message (folder, uids->pdata[8]);
test_folder_counts (folder, 8, 8);
camel_folder_free_uids (folder, uids);
uids = camel_folder_get_uids (folder);
check (uids != NULL);
check (uids->len == 8);
for (j = 0; j < 8; j++) {
gchar *subject = g_strdup_printf ("Test message %d", j + 1);
push ("verify after expunge of %s", subject);
test_folder_message (folder, uids->pdata[j]);
info = camel_folder_get_message_info (folder, uids->pdata[j]);
check_msg (
strcmp (camel_message_info_get_subject (info), subject) == 0,
"info->subject %s", camel_message_info_get_subject (info));
test_free (subject);
camel_message_info_unref (info);
pull ();
}
pull ();
push ("deleting all messages & expunging");
for (j = 0; j < 8; j++) {
camel_folder_delete_message (folder, uids->pdata[j]);
}
/* sync? */
test_folder_counts (folder, 8, 0);
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
for (j = 0; j < 8; j++) {
test_folder_not_message (folder, uids->pdata[j]);
}
test_folder_counts (folder, 0, 0);
camel_folder_free_uids (folder, uids);
pull ();
if (local)
check_unref (folder, 1);
else
check_unref (folder, 2);
pull (); /* re-opening folder */
if (g_ascii_strcasecmp (mailbox, "INBOX") != 0) {
push ("deleting test folder, with no messages in it");
camel_store_delete_folder_sync (
store, mailbox, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
}
if (!local) {
push ("disconneect service");
camel_service_disconnect_sync (
CAMEL_SERVICE (store), TRUE, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
}
check_unref (store, 1);
camel_test_end ();
}
}
/* TODO: Add subscription stuff */
void
test_folder_basic (CamelSession *session,
const gchar *storename,
gint local,
gint spool)
{
CamelStore *store;
CamelFolder *folder;
CamelService *service;
gchar *what = g_strdup_printf ("testing store: %s", storename);
GError *error = NULL;
camel_test_start (what);
test_free (what);
push ("getting store");
service = camel_session_add_service (
session, storename, storename, CAMEL_PROVIDER_STORE, &error);
check_msg (error == NULL, "adding store: %s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
pull ();
/* local providers == no inbox */
push ("getting inbox folder");
folder = camel_store_get_inbox_folder_sync (store, NULL, &error);
if (local) {
/* Well, maildir can have an inbox */
if (folder) {
check (error == NULL);
check_unref (folder, 1);
} else {
check (error != NULL);
}
} else {
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
check_unref (folder, 2);
}
g_clear_error (&error);
pull ();
push ("getting a non-existant folder, no create");
folder = camel_store_get_folder_sync (
store, "unknown", 0, NULL, &error);
check (error != NULL);
check (folder == NULL);
g_clear_error (&error);
pull ();
if (!spool) {
push ("getting a non-existant folder, with create");
folder = camel_store_get_folder_sync (
store, "testbox", CAMEL_STORE_FOLDER_CREATE,
NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
if (local)
check_unref (folder, 1);
else
check_unref (folder, 2);
g_clear_error (&error);
pull ();
push ("getting an existing folder");
folder = camel_store_get_folder_sync (
store, "testbox", 0, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
if (local)
check_unref (folder, 1);
else
check_unref (folder, 2);
g_clear_error (&error);
pull ();
push ("renaming a non-existant folder");
camel_store_rename_folder_sync (
store, "unknown1", "unknown2", NULL, &error);
check (error != NULL);
g_clear_error (&error);
pull ();
push ("renaming an existing folder");
camel_store_rename_folder_sync (
store, "testbox", "testbox2", NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
push ("opening the old name of a renamed folder");
folder = camel_store_get_folder_sync (
store, "testbox", 0, NULL, &error);
check (error != NULL);
check (folder == NULL);
g_clear_error (&error);
pull ();
push ("opening the new name of a renamed folder");
folder = camel_store_get_folder_sync (
store, "testbox2", 0, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
if (local)
check_unref (folder, 1);
else
check_unref (folder, 2);
pull ();
}
push ("deleting a non-existant folder");
camel_store_delete_folder_sync (store, "unknown", NULL, &error);
check (error != NULL);
g_clear_error (&error);
pull ();
if (!spool) {
push ("deleting an existing folder");
camel_store_delete_folder_sync (
store, "testbox2", NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
}
push ("opening a folder that has been deleted");
folder = camel_store_get_folder_sync (
store, "testbox2", 0, NULL, &error);
check (error != NULL);
check (folder == NULL);
g_clear_error (&error);
pull ();
check_unref (store, 1);
camel_test_end ();
}
gchar *
mail_tool_do_movemail (CamelStore *store,
GError **error)
{
#ifndef G_OS_WIN32
CamelService *service;
CamelProvider *provider;
CamelSettings *settings;
gchar *src_path;
gchar *dest_path;
struct stat sb;
gboolean success;
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
service = CAMEL_SERVICE (store);
provider = camel_service_get_provider (service);
g_return_val_if_fail (provider != NULL, NULL);
if (g_strcmp0 (provider->protocol, "mbox") != 0) {
/* This is really only an internal error anyway */
g_set_error (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_URL_INVALID,
_("Trying to movemail a non-mbox source '%s'"),
camel_service_get_uid (CAMEL_SERVICE (store)));
return NULL;
}
settings = camel_service_ref_settings (service);
src_path = camel_local_settings_dup_path (
CAMEL_LOCAL_SETTINGS (settings));
g_object_unref (settings);
/* Set up our destination. */
dest_path = mail_tool_get_local_movemail_path (store, error);
if (dest_path == NULL)
return NULL;
/* Movemail from source to dest_path */
success = camel_movemail (src_path, dest_path, error) != -1;
g_free (src_path);
if (g_stat (dest_path, &sb) < 0 || sb.st_size == 0) {
g_unlink (dest_path); /* Clean up the movemail.foo file. */
g_free (dest_path);
return NULL;
}
if (!success) {
g_free (dest_path);
return NULL;
}
return dest_path;
#else
/* Unclear yet whether camel-movemail etc makes any sense on
* Win32, at least it is not ported yet.
*/
g_warning ("%s: Not implemented", __FUNCTION__);
return NULL;
#endif
}
static gboolean
mail_store_save_setup_key (CamelStore *store,
ESource *source,
const gchar *extension_name,
const gchar *property_name,
const gchar *type_id,
const gchar *value)
{
gpointer extension;
GObjectClass *klass;
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
if (source)
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
g_return_val_if_fail (extension_name != NULL, FALSE);
g_return_val_if_fail (property_name != NULL, FALSE);
g_return_val_if_fail (value != NULL, FALSE);
if (!source)
return FALSE;
extension = e_source_get_extension (source, extension_name);
if (!extension) {
g_warning ("%s: Cannot find extension '%s'", G_STRFUNC, extension_name);
return FALSE;
}
klass = G_OBJECT_GET_CLASS (extension);
g_return_val_if_fail (klass != NULL, FALSE);
if (!g_object_class_find_property (klass, property_name)) {
g_warning ("%s: Extension '%s' doesn't have property '%s'", G_STRFUNC, extension_name, property_name);
return FALSE;
}
if (!type_id || g_str_equal (type_id, "s")) {
g_object_set (extension, property_name, value, NULL);
} else if (g_str_equal (type_id, "b")) {
gboolean val;
val = g_strcmp0 (value, "false") != 0 && g_strcmp0 (value, "0") != 0;
g_object_set (extension, property_name, val, NULL);
} else if (g_str_equal (type_id, "i")) {
gint val;
val = (gint) g_ascii_strtoll (value, NULL, 10);
g_object_set (extension, property_name, val, NULL);
} else if (g_str_equal (type_id, "f")) {
gchar *folder_uri;
folder_uri = e_mail_folder_uri_build (store, value);
g_object_set (extension, property_name, folder_uri, NULL);
g_free (folder_uri);
} else {
g_warning ("%s: Unknown type identifier '%s' provided", G_STRFUNC, type_id);
return FALSE;
}
return TRUE;
}
void
mail_filter_delete_folder (EMailBackend *backend,
CamelStore *store,
const gchar *folder_name)
{
EMFilterContext *fc;
const gchar *config_dir;
gchar *user, *system;
GList *deleted;
gchar *uri;
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (folder_name != NULL);
uri = e_mail_folder_uri_build (store, folder_name);
fc = em_filter_context_new (backend);
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);
deleted = e_rule_context_delete_uri (
(ERuleContext *) fc, uri, g_str_equal);
if (deleted) {
GString *s;
guint s_count;
gchar *info;
GList *l;
s = g_string_new("");
s_count = 0;
for (l = deleted; l; l = l->next) {
const gchar *name = (const gchar *) l->data;
if (s_count == 0) {
g_string_append (s, name);
} else {
if (s_count == 1) {
g_string_prepend (s, " ");
g_string_append (s, "\n");
}
g_string_append_printf (s, " %s\n", name);
}
s_count++;
}
info = g_strdup_printf (ngettext (
/* Translators: The first %s is name of the affected
* filter rule(s), the second %s is URI of the removed
* folder. For more than one filter rule is each of
* them on a separate line, with four spaces in front
* of its name, without quotes. */
"The filter rule \"%s\" has been modified to account "
"for the deleted folder\n\"%s\".",
"The following filter rules\n%s have been modified "
"to account for the deleted folder\n\"%s\".",
s_count), s->str, folder_name);
e_mail_backend_submit_alert (
backend, "mail:filter-updated", info, NULL);
g_string_free (s, TRUE);
g_free (info);
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, deleted);
}
g_free (user);
g_object_unref (fc);
g_free (uri);
}
gboolean
e_mail_store_save_initial_setup_sync (CamelStore *store,
GHashTable *save_setup,
ESource *collection_source,
ESource *account_source,
ESource *submission_source,
ESource *transport_source,
gboolean write_sources,
GCancellable *cancellable,
GError **error)
{
gboolean collection_changed = FALSE;
gboolean account_changed = FALSE;
gboolean submission_changed = FALSE;
gboolean transport_changed = FALSE;
gboolean success = TRUE;
GHashTableIter iter;
gpointer key, value;
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
g_return_val_if_fail (save_setup != NULL, FALSE);
g_return_val_if_fail (E_IS_SOURCE (account_source), FALSE);
if (!g_hash_table_size (save_setup))
return TRUE;
/* The key name consists of up to four parts: Source:Extension:Property[:Type]
Source can be 'Collection', 'Account', 'Submission', 'Transport', 'Backend'
Extension is any extension name; it's up to the key creator to make sure
the extension belongs to that particular Source.
Property is a property name in the Extension.
Type is an optional letter describing the type of the value; if not set, then
string is used. Available values are: 'b' for boolean, 'i' for integer,
's' for string, 'f' for folder full path.
All the part values are case sensitive.
*/
g_hash_table_iter_init (&iter, save_setup);
while (g_hash_table_iter_next (&iter, &key, &value)) {
gchar **keys;
keys = g_strsplit (key, ":", -1);
if (g_strv_length (keys) < 3 || g_strv_length (keys) > 4) {
g_warning ("%s: Incorrect store setup key, expects 3 or 4 parts, but %d given in '%s'",
G_STRFUNC, g_strv_length (keys), (const gchar *) key);
} else if (g_str_equal (keys[0], "Collection")) {
if (mail_store_save_setup_key (store, collection_source, keys[1], keys[2], keys[3], value))
collection_changed = TRUE;
} else if (g_str_equal (keys[0], "Account")) {
if (mail_store_save_setup_key (store, account_source, keys[1], keys[2], keys[3], value))
account_changed = TRUE;
} else if (g_str_equal (keys[0], "Submission")) {
if (mail_store_save_setup_key (store, submission_source, keys[1], keys[2], keys[3], value))
submission_changed = TRUE;
} else if (g_str_equal (keys[0], "Transport")) {
if (mail_store_save_setup_key (store, transport_source, keys[1], keys[2], keys[3], value))
transport_changed = TRUE;
} else if (g_str_equal (keys[0], "Backend")) {
ESource *backend_source = NULL;
if (collection_source && e_source_has_extension (collection_source, keys[1]))
backend_source = collection_source;
else if (account_source && e_source_has_extension (account_source, keys[1]))
backend_source = account_source;
if (mail_store_save_setup_key (store, backend_source, keys[1], keys[2], keys[3], value))
transport_changed = TRUE;
} else {
g_warning ("%s: Unknown source name '%s' given in '%s'", G_STRFUNC, keys[0], (const gchar *) key);
}
}
if (write_sources) {
if (transport_changed && success && e_source_get_writable (transport_source))
success = e_source_write_sync (transport_source, cancellable, error);
if (submission_changed && success && e_source_get_writable (submission_source))
success = e_source_write_sync (submission_source, cancellable, error);
if (account_changed && success && e_source_get_writable (account_source))
success = e_source_write_sync (account_source, cancellable, error);
if (collection_changed && success && e_source_get_writable (collection_source))
success = e_source_write_sync (collection_source, cancellable, error);
}
return success;
}
static gboolean
is_eex_folder_selected (EShellView *shell_view,
gchar **puri)
{
ExchangeAccount *account = NULL;
EShellSidebar *shell_sidebar;
EMFolderTree *folder_tree = NULL;
GtkTreeSelection *selection;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
CamelStore *store;
gchar *folder_name;
gboolean is_store = FALSE, res = FALSE;
gboolean is_exchange_store = 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);
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_POINTER_CAMEL_STORE, &store,
COL_STRING_FULL_NAME, &folder_name,
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;
if (res) {
gint mode;
/* check for the account later, as it is connecting to the server for the first time */
account = exchange_operations_get_exchange_account ();
if (!account) {
res = FALSE;
} else {
exchange_account_is_offline (account, &mode);
if (mode == OFFLINE_MODE)
res = FALSE;
}
}
if (folder_name != NULL && puri != NULL) {
*puri = folder_name;
folder_name = NULL;
}
g_free (folder_name);
return res;
}
static gboolean
migrate_mbox_to_maildir (EShell *shell,
CamelSession *session,
ESource *mbox_source)
{
ESourceRegistry *registry;
ESourceExtension *extension;
const gchar *extension_name;
CamelService *mbox_service = NULL;
CamelService *maildir_service = NULL;
CamelSettings *settings;
const gchar *data_dir;
const gchar *mbox_uid;
gchar *path;
struct MigrateStore ms;
GThread *thread;
GError *error = NULL;
registry = e_shell_get_registry (shell);
data_dir = camel_session_get_user_data_dir (session);
mbox_uid = e_source_get_uid (mbox_source);
e_source_set_display_name (mbox_source, "local_mbox");
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
extension = e_source_get_extension (mbox_source, extension_name);
e_source_backend_set_backend_name (
E_SOURCE_BACKEND (extension), "mbox");
extension_name = e_source_camel_get_extension_name ("mbox");
extension = e_source_get_extension (mbox_source, extension_name);
settings = e_source_camel_get_settings (E_SOURCE_CAMEL (extension));
path = g_build_filename (data_dir, mbox_uid, NULL);
g_object_set (settings, "path", path, NULL);
g_free (path);
e_source_registry_commit_source_sync (
registry, mbox_source, NULL, &error);
if (error == NULL)
mbox_service = camel_session_add_service (
session, mbox_uid, "mbox",
CAMEL_PROVIDER_STORE, &error);
if (error == NULL)
maildir_service = camel_session_add_service (
session, "local", "maildir",
CAMEL_PROVIDER_STORE, &error);
if (error != NULL) {
if (mbox_service != NULL)
g_object_unref (mbox_service);
if (maildir_service != NULL)
g_object_unref (maildir_service);
g_warning ("%s: %s", G_STRFUNC, error->message);
g_error_free (error);
return FALSE;
}
g_return_val_if_fail (CAMEL_IS_STORE (mbox_service), FALSE);
g_return_val_if_fail (CAMEL_IS_STORE (maildir_service), FALSE);
camel_service_set_settings (mbox_service, settings);
settings = camel_service_ref_settings (maildir_service);
path = g_build_filename (data_dir, "local", NULL);
g_object_set (settings, "path", path, NULL);
if (g_mkdir (path, 0700) == -1)
g_warning (
"%s: Failed to make directory '%s': %s",
G_STRFUNC, path, g_strerror (errno));
g_free (path);
g_object_unref (settings);
ms.mail_store = CAMEL_STORE (mbox_service);
ms.maildir_store = CAMEL_STORE (maildir_service);
ms.session = session;
ms.complete = FALSE;
thread = g_thread_new (NULL, (GThreadFunc) migrate_stores, &ms);
/* coverity[loop_condition] */
while (!ms.complete)
g_main_context_iteration (NULL, TRUE);
g_object_unref (mbox_service);
g_object_unref (maildir_service);
g_thread_unref (thread);
return TRUE;
}
gint
main (gint argc,
gchar **argv)
{
CamelService *service;
CamelSession *session;
CamelStore *store;
CamelFolder *folder;
CamelMimeMessage *msg;
gint i, j;
gint indexed;
GPtrArray *uids;
GError *error = NULL;
camel_test_init (argc, argv);
camel_test_provider_init (1, local_drivers);
/* clear out any camel-test data */
system ("/bin/rm -rf /tmp/camel-test");
session = camel_test_session_new ("/tmp/camel-test");
/* todo: cross-check everything with folder_info checks as well */
/* todo: work out how to do imap/pop/nntp tests */
/* we iterate over all stores we want to test, with indexing or indexing turned on or off */
for (i = 0; i < G_N_ELEMENTS (stores); i++) {
const gchar *name = stores[i];
for (indexed = 0; indexed < 2; indexed++) {
gchar *what = g_strdup_printf ("folder search: %s (%sindexed)", name, indexed?"":"non-");
gchar *uid;
gint flags;
camel_test_start (what);
test_free (what);
push ("getting store");
uid = g_strdup_printf ("test-uid-%d", i);
service = camel_session_add_service (
session, uid, stores[i],
CAMEL_PROVIDER_STORE, &error);
g_free (uid);
check_msg (error == NULL, "adding store: %s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
g_clear_error (&error);
pull ();
push ("creating %sindexed folder", indexed?"":"non-");
if (indexed)
flags = CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_FOLDER_BODY_INDEX;
else
flags = CAMEL_STORE_FOLDER_CREATE;
folder = camel_store_get_folder_sync (
store, "testbox", flags, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
/* we need an empty folder for this to work */
test_folder_counts (folder, 0, 0);
g_clear_error (&error);
pull ();
/* append a bunch of messages with specific content */
push ("appending 100 test messages");
for (j = 0; j < 100; j++) {
gchar *content, *subject;
push ("creating test message");
msg = test_message_create_simple ();
content = g_strdup_printf ("data%d content\n", j);
test_message_set_content_simple (
(CamelMimePart *) msg, 0, "text/plain",
content, strlen (content));
test_free (content);
subject = g_strdup_printf ("Test%d message%d subject", j, 100 - j);
camel_mime_message_set_subject (msg, subject);
camel_mime_message_set_date (msg, j * 60 * 24, 0);
pull ();
push ("appending simple message %d", j);
camel_folder_append_message_sync (
folder, msg, NULL, NULL, NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
test_free (subject);
check_unref (msg, 1);
}
pull ();
push ("Setting up some flags &c");
uids = camel_folder_get_uids (folder);
check (uids->len == 100);
for (j = 0; j < 100; j++) {
gchar *uid = uids->pdata[j];
if ((j / 13) * 13 == j) {
camel_folder_set_message_user_flag (folder, uid, "every13", TRUE);
}
if ((j / 17) * 17 == j) {
camel_folder_set_message_user_flag (folder, uid, "every17", TRUE);
}
if ((j / 7) * 7 == j) {
gchar *tag = g_strdup_printf ("7tag%d", j / 7);
camel_folder_set_message_user_tag (folder, uid, "every7", tag);
test_free (tag);
}
if ((j / 11) * 11 == j) {
camel_folder_set_message_user_tag (folder, uid, "every11", "11tag");
}
}
camel_folder_free_uids (folder, uids);
pull ();
camel_test_nonfatal ("Index not guaranteed to be accurate before sync: should be fixed eventually");
push ("Search before sync");
run_search (folder, 100);
pull ();
camel_test_fatal ();
push ("syncing folder, searching");
camel_folder_synchronize_sync (
folder, FALSE, NULL, NULL);
run_search (folder, 100);
pull ();
push ("syncing wiht expunge, search");
camel_folder_synchronize_sync (
folder, TRUE, NULL, NULL);
run_search (folder, 100);
pull ();
push ("deleting every 2nd message");
uids = camel_folder_get_uids (folder);
check (uids->len == 100);
for (j = 0; j < uids->len; j+=2) {
camel_folder_delete_message (folder, uids->pdata[j]);
}
camel_folder_free_uids (folder, uids);
run_search (folder, 100);
push ("syncing");
camel_folder_synchronize_sync (
folder, FALSE, NULL, &error);
check_msg (error == NULL, "%s", error->message);
run_search (folder, 100);
g_clear_error (&error);
pull ();
push ("expunging");
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
run_search (folder, 50);
g_clear_error (&error);
pull ();
pull ();
push ("closing and re-opening folder");
check_unref (folder, 1);
folder = camel_store_get_folder_sync (
store, "testbox",
flags & ~(CAMEL_STORE_FOLDER_CREATE),
NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
g_clear_error (&error);
push ("deleting remaining messages");
uids = camel_folder_get_uids (folder);
check (uids->len == 50);
for (j = 0; j < uids->len; j++) {
camel_folder_delete_message (folder, uids->pdata[j]);
}
camel_folder_free_uids (folder, uids);
run_search (folder, 50);
push ("syncing");
camel_folder_synchronize_sync (
folder, FALSE, NULL, &error);
check_msg (error == NULL, "%s", error->message);
run_search (folder, 50);
g_clear_error (&error);
pull ();
push ("expunging");
camel_folder_expunge_sync (folder, NULL, &error);
check_msg (error == NULL, "%s", error->message);
run_search (folder, 0);
g_clear_error (&error);
pull ();
pull ();
check_unref (folder, 1);
pull ();
push ("deleting test folder, with no messages in it");
camel_store_delete_folder_sync (
store, "testbox", NULL, &error);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
check_unref (store, 1);
camel_test_end ();
}
}
check_unref (session, 1);
return 0;
}
