citadel/serv_sieve.c

   1 /*
   2  * $Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $
   3  *
   4  * This module glues libSieve to the Citadel server in order to implement
   5  * the Sieve mailbox filtering language (RFC 3028).
   6  *
   7  * This code is released under the terms of the GNU General Public License.
   8  */
   9
  10 #include "sysdep.h"
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #include <pwd.h>
  17 #include <errno.h>
  18 #include <sys/types.h>
  19
  20 #if TIME_WITH_SYS_TIME
  21 # include <sys/time.h>
  22 # include <time.h>
  23 #else
  24 # if HAVE_SYS_TIME_H
  25 #  include <sys/time.h>
  26 # else
  27 #  include <time.h>
  28 # endif
  29 #endif
  30
  31 #include <sys/wait.h>
  32 #include <string.h>
  33 #include <limits.h>
  34 #include "citadel.h"
  35 #include "server.h"
  36 #include "sysdep_decls.h"
  37 #include "citserver.h"
  38 #include "support.h"
  39 #include "config.h"
  40 #include "serv_extensions.h"
  41 #include "room_ops.h"
  42 #include "policy.h"
  43 #include "database.h"
  44 #include "msgbase.h"
  45 #include "tools.h"
  46
  47 #ifdef HAVE_LIBSIEVE
  48
  49 #include <sieve2.h>
  50 #include <sieve2_error.h>
  51 #include "serv_sieve.h"
  52
  53 struct RoomProcList *sieve_list = NULL;
  54
  55 struct ctdl_sieve {
  56         char *rfc822headers;
  57         int actiontaken;                /* Set to 1 if the message was successfully acted upon */
  58         int keep;                       /* Set to 1 to suppress message deletion from the inbox */
  59         long usernum;                   /* Owner of the mailbox we're processing */
  60         long msgnum;                    /* Message base ID of the message being processed */
  61 };
  62
  63
  64 /*
  65  * Callback function to send libSieve trace messages to Citadel log facility
  66  * Set ctdl_libsieve_debug=1 to see extremely verbose libSieve trace
  67  */
  68 int ctdl_debug(sieve2_context_t *s, void *my)
  69 {
  70         static int ctdl_libsieve_debug = 0;
  71
  72         if (ctdl_libsieve_debug) {
  73                 lprintf(CTDL_DEBUG, "Sieve: level [%d] module [%s] file [%s] function [%s]\n",
  74                         sieve2_getvalue_int(s, "level"),
  75                         sieve2_getvalue_string(s, "module"),
  76                         sieve2_getvalue_string(s, "file"),
  77                         sieve2_getvalue_string(s, "function"));
  78                 lprintf(CTDL_DEBUG, "       message [%s]\n",
  79                         sieve2_getvalue_string(s, "message"));
  80         }
  81         return SIEVE2_OK;
  82 }
  83
  84
  85 /*
  86  * Callback function to log script parsing errors
  87  */
  88 int ctdl_errparse(sieve2_context_t *s, void *my)
  89 {
  90         lprintf(CTDL_WARNING, "Error in script, line %d: %s\n",
  91                 sieve2_getvalue_int(s, "lineno"),
  92                 sieve2_getvalue_string(s, "message")
  93         );
  94         return SIEVE2_OK;
  95 }
  96
  97
  98 /*
  99  * Callback function to log script execution errors
 100  */
 101 int ctdl_errexec(sieve2_context_t *s, void *my)
 102 {
 103         lprintf(CTDL_WARNING, "Error executing script: %s\n",
 104                 sieve2_getvalue_string(s, "message")
 105         );
 106         return SIEVE2_OK;
 107 }
 108
 109
 110 /*
 111  * Callback function to redirect a message to a different folder
 112  */
 113 int ctdl_redirect(sieve2_context_t *s, void *my)
 114 {
 115         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 116         struct CtdlMessage *msg = NULL;
 117         struct recptypes *valid = NULL;
 118         char recp[256];
 119
 120         safestrncpy(recp, sieve2_getvalue_string(s, "address"), sizeof recp);
 121
 122         lprintf(CTDL_DEBUG, "Action is REDIRECT, recipient <%s>\n", recp);
 123
 124         valid = validate_recipients(recp);
 125         if (valid == NULL) {
 126                 lprintf(CTDL_WARNING, "REDIRECT failed: bad recipient <%s>\n", recp);
 127                 return SIEVE2_ERROR_BADARGS;
 128         }
 129         if (valid->num_error > 0) {
 130                 lprintf(CTDL_WARNING, "REDIRECT failed: bad recipient <%s>\n", recp);
 131                 free(valid);
 132                 return SIEVE2_ERROR_BADARGS;
 133         }
 134
 135         msg = CtdlFetchMessage(cs->msgnum, 1);
 136         if (msg == NULL) {
 137                 lprintf(CTDL_WARNING, "REDIRECT failed: unable to fetch msg %ld\n", cs->msgnum);
 138                 free(valid);
 139                 return SIEVE2_ERROR_BADARGS;
 140         }
 141
 142         CtdlSubmitMsg(msg, valid, NULL);
 143         cs->actiontaken = 1;
 144         free(valid);
 145         CtdlFreeMessage(msg);
 146         return SIEVE2_OK;
 147 }
 148
 149
 150 /*
 151  * Callback function to indicate that a message *will* be kept in the inbox
 152  */
 153 int ctdl_keep(sieve2_context_t *s, void *my)
 154 {
 155         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 156
 157         lprintf(CTDL_DEBUG, "Action is KEEP\n");
 158
 159         cs->keep = 1;
 160         cs->actiontaken = 1;
 161         return SIEVE2_OK;
 162 }
 163
 164
 165 /*
 166  * Callback function to file a message into a different mailbox
 167  */
 168 int ctdl_fileinto(sieve2_context_t *s, void *my)
 169 {
 170         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 171         const char *dest_folder = sieve2_getvalue_string(s, "mailbox");
 172         int c;
 173         char foldername[256];
 174         char original_room_name[ROOMNAMELEN];
 175
 176         lprintf(CTDL_DEBUG, "Action is FILEINTO, destination is <%s>\n", dest_folder);
 177
 178         /* FILEINTO 'INBOX' is the same thing as KEEP */
 179         if ( (!strcasecmp(dest_folder, "INBOX")) || (!strcasecmp(dest_folder, MAILROOM)) ) {
 180                 cs->keep = 1;
 181                 cs->actiontaken = 1;
 182                 return SIEVE2_OK;
 183         }
 184
 185         /* Remember what room we came from */
 186         safestrncpy(original_room_name, CC->room.QRname, sizeof original_room_name);
 187
 188         /* First try a mailbox name match (check personal mail folders first) */
 189         snprintf(foldername, sizeof foldername, "%010ld.%s", cs->usernum, dest_folder);
 190         c = getroom(&CC->room, foldername);
 191
 192         /* Then a regular room name match (public and private rooms) */
 193         if (c < 0) {
 194                 safestrncpy(foldername, dest_folder, sizeof foldername);
 195                 c = getroom(&CC->room, foldername);
 196         }
 197
 198         if (c < 0) {
 199                 lprintf(CTDL_WARNING, "FILEINTO failed: target <%s> does not exist\n", dest_folder);
 200                 return SIEVE2_ERROR_BADARGS;
 201         }
 202
 203         /* Yes, we actually have to go there */
 204         usergoto(NULL, 0, 0, NULL, NULL);
 205
 206         c = CtdlSaveMsgPointersInRoom(NULL, &cs->msgnum, 1, 0, NULL);
 207
 208         /* Go back to the room we came from */
 209         if (strcasecmp(original_room_name, CC->room.QRname)) {
 210                 usergoto(original_room_name, 0, 0, NULL, NULL);
 211         }
 212
 213         if (c == 0) {
 214                 cs->actiontaken = 1;
 215                 return SIEVE2_OK;
 216         }
 217         else {
 218                 return SIEVE2_ERROR_BADARGS;
 219         }
 220 }
 221
 222
 223 /*
 224  * Callback function to indicate that a message should be rejected
 225  * FIXME implement this
 226  */
 227 int ctdl_reject(sieve2_context_t *s, void *my)
 228 {
 229         lprintf(CTDL_DEBUG, "Action is REJECT\n");
 230         return SIEVE2_ERROR_UNSUPPORTED;
 231 }
 232
 233
 234 /*
 235  * Callback function to indicate that the user should be notified
 236  * FIXME implement this
 237  */
 238 int ctdl_notify(sieve2_context_t *s, void *my)
 239 {
 240         lprintf(CTDL_DEBUG, "Action is NOTIFY\n");
 241         return SIEVE2_ERROR_UNSUPPORTED;
 242 }
 243
 244
 245 /*
 246  * Callback function to indicate that a vacation message should be generated
 247  * FIXME implement this
 248  */
 249 int ctdl_vacation(sieve2_context_t *s, void *my)
 250 {
 251         lprintf(CTDL_DEBUG, "Action is VACATION\n");
 252         return SIEVE2_ERROR_UNSUPPORTED;
 253 }
 254
 255
 256 /*
 257  * Callback function to parse addresses per local system convention
 258  * FIXME implement this
 259  */
 260 int ctdl_getsubaddress(sieve2_context_t *s, void *my)
 261 {
 262         return SIEVE2_ERROR_UNSUPPORTED;
 263 }
 264
 265
 266 /*
 267  * Callback function to parse message envelope
 268  * FIXME implement this
 269  */
 270 int ctdl_getenvelope(sieve2_context_t *s, void *my)
 271 {
 272         return SIEVE2_ERROR_UNSUPPORTED;
 273 }
 274
 275
 276 /*
 277  * Callback function to fetch message body
 278  * FIXME implement this
 279  */
 280 int ctdl_getbody(sieve2_context_t *s, void *my)
 281 {
 282         return SIEVE2_ERROR_UNSUPPORTED;
 283 }
 284
 285
 286 /*
 287  * Callback function to fetch message size
 288  * FIXME implement this
 289  */
 290 int ctdl_getsize(sieve2_context_t *s, void *my)
 291 {
 292         return SIEVE2_ERROR_UNSUPPORTED;
 293 }
 294
 295
 296 /*
 297  * Callback function to indicate that a message should be discarded.
 298  */
 299 int ctdl_discard(sieve2_context_t *s, void *my)
 300 {
 301         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 302
 303         lprintf(CTDL_DEBUG, "Action is DISCARD\n");
 304
 305         /* Yes, this is really all there is to it.  Since we are not setting "keep" to 1,
 306          * the message will be discarded because "some other action" was successfully taken.
 307          */
 308         cs->actiontaken = 1;
 309         return SIEVE2_OK;
 310 }
 311
 312
 313
 314 /*
 315  * Callback function to retrieve the sieve script
 316  * FIXME fetch script from Citadel instead of hardcode
 317  */
 318 int ctdl_getscript(sieve2_context_t *s, void *my) {
 319
 320         lprintf(CTDL_DEBUG, "ctdl_getscript() was called\n");
 321
 322         sieve2_setvalue_string(s, "script",
 323
 324                 "require \"fileinto\";                                          \n"
 325                 "    if header :contains [\"Subject\"]  [\"frobnitz\"] {        \n"
 326                 "        redirect \"foo@example.com\";                          \n"
 327                 "    } elsif header :contains \"Subject\" \"XYZZY\" {           \n"
 328                 "        fileinto \"plugh\";                                    \n"
 329                 "    } else {                                                   \n"
 330                 "        keep;                                                  \n"
 331                 "    }                                                          \n"
 332
 333         );
 334
 335         return SIEVE2_OK;
 336 }
 337
 338 /*
 339  * Callback function to retrieve message headers
 340  */
 341 int ctdl_getheaders(sieve2_context_t *s, void *my) {
 342
 343         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 344
 345         lprintf(CTDL_DEBUG, "ctdl_getheaders() was called\n");
 346
 347         sieve2_setvalue_string(s, "allheaders", cs->rfc822headers);
 348         return SIEVE2_OK;
 349 }
 350
 351
 352
 353 /*
 354  * Add a room to the list of those rooms which potentially require sieve processing
 355  */
 356 void sieve_queue_room(struct ctdlroom *which_room) {
 357         struct RoomProcList *ptr;
 358
 359         ptr = (struct RoomProcList *) malloc(sizeof (struct RoomProcList));
 360         if (ptr == NULL) return;
 361
 362         safestrncpy(ptr->name, which_room->QRname, sizeof ptr->name);
 363         begin_critical_section(S_SIEVELIST);
 364         ptr->next = sieve_list;
 365         sieve_list = ptr;
 366         end_critical_section(S_SIEVELIST);
 367 }
 368
 369
 370
 371 /*
 372  * Perform sieve processing for one message (called by sieve_do_room() for each message)
 373  */
 374 void sieve_do_msg(long msgnum, void *userdata) {
 375         sieve2_context_t *sieve2_context = (sieve2_context_t *) userdata;
 376         struct ctdl_sieve my;
 377         int res;
 378
 379         lprintf(CTDL_DEBUG, "Performing sieve processing on msg <%ld>\n", msgnum);
 380
 381         CC->redirect_buffer = malloc(SIZ);
 382         CC->redirect_len = 0;
 383         CC->redirect_alloc = SIZ;
 384         CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ONLY, 0, 1, NULL);
 385         my.rfc822headers = CC->redirect_buffer;
 386         CC->redirect_buffer = NULL;
 387         CC->redirect_len = 0;
 388         CC->redirect_alloc = 0;
 389
 390         my.keep = 0;            /* Don't keep a copy in the inbox unless a callback tells us to do so */
 391         my.actiontaken = 0;     /* Keep track of whether any actions were successfully taken */
 392         my.usernum = atol(CC->room.QRname);     /* Keep track of the owner of the room's namespace */
 393         my.msgnum = msgnum;     /* Keep track of the message number in our local store */
 394
 395         sieve2_setvalue_string(sieve2_context, "allheaders", my.rfc822headers);
 396
 397         lprintf(CTDL_DEBUG, "Calling sieve2_execute()\n");
 398         res = sieve2_execute(sieve2_context, &my);
 399         if (res != SIEVE2_OK) {
 400                 lprintf(CTDL_CRIT, "sieve2_execute() returned %d: %s\n", res, sieve2_errstr(res));
 401         }
 402
 403         free(my.rfc822headers);
 404         my.rfc822headers = NULL;
 405
 406         /*
 407          * Delete the message from the inbox unless either we were told not to, or
 408          * if no other action was successfully taken.
 409          */
 410         if ( (!my.keep) && (my.actiontaken) ) {
 411                 lprintf(CTDL_DEBUG, "keep is 0 -- deleting message from inbox\n");
 412                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "", 0);
 413         }
 414
 415         lprintf(CTDL_DEBUG, "Completed sieve processing on msg <%ld>\n", msgnum);
 416
 417         return;
 418 }
 419
 420
 421 /*
 422  * Perform sieve processing for a single room
 423  */
 424 void sieve_do_room(char *roomname) {
 425
 426         sieve2_context_t *sieve2_context = NULL;        /* Context for sieve parser */
 427         int res;                                        /* Return code from libsieve calls */
 428
 429         /*
 430          * This is our callback registration table for libSieve.
 431          */
 432         sieve2_callback_t ctdl_sieve_callbacks[] = {
 433                 { SIEVE2_ACTION_REJECT,         ctdl_reject             },
 434                 { SIEVE2_ACTION_NOTIFY,         ctdl_notify             },
 435                 { SIEVE2_ACTION_VACATION,       ctdl_vacation           },
 436                 { SIEVE2_ERRCALL_PARSE,         ctdl_errparse           },
 437                 { SIEVE2_ERRCALL_RUNTIME,       ctdl_errexec            },
 438                 { SIEVE2_ACTION_FILEINTO,       ctdl_fileinto           },
 439                 { SIEVE2_ACTION_REDIRECT,       ctdl_redirect           },
 440                 { SIEVE2_ACTION_DISCARD,        ctdl_discard            },
 441                 { SIEVE2_ACTION_KEEP,           ctdl_keep               },
 442                 { SIEVE2_SCRIPT_GETSCRIPT,      ctdl_getscript          },
 443                 { SIEVE2_DEBUG_TRACE,           ctdl_debug              },
 444                 { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders         },
 445                 { SIEVE2_MESSAGE_GETSUBADDRESS, ctdl_getsubaddress      },
 446                 { SIEVE2_MESSAGE_GETENVELOPE,   ctdl_getenvelope        },
 447                 { SIEVE2_MESSAGE_GETBODY,       ctdl_getbody            },
 448                 { SIEVE2_MESSAGE_GETSIZE,       ctdl_getsize            },
 449                 { 0 }
 450         };
 451
 452         /* FIXME check to see if this room has any sieve scripts to run */
 453
 454         lprintf(CTDL_DEBUG, "Performing Sieve processing for <%s>\n", roomname);
 455
 456         if (getroom(&CC->room, roomname) != 0) {
 457                 lprintf(CTDL_CRIT, "ERROR: cannot load <%s>\n", roomname);
 458                 return;
 459         }
 460
 461         /* Initialize the Sieve parser */
 462
 463         res = sieve2_alloc(&sieve2_context);
 464         if (res != SIEVE2_OK) {
 465                 lprintf(CTDL_CRIT, "sieve2_alloc() returned %d: %s\n", res, sieve2_errstr(res));
 466                 return;
 467         }
 468
 469         res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks);
 470         if (res != SIEVE2_OK) {
 471                 lprintf(CTDL_CRIT, "sieve2_callbacks() returned %d: %s\n", res, sieve2_errstr(res));
 472                 goto BAIL;
 473         }
 474
 475         /* Validate the script */
 476
 477         res = sieve2_validate(sieve2_context, NULL);
 478         if (res != SIEVE2_OK) {
 479                 lprintf(CTDL_CRIT, "sieve2_validate() returned %d: %s\n", res, sieve2_errstr(res));
 480                 goto BAIL;
 481         }
 482
 483         /* Do something useful */
 484         /* CtdlForEachMessage(MSGS_GT, sc.lastsent, NULL, NULL, NULL, */
 485         /* FIXME figure out which messages haven't yet been processed by sieve */
 486         CtdlForEachMessage(MSGS_LAST, 1, NULL, NULL, NULL,
 487                 sieve_do_msg,
 488                 (void *) sieve2_context
 489         );
 490
 491 BAIL:
 492         res = sieve2_free(&sieve2_context);
 493         if (res != SIEVE2_OK) {
 494                 lprintf(CTDL_CRIT, "sieve2_free() returned %d: %s\n", res, sieve2_errstr(res));
 495         }
 496 }
 497
 498
 499 /*
 500  * Perform sieve processing for all rooms which require it
 501  */
 502 void perform_sieve_processing(void) {
 503         struct RoomProcList *ptr = NULL;
 504
 505         if (sieve_list != NULL) {
 506                 lprintf(CTDL_DEBUG, "Begin Sieve processing\n");
 507                 while (sieve_list != NULL) {
 508                         char spoolroomname[ROOMNAMELEN];
 509                         safestrncpy(spoolroomname, sieve_list->name, sizeof spoolroomname);
 510                         begin_critical_section(S_SIEVELIST);
 511
 512                         /* pop this record off the list */
 513                         ptr = sieve_list;
 514                         sieve_list = sieve_list->next;
 515                         free(ptr);
 516
 517                         /* invalidate any duplicate entries to prevent double processing */
 518                         for (ptr=sieve_list; ptr!=NULL; ptr=ptr->next) {
 519                                 if (!strcasecmp(ptr->name, spoolroomname)) {
 520                                         ptr->name[0] = 0;
 521                                 }
 522                         }
 523
 524                         end_critical_section(S_SIEVELIST);
 525                         if (spoolroomname[0] != 0) {
 526                                 sieve_do_room(spoolroomname);
 527                         }
 528                 }
 529         }
 530 }
 531
 532
 533
 534 /**
 535  *      We don't really care about dumping the entire credits to the log
 536  *      every time the server is initialized.  The documentation will suffice
 537  *      for that purpose.  We are making a call to sieve2_credits() in order
 538  *      to demonstrate that we have successfully linked in to libsieve.
 539  */
 540 void log_the_sieve2_credits(void) {
 541         char *cred = NULL;
 542
 543         cred = strdup(sieve2_credits());
 544         if (cred == NULL) return;
 545
 546         if (strlen(cred) > 60) {
 547                 strcpy(&cred[55], "...");
 548         }
 549
 550         lprintf(CTDL_INFO, "%s\n",cred);
 551         free(cred);
 552 }
 553
 554
 555 char *serv_sieve_init(void)
 556 {
 557         log_the_sieve2_credits();
 558         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 559 }
 560
 561 #else   /* HAVE_LIBSIEVE */
 562
 563 char *serv_sieve_init(void)
 564 {
 565         lprintf(CTDL_INFO, "This server is missing libsieve.  Mailbox filtering will be disabled.\n");
 566         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 567 }
 568
 569 #endif  /* HAVE_LIBSIEVE */