aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJohannes Berg <johannes@sipsolutions.net>2008-04-26 20:34:06 +0200
committerJohannes Berg <johannes@sipsolutions.net>2008-04-26 20:34:06 +0200
commitc3a343290773d6e22a08946cb2ef80b1b8fe8a06 (patch)
tree50d4a6165788c15a943f420ae31001ed01eeba69
parentfd7d4c8a31604c9888aed9bc47b1218a7e4495f8 (diff)
downloaddovecot-antispam-c3a343290773d6e22a08946cb2ef80b1b8fe8a06.tar.gz
dovecot-antispam-c3a343290773d6e22a08946cb2ef80b1b8fe8a06.tar.xz
dovecot-antispam-c3a343290773d6e22a08946cb2ef80b1b8fe8a06.zip
add 1.1 storage. probably doesn't work
-rw-r--r--antispam-storage-1.1.c509
1 files changed, 509 insertions, 0 deletions
diff --git a/antispam-storage-1.1.c b/antispam-storage-1.1.c
new file mode 100644
index 0000000..372f3a6
--- /dev/null
+++ b/antispam-storage-1.1.c
@@ -0,0 +1,509 @@
+/*
+ * Storage implementation for antispam plugin
+ * Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * Derived from Quota plugin:
+ * Copyright (C) 2005 Timo Sirainen
+ */
+
+#include <sys/stat.h>
+
+#include "lib.h"
+#include "array.h"
+#include "istream.h"
+#include "mail-search.h"
+#include "mail-index.h"
+#include "mailbox-list-private.h"
+#include "mail-storage-private.h"
+
+#include "antispam-plugin.h"
+
+#define ANTISPAM_CONTEXT(obj) \
+ MODULE_CONTEXT(obj, antispam_storage_module)
+#define ANTISPAM_MAIL_CONTEXT(obj) \
+ MODULE_CONTEXT(obj, antispam_mail_module)
+
+static MODULE_CONTEXT_DEFINE_INIT(antispam_storage_module,
+ &mail_storage_module_register);
+static MODULE_CONTEXT_DEFINE_INIT(antispam_mail_module,
+ &mail_module_register);
+
+
+struct antispam_mail_storage {
+ union mail_storage_module_context module_ctx;
+ struct antispam *antispam;
+};
+
+enum mailbox_move_type {
+ MMT_APPEND,
+ MMT_UNINTERESTING,
+ MMT_TO_CLEAN,
+ MMT_TO_SPAM,
+};
+
+struct antispam_internal_context {
+ union mailbox_transaction_module_context module_ctx;
+ struct antispam_transaction_context *backendctx;
+ struct mail *mail;
+};
+
+enum classification move_to_class(enum mailbox_move_type tp)
+{
+ switch (tp) {
+ case MMT_TO_CLEAN:
+ return CLASS_NOTSPAM;
+ case MMT_TO_SPAM:
+ return CLASS_SPAM;
+ default:
+ i_assert(0);
+ }
+}
+
+struct antispam_mailbox {
+ union mailbox_module_context module_ctx;
+
+ enum mailbox_move_type movetype;
+
+ /* used to check if copy was implemented with save */
+ unsigned int save_hack:1;
+};
+
+struct antispam_mail {
+ union mail_module_context module_ctx;
+};
+
+static uint32_t antispam_storage_module_id = 0;
+static bool antispam_storage_module_id_set = FALSE;
+
+static int
+antispam_copy(struct mailbox_transaction_context *t, struct mail *mail,
+ enum mail_flags flags, struct mail_keywords *keywords,
+ struct mail *dest_mail)
+{
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(t->box);
+ struct antispam_internal_context *ast = ANTISPAM_CONTEXT(t);
+ struct mail *copy_dest_mail;
+ int ret;
+ bool src_trash, dst_trash;
+
+ if (dest_mail != NULL)
+ copy_dest_mail = dest_mail;
+ else
+ copy_dest_mail = mail_alloc(t, MAIL_FETCH_PHYSICAL_SIZE, NULL);
+
+ i_assert(mail->box);
+
+ asbox->save_hack = FALSE;
+ asbox->movetype = MMT_UNINTERESTING;
+
+ if (mailbox_is_unsure(t->box)) {
+ mail_storage_set_error(t->box->storage, MAIL_ERROR_NOTPOSSIBLE,
+ "Cannot copy to unsure folder");
+ return -1;
+ }
+
+ src_trash = mailbox_is_trash(mail->box);
+ dst_trash = mailbox_is_trash(t->box);
+
+ debug_verbose("mail copy: from trash: %d, to trash: %d\n",
+ src_trash, dst_trash);
+
+ if (!src_trash && !dst_trash) {
+ bool src_spam = mailbox_is_spam(mail->box);
+ bool dst_spam = mailbox_is_spam(t->box);
+ bool src_unsu = mailbox_is_unsure(mail->box);
+
+ debug_verbose("mail copy: src spam: %d, dst spam: %d,"
+ " src unsure: %d\n",
+ src_spam, dst_spam, src_unsu);
+
+ if ((src_spam || src_unsu) && !dst_spam)
+ asbox->movetype = MMT_TO_CLEAN;
+ else if ((!src_spam || src_unsu) && dst_spam)
+ asbox->movetype = MMT_TO_SPAM;
+ }
+
+ if (asbox->module_ctx.super.copy(t, mail, flags, keywords, copy_dest_mail) < 0)
+ return -1;
+
+ /*
+ * If copying used saving internally, we already have treated the mail
+ */
+ if (asbox->save_hack || asbox->movetype == MMT_UNINTERESTING)
+ ret = 0;
+ else
+ ret = backend_handle_mail(t, ast->backendctx, copy_dest_mail,
+ move_to_class(asbox->movetype));
+
+ /*
+ * Both save_hack and movetype are only valid within a copy operation,
+ * i.e. they are now invalid. Because, in theory, another operation
+ * could be done after mailbox_open(), we need to reset the movetype
+ * variable here. save_hack doesn't need to be reset because it is
+ * only ever set within the save function and tested within this copy
+ * function after being reset at the beginning of the copy, movetype
+ * however is tested within the save_finish() function and a subsequent
+ * save to the mailbox should not invoke the backend.
+ */
+ asbox->movetype = MMT_APPEND;
+
+ if (copy_dest_mail != dest_mail)
+ mail_free(&copy_dest_mail);
+ return ret;
+}
+
+static int antispam_save_init(struct mailbox_transaction_context *t,
+ enum mail_flags flags,
+ struct mail_keywords *keywords,
+ time_t received_date, int timezone_offset,
+ const char *from_envelope, struct istream *input,
+ struct mail *dest_mail, struct mail_save_context **ctx_r)
+{
+ struct antispam_internal_context *ast = ANTISPAM_CONTEXT(t);
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(t->box);
+
+ if (!dest_mail && !ast->mail) {
+ ast->mail = mail_alloc(t, MAIL_FETCH_STREAM_HEADER |
+ MAIL_FETCH_STREAM_BODY, NULL);
+ dest_mail = ast->mail;
+ }
+ return asbox->module_ctx.super.save_init(t, flags, keywords, received_date,
+ timezone_offset, from_envelope,
+ input, dest_mail, ctx_r);
+}
+
+static int antispam_save_finish(struct mail_save_context *ctx)
+{
+ struct antispam_mailbox *asbox =
+ ANTISPAM_CONTEXT(ctx->transaction->box);
+ struct antispam_internal_context *ast =
+ ANTISPAM_CONTEXT(ctx->transaction);
+ struct mail *dest_mail = ast->mail;
+ int ret;
+
+ if (asbox->module_ctx.super.save_finish(ctx) < 0)
+ return -1;
+
+ asbox->save_hack = TRUE;
+
+ ret = 0;
+
+ switch (asbox->movetype) {
+ case MMT_UNINTERESTING:
+ break;
+ case MMT_APPEND:
+ /* Disallow APPENDs to UNSURE folders. */
+ if (mailbox_is_unsure(dest_mail->box)) {
+ ret = -1;
+ mail_storage_set_error(dest_mail->box->storage,
+ MAIL_ERROR_NOTPOSSIBLE,
+ "Cannot APPEND to an UNSURE folder.");
+ break;
+ } else if (mailbox_is_spam(dest_mail->box)) {
+ /*
+ * The client is APPENDing a message to a SPAM folder
+ * so we try to train the backend on it. For most of
+ * the backends, that can only succeed if the message
+ * contains appropriate information.
+ *
+ * This happens especially when offlineimap is used and
+ * the user moved a message to the SPAM folder while
+ * offline---offlineimap cannot reproduce the COPY but
+ * rather APPENDs the moved message on the next sync.
+ *
+ * This could be a bad if the spam headers were not
+ * generated on our server, but since the user can
+ * always APPEND to another folder and then COPY to a
+ * SPAM folder backends need to be prepared for cases
+ * like this anyway. With dspam, for example, the worst
+ * that can happen is that the APPEND fails with a
+ * training error from dspam.
+ *
+ * Unfortunately, we cannot handle the cases where
+ * (1) the user moved a message from one folder that
+ * contains SPAM to another folder containing SPAM
+ * (2) the user moved a message out of the SPAM folder
+ * (3) the user recovered a message from trash
+ *
+ * Because of these limitations, this behaviour needs
+ * to be enabled with an option.
+ */
+ if (!antispam_can_append_to_spam) {
+ ret = -1;
+ mail_storage_set_error(
+ dest_mail->box->storage,
+ MAIL_ERROR_NOTPOSSIBLE,
+ "Cannot APPEND to a SPAM folder.");
+ break;
+ }
+ asbox->movetype = MMT_TO_SPAM;
+ /* fall through to default case to invoke backend */
+ } else {
+ /* neither UNSURE nor SPAM, regular folder */
+ break;
+ }
+ /* fall through */
+ default:
+ ret = backend_handle_mail(ctx->transaction, ast->backendctx,
+ dest_mail,
+ move_to_class(asbox->movetype));
+ }
+
+ return ret;
+}
+
+static struct antispam_transaction_context *
+antispam_transaction_begin(struct mailbox *box)
+{
+ struct antispam_transaction_context *ast;
+
+ ast = backend_start(box);
+ i_assert(ast != NULL);
+
+ return ast;
+}
+
+static void
+antispam_transaction_rollback(struct antispam_transaction_context **_ast)
+{
+ struct antispam_transaction_context *ast = *_ast;
+
+ backend_rollback(ast);
+ *_ast = NULL;
+}
+
+static int
+antispam_transaction_commit(struct mailbox_transaction_context *ctx,
+ struct antispam_transaction_context **_ast)
+{
+ struct antispam_transaction_context *ast = *_ast;
+ int ret;
+
+ ret = backend_commit(ctx, ast);
+ *_ast = NULL;
+ return ret;
+}
+
+static void
+antispam_mail_update_keywords(struct mail *mail,
+ enum modify_type modify_type,
+ struct mail_keywords *keywords)
+{
+ struct mail_private *pmail = (struct mail_private *)mail;
+ struct antispam_mail *amail = ANTISPAM_MAIL_CONTEXT(pmail);
+ unsigned int i, numkwds;
+ const ARRAY_TYPE(keywords) *idxkwd = mail_index_get_keywords(keywords->index);
+ const char *const *keyword_names = array_get(idxkwd, &numkwds);
+ const char *const *orig_keywords;
+ bool previous_spam_keyword, now_spam_keyword;
+
+ switch (modify_type) {
+ case MODIFY_ADD:
+ debug("adding keyword(s)\n");
+ break;
+ case MODIFY_REMOVE:
+ debug("removing keyword(s)\n");
+ break;
+ case MODIFY_REPLACE:
+ debug("replacing keyword(s)\n");
+ break;
+ default:
+ i_assert(0);
+ }
+
+ orig_keywords = pmail->v.get_keywords(mail);
+ if (orig_keywords) {
+ debug("original keyword list:\n");
+ while (*orig_keywords) {
+ debug(" * %s\n", *orig_keywords);
+ if (keyword_is_spam(*orig_keywords))
+ previous_spam_keyword = TRUE;
+ orig_keywords++;
+ }
+ }
+
+ debug("keyword list:\n");
+
+ for (i = 0; i < keywords->count; i++) {
+ unsigned int idx = keywords->idx[i];
+
+ i_assert(idx < numkwds);
+
+ debug(" * %s\n", keyword_names[idx]);
+
+ switch (modify_type) {
+ case MODIFY_ADD:
+ case MODIFY_REPLACE:
+ if (keyword_is_spam(keyword_names[idx]))
+ now_spam_keyword = TRUE;
+ break;
+ case MODIFY_REMOVE:
+ if (keyword_is_spam(keyword_names[idx]))
+ now_spam_keyword = FALSE;
+ break;
+ default:
+ i_assert(0);
+ }
+ }
+
+ amail->module_ctx.super.update_keywords(mail, modify_type, keywords);
+
+ debug("previous-spam, now-spam: %d, %d\n",
+ previous_spam_keyword, now_spam_keyword);
+
+ if (previous_spam_keyword != now_spam_keyword) {
+ /*
+ * Call backend here.
+ *
+ * TODO: It is not clear how to roll back the
+ * keyword change if the backend fails.
+ */
+ }
+}
+
+static void
+antispam_mail_free(struct mail *mail)
+{
+ struct mail_private *pmail = (struct mail_private *)mail;
+ struct antispam_mail *amail = ANTISPAM_MAIL_CONTEXT(pmail);
+
+ amail->module_ctx.super.free(mail);
+ i_free(amail);
+}
+
+static struct mailbox_transaction_context *
+antispam_mailbox_transaction_begin(struct mailbox *box,
+ enum mailbox_transaction_flags flags)
+{
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(box);
+ struct mailbox_transaction_context *t;
+ struct antispam_transaction_context *ast;
+ struct antispam_internal_context *aic;
+
+ t = asbox->module_ctx.super.transaction_begin(box, flags);
+ aic = i_new(struct antispam_internal_context, 1);
+ ast = antispam_transaction_begin(box);
+ aic->backendctx = ast;
+
+ MODULE_CONTEXT_SET(t, antispam_storage_module, aic);
+ return t;
+}
+
+static int
+antispam_mailbox_transaction_commit(struct mailbox_transaction_context *ctx,
+ uint32_t *uid_validity_r,
+ uint32_t *first_saved_uid_r,
+ uint32_t *last_saved_uid_r)
+{
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(ctx->box);
+ struct antispam_internal_context *ast = ANTISPAM_CONTEXT(ctx);
+
+ if (antispam_transaction_commit(ctx, &ast->backendctx) < 0) {
+ if (ast->mail)
+ mail_free(&ast->mail);
+
+ asbox->module_ctx.super.transaction_rollback(ctx);
+ return -1;
+ }
+
+ if (ast->mail)
+ mail_free(&ast->mail);
+
+ return asbox->module_ctx.super.transaction_commit(ctx, uid_validity_r,
+ first_saved_uid_r,
+ last_saved_uid_r);
+}
+
+static void
+antispam_mailbox_transaction_rollback(struct mailbox_transaction_context *ctx)
+{
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(ctx->box);
+ struct antispam_internal_context *ast = ANTISPAM_CONTEXT(ctx);
+
+ asbox->module_ctx.super.transaction_rollback(ctx);
+
+ if (ast->mail)
+ mail_free(&ast->mail);
+
+ antispam_transaction_rollback(&ast->backendctx);
+}
+
+static struct mail *
+antispam_mailbox_mail_alloc(struct mailbox_transaction_context *ctx,
+ enum mail_fetch_field wanted_fields,
+ struct mailbox_header_lookup_ctx *wanted_headers)
+{
+ struct antispam_mailbox *asbox = ANTISPAM_CONTEXT(ctx->box);
+ struct antispam_mail *amail = i_new(struct antispam_mail, 1);
+ struct mail_private *pmail;
+
+ /* XXX: is this cast the right thing to do? */
+ pmail = (struct mail_private *) asbox->module_ctx.super.mail_alloc(
+ ctx,
+ wanted_fields,
+ wanted_headers);
+
+ amail->module_ctx.super = pmail->v;
+
+ MODULE_CONTEXT_SET(pmail, antispam_mail_module, amail);
+
+ pmail->v.update_keywords = antispam_mail_update_keywords;
+ pmail->v.free = antispam_mail_free;
+
+ return (struct mail *)pmail;
+}
+
+static struct mailbox *antispam_mailbox_open(struct mail_storage *storage,
+ const char *name,
+ struct istream *input,
+ enum mailbox_open_flags flags)
+{
+ struct antispam_mail_storage *as_storage = ANTISPAM_CONTEXT(storage);
+ struct mailbox *box;
+ struct antispam_mailbox *asbox;
+
+ box = as_storage->module_ctx.super.mailbox_open(storage, name, input, flags);
+ if (box == NULL)
+ return NULL;
+
+ asbox = p_new(box->pool, struct antispam_mailbox, 1);
+ asbox->module_ctx.super = box->v;
+ asbox->save_hack = FALSE;
+ asbox->movetype = MMT_APPEND;
+
+ if (need_folder_hook) {
+ /* override save_init to override want_mail, we need that */
+ box->v.save_init = antispam_save_init;
+ box->v.save_finish = antispam_save_finish;
+ box->v.transaction_begin = antispam_mailbox_transaction_begin;
+ box->v.transaction_commit = antispam_mailbox_transaction_commit;
+ box->v.transaction_rollback = antispam_mailbox_transaction_rollback;
+ box->v.copy = antispam_copy;
+ }
+
+ if (need_keyword_hook)
+ box->v.mail_alloc = antispam_mailbox_mail_alloc;
+
+ MODULE_CONTEXT_SET(box, antispam_storage_module, asbox);
+ return box;
+}
+
+void antispam_mail_storage_created(struct mail_storage *storage)
+{
+ struct antispam_mail_storage *as_storage;
+ union mail_storage_module_context *astorage;
+
+ if (antispam_next_hook_mail_storage_created != NULL)
+ antispam_next_hook_mail_storage_created(storage);
+
+ as_storage = p_new(storage->pool, struct antispam_mail_storage, 1);
+ as_storage->module_ctx.super = storage->v;
+ storage->v.mailbox_open = antispam_mailbox_open;
+
+ if (!antispam_storage_module_id_set) {
+ antispam_storage_module_id = PLUGIN_FUNCTION(id);
+ antispam_storage_module_id_set = TRUE;
+ }
+
+ MODULE_CONTEXT_SET_SELF(storage, antispam_storage_module, astorage);
+}