/*
 * evolution-spamassassin.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 */

#include <config.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <glib/gi18n-lib.h>

#include <camel/camel.h>

#include <shell/e-shell.h>
#include <e-util/e-mktemp.h>
#include <libemail-engine/e-mail-junk-filter.h>

/* Standard GObject macros */
#define E_TYPE_SPAM_ASSASSIN \
	(e_spam_assassin_get_type ())
#define E_SPAM_ASSASSIN(obj) \
	(G_TYPE_CHECK_INSTANCE_CAST \
	((obj), E_TYPE_SPAM_ASSASSIN, ESpamAssassin))

#ifndef SPAMASSASSIN_BINARY
#define SPAMASSASSIN_BINARY "/usr/bin/spamassassin"
#endif

#ifndef SA_LEARN_BINARY
#define SA_LEARN_BINARY "/usr/bin/sa-learn"
#endif

#ifndef SPAMC_BINARY
#define SPAMC_BINARY "/usr/bin/spamc"
#endif

#ifndef SPAMD_BINARY
#define SPAMD_BINARY "/usr/bin/spamd"
#endif

/* For starting our own daemon. */
#define DAEMON_MAX_RETRIES 100
#define DAEMON_RETRY_DELAY 0.05  /* seconds */

#define SPAM_ASSASSIN_EXIT_STATUS_SUCCESS	0
#define SPAM_ASSASSIN_EXIT_STATUS_ERROR		-1

typedef struct _ESpamAssassin ESpamAssassin;
typedef struct _ESpamAssassinClass ESpamAssassinClass;

struct _ESpamAssassin {
	EMailJunkFilter parent;

	GMutex *socket_path_mutex;

	gchar *pid_file;
	gchar *socket_path;
	gchar *spamc_binary;
	gchar *spamd_binary;
	gint version;

	gboolean local_only;
	gboolean use_daemon;
	gboolean version_set;

	/* spamc/spamd state */
	gboolean spamd_tested;
	gboolean spamd_using_allow_tell;
	gboolean system_spamd_available;
	gboolean use_spamc;
};

struct _ESpamAssassinClass {
	EMailJunkFilterClass parent_class;
};

enum {
	PROP_0,
	PROP_LOCAL_ONLY,
	PROP_SPAMC_BINARY,
	PROP_SPAMD_BINARY,
	PROP_SOCKET_PATH,
	PROP_USE_DAEMON
};

/* Module Entry Points */
void e_module_load (GTypeModule *type_module);
void e_module_unload (GTypeModule *type_module);

/* Forward Declarations */
GType e_spam_assassin_get_type (void);
static void e_spam_assassin_interface_init (CamelJunkFilterInterface *interface);

G_DEFINE_DYNAMIC_TYPE_EXTENDED (
	ESpamAssassin,
	e_spam_assassin,
	E_TYPE_MAIL_JUNK_FILTER, 0,
	G_IMPLEMENT_INTERFACE_DYNAMIC (
		CAMEL_TYPE_JUNK_FILTER,
		e_spam_assassin_interface_init))

#ifdef G_OS_UNIX
static void
spam_assassin_cancelled_cb (GCancellable *cancellable,
                            GPid *pid)
{
	/* XXX On UNIX-like systems we can safely assume a GPid is the
	 *     process ID and use it to terminate the process via signal. */
	kill (*pid, SIGTERM);
}
#endif

static void
spam_assassin_exited_cb (GPid *pid,
                         gint status,
                         gpointer user_data)
{
	struct {
		GMainLoop *loop;
		gint exit_code;
	} *source_data = user_data;

	if (WIFEXITED (status))
		source_data->exit_code = WEXITSTATUS (status);
	else
		source_data->exit_code = SPAM_ASSASSIN_EXIT_STATUS_ERROR;

	g_main_loop_quit (source_data->loop);
}

static gint
spam_assassin_command_full (const gchar **argv,
                            CamelMimeMessage *message,
                            const gchar *input_data,
                            GByteArray *output_buffer,
                            gboolean wait_for_termination,
                            GCancellable *cancellable,
                            GError **error)
{
	GMainContext *context;
	GSpawnFlags flags = 0;
	GSource *source;
	GPid child_pid;
	gint standard_input;
	gint standard_output;
	gulong handler_id = 0;
	gboolean success;

	struct {
		GMainLoop *loop;
		gint exit_code;
	} source_data;

	if (wait_for_termination)
		flags |= G_SPAWN_DO_NOT_REAP_CHILD;
	if (output_buffer == NULL)
		flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
	flags |= G_SPAWN_STDERR_TO_DEV_NULL;

	/* Spawn SpamAssassin with an open stdin pipe. */
	success = g_spawn_async_with_pipes (
		NULL,
		(gchar **) argv,
		NULL,
		flags,
		NULL, NULL,
		&child_pid,
		&standard_input,
		(output_buffer != NULL) ? &standard_output : NULL,
		NULL,
		error);

	if (!success) {
		gchar *command_line;

		command_line = g_strjoinv (" ", (gchar **) argv);
		g_prefix_error (
			error, _("Failed to spawn SpamAssassin (%s): "),
			command_line);
		g_free (command_line);

		return SPAM_ASSASSIN_EXIT_STATUS_ERROR;
	}

	if (message != NULL) {
		CamelStream *stream;
		gssize bytes_written;

		/* Stream the CamelMimeMessage to SpamAssassin. */
		stream = camel_stream_fs_new_with_fd (standard_input);
		bytes_written = camel_data_wrapper_write_to_stream_sync (
			CAMEL_DATA_WRAPPER (message),
			stream, cancellable, error);
		success = (bytes_written >= 0) &&
			(camel_stream_close (stream, cancellable, error) == 0);
		g_object_unref (stream);

		if (!success) {
			g_spawn_close_pid (child_pid);
			g_prefix_error (
				error, _("Failed to stream mail "
				"message content to SpamAssassin: "));
			return SPAM_ASSASSIN_EXIT_STATUS_ERROR;
		}

	} else if (input_data != NULL) {
		gssize bytes_written;

		/* Write raw data directly to SpamAssassin. */
		bytes_written = camel_write (
			standard_input, input_data,
			strlen (input_data), cancellable, error);
		success = (bytes_written >= 0);

		close (standard_input);

		if (!success) {
			g_spawn_close_pid (child_pid);
			g_prefix_error (
				error, _("Failed to write '%s' "
				"to SpamAssassin: "), input_data);
			return SPAM_ASSASSIN_EXIT_STATUS_ERROR;
		}
	}

	if (output_buffer != NULL) {
		CamelStream *input_stream;
		CamelStream *output_stream;
		gssize bytes_written;

		input_stream = camel_stream_fs_new_with_fd (standard_output);

		output_stream = camel_stream_mem_new ();
		camel_stream_mem_set_byte_array (
			CAMEL_STREAM_MEM (output_stream), output_buffer);

		bytes_written = camel_stream_write_to_stream (
			input_stream, output_stream, cancellable, error);
		g_byte_array_append (output_buffer, (guint8 *) "", 1);
		success = (bytes_written >= 0);

		g_object_unref (input_stream);
		g_object_unref (output_stream);

		if (!success) {
			g_spawn_close_pid (child_pid);
			g_prefix_error (
				error, _("Failed to read "
				"output from SpamAssassin: "));
			return SPAM_ASSASSIN_EXIT_STATUS_ERROR;
		}
	}

	/* XXX I'm not sure if we should call g_spawn_close_pid()
	 *     here or not.  Only really matters on Windows anyway. */
	if (!wait_for_termination)
		return 0;

	/* Wait for the SpamAssassin process to terminate
	 * using GLib's main loop for better portability. */

	context = g_main_context_new ();

	source = g_child_watch_source_new (child_pid);
	g_source_set_callback (
		source, (GSourceFunc)
		spam_assassin_exited_cb,
		&source_data, NULL);
	g_source_attach (source, context);
	g_source_unref (source);

	source_data.loop = g_main_loop_new (context, TRUE);
	source_data.exit_code = 0;

#ifdef G_OS_UNIX
	if (G_IS_CANCELLABLE (cancellable))
		handler_id = g_cancellable_connect (
			cancellable,
			G_CALLBACK (spam_assassin_cancelled_cb),
			&child_pid, (GDestroyNotify) NULL);
#endif

	g_main_loop_run (source_data.loop);

	if (handler_id > 0)
		g_cancellable_disconnect (cancellable, handler_id);

	g_main_loop_unref (source_data.loop);
	source_data.loop = NULL;

	g_main_context_unref (context);

	/* Clean up. */

	g_spawn_close_pid (child_pid);

	if (g_cancellable_set_error_if_cancelled (cancellable, error))
		source_data.exit_code = SPAM_ASSASSIN_EXIT_STATUS_ERROR;

	else if (source_data.exit_code == SPAM_ASSASSIN_EXIT_STATUS_ERROR)
		g_set_error_literal (
			error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
			_("SpamAssassin either crashed or "
			  "failed to process a mail message"));

	return source_data.exit_code;
}

static gint
spam_assassin_command (const gchar **argv,
                       CamelMimeMessage *message,
                       const gchar *input_data,
                       GCancellable *cancellable,
                       GError **error)
{
	return spam_assassin_command_full (
		argv, message, input_data, NULL, TRUE, cancellable, error);
}

static gboolean
spam_assassin_get_local_only (ESpamAssassin *extension)
{
	return extension->local_only;
}

static void
spam_assassin_set_local_only (ESpamAssassin *extension,
                              gboolean local_only)
{
	extension->local_only = local_only;

	g_object_notify (G_OBJECT (extension), "local-only");
}

static const gchar *
spam_assassin_get_spamc_binary (ESpamAssassin *extension)
{
	return extension->spamc_binary;
}

static void
spam_assassin_set_spamc_binary (ESpamAssassin *extension,
                                const gchar *spamc_binary)
{
	g_free (extension->spamc_binary);
	extension->spamc_binary = g_strdup (spamc_binary);

	g_object_notify (G_OBJECT (extension), "spamc-binary");
}

static const gchar *
spam_assassin_get_spamd_binary (ESpamAssassin *extension)
{
	return extension->spamd_binary;
}

static void
spam_assassin_set_spamd_binary (ESpamAssassin *extension,
                                const gchar *spamd_binary)
{
	g_free (extension->spamd_binary);
	extension->spamd_binary = g_strdup (spamd_binary);

	g_object_notify (G_OBJECT (extension), "spamd-binary");
}

static const gchar *
spam_assassin_get_socket_path (ESpamAssassin *extension)
{
	return extension->socket_path;
}

static void
spam_assassin_set_socket_path (ESpamAssassin *extension,
                               const gchar *socket_path)
{
	g_free (extension->socket_path);
	extension->socket_path = g_strdup (socket_path);

	g_object_notify (G_OBJECT (extension), "socket-path");
}

static gboolean
spam_assassin_get_use_daemon (ESpamAssassin *extension)
{
	return extension->use_daemon;
}

static void
spam_assassin_set_use_daemon (ESpamAssassin *extension,
                              gboolean use_daemon)
{
	extension->use_daemon = use_daemon;

	g_object_notify (G_OBJECT (extension), "use-daemon");
}

static gboolean
spam_assassin_get_version (ESpamAssassin *extension,
                           gint *spam_assassin_version,
                           GCancellable *cancellable,
                           GError **error)
{
	GByteArray *output_buffer;
	gint exit_code;
	guint ii;

	const gchar *argv[] = {
		SA_LEARN_BINARY,
		"--version",
		NULL
	};

	if (extension->version_set) {
		if (spam_assassin_version != NULL)
			*spam_assassin_version = extension->version;
		return TRUE;
	}

	output_buffer = g_byte_array_new ();

	exit_code = spam_assassin_command_full (
		argv, NULL, NULL, output_buffer, TRUE, cancellable, error);

	if (exit_code != 0) {
		g_byte_array_free (output_buffer, TRUE);
		return FALSE;
	}

	for (ii = 0; ii < output_buffer->len; ii++) {
		if (g_ascii_isdigit (output_buffer->data[ii])) {
			guint8 ch = output_buffer->data[ii];
			extension->version = (ch - '0');
			extension->version_set = TRUE;
			break;
		}
	}

	if (spam_assassin_version != NULL)
		*spam_assassin_version = extension->version;

	g_byte_array_free (output_buffer, TRUE);

	return TRUE;
}

static void
spam_assassin_test_spamd_allow_tell (ESpamAssassin *extension)
{
	gint exit_code;
	GError *error = NULL;

	const gchar *argv[] = {
		SPAMC_BINARY,
		"--learntype=forget",
		NULL
	};

	/* Check if spamd is running with --allow-tell. */

	exit_code = spam_assassin_command (argv, NULL, "\n", NULL, &error);
	extension->spamd_using_allow_tell = (exit_code == 0);

	if (error != NULL) {
		g_warning ("%s", error->message);
		g_error_free (error);
	}
}

static gboolean
spam_assassin_test_spamd_running (ESpamAssassin *extension,
                                  gboolean system_spamd)
{
	const gchar *argv[5];
	gint exit_code;
	gint ii = 0;
	GError *error = NULL;

	g_mutex_lock (extension->socket_path_mutex);

	argv[ii++] = extension->spamc_binary;
	argv[ii++] = "--no-safe-fallback";
	if (!system_spamd) {
		argv[ii++] = "--socket";
		argv[ii++] = extension->socket_path;
	}
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command (
		argv, NULL, "From test@127.0.0.1", NULL, &error);

	if (error != NULL) {
		g_warning ("%s", error->message);
		g_error_free (error);
	}

	g_mutex_unlock (extension->socket_path_mutex);

	return (exit_code == 0);
}

static void
spam_assassin_kill_our_own_daemon (ESpamAssassin *extension)
{
	gint pid;
	gchar *contents = NULL;
	GError *error = NULL;

	g_mutex_lock (extension->socket_path_mutex);

	g_free (extension->socket_path);
	extension->socket_path = NULL;

	g_mutex_unlock (extension->socket_path_mutex);

	if (extension->pid_file == NULL)
		return;

	g_file_get_contents (extension->pid_file, &contents, NULL, &error);

	if (error != NULL) {
		g_warn_if_fail (contents == NULL);
		g_warning ("%s", error->message);
		g_error_free (error);
		return;
	}

	g_return_if_fail (contents != NULL);

	pid = atoi (contents);
	g_free (contents);

	if (pid > 0 && kill (pid, SIGTERM) == 0)
		waitpid (pid, NULL, 0);
}

static void
spam_assassin_prepare_for_quit (EShell *shell,
                                EActivity *activity,
                                ESpamAssassin *extension)
{
	spam_assassin_kill_our_own_daemon (extension);
}

static gboolean
spam_assassin_start_our_own_daemon (ESpamAssassin *extension)
{
	const gchar *argv[8];
	gchar *pid_file;
	gchar *socket_path;
	gboolean started = FALSE;
	gint exit_code;
	gint ii = 0;
	GError *error = NULL;

	g_mutex_lock (extension->socket_path_mutex);

	pid_file = e_mktemp ("spamd-pid-file-XXXXXX");
	socket_path = e_mktemp ("spamd-socket-path-XXXXXX");

	argv[ii++] = extension->spamd_binary;
	argv[ii++] = "--socketpath";
	argv[ii++] = socket_path;

	if (spam_assassin_get_local_only (extension))
		argv[ii++] = "--local";

	argv[ii++] = "--max-children=1";
	argv[ii++] = "--pidfile";
	argv[ii++] = pid_file;
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command_full (
		argv, NULL, NULL, NULL, FALSE, NULL, &error);

	if (error != NULL) {
		g_warning ("%s", error->message);
		g_error_free (error);
		goto exit;
	}

	if (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS) {
		/* Wait for the socket path to appear. */
		for (ii = 0; ii < DAEMON_MAX_RETRIES; ii++) {
			if (g_file_test (socket_path, G_FILE_TEST_EXISTS)) {
				started = TRUE;
				break;
			}
			g_usleep (DAEMON_RETRY_DELAY * G_USEC_PER_SEC);
		}
	}

	/* Set these directly to avoid emitting "notify" signals. */
	if (started) {
		g_free (extension->pid_file);
		extension->pid_file = pid_file;
		pid_file = NULL;

		g_free (extension->socket_path);
		extension->socket_path = socket_path;
		socket_path = NULL;

		/* XXX EMailSession is too prone to reference leaks to leave
		 *     this for our finalize() method.  We want to be sure to
		 *     kill the spamd process we started when Evolution shuts
		 *     down, so connect to an EShell signal instead. */
		g_signal_connect (
			e_shell_get_default (), "prepare-for-quit",
			G_CALLBACK (spam_assassin_prepare_for_quit),
			extension);
	}

exit:
	g_free (pid_file);
	g_free (socket_path);

	g_mutex_unlock (extension->socket_path_mutex);

	return started;
}

static void
spam_assassin_test_spamd (ESpamAssassin *extension)
{
	const gchar *spamd_binary;
	gboolean try_system_spamd;

	/* XXX SpamAssassin could really benefit from a D-Bus interface
	 *     these days.  These tests are just needlessly painful for
	 *     clients trying to talk to an already-running spamd. */

	extension->use_spamc = FALSE;
	spamd_binary = extension->spamd_binary;
	try_system_spamd = (g_strcmp0 (spamd_binary, SPAMD_BINARY) == 0);

	if (extension->local_only && try_system_spamd) {
		gint exit_code;

		/* Run a shell command to check for a running
		 * spamd process with a -L/--local option or a
		 * -p/--port option. */

		const gchar *argv[] = {
			"/bin/sh",
			"-c",
			"ps ax | grep -v grep | "
			"grep -E 'spamd.*(\\-L|\\-\\-local)' | "
			"grep -E -v '\\ \\-p\\ |\\ \\-\\-port\\ '",
			NULL
		};

		exit_code = spam_assassin_command (
			argv, NULL, NULL, NULL, NULL);
		try_system_spamd = (exit_code == 0);
	}

	/* Try to use the system spamd first. */
	if (try_system_spamd) {
		if (spam_assassin_test_spamd_running (extension, TRUE)) {
			extension->use_spamc = TRUE;
			extension->system_spamd_available = TRUE;
		}
	}

	/* If there's no system spamd running, try
	 * to use one with a user specified socket. */
	if (!extension->use_spamc && extension->socket_path != NULL) {
		if (spam_assassin_test_spamd_running (extension, FALSE)) {
			extension->use_spamc = TRUE;
			extension->system_spamd_available = FALSE;
		}
	}

	/* Still unsuccessful?  Try to start our own spamd. */
	if (!extension->use_spamc) {
		extension->use_spamc =
			spam_assassin_start_our_own_daemon (extension) &&
			spam_assassin_test_spamd_running (extension, FALSE);
	}
}

static void
spam_assassin_set_property (GObject *object,
                            guint property_id,
                            const GValue *value,
                            GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_LOCAL_ONLY:
			spam_assassin_set_local_only (
				E_SPAM_ASSASSIN (object),
				g_value_get_boolean (value));
			return;

		case PROP_SPAMC_BINARY:
			spam_assassin_set_spamc_binary (
				E_SPAM_ASSASSIN (object),
				g_value_get_string (value));
			return;

		case PROP_SPAMD_BINARY:
			spam_assassin_set_spamd_binary (
				E_SPAM_ASSASSIN (object),
				g_value_get_string (value));
			return;

		case PROP_SOCKET_PATH:
			spam_assassin_set_socket_path (
				E_SPAM_ASSASSIN (object),
				g_value_get_string (value));
			return;

		case PROP_USE_DAEMON:
			spam_assassin_set_use_daemon (
				E_SPAM_ASSASSIN (object),
				g_value_get_boolean (value));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
spam_assassin_get_property (GObject *object,
                            guint property_id,
                            GValue *value,
                            GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_LOCAL_ONLY:
			g_value_set_boolean (
				value, spam_assassin_get_local_only (
				E_SPAM_ASSASSIN (object)));
			return;

		case PROP_SPAMC_BINARY:
			g_value_set_string (
				value, spam_assassin_get_spamc_binary (
				E_SPAM_ASSASSIN (object)));
			return;

		case PROP_SPAMD_BINARY:
			g_value_set_string (
				value, spam_assassin_get_spamd_binary (
				E_SPAM_ASSASSIN (object)));
			return;

		case PROP_SOCKET_PATH:
			g_value_set_string (
				value, spam_assassin_get_socket_path (
				E_SPAM_ASSASSIN (object)));
			return;

		case PROP_USE_DAEMON:
			g_value_set_boolean (
				value, spam_assassin_get_use_daemon (
				E_SPAM_ASSASSIN (object)));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
spam_assassin_finalize (GObject *object)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (object);

	g_mutex_free (extension->socket_path_mutex);

	g_free (extension->pid_file);
	g_free (extension->socket_path);
	g_free (extension->spamc_binary);
	g_free (extension->spamd_binary);

	/* Chain up to parent's finalize() method. */
	G_OBJECT_CLASS (e_spam_assassin_parent_class)->finalize (object);
}

static gboolean
spam_assassin_available (EMailJunkFilter *junk_filter)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (junk_filter);
	gboolean available;
	GError *error = NULL;

	available = spam_assassin_get_version (extension, NULL, NULL, &error);

	/* XXX These tests block like crazy so maybe this isn't the best
	 *     place to be doing this, but the first available() call is
	 *     done at startup before the UI is shown.  So hopefully the
	 *     delay will not be noticeable. */
	if (available && extension->use_daemon && !extension->spamd_tested) {
		extension->spamd_tested = TRUE;
		spam_assassin_test_spamd (extension);
		spam_assassin_test_spamd_allow_tell (extension);
	}

	if (error != NULL) {
		g_warning ("%s", error->message);
		g_error_free (error);
	}

	return available;
}

static GtkWidget *
spam_assassin_new_config_widget (EMailJunkFilter *junk_filter)
{
	GtkWidget *box;
	GtkWidget *widget;
	GtkWidget *container;
	gchar *markup;

	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);

	markup = g_markup_printf_escaped (
		"<b>%s</b>", _("SpamAssassin Options"));
	widget = gtk_label_new (markup);
	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
	gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
	gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);
	g_free (markup);

	widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
	gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);

	container = widget;

	widget = gtk_check_button_new_with_mnemonic (
		_("I_nclude remote tests"));
	gtk_widget_set_margin_left (widget, 12);
	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);

	g_object_bind_property (
		junk_filter, "local-only",
		widget, "active",
		G_BINDING_BIDIRECTIONAL |
		G_BINDING_SYNC_CREATE |
		G_BINDING_INVERT_BOOLEAN);

	markup = g_markup_printf_escaped (
		"<small>%s</small>",
		_("This will make SpamAssassin more reliable, but slower."));
	widget = gtk_label_new (markup);
	gtk_widget_set_margin_left (widget, 36);
	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
	gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);
	g_free (markup);

	return box;
}

static gboolean
spam_assassin_classify (CamelJunkFilter *junk_filter,
                        CamelMimeMessage *message,
                        CamelJunkStatus *status,
                        GCancellable *cancellable,
                        GError **error)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (junk_filter);
	const gchar *argv[7];
	gboolean using_spamc;
	gint exit_code;
	gint ii = 0;

	g_mutex_lock (extension->socket_path_mutex);

	using_spamc = (extension->use_spamc && extension->use_daemon);

	if (using_spamc) {
		argv[ii++] = extension->spamc_binary;
		argv[ii++] = "--check";
		argv[ii++] = "--timeout=60";
		if (!extension->system_spamd_available) {
			argv[ii++] = "--socket";
			argv[ii++] = extension->socket_path;
		}
	} else {
		argv[ii++] = SPAMASSASSIN_BINARY;
		argv[ii++] = "--exit-code";
		if (extension->local_only)
			argv[ii++] = "--local";
	}
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command (
		argv, message, NULL, cancellable, error);

	/* For either program, exit code 0 means the message is ham. */
	if (exit_code == 0)
		*status = CAMEL_JUNK_STATUS_MESSAGE_IS_NOT_JUNK;

	/* spamassassin(1) only specifies zero and non-zero exit codes. */
	else if (!using_spamc)
		*status = CAMEL_JUNK_STATUS_MESSAGE_IS_JUNK;

	/* Whereas spamc(1) explicitly states exit code 1 means spam. */
	else if (exit_code == 1)
		*status = CAMEL_JUNK_STATUS_MESSAGE_IS_JUNK;

	/* Consider any other spamc(1) exit code to be inconclusive
	 * since it most likely failed to process the message. */
	else
		*status = CAMEL_JUNK_STATUS_INCONCLUSIVE;

	/* Check that the return value and GError agree. */
	if (exit_code != SPAM_ASSASSIN_EXIT_STATUS_ERROR)
		g_warn_if_fail (error == NULL || *error == NULL);
	else
		g_warn_if_fail (error == NULL || *error != NULL);

	g_mutex_unlock (extension->socket_path_mutex);

	return (exit_code != SPAM_ASSASSIN_EXIT_STATUS_ERROR);
}

static gboolean
spam_assassin_learn_junk (CamelJunkFilter *junk_filter,
                          CamelMimeMessage *message,
                          GCancellable *cancellable,
                          GError **error)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (junk_filter);
	const gchar *argv[5];
	gint exit_code;
	gint ii = 0;

	if (extension->spamd_using_allow_tell) {
		argv[ii++] = extension->spamc_binary;
		argv[ii++] = "--learntype=spam";
	} else {
		argv[ii++] = SA_LEARN_BINARY;
		argv[ii++] = "--spam";
		if (extension->version >= 3)
			argv[ii++] = "--no-sync";
		else
			argv[ii++] = "--no-rebuild";
		if (extension->local_only)
			argv[ii++] = "--local";
	}
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command (
		argv, message, NULL, cancellable, error);

	/* Check that the return value and GError agree. */
	if (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS)
		g_warn_if_fail (error == NULL || *error == NULL);
	else
		g_warn_if_fail (error == NULL || *error != NULL);

	return (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS);
}

static gboolean
spam_assassin_learn_not_junk (CamelJunkFilter *junk_filter,
                              CamelMimeMessage *message,
                              GCancellable *cancellable,
                              GError **error)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (junk_filter);
	const gchar *argv[5];
	gint exit_code;
	gint ii = 0;

	if (extension->spamd_using_allow_tell) {
		argv[ii++] = extension->spamc_binary;
		argv[ii++] = "--learntype=ham";
	} else {
		argv[ii++] = SA_LEARN_BINARY;
		argv[ii++] = "--ham";
		if (extension->version >= 3)
			argv[ii++] = "--no-sync";
		else
			argv[ii++] = "--no-rebuild";
		if (extension->local_only)
			argv[ii++] = "--local";
	}
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command (
		argv, message, NULL, cancellable, error);

	/* Check that the return value and GError agree. */
	if (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS)
		g_warn_if_fail (error == NULL || *error == NULL);
	else
		g_warn_if_fail (error == NULL || *error != NULL);

	return (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS);
}

static gboolean
spam_assassin_synchronize (CamelJunkFilter *junk_filter,
                           GCancellable *cancellable,
                           GError **error)
{
	ESpamAssassin *extension = E_SPAM_ASSASSIN (junk_filter);
	const gchar *argv[4];
	gint exit_code;
	gint ii = 0;

	/* If we're using a spamd that allows learning,
	 * there's no need to synchronize anything. */
	if (extension->spamd_using_allow_tell)
		return TRUE;

	argv[ii++] = SA_LEARN_BINARY;
	if (extension->version >= 3)
		argv[ii++] = "--sync";
	else
		argv[ii++] = "--rebuild";
	if (extension->local_only)
		argv[ii++] = "--local";
	argv[ii] = NULL;

	g_assert (ii < G_N_ELEMENTS (argv));

	exit_code = spam_assassin_command (
		argv, NULL, NULL, cancellable, error);

	/* Check that the return value and GError agree. */
	if (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS)
		g_warn_if_fail (error == NULL || *error == NULL);
	else
		g_warn_if_fail (error == NULL || *error != NULL);

	return (exit_code == SPAM_ASSASSIN_EXIT_STATUS_SUCCESS);
}

static void
e_spam_assassin_class_init (ESpamAssassinClass *class)
{
	GObjectClass *object_class;
	EMailJunkFilterClass *junk_filter_class;

	object_class = G_OBJECT_CLASS (class);
	object_class->set_property = spam_assassin_set_property;
	object_class->get_property = spam_assassin_get_property;
	object_class->finalize = spam_assassin_finalize;

	junk_filter_class = E_MAIL_JUNK_FILTER_CLASS (class);
	junk_filter_class->filter_name = "SpamAssassin";
	junk_filter_class->display_name = _("SpamAssassin");
	junk_filter_class->available = spam_assassin_available;
	junk_filter_class->new_config_widget = spam_assassin_new_config_widget;

	g_object_class_install_property (
		object_class,
		PROP_LOCAL_ONLY,
		g_param_spec_boolean (
			"local-only",
			"Local Only",
			"Do not use tests requiring DNS lookups",
			TRUE,
			G_PARAM_READWRITE));

	g_object_class_install_property (
		object_class,
		PROP_SPAMC_BINARY,
		g_param_spec_string (
			"spamc-binary",
			"spamc Binary",
			"File path for the spamc binary",
			NULL,
			G_PARAM_READWRITE));

	g_object_class_install_property (
		object_class,
		PROP_SPAMD_BINARY,
		g_param_spec_string (
			"spamd-binary",
			"spamd Binary",
			"File path for the spamd binary",
			NULL,
			G_PARAM_READWRITE));

	g_object_class_install_property (
		object_class,
		PROP_SOCKET_PATH,
		g_param_spec_string (
			"socket-path",
			"Socket Path",
			"Socket path for a SpamAssassin daemon",
			NULL,
			G_PARAM_READWRITE));

	g_object_class_install_property (
		object_class,
		PROP_USE_DAEMON,
		g_param_spec_boolean (
			"use-daemon",
			"Use Daemon",
			"Whether to use a SpamAssassin daemon",
			FALSE,
			G_PARAM_READWRITE));
}

static void
e_spam_assassin_class_finalize (ESpamAssassinClass *class)
{
}

static void
e_spam_assassin_interface_init (CamelJunkFilterInterface *interface)
{
	interface->classify = spam_assassin_classify;
	interface->learn_junk = spam_assassin_learn_junk;
	interface->learn_not_junk = spam_assassin_learn_not_junk;
	interface->synchronize = spam_assassin_synchronize;
}

static void
e_spam_assassin_init (ESpamAssassin *extension)
{
	GSettings *settings;

	extension->socket_path_mutex = g_mutex_new ();

	/* XXX Once we move to GSettings these probably don't
	 *     need to be properties anymore.  GConfBridge is
	 *     just easier to deal with than GConfClient. */

	settings = g_settings_new ("org.gnome.evolution.spamassassin");

	g_settings_bind (
		settings, "local-only",
		G_OBJECT (extension), "local-only",
		G_SETTINGS_BIND_DEFAULT);
	g_settings_bind (
		settings, "spamc-binary",
		G_OBJECT (extension), "spamc-binary",
		G_SETTINGS_BIND_DEFAULT);
	g_settings_bind (
		settings, "spamd-binary",
		G_OBJECT (extension), "spamd-binary",
		G_SETTINGS_BIND_DEFAULT);
	g_settings_bind (
		settings, "socket-path",
		G_OBJECT (extension), "socket-path",
		G_SETTINGS_BIND_DEFAULT);
	g_settings_bind (
		settings, "use-daemon",
		G_OBJECT (extension), "use-daemon",
		G_SETTINGS_BIND_DEFAULT);

	g_object_unref (settings);

	if (extension->spamc_binary == NULL)
		extension->spamc_binary = g_strdup (SPAMC_BINARY);

	if (extension->spamd_binary == NULL)
		extension->spamd_binary = g_strdup (SPAMD_BINARY);
}

G_MODULE_EXPORT void
e_module_load (GTypeModule *type_module)
{
	e_spam_assassin_register_type (type_module);
}

G_MODULE_EXPORT void
e_module_unload (GTypeModule *type_module)
{
}