imap_thread.c

/**
 * @file
 *
 * The communications happens in a separate thread of name #IMAP_THREAD_NAME.
 */

#include "imap_thread.h"

#include <stdlib.h>
#include <string.h>

#include "account.h"
#include "debug.h"
#include "folder.h"
#include "imap.h"
#include "lists.h"
#include "mail.h"
#include "request.h"
#include "simplemail.h"
#include "status.h"
#include "subthreads.h"
#include "support_indep.h"
#include "tcp.h"
#include "tcpip.h"

/*****************************************************************************/

/**
 * The name of the IMAP thread.
 */
#define IMAP_THREAD_NAME "SimpleMail - IMAP thread"


/*****************************************************************************/

/* Very similar to trans_set_status(). TODO: consolidate */
static void imap_set_status(const char *str)
{
	thread_call_parent_function_async_string(status_set_status, 1, str);
}

static void imap_set_status_static(const char *str)
{
	thread_call_function_async(thread_get_main(), status_set_status, 1, str);
}

static void imap_set_connect_to_server(const char *server)
{
	thread_call_parent_function_async_string(status_set_connect_to_server, 1, server);
}

static void imap_set_head(const char *head)
{
	thread_call_parent_function_async_string(status_set_head, 1, head);
}

static void imap_set_title_utf8(const char *title)
{
	thread_call_parent_function_async_string(status_set_title_utf8, 1, title);
}

static void imap_set_title(const char *title)
{
	thread_call_parent_function_async_string(status_set_title, 1, title);
}

static void imap_new_mails_arrived(int num_filenames, char **filenames, char *user, char *server, char *path)
{
	thread_call_parent_function_sync(NULL, callback_new_imap_mails_arrived, 5, num_filenames, filenames, user, server, path);
}

static void imap_new_uids(unsigned int uid_validity, unsigned int uid_next, char *user, char *server, char *path)
{
	thread_call_parent_function_sync(NULL, callback_new_imap_uids, 5, uid_validity, uid_next, user, server, path);
}

static int imap_request_login(const char *text, char *login, char *password, int len)
{
	return thread_call_parent_function_sync(NULL,sm_request_login,4,text,login,password,len);
}

static void imap_delete_mail_by_uid(char *user, char *server, char *path, unsigned int uid)
{
	thread_call_parent_function_sync(NULL, callback_delete_mail_by_uid, 4, user, server, path, uid);
}

static void imap_add_imap_folder(char *user, char *server, char *path, char delim)
{
	thread_call_parent_function_sync(NULL, callback_add_imap_folder, 4, user, server, path, delim);
}

static void imap_refresh_folders(void)
{
	thread_call_parent_function_sync(NULL,callback_refresh_folders,0);
}

/*****************************************************************************/

/**
 * Contains the arguments submitted to the get folder list thread.
 */
struct imap_get_folder_list_entry_msg
{
	struct imap_server *server;
	imap_get_folder_list_callback_t callback;
};

/**
 * Entry point for the thread to get the folder list.
 *
 * @param msg
 * @return
 */
static int imap_get_folder_list_entry(struct imap_get_folder_list_entry_msg *msg)
{
	struct imap_server *server = imap_duplicate(msg->server);
	imap_get_folder_list_callback_t callback = msg->callback;

	if (thread_parent_task_can_contiue())
	{
		struct imap_get_folder_list_options options = {0};
		struct remote_folder *all_folders;
		struct remote_folder *sub_folders;
		int num_all_folders, num_sub_folders;

		thread_call_function_async(thread_get_main(),status_init,1,0);
		thread_call_function_async(thread_get_main(),status_open,0);

		options.server = server;
		options.callbacks.set_status = imap_set_status;
		options.callbacks.set_status_static = imap_set_status_static;
		options.callbacks.set_connect_to_server = imap_set_connect_to_server;
		options.callbacks.set_head = imap_set_head;
		options.callbacks.set_title = imap_set_title;
		options.callbacks.set_title_utf8 = imap_set_title_utf8;

		if (!(imap_get_folder_list_really(&options, &all_folders, &num_all_folders, &sub_folders, &num_sub_folders)))
			return 0;

		thread_call_parent_function_sync(NULL, callback, 5, server, all_folders, num_all_folders, sub_folders, num_sub_folders);

		thread_call_function_async(thread_get_main(),status_close,0);
	}
	return 0;
}

/*****************************************************************************/

int imap_get_folder_list(struct imap_server *server, imap_get_folder_list_callback_t callback)
{
	struct imap_get_folder_list_entry_msg msg;
	msg.server = server;
	msg.callback = callback;
	return thread_start(THREAD_FUNCTION(&imap_get_folder_list_entry),&msg);
}


/**
 * Contains the arguments send to the submit folder list thread.
 */
struct imap_submit_folder_list_entry_msg
{
	struct imap_server *server;
	struct string_list *list;
};


/**
 * The entry point for the submit folder list thread.
 *
 * @param msg
 * @return
 */
static int imap_submit_folder_list_entry(struct imap_submit_folder_list_entry_msg *msg)
{
	struct imap_server *server = imap_duplicate(msg->server);
	struct string_list list;
	struct string_node *node;

	string_list_init(&list);
	node = string_list_first(msg->list);
	while (node)
	{
		string_list_insert_tail(&list,node->string);
		node = string_node_next(node);
	}


	if (thread_parent_task_can_contiue())
	{
		struct imap_submit_folder_options options = {0};

		thread_call_function_async(thread_get_main(),status_init,1,0);
		thread_call_function_async(thread_get_main(),status_open,0);

		options.server = server;
		options.list = &list;
		options.callbacks.set_status = imap_set_status;
		options.callbacks.set_status_static = imap_set_status_static;
		options.callbacks.set_connect_to_server = imap_set_connect_to_server;
		options.callbacks.set_head = imap_set_head;
		options.callbacks.set_title = imap_set_title;
		options.callbacks.set_title_utf8 = imap_set_title_utf8;

		imap_submit_folder_list_really(&options);

		thread_call_function_async(thread_get_main(),status_close,0);
	}
	string_list_clear(&list);
	return 0;
}

/*****************************************************************************/

int imap_submit_folder_list(struct imap_server *server, struct string_list *list)
{
	struct imap_submit_folder_list_entry_msg msg;
	msg.server = server;
	msg.list = list;
	return thread_start(THREAD_FUNCTION(&imap_submit_folder_list_entry),&msg);
}

/*****************************************************************************/

/***** IMAP Thread *****/

static thread_t imap_thread;
static struct connection *imap_connection;
static int imap_socket_lib_open;
static struct imap_server *imap_server;
static char *imap_folder; /** The path of the folder on the imap server */
static char *imap_local_path; /** The local path of the folder */

/**************************************************************************/

/**
 * The entry point for the imap thread. It just go into the wait state and
 * then frees all resources when finished
 *
 * @param test
 */
static void imap_thread_entry(void *test)
{
	if (thread_parent_task_can_contiue())
	{
		thread_wait(NULL,NULL,NULL,0);

		imap_free(imap_server);
		free(imap_folder);
		free(imap_local_path);

		if (imap_connection)
		{
			tcp_disconnect(imap_connection);
			imap_connection = NULL;
		}

		if (imap_socket_lib_open)
		{
			close_socket_lib();
			imap_socket_lib_open = 0;
		}
	}
}

/**
 * The function creates the IMAP thread. It doesn't start the thread
 * if it is already started.
 *
 * @return whether the thread has been started.
 */
static int imap_start_thread(void)
{
	if (imap_thread) return 1;
	imap_thread = thread_add(IMAP_THREAD_NAME, THREAD_FUNCTION(&imap_thread_entry),NULL);
	return !!imap_thread;
}

/**
 * Open the socket library, but make sure that this happns only once.
 *
 * @return socket is open (1) or not (0).
 */
static int imap_open_socket_lib(void)
{
	if (!imap_socket_lib_open)
	 imap_socket_lib_open = open_socket_lib();
	return imap_socket_lib_open;
}

/**
 * Disconnect the current imap connection if any is open.
 */
static void imap_disconnect(void)
{
	if (imap_connection)
	{
		tcp_disconnect(imap_connection);
		imap_connection = NULL;
	}
}

static int imap_thread_really_login_to_given_server(struct imap_server *server)
{
	if (!imap_open_socket_lib())
		return 0;

	if (!imap_connection || imap_new_connection_needed(imap_server,server))
	{
		free(imap_folder); imap_folder = NULL;
		free(imap_local_path); imap_local_path = NULL;

		if (imap_server) imap_free(imap_server);
		if ((imap_server = imap_duplicate(server)))
		{
			struct imap_connect_and_login_to_server_callbacks callbacks = {0};

			callbacks.set_status = imap_set_status;
			callbacks.request_login = imap_request_login;

			imap_disconnect();

			return imap_really_connect_and_login_to_server(&imap_connection, imap_server, &callbacks);
		}
		return 0;
	}
	return 1;
}

/**
 * Connect to the given imap server. Shall be invoked only in the context of the IMAP thread.
 *
 * @param server
 * @param folder
 * @param local_path
 * @return
 */
static int imap_thread_connect_to_server(struct imap_server *server, char *folder, char *local_path)
{
	static int connecting;

	int rc = 0;

	SM_ENTER;

	/* Ignore this request if we are already connecting. This can happen for instance, if a synchronous call
	 * to the parent task is issued.  */
	if (connecting)
	{
		SM_DEBUGF(5, ("Ignoring connect to server request for %s\n", local_path));

		if (server) imap_free(server);
		free(folder);
		free(local_path);
		goto bailout;
	}

	if (!imap_open_socket_lib())
		goto bailout;

	connecting = 1;

	if (!imap_connection || imap_new_connection_needed(imap_server,server))
	{
		struct imap_connect_to_server_options options = {0};

		imap_disconnect();

		if (imap_server) imap_free(imap_server);
		imap_server = server;

		free(imap_folder);
		imap_folder = folder;

		free(imap_local_path);
		imap_local_path = local_path;

		options.imap_local_path = imap_local_path;
		options.imap_server = imap_server;
		options.imap_folder = imap_folder;
		options.callbacks.set_status = imap_set_status;
		options.callbacks.request_login = imap_request_login;
		options.callbacks.add_imap_folder = imap_add_imap_folder;
		options.callbacks.refresh_folders = imap_refresh_folders;
		options.download_callbacks.new_uids = imap_new_uids;
		options.download_callbacks.new_mails_arrived = imap_new_mails_arrived;
		options.download_callbacks.set_status = imap_set_status;
		options.download_callbacks.set_status_static = imap_set_status_static;
		imap_really_connect_to_server(&imap_connection, &options);
		rc = 1;
	} else
	{
		struct imap_download_mails_options download_options = {0};

		imap_free(server);

		free(imap_folder);
		imap_folder = folder;

		free(imap_local_path);
		imap_local_path = local_path;

		download_options.imap_folder = imap_folder;
		download_options.imap_server = imap_server;
		download_options.imap_local_path = imap_local_path;

		download_options.callbacks.new_mails_arrived = imap_new_mails_arrived;
		download_options.callbacks.new_uids = imap_new_uids;
		download_options.callbacks.set_status = imap_set_status;
		download_options.callbacks.set_status_static = imap_set_status_static;
		download_options.callbacks.delete_mail_by_uid = imap_delete_mail_by_uid;

		imap_really_download_mails(imap_connection, &download_options);
		rc = 1;
	}

	connecting = 0;

bailout:
	SM_RETURN(rc,"%d");
	return rc;
}

/**
 * Download the given mail. Usually called in the context of the imap thread.
 *
 * @param server
 * @param local_path
 * @param m
 * @param callback called on the context of the calling task.
 * @param userdata user data supplied for the callback
 * @return
 */
static int imap_thread_download_mail(struct imap_server *server, char *local_path, struct mail_info *m, void (*callback)(struct mail_info *m, void *userdata), void *userdata)
{
	if (!imap_thread_really_login_to_given_server(server)) return 0;

	return imap_really_download_mail(imap_connection, local_path, m, callback, userdata);
}

/**
 * Move a given mail from one folder into another one of the given imap account.
 *
 * Usually called in the context of the imap thread.
 *
 * @param mail
 * @param server
 * @param src_folder
 * @param dest_folder
 * @return success or failure.
 */
static int imap_thread_move_mail(struct mail_info *mail, struct imap_server *server, struct folder *src_folder, struct folder *dest_folder)
{
	if (!imap_thread_really_login_to_given_server(server)) return 0;

	return imap_really_move_mail(imap_connection, mail, server, src_folder, dest_folder);
}

/**
 * Delete a mail permanently from the server
 *
 * @param filename
 * @param server
 * @param folder
 * @return success or not.
 * @note This function can only be called in the context of the imap thread.
 */
static int imap_thread_delete_mail_by_filename(char *filename, struct imap_server *server, struct folder *folder)
{
	struct imap_delete_mail_by_filename_options options = {0};

	if (!imap_thread_really_login_to_given_server(server)) return 0;

	options.filename = filename;
	options.folder = folder;

	return imap_really_delete_mail_by_filename(imap_connection, &options);
}

/**
 * Store the mail represented by the mail located in the given source_dir
 * on the given server in the given dest_folder.
 *
 * @param mail
 * @param source_dir
 * @param server
 * @param dest_folder
 * @return success or not.
 * @note This function can only be called in the context of the imap thread.
 */
static int imap_thread_append_mail(struct mail_info *mail, char *source_dir, struct imap_server *server, struct folder *dest_folder)
{
	if (!imap_thread_really_login_to_given_server(server)) return 0;

	return imap_really_append_mail(imap_connection, mail, source_dir, server, dest_folder);
}

/*****************************************************************************/

void imap_thread_connect(struct folder *folder)
{
	struct imap_server *server;
	char *imap_folder;
	char *imap_local_path;

	SM_ENTER;

	if (!(server = account_find_imap_server_by_folder(folder)))
	{
		SM_DEBUGF(5,("Server for folder %p (%s) not found\n",folder,folder?folder->name:"NONE"));
		goto bailout;
	}

	if (!imap_start_thread())
	{
		SM_DEBUGF(5,("Could not start IMAP thread\n"));
		goto bailout;
	}

	if (!(server = imap_duplicate(server)))
	{
		SM_DEBUGF(5,("Could not duplicate imap server\n"));
		goto bailout;
	}

	if ((!(imap_folder = mystrdup(folder->imap_path))) && folder->imap_path != NULL && strlen(folder->imap_path))
	{
		SM_DEBUGF(5,("Could not duplicate imap path\n"));
		goto bailout;
	}

	if (!(imap_local_path = mystrdup(folder->path)))
	{
		SM_DEBUGF(5,("Could not duplicate folder path\n"));
		goto bailout;
	}

	thread_call_function_async(imap_thread, imap_thread_connect_to_server, 3, server, imap_folder, imap_local_path);
bailout:
	SM_LEAVE;
}

/*****************************************************************************/

int imap_download_mail(struct folder *f, struct mail_info *m)
{
	struct imap_server *server;

	if (!(m->flags & MAIL_FLAGS_PARTIAL)) return 0;
	if (!(server = account_find_imap_server_by_folder(f))) return 0;
	if (!imap_start_thread()) return 0;

	if (thread_call_function_sync(imap_thread, imap_thread_download_mail, 5, server, f->path, m, (void (*)(struct mail_info *, void *))NULL, (void *)NULL))
	{
		folder_set_mail_flags(f, m, (m->flags & (~MAIL_FLAGS_PARTIAL)));
		return 1;
	}
	return 0;
}

struct imap_download_data
{
	struct imap_server *server;
	char *local_path;
	char *remote_path;
	void (*callback)(struct mail_info *m, void *userdata);
	void *userdata;
};

/**
 * Function that is called when an email has been downloaded. It is assumed
 * that is called on parent task.
 *
 * @param m
 * @param userdata
 */
static void imap_download_mail_callback_on_parent_task(struct mail_info *m, void *userdata)
{
	struct imap_download_data *d = (struct imap_download_data*)userdata;
	struct folder *local_folder;

	SM_ENTER;

	SM_DEBUGF(20,("m=%p, d=%p, local_path=%p\n",m,d,d->local_path));

	folders_lock();
	if ((local_folder = folder_find_by_path(d->local_path)))
		folder_lock(local_folder);
	folders_unlock();

	if (local_folder)
	{
		folder_set_mail_flags(local_folder, m, (m->flags & (~MAIL_FLAGS_PARTIAL)));
		folder_unlock(local_folder);
	}
	d->callback(m,d->userdata);
	mail_dereference(m);
	free(d->remote_path);
	free(d->local_path);
	imap_free(d->server);
	free(d);

	SM_LEAVE;
}

/**
 * Function that is called when an email has been downloaded asynchronously.
 * It is assumed that this called on a task that is not the main task.
 *
 * @param m
 * @param userdata
 */
static void imap_download_mail_async_callback(struct mail_info *m, void *userdata)
{
	thread_call_function_async(thread_get_main(), imap_download_mail_callback_on_parent_task, 2, m, userdata);
}

/*****************************************************************************/

int imap_download_mail_async(struct folder *f, struct mail_info *m, void (*callback)(struct mail_info *m, void *userdata), void *userdata)
{
	struct imap_download_data *d = NULL;

	SM_ENTER;

	if (!imap_start_thread()) goto bailout;
	if (!(d = (struct imap_download_data *)malloc(sizeof(*d)))) goto bailout;
	memset(d,0,sizeof(*d));
	d->userdata = userdata;
	if (!(d->server = account_find_imap_server_by_folder(f))) goto bailout;
	if (!(d->server = imap_duplicate(d->server))) goto bailout;
	if (!(d->local_path = mystrdup(f->path))) goto bailout;
	if (!(d->remote_path = mystrdup(f->imap_path))) goto bailout;

	mail_reference(m);
	d->callback = callback;

	if (!thread_call_function_async(imap_thread, imap_thread_download_mail, 5, d->server, d->local_path, m, imap_download_mail_async_callback, (void*)d))
		goto bailout;
	SM_RETURN(1,"%ld");
	return 1;
bailout:
	if (d)
	{
		if (d->remote_path)
		{
			free(d->remote_path);
			mail_dereference(m);
		}
		free(d->local_path);
		imap_free(d->server);
		free(d);
	}
	SM_RETURN(0,"%ld");
	return 0;
}

/*****************************************************************************/

int imap_move_mail(struct mail_info *mail, struct folder *src_folder, struct folder *dest_folder)
{
	struct imap_server *server;

	if (!imap_start_thread()) return 0;
	if (!folder_on_same_imap_server(src_folder,dest_folder)) return 0;
	if (!(server = account_find_imap_server_by_folder(src_folder))) return 0;

	if (thread_call_function_sync(imap_thread, imap_thread_move_mail, 4, mail, server, src_folder, dest_folder))
	{
		return 1;
	}
	return 0;
}

/*****************************************************************************/

int imap_delete_mail_by_filename(char *filename, struct folder *folder)
{
	struct imap_server *server;

	if (!imap_start_thread()) return 0;
	if (!(server = account_find_imap_server_by_folder(folder))) return 0;

	if (thread_call_function_sync(imap_thread, imap_thread_delete_mail_by_filename, 3, filename, server, folder))
	{
		return 1;
	}
	return 0;
}

/*****************************************************************************/

int imap_append_mail(struct mail_info *mail, char *source_dir, struct folder *dest_folder)
{
	struct imap_server *server;

	if (!imap_start_thread()) return 0;
	if (!(server = account_find_imap_server_by_folder(dest_folder))) return 0;

	if (thread_call_function_sync(imap_thread, imap_thread_append_mail, 4, mail, source_dir, server, dest_folder))
	{
		return 1;
	}
	return 0;
}