spam.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Spam related facilities.
   3  *
   4  * Copyright (c) 2013 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   5  *
   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.
   9  *
  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.
  17  */
  18
  19 #ifndef HAVE_AMALGAMATION
  20 # include "nail.h"
  21 #endif
  22
  23 EMPTY_FILE(spam)
  24 #ifdef HAVE_SPAM
  25 /*
  26  * TODO - We cannot use the spamc library because of our jumping behaviour.
  27  * TODO   We could nonetheless if we'd start a fork(2)ed child which would
  28  * TODO   use the spamc library.
  29  * TODO -- In fact using a child process that is immune from the terrible
  30  * TODO    signal and jumping mess, and that controls further childs, and
  31  * TODO    gains file descriptors via sendmsg(2), and is started once it is
  32  * TODO    needed first, i have in mind for quite some time, for the transition
  33  * TODO    to a select(2) based implementation: we could slowly convert SMTP,
  34  * TODO    etc., finally IMAP, at which case we could rejoin back into a single
  35  * TODO    process program (unless we want to isolate the UI at that time, to
  36  * TODO    allow for some xUI protocol).
  37  * TODO    :: That is to say -- it's a horrible signal and jump mess ::
  38  * TODO - We do not yet handle direct communication with spamd(1).
  39  * TODO   I.e., this could be a lean alternative to the first item;
  40  * TODO   the protocol is easy and we could support ALL operations easily.
  41  * TODO - We do not yet update mails in place, i.e., replace the original
  42  * TODO   message with the updated one; we could easily do it as if `edit' has
  43  * TODO   been used, but the nail codebase doesn't truly support that for IMAP.
  44  * TODO   (And it seems a bit grazy to download a message, update it and upload
  45  * TODO   it again.)
  46  */
  47
  48 enum spam_action {
  49    _SPAM_RATE,
  50    _SPAM_HAM,
  51    _SPAM_SPAM,
  52    _SPAM_FORGET
  53 };
  54
  55 struct spam_vc {
  56    struct message    *mp;
  57    size_t            mno;
  58    int               action;
  59    int               __dummy;
  60    char              *comm_s;
  61    char              *buffer;
  62    /* TODO This codebase jumps around and uses "stacks" of signal handling;
  63     * TODO until some later time we have to play the same game */
  64    sighandler_type   otstp;
  65    sighandler_type   ottin;
  66    sighandler_type   ottou;
  67    sighandler_type   ohup;
  68    sighandler_type   opipe;
  69    sighandler_type   oint;
  70    char const        *comm_a[16];
  71 };
  72
  73 /* Indices according to enum spam_action */
  74 static char const _spam_comms[][16] = {
  75    "spamrate", "spamham", "spamspam", "spamforget"
  76 };
  77
  78 /* Shared action setup */
  79 static bool_t  _spam_action(enum spam_action sa, int *ip);
  80
  81 /* Convert a 2[.x]/whatever spam rate into message.m_spamscore */
  82 static void    _spam_rate2score(struct spam_vc *vc);
  83
  84 /* Interact with spamc(1) */
  85 static bool_t  _spam_interact(struct spam_vc *vc);
  86
  87 static bool_t
  88 _spam_action(enum spam_action sa, int *ip)
  89 {
  90    struct spam_vc vc;
  91    struct str str;
  92    size_t maxsize;
  93    char const *cp, **args;
  94    bool_t ok = FAL0;
  95    NYD_ENTER;
  96
  97    vc.action = sa;
  98
  99    if ((cp = ok_vlook(spam_command)) == NULL) {
 100 #ifdef SPAMC_PATH
 101       cp = SPAMC_PATH;
 102 #else
 103       fprintf(stderr, tr(514, "`%s': *spam-command* is not set\n"),
 104          _spam_comms[sa]);
 105       goto jleave;
 106 #endif
 107    }
 108
 109    /* Prepare the spamc(1) command line */
 110    args = vc.comm_a;
 111    *args++ = cp;
 112
 113    switch (sa) {
 114    case _SPAM_RATE:
 115       *args = "-c";
 116       break;
 117    case _SPAM_HAM:
 118       args[1] = "ham";
 119       goto jlearn;
 120    case _SPAM_SPAM:
 121       args[1] = "spam";
 122       goto jlearn;
 123    case _SPAM_FORGET:
 124       args[1] = "forget";
 125 jlearn:
 126       *args = "-L";
 127       ++args;
 128       break;
 129    }
 130    ++args;
 131
 132    if ((cp = ok_vlook(spam_socket)) != NULL) {
 133       *args++ = "-U";
 134       *args++ = cp;
 135    } else {
 136       if ((cp = ok_vlook(spam_host)) != NULL) {
 137          *args++ = "-d";
 138          *args++ = cp;
 139       }
 140       if ((cp = ok_vlook(spam_port)) != NULL) {
 141          *args++ = "-p";
 142          *args++ = cp;
 143       }
 144    }
 145
 146    *args++ = "-l"; /* --log-to-stderr */
 147
 148    if ((cp = ok_vlook(spam_user)) != NULL) {
 149       *args++ = "-u";
 150       *args++ = cp;
 151    }
 152
 153    *args = 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);
 157
 158    /* *spam-maxsize* we do handle ourselfs instead */
 159    maxsize = 0;
 160    if ((cp = ok_vlook(spam_maxsize)) != NULL)
 161       maxsize = (size_t)strtol(cp, NULL, 10);
 162    if (maxsize <= 0)
 163       maxsize = SPAM_MAXSIZE;
 164
 165    /* Finally get an I/O buffer */
 166    vc.buffer = salloc(BUFFER_SIZE);
 167
 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);
 179          continue;
 180       }
 181       if ((ok = _spam_interact(&vc)) == FAL0)
 182          break;
 183    }
 184 #ifndef SPAMC_PATH
 185 jleave:
 186 #endif
 187    NYD_LEAVE;
 188    return !ok;
 189 }
 190
 191 static void
 192 _spam_rate2score(struct spam_vc *vc)
 193 {
 194    char *cp;
 195    size_t size;
 196    ui32_t m, s;
 197    NYD_ENTER;
 198
 199    cp = strchr(vc->buffer, '/');
 200    if (cp == NULL)
 201       goto jleave;
 202    size = PTR2SIZE(cp - vc->buffer);
 203    vc->buffer[size] = '\0';
 204
 205    m = (ui32_t)strtol(vc->buffer, &cp, 10);
 206    if (cp == vc->buffer)
 207       goto jleave;
 208
 209    s = (*cp == '\0') ? 0 : (ui32_t)strtol(++cp, NULL, 10);
 210
 211    vc->mp->m_spamscore = (m << 8) | (s & 0xFF);
 212 jleave:
 213    NYD_LEAVE;
 214 }
 215
 216 static sigjmp_buf __spam_actjmp; /* TODO someday, we won't need it no more */
 217 static int        __spam_sig; /* TODO someday, we won't need it no more */
 218 static void
 219 __spam_onsig(int sig) /* TODO someday, we won't need it no more */
 220 {
 221    NYD_X; /* Signal handler */
 222    __spam_sig = sig;
 223    siglongjmp(__spam_actjmp, 1);
 224 }
 225
 226 static bool_t
 227 _spam_interact(struct spam_vc *vc)
 228 {
 229    int p2c[2], c2p[2];
 230    sigset_t cset;
 231    size_t size;
 232    pid_t pid;
 233    FILE *ibuf;
 234    enum {
 235       _NONE    = 0,
 236       _SIGHOLD = 1<<0,
 237       _P2C_0   = 1<<1,
 238       _P2C_1   = 1<<2,
 239       _P2C     = _P2C_0 | _P2C_1,
 240       _C2P_0   = 1<<3,
 241       _C2P_1   = 1<<4,
 242       _C2P     = _C2P_0 | _C2P_1,
 243       _JUMPED  = 1<<5,
 244       _RUNNING = 1<<6,
 245       _GOODRUN = 1<<7,
 246       _ERRORS  = 1<<8
 247    } state = _NONE;
 248    NYD_ENTER;
 249
 250    setdot(vc->mp);
 251    if ((ibuf = setinput(&mb, vc->mp, NEED_BODY)) == NULL) {
 252       perror("setinput"); /* XXX tr() */
 253       goto j_leave;
 254    }
 255
 256    /* TODO Avoid that we jump away; yet necessary signal mess */
 257    vc->otstp = safe_signal(SIGTSTP, SIG_DFL);
 258    vc->ottin = safe_signal(SIGTTIN, SIG_DFL);
 259    vc->ottou = safe_signal(SIGTTOU, SIG_DFL);
 260    vc->opipe = safe_signal(SIGPIPE, SIG_IGN);
 261    hold_sigs();
 262    state |= _SIGHOLD;
 263    vc->ohup = safe_signal(SIGHUP, &__spam_onsig);
 264    vc->oint = safe_signal(SIGINT, &__spam_onsig);
 265    /* Keep sigs blocked */
 266    pid = 0; /* cc uninit */
 267
 268    if (!pipe_cloexec(p2c)) {
 269       perror("pipe"); /* XXX tr() */
 270       goto jleave;
 271    }
 272    state |= _P2C;
 273
 274    if (!pipe_cloexec(c2p)) {
 275       perror("pipe"); /* XXX tr() */
 276       goto jleave;
 277    }
 278    state |= _C2P;
 279
 280    if (sigsetjmp(__spam_actjmp, 1)) {
 281       state |= _JUMPED;
 282       goto jleave;
 283    }
 284    rele_sigs();
 285    state &= ~_SIGHOLD;
 286
 287    sigemptyset(&cset);
 288    pid = start_command(vc->comm_s, &cset, p2c[0], c2p[1], NULL, NULL, NULL);
 289    state |= _RUNNING;
 290    close(p2c[0]);
 291    state &= ~_P2C_0;
 292
 293    /* Yes, we could sendmp(SEND_MBOX), but simply passing through the MBOX
 294     * content does the same in effect, but is much more efficient.
 295     * NOTE: this may mean we pass a message without From_ line! */
 296    for (size = vc->mp->m_size; size > 0;) {
 297       size_t i = fread(vc->buffer, 1, MIN(size, BUFFER_SIZE), ibuf);
 298       if (i == 0) {
 299          if (ferror(ibuf))
 300             state |= _ERRORS;
 301          break;
 302       }
 303       size -= i;
 304       if (i != (size_t)write(p2c[1], vc->buffer, i)) {
 305          state |= _ERRORS;
 306          break;
 307       }
 308    }
 309
 310 jleave:
 311    /* TODO In what follows you see a lot of races; these can't be helped without
 312     * TODO atomic compare-and-swap -- WE COULD ALSO BLOCK ANYTHING FOR A WHILE*/
 313    if (state & _SIGHOLD) {
 314       state &= ~_SIGHOLD;
 315       rele_sigs();
 316    }
 317
 318    if (state & _P2C_0) {
 319       state &= ~_P2C_0;
 320       close(p2c[0]);
 321    }
 322    if (state & _C2P_1) {
 323       state &= ~_C2P_1;
 324       close(c2p[1]);
 325    }
 326    /* Close the write end, so that spamc(1) goes */
 327    if (state & _P2C_1) {
 328       state &= ~_P2C_1;
 329       close(p2c[1]);
 330    }
 331
 332    if (state & _RUNNING) {
 333       state &= ~_RUNNING;
 334       if (wait_child(pid, NULL))
 335          state |= _GOODRUN;
 336    }
 337
 338    /* XXX This only works because spamc(1) follows the clear protocol (1) read
 339     * XXX everything until EOF on input, then (2) work, then (3) output
 340     * XXX a single result line; otherwise we could deadlock here, but since
 341     * TODO this is rather intermediate, go with it */
 342    if (vc->action == _SPAM_RATE && !(state & (_JUMPED | _ERRORS))) {
 343       ssize_t i = read(c2p[0], vc->buffer, BUFFER_SIZE - 1);
 344       if (i > 0) {
 345          vc->buffer[i] = '\0';
 346          _spam_rate2score(vc);
 347       } else if (i != 0)
 348          state |= _ERRORS;
 349    }
 350
 351    if (state & _C2P_0) {
 352       state &= ~_C2P_0;
 353       close(c2p[0]);
 354    }
 355
 356    if (vc->action == _SPAM_RATE) {
 357       switch (state & (_JUMPED | _GOODRUN | _ERRORS)) {
 358       case _GOODRUN:
 359          vc->mp->m_flag &= ~MSPAM;
 360          break;
 361       case 0:
 362          vc->mp->m_flag |= MSPAM;
 363       default:
 364          break;
 365       }
 366    } else {
 367       if (state & (_JUMPED | _ERRORS))
 368          /* xxx print message? */;
 369       else if (vc->action == _SPAM_SPAM)
 370          vc->mp->m_flag |= MSPAM;
 371       else if (vc->action == _SPAM_HAM)
 372          vc->mp->m_flag &= ~MSPAM;
 373    }
 374
 375    safe_signal(SIGINT, vc->oint);
 376    safe_signal(SIGHUP, vc->ohup);
 377    safe_signal(SIGPIPE, vc->opipe);
 378    safe_signal(SIGTSTP, vc->otstp);
 379    safe_signal(SIGTTIN, vc->ottin);
 380    safe_signal(SIGTTOU, vc->ottou);
 381
 382    /* Bounce jumps to the lex.c trampolines
 383     * (i'd have never believed i'd ever say or even do something like this) */
 384    if (state & _JUMPED) {
 385       sigemptyset(&cset);
 386       sigaddset(&cset, __spam_sig);
 387       sigprocmask(SIG_UNBLOCK, &cset, NULL);
 388    }
 389 j_leave:
 390    NYD_LEAVE;
 391    if (state & _JUMPED)
 392       kill(0, __spam_sig);
 393    return !(state & _ERRORS);
 394 }
 395
 396 FL int
 397 c_spam_clear(void *v)
 398 {
 399    int *ip;
 400    NYD_ENTER;
 401
 402    for (ip = v; *ip != 0; ++ip)
 403       message[(size_t)*ip - 1].m_flag &= ~MSPAM;
 404    NYD_LEAVE;
 405    return 0;
 406 }
 407
 408 FL int
 409 c_spam_set(void *v)
 410 {
 411    int *ip;
 412    NYD_ENTER;
 413
 414    for (ip = v; *ip != 0; ++ip)
 415       message[(size_t)*ip - 1].m_flag |= MSPAM;
 416    NYD_LEAVE;
 417    return 0;
 418 }
 419
 420 FL int
 421 c_spam_forget(void *v)
 422 {
 423    int rv;
 424    NYD_ENTER;
 425
 426    rv = _spam_action(_SPAM_FORGET, (int*)v) ? OKAY : STOP;
 427    NYD_LEAVE;
 428    return rv;
 429 }
 430
 431 FL int
 432 c_spam_ham(void *v)
 433 {
 434    int rv;
 435    NYD_ENTER;
 436
 437    rv = _spam_action(_SPAM_HAM, (int*)v) ? OKAY : STOP;
 438    NYD_LEAVE;
 439    return rv;
 440 }
 441
 442 FL int
 443 c_spam_rate(void *v)
 444 {
 445    int rv;
 446    NYD_ENTER;
 447
 448    rv = _spam_action(_SPAM_RATE, (int*)v) ? OKAY : STOP;
 449    NYD_LEAVE;
 450    return rv;
 451 }
 452
 453 FL int
 454 c_spam_spam(void *v)
 455 {
 456    int rv;
 457    NYD_ENTER;
 458
 459    rv = _spam_action(_SPAM_SPAM, (int*)v) ? OKAY : STOP;
 460    NYD_LEAVE;
 461    return rv;
 462 }
 463 #endif /* HAVE_SPAM */
 464
 465 /* vim:set fenc=utf-8:s-it-mode */