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  * We need this struct to pass a bunch of information
 372  * between sieve_do_msg() and sieve_do_room()
 373  */
 374 struct sdm_userdata {
 375         sieve2_context_t *sieve2_context;       /**< for libsieve's use */
 376         long lastproc;                          /**< last message processed */
 377 };
 378
 379
 380 /*
 381  * Perform sieve processing for one message (called by sieve_do_room() for each message)
 382  */
 383 void sieve_do_msg(long msgnum, void *userdata) {
 384         struct sdm_userdata *u = (struct sdm_userdata *) userdata;
 385         sieve2_context_t *sieve2_context = u->sieve2_context;
 386         struct ctdl_sieve my;
 387         int res;
 388
 389         lprintf(CTDL_DEBUG, "Performing sieve processing on msg <%ld>\n", msgnum);
 390
 391         CC->redirect_buffer = malloc(SIZ);
 392         CC->redirect_len = 0;
 393         CC->redirect_alloc = SIZ;
 394         CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ONLY, 0, 1, NULL);
 395         my.rfc822headers = CC->redirect_buffer;
 396         CC->redirect_buffer = NULL;
 397         CC->redirect_len = 0;
 398         CC->redirect_alloc = 0;
 399
 400         my.keep = 0;            /* Don't keep a copy in the inbox unless a callback tells us to do so */
 401         my.actiontaken = 0;     /* Keep track of whether any actions were successfully taken */
 402         my.usernum = atol(CC->room.QRname);     /* Keep track of the owner of the room's namespace */
 403         my.msgnum = msgnum;     /* Keep track of the message number in our local store */
 404
 405         sieve2_setvalue_string(sieve2_context, "allheaders", my.rfc822headers);
 406
 407         lprintf(CTDL_DEBUG, "Calling sieve2_execute()\n");
 408         res = sieve2_execute(sieve2_context, &my);
 409         if (res != SIEVE2_OK) {
 410                 lprintf(CTDL_CRIT, "sieve2_execute() returned %d: %s\n", res, sieve2_errstr(res));
 411         }
 412
 413         free(my.rfc822headers);
 414         my.rfc822headers = NULL;
 415
 416         /*
 417          * Delete the message from the inbox unless either we were told not to, or
 418          * if no other action was successfully taken.
 419          */
 420         if ( (!my.keep) && (my.actiontaken) ) {
 421                 lprintf(CTDL_DEBUG, "keep is 0 -- deleting message from inbox\n");
 422                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "", 0);
 423         }
 424
 425         lprintf(CTDL_DEBUG, "Completed sieve processing on msg <%ld>\n", msgnum);
 426         u->lastproc = msgnum;
 427
 428         return;
 429 }
 430
 431
 432 /*
 433  * Perform sieve processing for a single room
 434  */
 435 void sieve_do_room(char *roomname) {
 436
 437         struct sdm_userdata u;
 438         sieve2_context_t *sieve2_context = NULL;        /* Context for sieve parser */
 439         int res;                                        /* Return code from libsieve calls */
 440         char sieveroomname[ROOMNAMELEN];
 441
 442         /*
 443          * This is our callback registration table for libSieve.
 444          */
 445         sieve2_callback_t ctdl_sieve_callbacks[] = {
 446                 { SIEVE2_ACTION_REJECT,         ctdl_reject             },
 447                 { SIEVE2_ACTION_NOTIFY,         ctdl_notify             },
 448                 { SIEVE2_ACTION_VACATION,       ctdl_vacation           },
 449                 { SIEVE2_ERRCALL_PARSE,         ctdl_errparse           },
 450                 { SIEVE2_ERRCALL_RUNTIME,       ctdl_errexec            },
 451                 { SIEVE2_ACTION_FILEINTO,       ctdl_fileinto           },
 452                 { SIEVE2_ACTION_REDIRECT,       ctdl_redirect           },
 453                 { SIEVE2_ACTION_DISCARD,        ctdl_discard            },
 454                 { SIEVE2_ACTION_KEEP,           ctdl_keep               },
 455                 { SIEVE2_SCRIPT_GETSCRIPT,      ctdl_getscript          },
 456                 { SIEVE2_DEBUG_TRACE,           ctdl_debug              },
 457                 { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders         },
 458                 { SIEVE2_MESSAGE_GETSUBADDRESS, ctdl_getsubaddress      },
 459                 { SIEVE2_MESSAGE_GETENVELOPE,   ctdl_getenvelope        },
 460                 { SIEVE2_MESSAGE_GETBODY,       ctdl_getbody            },
 461                 { SIEVE2_MESSAGE_GETSIZE,       ctdl_getsize            },
 462                 { 0 }
 463         };
 464
 465         /* See if the user who owns this 'mailbox' has any Sieve scripts that
 466          * require execution.
 467          */
 468         snprintf(sieveroomname, sizeof sieveroomname, "%010ld.%s", atol(roomname), SIEVERULES);
 469         if (getroom(&CC->room, sieveroomname) != 0) {
 470                 lprintf(CTDL_DEBUG, "<%s> does not exist.  No processing is required.\n", sieveroomname);
 471                 return;
 472         }
 473
 474         /* CtdlForEachMessage(FIXME find the sieve scripts and control record and do something */
 475
 476         lprintf(CTDL_DEBUG, "Performing Sieve processing for <%s>\n", roomname);
 477
 478         if (getroom(&CC->room, roomname) != 0) {
 479                 lprintf(CTDL_CRIT, "ERROR: cannot load <%s>\n", roomname);
 480                 return;
 481         }
 482
 483         /* Initialize the Sieve parser */
 484
 485         res = sieve2_alloc(&sieve2_context);
 486         if (res != SIEVE2_OK) {
 487                 lprintf(CTDL_CRIT, "sieve2_alloc() returned %d: %s\n", res, sieve2_errstr(res));
 488                 return;
 489         }
 490
 491         res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks);
 492         if (res != SIEVE2_OK) {
 493                 lprintf(CTDL_CRIT, "sieve2_callbacks() returned %d: %s\n", res, sieve2_errstr(res));
 494                 goto BAIL;
 495         }
 496
 497         /* Validate the script */
 498
 499         res = sieve2_validate(sieve2_context, NULL);
 500         if (res != SIEVE2_OK) {
 501                 lprintf(CTDL_CRIT, "sieve2_validate() returned %d: %s\n", res, sieve2_errstr(res));
 502                 goto BAIL;
 503         }
 504
 505         /* Do something useful */
 506         u.sieve2_context = sieve2_context;
 507         CtdlForEachMessage(MSGS_GT, u.lastproc, NULL, NULL, NULL,
 508                 sieve_do_msg,
 509                 (void *) &u
 510         );
 511
 512 BAIL:
 513         res = sieve2_free(&sieve2_context);
 514         if (res != SIEVE2_OK) {
 515                 lprintf(CTDL_CRIT, "sieve2_free() returned %d: %s\n", res, sieve2_errstr(res));
 516         }
 517 }
 518
 519
 520 /*
 521  * Perform sieve processing for all rooms which require it
 522  */
 523 void perform_sieve_processing(void) {
 524         struct RoomProcList *ptr = NULL;
 525
 526         if (sieve_list != NULL) {
 527                 lprintf(CTDL_DEBUG, "Begin Sieve processing\n");
 528                 while (sieve_list != NULL) {
 529                         char spoolroomname[ROOMNAMELEN];
 530                         safestrncpy(spoolroomname, sieve_list->name, sizeof spoolroomname);
 531                         begin_critical_section(S_SIEVELIST);
 532
 533                         /* pop this record off the list */
 534                         ptr = sieve_list;
 535                         sieve_list = sieve_list->next;
 536                         free(ptr);
 537
 538                         /* invalidate any duplicate entries to prevent double processing */
 539                         for (ptr=sieve_list; ptr!=NULL; ptr=ptr->next) {
 540                                 if (!strcasecmp(ptr->name, spoolroomname)) {
 541                                         ptr->name[0] = 0;
 542                                 }
 543                         }
 544
 545                         end_critical_section(S_SIEVELIST);
 546                         if (spoolroomname[0] != 0) {
 547                                 sieve_do_room(spoolroomname);
 548                         }
 549                 }
 550         }
 551 }
 552
 553
 554
 555 /**
 556  *      We don't really care about dumping the entire credits to the log
 557  *      every time the server is initialized.  The documentation will suffice
 558  *      for that purpose.  We are making a call to sieve2_credits() in order
 559  *      to demonstrate that we have successfully linked in to libsieve.
 560  */
 561 void log_the_sieve2_credits(void) {
 562         char *cred = NULL;
 563
 564         cred = strdup(sieve2_credits());
 565         if (cred == NULL) return;
 566
 567         if (strlen(cred) > 60) {
 568                 strcpy(&cred[55], "...");
 569         }
 570
 571         lprintf(CTDL_INFO, "%s\n",cred);
 572         free(cred);
 573 }
 574
 575
 576 char *serv_sieve_init(void)
 577 {
 578         log_the_sieve2_credits();
 579         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 580 }
 581
 582 #else   /* HAVE_LIBSIEVE */
 583
 584 char *serv_sieve_init(void)
 585 {
 586         lprintf(CTDL_INFO, "This server is missing libsieve.  Mailbox filtering will be disabled.\n");
 587         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 588 }
 589
 590 #endif  /* HAVE_LIBSIEVE */