1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Spam related facilities.
4 * Copyright (c) 2013 Steffen "Daode" Nurpmeso <sdaoden@users.sf.net>.
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22 typedef int avoid_empty_file_compiler_warning
;
27 * TODO - We cannot use the spamc library because of our jumping behaviour.
28 * TODO We could nonetheless if we'd start a fork(2)ed child which would
29 * TODO use the spamc library.
30 * TODO -- In fact using a child process that is immune from the terrible
31 * TODO signal and jumping mess, and that controls further childs, and
32 * TODO gains file descriptors via sendmsg(2), and is started once it is
33 * TODO needed first, i have in mind for quite some time, for the transition
34 * TODO to a select(2) based implementation: we could slowly convert SMTP,
35 * TODO etc., finally IMAP, at which case we could rejoin back into a single
36 * TODO process program (unless we want to isolate the UI at that time, to
37 * TODO allow for some xUI protocol).
38 * TODO :: That is to say -- it's a horrible signal and jump mess ::
39 * TODO - We do not yet handle direct communication with spamd(1).
40 * TODO I.e., this could be a lean alternative to the first item;
41 * TODO the protocol is easy and we could support ALL operations easily.
42 * TODO - We do not yet update mails in place, i.e., replace the original
43 * TODO message with the updated one; we could easily do it as if `edit' has
44 * TODO been used, but the nail codebase doesn't truly support that for IMAP.
45 * TODO (And it seems a bit grazy to download a message, update it and upload
63 /* TODO This codebase jumps around and uses "stacks" of signal handling;
64 * TODO until some later time we have to play the same game */
65 sighandler_type otstp
;
66 sighandler_type ottin
;
67 sighandler_type ottou
;
69 sighandler_type opipe
;
71 char const * comm_a
[16];
74 /* Indices according to enum spam_action */
75 static char const _spam_comms
[][16] = {
76 "spamrate", "spamham", "spamspam", "spamforget"
79 /* Shared action setup */
80 static bool_t
_spam_action(enum spam_action sa
, int *ip
);
82 /* Convert a 2[.x]/whatever spam rate into message.m_spamscore */
83 static void _spam_rate2score(struct spam_vc
*vc
);
85 /* Interact with spamc(1) */
86 static bool_t
_spam_interact(struct spam_vc
*vc
);
89 _spam_action(enum spam_action sa
, int *ip
)
94 char const *cp
, **args
;
99 if ((cp
= voption("spam-command")) == NULL
) {
103 fprintf(stderr
, tr(514, "`%s': *spam-command* is not set\n"),
109 /* Prepare the spamc(1) command line */
132 if ((cp
= voption("spam-socket")) != NULL
) {
136 if ((cp
= voption("spam-host")) != NULL
) {
140 if ((cp
= voption("spam-port")) != NULL
) {
146 *args
++ = "-l"; /* --log-to-stderr */
148 if ((cp
= voption("spam-user")) != NULL
) {
154 vc
.comm_s
= str_concat_cpa(&str
, vc
.comm_a
, " ")->s
;
155 if (options
& OPT_DEBUG
)
156 fprintf(stderr
, "spamc(1) via <%s>\n", vc
.comm_s
);
158 /* *spam-maxsize* we do handle ourselfs instead */
160 if ((cp
= voption("spam-maxsize")) != NULL
)
161 maxsize
= (size_t)strtol(cp
, NULL
, 10);
163 maxsize
= SPAM_MAXSIZE
;
165 /* Finally get an I/O buffer */
166 vc
.buffer
= salloc(BUFFER_SIZE
);
168 for (ok
= TRU1
; *ip
!= 0; ++ip
) {
169 vc
.mno
= (size_t)*ip
- 1;
170 vc
.mp
= message
+ vc
.mno
;
171 if (sa
== _SPAM_RATE
)
172 vc
.mp
->m_spamscore
= 0;
173 if (vc
.mp
->m_size
> maxsize
) {
174 if (options
& OPT_VERBOSE
)
175 fprintf(stderr
, tr(515,
176 "`%s': message %lu exceeds maxsize (%lu > %lu), skip\n"),
177 _spam_comms
[sa
], (ul_it
)vc
.mno
+ 1,
178 (ul_it
)vc
.mp
->m_size
, (ul_it
)maxsize
);
181 if ((ok
= _spam_interact(&vc
)) == FAL0
)
191 _spam_rate2score(struct spam_vc
*vc
)
197 cp
= strchr(vc
->buffer
, '/');
200 size
= (size_t)(cp
- vc
->buffer
);
201 vc
->buffer
[size
] = '\0';
203 m
= (ui_it
)strtol(vc
->buffer
, &cp
, 10);
204 if (cp
== vc
->buffer
)
207 s
= (*cp
== '\0') ? 0 : (ui_it
)strtol(++cp
, NULL
, 10);
209 vc
->mp
->m_spamscore
= (m
<< 8) | (s
& 0xFF);
214 static sigjmp_buf __spam_actjmp
; /* TODO someday, we won't need it no more */
215 static int __spam_sig
; /* TODO someday, we won't need it no more */
217 __spam_onsig(int sig
) /* TODO someday, we won't need it no more */
220 siglongjmp(__spam_actjmp
, 1);
224 _spam_interact(struct spam_vc
*vc
)
236 _P2C
= _P2C_0
| _P2C_1
,
239 _C2P
= _C2P_0
| _C2P_1
,
247 if ((ibuf
= setinput(&mb
, vc
->mp
, NEED_BODY
)) == NULL
) {
248 perror("setinput"); /* XXX tr() */
252 /* TODO Avoid that we jump away; yet necessary signal mess */
253 vc
->otstp
= safe_signal(SIGTSTP
, SIG_DFL
);
254 vc
->ottin
= safe_signal(SIGTTIN
, SIG_DFL
);
255 vc
->ottou
= safe_signal(SIGTTOU
, SIG_DFL
);
256 vc
->opipe
= safe_signal(SIGPIPE
, SIG_IGN
);
259 vc
->ohup
= safe_signal(SIGHUP
, &__spam_onsig
);
260 vc
->oint
= safe_signal(SIGINT
, &__spam_onsig
);
261 /* Keep sigs blocked */
262 pid
= 0; /* cc uninit */
264 if (! pipe_cloexec(p2c
)) {
265 perror("pipe"); /* XXX tr() */
270 if (! pipe_cloexec(c2p
)) {
271 perror("pipe"); /* XXX tr() */
276 if (sigsetjmp(__spam_actjmp
, 1)) {
284 pid
= start_command(vc
->comm_s
, &cset
, p2c
[0], c2p
[1], NULL
, NULL
, NULL
);
289 /* Yes, we could sendmp(SEND_MBOX), but simply passing through the MBOX
290 * content does the same in effect, but is much more efficient.
291 * NOTE: this may mean we pass a message without From_ line! */
292 for (size
= vc
->mp
->m_size
; size
> 0;) {
293 size_t i
= fread(vc
->buffer
, 1, MIN(size
, BUFFER_SIZE
), ibuf
);
300 if (i
!= (size_t)write(p2c
[1], vc
->buffer
, i
)) {
307 /* In what follows you see a lot of races; these can't be helped without
308 * atomic compare-and-swap; it only matters if we */
309 if (state
& _SIGHOLD
) {
314 if (state
& _P2C_0
) {
318 if (state
& _C2P_1
) {
322 /* Close the write end, so that spamc(1) goes */
323 if (state
& _P2C_1
) {
328 if (state
& _RUNNING
) {
330 if (wait_child(pid
) == 0)
334 /* XXX This only works because spamc(1) follows the clear protocol (1) read
335 * XXX everything until EOF on input, then (2) work, then (3) output
336 * XXX a single result line; otherwise we could deadlock here, but since
337 * TODO this is rather intermediate, go with it */
338 if (vc
->action
== _SPAM_RATE
&& ! (state
& (_JUMPED
| _ERRORS
))) {
339 ssize_t i
= read(c2p
[0], vc
->buffer
, BUFFER_SIZE
- 1);
341 vc
->buffer
[i
] = '\0';
342 _spam_rate2score(vc
);
347 if (state
& _C2P_0
) {
352 if (vc
->action
== _SPAM_RATE
) {
353 switch (state
& (_JUMPED
| _GOODRUN
| _ERRORS
)) {
355 vc
->mp
->m_flag
&= ~MSPAM
;
358 vc
->mp
->m_flag
|= MSPAM
;
363 if (state
& (_JUMPED
| _ERRORS
))
364 /* xxx print message? */;
365 else if (vc
->action
== _SPAM_SPAM
)
366 vc
->mp
->m_flag
|= MSPAM
;
367 else if (vc
->action
== _SPAM_HAM
)
368 vc
->mp
->m_flag
&= ~MSPAM
;
371 safe_signal(SIGINT
, vc
->oint
);
372 safe_signal(SIGHUP
, vc
->ohup
);
373 safe_signal(SIGPIPE
, vc
->opipe
);
374 safe_signal(SIGTSTP
, vc
->otstp
);
375 safe_signal(SIGTTIN
, vc
->ottin
);
376 safe_signal(SIGTTOU
, vc
->ottou
);
378 /* Bounce jumps to the lex.c trampolines
379 * (i'd have never believed i'd ever say or even do something like this) */
380 if (state
& _JUMPED
) {
382 sigaddset(&cset
, __spam_sig
);
383 sigprocmask(SIG_UNBLOCK
, &cset
, NULL
);
387 return ! (state
& _ERRORS
);
395 for (ip
= v
; *ip
!= 0; ++ip
)
396 message
[(size_t)*ip
- 1].m_flag
&= ~MSPAM
;
405 for (ip
= v
; *ip
!= 0; ++ip
)
406 message
[(size_t)*ip
- 1].m_flag
|= MSPAM
;
411 cspam_forget(void *v
)
413 return _spam_action(_SPAM_FORGET
, (int*)v
) ? OKAY
: STOP
;
419 return _spam_action(_SPAM_HAM
, (int*)v
) ? OKAY
: STOP
;
425 return _spam_action(_SPAM_RATE
, (int*)v
) ? OKAY
: STOP
;
431 return _spam_action(_SPAM_SPAM
, (int*)v
) ? OKAY
: STOP
;
433 #endif /* HAVE_SPAM */
435 /* vim:set fenc=utf-8:s-it-mode */