aboutsummaryrefslogblamecommitdiffstats
path: root/plugin.c
blob: ddff1717df4123dbf4ed156c66d29ccb181f2ba9 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
































































































































































































































































































































































































































































                                                                                                  
#format CPLUSPLUS
/*
  dspam plugin for dovecot

  Copyright (C) 2004-2006  Johannes Berg <johannes@sipsolutions.net>
                     2006  Frank Cusack

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License Version 2 as
  published by the Free Software Foundation.

  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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

  based on the original framework http://www.dovecot.org/patches/1.0/copy_plugin.c

  Please see http://johannes.sipsolutions.net/wiki/Projects/dovecot-dspam-integration
  for more information on this code.

  To compile:
  make "plugins" directory right beside "src" in the dovecot source tree,
  copy this into there and run

  cc -fPIC -shared -Wall \
    -I../src/ \
    -I../src/lib \
    -I.. \
    -I../src/lib-storage \
    -I../src/lib-mail \
    -I../src/lib-imap \
    -I../src/imap/ \
    -DHAVE_CONFIG_H \
    -DDSPAM=\"/path/to/dspam\" \
    dspam.c -o lib_dspam.so

  (if you leave out -DDSPAM=... then /usr/bin/dspam is taken as default)

  Install the plugin in the usual dovecot module location.
*/

/*
 * If you need to ignore a trash folder, define a trash folder
 * name as follows, or alternatively give -DIGNORE_TRASH_NAME=\"Trash\" on
 * the cc command line.
 */
/*#define IGNORE_TRASH_NAME "Trash"*/

#include "common.h"
#include "str.h"
#include "strfuncs.h"
#include "commands.h"
#include "imap-search.h"
#include "lib-storage/mail-storage.h"
#include "lib/mempool.h"
#include "mail-storage.h"
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#ifdef DEBUG
#include <syslog.h>
#endif

#define SIGHEADERLINE "X-DSPAM-Signature"
#define MAXSIGLEN 100

#ifndef DSPAM
#define DSPAM "/usr/bin/dspam"
#endif				/* DSPAM */

static int call_dspam(const char *signature, int is_spam)
{
	pid_t pid;
	int s;
	char class_arg[16 + 2];
	char sign_arg[MAXSIGLEN + 2];
	int pipes[2];

	s = snprintf(sign_arg, 101, "--signature=%s", signature);
	if (s > MAXSIGLEN || s <= 0)
		return -1;

	snprintf(class_arg, 17, "--class=%s", is_spam ? "spam" : "innocent");

	pipe(pipes);		/* for dspam stderr */

	pid = fork();
	if (pid < 0)
		return -1;

	if (pid) {
		int status;
		/* well. dspam doesn't report an error if it has an error,
		   but instead only prints stuff to stderr. Usually, it
		   won't print anything, so we treat it having output as
		   an error condition */

		char buf[1024];
		int readsize;
		close(pipes[1]);

		do {
			readsize = read(pipes[0], buf, 1024);
			if (readsize < 0) {
				readsize = -1;
				if (errno == EINTR)
					readsize = -2;
			}
		} while (readsize == -2);

		if (readsize != 0) {
			close(pipes[0]);
			return -1;
		}

		waitpid(pid, &status, 0);
		if (!WIFEXITED(status)) {
			close(pipes[0]);
			return -1;
		}

		readsize = read(pipes[0], buf, 1024);
		if (readsize != 0) {
			close(pipes[0]);
			return -1;
		}

		close(pipes[0]);
		return WEXITSTATUS(status);
	} else {
		int fd = open("/dev/null", O_RDONLY);
		close(0);
		close(1);
		close(2);
		/* see above */
		close(pipes[0]);

		if (dup2(pipes[1], 2) != 2) {
			exit(1);
		}
		if (dup2(pipes[1], 1) != 1) {
			exit(1);
		}
		close(pipes[1]);

		if (dup2(fd, 0) != 0) {
			exit(1);
		}
		close(fd);

#ifdef DEBUG
		syslog(LOG_INFO, DSPAM " --source=error --stdout %s %s",
		       class_arg, sign_arg);
#endif
		execl(DSPAM, DSPAM, "--source=error", "--stdout", class_arg,
		      sign_arg, NULL);
		exit(127);	/* fall through if dspam can't be found */
		return -1;	/* never executed */
	}
}

struct dspam_signature_list {
	struct dspam_signature_list *next;
	char *sig;
};
typedef struct dspam_signature_list *siglist_t;

static siglist_t list_append(pool_t pool, siglist_t * list)
{
	siglist_t l = *list;
	siglist_t p = NULL;
	siglist_t n;

	while (l != NULL) {
		p = l;
		l = l->next;
	}
	n = p_malloc(pool, sizeof(struct dspam_signature_list));
	n->next = NULL;
	n->sig = NULL;
	if (p == NULL) {
		*list = n;
	} else {
		p->next = n;
	}
	return n;
}

static int
fetch_and_copy_reclassified(struct mailbox_transaction_context *t,
			    struct mailbox *srcbox,
			    struct mail_search_arg *search_args,
			    int is_spam, int *enh_error)
{
	struct mail_search_context *search_ctx;
	struct mailbox_transaction_context *src_trans;
	struct mail_keywords *keywords;
	const char *const *keywords_list;
	struct mail *mail;
	int ret;

	const char *signature;
	struct dspam_signature_list *siglist = NULL;
	pool_t listpool = pool_alloconly_create("dspam-siglist-pool", 1024);

	*enh_error = 0;

	src_trans = mailbox_transaction_begin(srcbox, 0);
	search_ctx = mailbox_search_init(src_trans, NULL, search_args, NULL);

	mail = mail_alloc(src_trans, MAIL_FETCH_STREAM_HEADER |
			  MAIL_FETCH_STREAM_BODY, NULL);
	ret = 1;
	while (mailbox_search_next(search_ctx, mail) > 0 && ret > 0) {
		if (mail->expunged) {
			ret = 0;
			break;
		}

		signature = mail_get_first_header(mail, SIGHEADERLINE);
		if (is_empty_str(signature)) {
			ret = -1;
			*enh_error = -2;
			break;
		}
		list_append(listpool, &siglist)->sig =
		    p_strdup(listpool, signature);

		keywords_list = mail_get_keywords(mail);
		keywords = strarray_length(keywords_list) == 0 ? NULL :
		    mailbox_keywords_create(t, keywords_list);
		if (mailbox_copy(t, mail, mail_get_flags(mail),
				 keywords, NULL) < 0)
			ret = -1;
		mailbox_keywords_free(t, &keywords);
	}
	mail_free(&mail);

	if (mailbox_search_deinit(&search_ctx) < 0)
		ret = -1;

	/* got all signatures now, walk them passing to dspam */
	while (siglist) {
		if ((*enh_error = call_dspam(siglist->sig, is_spam))) {
			ret = -1;
			break;
		}
		siglist = siglist->next;
	}

	pool_unref(listpool);

	if (*enh_error) {
		mailbox_transaction_rollback(&src_trans);
	} else {
		if (mailbox_transaction_commit(&src_trans, 0) < 0)
			ret = -1;
	}

	return ret;
}

static bool cmd_append_spam_plugin(struct client_command_context *cmd)
{
	const char *mailbox;
	struct mail_storage *storage;
	struct mailbox *box;

	/* <mailbox> */
	if (!client_read_string_args(cmd, 1, &mailbox))
		return FALSE;

	storage = client_find_storage(cmd, &mailbox);
	if (storage == NULL)
		return FALSE;
	/* TODO: is this really the best way to handle this? maybe more logic could be provided */
	box =
	    mailbox_open(storage, mailbox, NULL,
			 MAILBOX_OPEN_FAST | MAILBOX_OPEN_KEEP_RECENT);
	if (box != NULL) {

		if (mailbox_equals(box, storage, "SPAM")) {
			mailbox_close(&box);
			return cmd_sync(cmd, 0, 0,
					"NO Cannot APPEND to SPAM box, sorry.");
		}

		mailbox_close(&box);
	}

	return cmd_append(cmd);
}

static bool cmd_copy_spam_plugin(struct client_command_context *cmd)
{
	struct client *client = cmd->client;
	struct mail_storage *storage;
	struct mailbox *destbox;
	struct mailbox_transaction_context *t;
	struct mail_search_arg *search_arg;
	const char *messageset, *mailbox;
	enum mailbox_sync_flags sync_flags = 0;
	int ret;
	int spam_folder = 0;
	int enh_error = 0, is_spam;
#ifdef IGNORE_TRASH_NAME
	int is_trash;
	int trash_folder = 0;
#endif
	struct mailbox *box;

	/* <message set> <mailbox> */
	if (!client_read_string_args(cmd, 2, &messageset, &mailbox))
		return FALSE;

	if (!client_verify_open_mailbox(cmd))
		return TRUE;

	storage = client_find_storage(cmd, &mailbox);
	if (storage == NULL)
		return FALSE;
	box =
	    mailbox_open(storage, mailbox, NULL,
			 MAILBOX_OPEN_FAST | MAILBOX_OPEN_KEEP_RECENT);
	if (!box) {
		client_send_storage_error(cmd, storage);
		return TRUE;
	}

	is_spam = mailbox_equals(box, storage, "SPAM");
	spam_folder = is_spam
	    || mailbox_equals(cmd->client->mailbox, storage, "SPAM");
#ifdef IGNORE_TRASH_NAME
	is_trash = mailbox_equals(box, storage, IGNORE_TRASH_NAME);
	trash_folder = is_trash
	    || mailbox_equals(cmd->client->mailbox, storage, IGNORE_TRASH_NAME);
#endif

	mailbox_close(&box);

	/* only act on spam */
	if (!spam_folder)
		return cmd_copy(cmd);
#ifdef IGNORE_TRASH_NAME
	/* ignore any mail going into or out of trash
	 * This means users can circumvent re-classification
	 * by moving into trash and then out again...
	 * All in all, it may be a better idea to not use
	 * a Trash folder at all :) */
	if (trash_folder)
		return cmd_copy(cmd);
#endif

	/* otherwise, do (almost) everything the copy would have done */
	/* open the destination mailbox */
	if (!client_verify_mailbox_name(cmd, mailbox, TRUE, FALSE))
		return TRUE;

	search_arg = imap_search_get_arg(cmd, messageset, cmd->uid);
	if (search_arg == NULL)
		return TRUE;

	storage = client_find_storage(cmd, &mailbox);
	if (storage == NULL)
		return TRUE;

	if (mailbox_equals(client->mailbox, storage, mailbox))
		destbox = client->mailbox;
	else {
		destbox = mailbox_open(storage, mailbox, NULL,
				       MAILBOX_OPEN_FAST |
				       MAILBOX_OPEN_KEEP_RECENT);
		if (destbox == NULL) {
			client_send_storage_error(cmd, storage);
			return TRUE;
		}
	}

	t = mailbox_transaction_begin(destbox,
				      MAILBOX_TRANSACTION_FLAG_EXTERNAL);
	ret =
	    fetch_and_copy_reclassified(t, client->mailbox, search_arg, is_spam,
					&enh_error);

	if (ret <= 0)
		mailbox_transaction_rollback(&t);
	else {
		if (mailbox_transaction_commit(&t, 0) < 0)
			ret = -1;
	}

	if (destbox != client->mailbox) {
		sync_flags |= MAILBOX_SYNC_FLAG_FAST;
		mailbox_close(&destbox);
	}

	if (ret > 0)
		return cmd_sync(cmd, sync_flags, 0, "OK Copy completed.");
	else if (ret == 0) {
		/* some messages were expunged, sync them */
		return cmd_sync(cmd, 0, 0,
				"NO Some of the requested messages no longer exist.");
	} else {
		switch (enh_error) {
		case -2:
			return cmd_sync(cmd, 0, 0,
					"NO Some messages did not have "
					SIGHEADERLINE " header line");
			break;
		case -3:
			return cmd_sync(cmd, 0, 0, "NO Failed to call dspam");
			break;
		case 0:
			client_send_storage_error(cmd, storage);
			return TRUE;
			break;
		default:
			return cmd_sync(cmd, 0, 0, "NO dspam failed");
			break;
		}
	}

	return TRUE;
}

void dspam_init(void)
{
	command_unregister("COPY");
	command_unregister("APPEND");
	command_unregister("UID COPY");
	/* i_strdup() here is a kludge to avoid crashing in commands_deinit()
	 * since modules are unloaded before it's called, this "COPY" string
	 * would otherwise point to nonexisting memory. */
	command_register(i_strdup("COPY"), cmd_copy_spam_plugin);
	command_register(i_strdup("UID COPY"), cmd_copy_spam_plugin);
	command_register(i_strdup("APPEND"), cmd_append_spam_plugin);
}

void dspam_deinit(void)
{
}