citadel/modules/inboxrules/serv_inboxrules.c

   1 /*
   2  * Inbox handling rules
   3  *
   4  * Copyright (c) 1987-2020 by the citadel.org team
   5  *
   6  * This program is open source software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 3.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include "sysdep.h"
  16 #include <stdlib.h>
  17 #include <unistd.h>
  18 #include <stdio.h>
  19 #include <fcntl.h>
  20 #include <ctype.h>
  21 #include <pwd.h>
  22 #include <errno.h>
  23 #include <sys/types.h>
  24
  25 #if TIME_WITH_SYS_TIME
  26 # include <sys/time.h>
  27 # include <time.h>
  28 #else
  29 # if HAVE_SYS_TIME_H
  30 #  include <sys/time.h>
  31 # else
  32 #  include <time.h>
  33 # endif
  34 #endif
  35
  36 #include <sys/wait.h>
  37 #include <string.h>
  38 #include <limits.h>
  39 #include <libcitadel.h>
  40 #include "citadel.h"
  41 #include "server.h"
  42 #include "citserver.h"
  43 #include "support.h"
  44 #include "config.h"
  45 #include "database.h"
  46 #include "msgbase.h"
  47 #include "internet_addressing.h"
  48 #include "ctdl_module.h"
  49
  50
  51 #if 0
  52
  53 /*
  54  * Callback function to redirect a message to a different folder
  55  */
  56 int ctdl_redirect(void)
  57 {
  58         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
  59         struct CtdlMessage *msg = NULL;
  60         recptypes *valid = NULL;
  61         char recp[256];
  62
  63         safestrncpy(recp, sieve2_getvalue_string(s, "address"), sizeof recp);
  64
  65         syslog(LOG_DEBUG, "Action is REDIRECT, recipient <%s>", recp);
  66
  67         valid = validate_recipients(recp, NULL, 0);
  68         if (valid == NULL) {
  69                 syslog(LOG_WARNING, "REDIRECT failed: bad recipient <%s>", recp);
  70                 return SIEVE2_ERROR_BADARGS;
  71         }
  72         if (valid->num_error > 0) {
  73                 syslog(LOG_WARNING, "REDIRECT failed: bad recipient <%s>", recp);
  74                 free_recipients(valid);
  75                 return SIEVE2_ERROR_BADARGS;
  76         }
  77
  78         msg = CtdlFetchMessage(cs->msgnum, 1, 1);
  79         if (msg == NULL) {
  80                 syslog(LOG_WARNING, "REDIRECT failed: unable to fetch msg %ld", cs->msgnum);
  81                 free_recipients(valid);
  82                 return SIEVE2_ERROR_BADARGS;
  83         }
  84
  85         CtdlSubmitMsg(msg, valid, NULL, 0);
  86         cs->cancel_implicit_keep = 1;
  87         free_recipients(valid);
  88         CM_Free(msg);
  89         return SIEVE2_OK;
  90 }
  91
  92
  93 /*
  94  * Callback function to indicate that a message *will* be kept in the inbox
  95  */
  96 int ctdl_keep(sieve2_context_t *s, void *my)
  97 {
  98         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
  99
 100         syslog(LOG_DEBUG, "Action is KEEP");
 101
 102         cs->keep = 1;
 103         cs->cancel_implicit_keep = 1;
 104         return SIEVE2_OK;
 105 }
 106
 107
 108 /*
 109  * Callback function to file a message into a different mailbox
 110  */
 111 int ctdl_fileinto(sieve2_context_t *s, void *my)
 112 {
 113         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 114         const char *dest_folder = sieve2_getvalue_string(s, "mailbox");
 115         int c;
 116         char foldername[256];
 117         char original_room_name[ROOMNAMELEN];
 118
 119         syslog(LOG_DEBUG, "Action is FILEINTO, destination is <%s>", dest_folder);
 120
 121         /* FILEINTO 'INBOX' is the same thing as KEEP */
 122         if ( (!strcasecmp(dest_folder, "INBOX")) || (!strcasecmp(dest_folder, MAILROOM)) ) {
 123                 cs->keep = 1;
 124                 cs->cancel_implicit_keep = 1;
 125                 return SIEVE2_OK;
 126         }
 127
 128         /* Remember what room we came from */
 129         safestrncpy(original_room_name, CC->room.QRname, sizeof original_room_name);
 130
 131         /* First try a mailbox name match (check personal mail folders first) */
 132         snprintf(foldername, sizeof foldername, "%010ld.%s", cs->usernum, dest_folder);
 133         c = CtdlGetRoom(&CC->room, foldername);
 134
 135         /* Then a regular room name match (public and private rooms) */
 136         if (c != 0) {
 137                 safestrncpy(foldername, dest_folder, sizeof foldername);
 138                 c = CtdlGetRoom(&CC->room, foldername);
 139         }
 140
 141         if (c != 0) {
 142                 syslog(LOG_WARNING, "FILEINTO failed: target <%s> does not exist", dest_folder);
 143                 return SIEVE2_ERROR_BADARGS;
 144         }
 145
 146         /* Yes, we actually have to go there */
 147         CtdlUserGoto(NULL, 0, 0, NULL, NULL, NULL, NULL);
 148
 149         c = CtdlSaveMsgPointersInRoom(NULL, &cs->msgnum, 1, 0, NULL, 0);
 150
 151         /* Go back to the room we came from */
 152         if (strcasecmp(original_room_name, CC->room.QRname)) {
 153                 CtdlUserGoto(original_room_name, 0, 0, NULL, NULL, NULL, NULL);
 154         }
 155
 156         if (c == 0) {
 157                 cs->cancel_implicit_keep = 1;
 158                 return SIEVE2_OK;
 159         }
 160         else {
 161                 return SIEVE2_ERROR_BADARGS;
 162         }
 163 }
 164
 165
 166 /*
 167  * Callback function to indicate that a message should be discarded.
 168  */
 169 int ctdl_discard(sieve2_context_t *s, void *my)
 170 {
 171         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 172
 173         syslog(LOG_DEBUG, "Action is DISCARD");
 174
 175         /* Cancel the implicit keep.  That's all there is to it. */
 176         cs->cancel_implicit_keep = 1;
 177         return SIEVE2_OK;
 178 }
 179
 180
 181 /*
 182  * Callback function to indicate that a message should be rejected
 183  */
 184 int ctdl_reject(sieve2_context_t *s, void *my)
 185 {
 186         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 187         char *reject_text = NULL;
 188
 189         syslog(LOG_DEBUG, "Action is REJECT");
 190
 191         /* If we don't know who sent the message, do a DISCARD instead. */
 192         if (IsEmptyStr(cs->sender)) {
 193                 syslog(LOG_INFO, "Unknown sender.  Doing DISCARD instead of REJECT.");
 194                 return ctdl_discard(s, my);
 195         }
 196
 197         /* Assemble the reject message. */
 198         reject_text = malloc(strlen(sieve2_getvalue_string(s, "message")) + 1024);
 199         if (reject_text == NULL) {
 200                 return SIEVE2_ERROR_FAIL;
 201         }
 202
 203         sprintf(reject_text,
 204                 "Content-type: text/plain\n"
 205                 "\n"
 206                 "The message was refused by the recipient's mail filtering program.\n"
 207                 "The reason given was as follows:\n"
 208                 "\n"
 209                 "%s\n"
 210                 "\n"
 211         ,
 212                 sieve2_getvalue_string(s, "message")
 213         );
 214
 215         quickie_message(        /* This delivers the message */
 216                 NULL,
 217                 cs->envelope_to,
 218                 cs->sender,
 219                 NULL,
 220                 reject_text,
 221                 FMT_RFC822,
 222                 "Delivery status notification"
 223         );
 224
 225         free(reject_text);
 226         cs->cancel_implicit_keep = 1;
 227         return SIEVE2_OK;
 228 }
 229
 230
 231 /*
 232  * Callback function to indicate that a vacation message should be generated
 233  */
 234 int ctdl_vacation(sieve2_context_t *s, void *my)
 235 {
 236         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 237         struct sdm_vacation *vptr;
 238         int days = 1;
 239         const char *message;
 240         char *vacamsg_text = NULL;
 241         char vacamsg_subject[1024];
 242
 243         syslog(LOG_DEBUG, "Action is VACATION");
 244
 245         message = sieve2_getvalue_string(s, "message");
 246         if (message == NULL) return SIEVE2_ERROR_BADARGS;
 247
 248         if (sieve2_getvalue_string(s, "subject") != NULL) {
 249                 safestrncpy(vacamsg_subject, sieve2_getvalue_string(s, "subject"), sizeof vacamsg_subject);
 250         }
 251         else {
 252                 snprintf(vacamsg_subject, sizeof vacamsg_subject, "Re: %s", cs->subject);
 253         }
 254
 255         days = sieve2_getvalue_int(s, "days");
 256         if (days < 1) days = 1;
 257         if (days > MAX_VACATION) days = MAX_VACATION;
 258
 259         /* Check to see whether we've already alerted this sender that we're on vacation. */
 260         for (vptr = cs->u->first_vacation; vptr != NULL; vptr = vptr->next) {
 261                 if (!strcasecmp(vptr->fromaddr, cs->sender)) {
 262                         if ( (time(NULL) - vptr->timestamp) < (days * 86400) ) {
 263                                 syslog(LOG_DEBUG, "Already alerted <%s> recently.", cs->sender);
 264                                 return SIEVE2_OK;
 265                         }
 266                 }
 267         }
 268
 269         /* Assemble the reject message. */
 270         vacamsg_text = malloc(strlen(message) + 1024);
 271         if (vacamsg_text == NULL) {
 272                 return SIEVE2_ERROR_FAIL;
 273         }
 274
 275         sprintf(vacamsg_text,
 276                 "Content-type: text/plain charset=utf-8\n"
 277                 "\n"
 278                 "%s\n"
 279                 "\n"
 280         ,
 281                 message
 282         );
 283
 284         quickie_message(        /* This delivers the message */
 285                 NULL,
 286                 cs->envelope_to,
 287                 cs->sender,
 288                 NULL,
 289                 vacamsg_text,
 290                 FMT_RFC822,
 291                 vacamsg_subject
 292         );
 293
 294         free(vacamsg_text);
 295
 296         /* Now update the list to reflect the fact that we've alerted this sender.
 297          * If they're already in the list, just update the timestamp.
 298          */
 299         for (vptr = cs->u->first_vacation; vptr != NULL; vptr = vptr->next) {
 300                 if (!strcasecmp(vptr->fromaddr, cs->sender)) {
 301                         vptr->timestamp = time(NULL);
 302                         return SIEVE2_OK;
 303                 }
 304         }
 305
 306         /* If we get to this point, create a new record.
 307          */
 308         vptr = malloc(sizeof(struct sdm_vacation));
 309         memset(vptr, 0, sizeof(struct sdm_vacation));
 310         vptr->timestamp = time(NULL);
 311         safestrncpy(vptr->fromaddr, cs->sender, sizeof vptr->fromaddr);
 312         vptr->next = cs->u->first_vacation;
 313         cs->u->first_vacation = vptr;
 314
 315         return SIEVE2_OK;
 316 }
 317
 318
 319 /*
 320  * Callback function to parse message envelope
 321  */
 322 int ctdl_getenvelope(sieve2_context_t *s, void *my)
 323 {
 324         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 325
 326         syslog(LOG_DEBUG, "Action is GETENVELOPE");
 327         syslog(LOG_DEBUG, "EnvFrom: %s", cs->envelope_from);
 328         syslog(LOG_DEBUG, "EnvTo: %s", cs->envelope_to);
 329
 330         if (cs->envelope_from != NULL) {
 331                 if ((cs->envelope_from[0] != '@')&&(cs->envelope_from[strlen(cs->envelope_from)-1] != '@')) {
 332                         sieve2_setvalue_string(s, "from", cs->envelope_from);
 333                 }
 334                 else {
 335                         sieve2_setvalue_string(s, "from", "invalid_envelope_from@example.org");
 336                 }
 337         }
 338         else {
 339                 sieve2_setvalue_string(s, "from", "null_envelope_from@example.org");
 340         }
 341
 342
 343         if (cs->envelope_to != NULL) {
 344                 if ((cs->envelope_to[0] != '@') && (cs->envelope_to[strlen(cs->envelope_to)-1] != '@')) {
 345                         sieve2_setvalue_string(s, "to", cs->envelope_to);
 346                 }
 347                 else {
 348                         sieve2_setvalue_string(s, "to", "invalid_envelope_to@example.org");
 349                 }
 350         }
 351         else {
 352                 sieve2_setvalue_string(s, "to", "null_envelope_to@example.org");
 353         }
 354
 355         return SIEVE2_OK;
 356 }
 357
 358
 359
 360 /*
 361  * Callback function to fetch message size
 362  */
 363 int ctdl_getsize(sieve2_context_t *s, void *my)
 364 {
 365         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 366         struct MetaData smi;
 367
 368         GetMetaData(&smi, cs->msgnum);
 369
 370         if (smi.meta_rfc822_length > 0L) {
 371                 sieve2_setvalue_int(s, "size", (int)smi.meta_rfc822_length);
 372                 return SIEVE2_OK;
 373         }
 374
 375         return SIEVE2_ERROR_UNSUPPORTED;
 376 }
 377
 378
 379 /*
 380  * Return a pointer to the active Sieve script.
 381  * (Caller does NOT own the memory and should not free the returned pointer.)
 382  */
 383 char *get_active_script(struct sdm_userdata *u) {
 384         struct sdm_script *sptr;
 385
 386         for (sptr=u->first_script; sptr!=NULL; sptr=sptr->next) {
 387                 if (sptr->script_active > 0) {
 388                         syslog(LOG_DEBUG, "get_active_script() is using script '%s'", sptr->script_name);
 389                         return(sptr->script_content);
 390                 }
 391         }
 392
 393         syslog(LOG_DEBUG, "get_active_script() found no active script");
 394         return(NULL);
 395 }
 396
 397
 398 /*
 399  * Callback function to retrieve the sieve script
 400  */
 401 int ctdl_getscript(sieve2_context_t *s, void *my) {
 402         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 403
 404         char *active_script = get_active_script(cs->u);
 405         if (active_script != NULL) {
 406                 sieve2_setvalue_string(s, "script", active_script);
 407                 return SIEVE2_OK;
 408         }
 409
 410         return SIEVE2_ERROR_GETSCRIPT;
 411 }
 412
 413
 414 /*
 415  * Callback function to retrieve message headers
 416  */
 417 int ctdl_getheaders(sieve2_context_t *s, void *my) {
 418
 419         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 420
 421         syslog(LOG_DEBUG, "ctdl_getheaders() was called");
 422         sieve2_setvalue_string(s, "allheaders", cs->rfc822headers);
 423         return SIEVE2_OK;
 424 }
 425
 426
 427
 428 /*
 429  * Perform sieve processing for one message (called by sieve_do_room() for each message)
 430  */
 431 void sieve_do_msg(long msgnum, void *userdata) {
 432         struct sdm_userdata *u = (struct sdm_userdata *) userdata;
 433         sieve2_context_t *sieve2_context;
 434         struct ctdl_sieve my;
 435         int res;
 436         struct CtdlMessage *msg;
 437         int i;
 438         size_t headers_len = 0;
 439         int len = 0;
 440
 441         if (u == NULL) {
 442                 syslog(LOG_ERR, "Can't process message <%ld> without userdata!", msgnum);
 443                 return;
 444         }
 445
 446         sieve2_context = u->sieve2_context;
 447
 448         syslog(LOG_DEBUG, "Performing sieve processing on msg <%ld>", msgnum);
 449
 450         /*
 451          * Make sure you include message body so you can get those second-level headers ;)
 452          */
 453         msg = CtdlFetchMessage(msgnum, 1, 1);
 454         if (msg == NULL) return;
 455
 456         /*
 457          * Grab the message headers so we can feed them to libSieve.
 458          * Use HEADERS_ONLY rather than HEADERS_FAST in order to include second-level headers.
 459          */
 460         CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
 461         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ONLY, 0, 1, 0);
 462         headers_len = StrLength(CC->redirect_buffer);
 463         my.rfc822headers = SmashStrBuf(&CC->redirect_buffer);
 464
 465         /*
 466          * libSieve clobbers the stack if it encounters badly formed
 467          * headers.  Sanitize our headers by stripping nonprintable
 468          * characters.
 469          */
 470         for (i=0; i<headers_len; ++i) {
 471                 if (!isascii(my.rfc822headers[i])) {
 472                         my.rfc822headers[i] = '_';
 473                 }
 474         }
 475
 476         my.keep = 0;                            /* Set to 1 to declare an *explicit* keep */
 477         my.cancel_implicit_keep = 0;            /* Some actions will cancel the implicit keep */
 478         my.usernum = atol(CC->room.QRname);     /* Keep track of the owner of the room's namespace */
 479         my.msgnum = msgnum;                     /* Keep track of the message number in our local store */
 480         my.u = u;                               /* Hand off a pointer to the rest of this info */
 481
 482         /* Keep track of the recipient so we can do handling based on it later */
 483         process_rfc822_addr(msg->cm_fields[eRecipient], my.recp_user, my.recp_node, my.recp_name);
 484
 485         /* Keep track of the sender so we can use it for REJECT and VACATION responses */
 486         if (!CM_IsEmpty(msg, erFc822Addr)) {
 487                 safestrncpy(my.sender, msg->cm_fields[erFc822Addr], sizeof my.sender);
 488         }
 489         else if (!CM_IsEmpty(msg, eAuthor)) {
 490                 safestrncpy(my.sender, msg->cm_fields[eAuthor], sizeof my.sender);
 491         }
 492         else {
 493                 strcpy(my.sender, "");
 494         }
 495
 496         /* Keep track of the subject so we can use it for VACATION responses */
 497         if (!CM_IsEmpty(msg, eMsgSubject)) {
 498                 safestrncpy(my.subject, msg->cm_fields[eMsgSubject], sizeof my.subject);
 499         }
 500         else {
 501                 strcpy(my.subject, "");
 502         }
 503
 504         /* Keep track of the envelope-from address (use body-from if not found) */
 505         if (!CM_IsEmpty(msg, eMessagePath)) {
 506                 safestrncpy(my.envelope_from, msg->cm_fields[eMessagePath], sizeof my.envelope_from);
 507                 stripallbut(my.envelope_from, '<', '>');
 508         }
 509         else if (!CM_IsEmpty(msg, erFc822Addr)) {
 510                 safestrncpy(my.envelope_from, msg->cm_fields[erFc822Addr], sizeof my.envelope_from);
 511                 stripallbut(my.envelope_from, '<', '>');
 512         }
 513         else {
 514                 strcpy(my.envelope_from, "");
 515         }
 516
 517         len = strlen(my.envelope_from);
 518         for (i=0; i<len; ++i) {
 519                 if (isspace(my.envelope_from[i])) my.envelope_from[i] = '_';
 520         }
 521         if (haschar(my.envelope_from, '@') == 0) {
 522                 strcat(my.envelope_from, "@");
 523                 strcat(my.envelope_from, CtdlGetConfigStr("c_fqdn"));
 524         }
 525
 526         /* Keep track of the envelope-to address (use body-to if not found) */
 527         if (!CM_IsEmpty(msg, eenVelopeTo)) {
 528                 safestrncpy(my.envelope_to, msg->cm_fields[eenVelopeTo], sizeof my.envelope_to);
 529                 stripallbut(my.envelope_to, '<', '>');
 530         }
 531         else if (!CM_IsEmpty(msg, eRecipient)) {
 532                 safestrncpy(my.envelope_to, msg->cm_fields[eRecipient], sizeof my.envelope_to);
 533                 stripallbut(my.envelope_to, '<', '>');
 534         }
 535         else {
 536                 strcpy(my.envelope_to, "");
 537         }
 538
 539         len = strlen(my.envelope_to);
 540         for (i=0; i<len; ++i) {
 541                 if (isspace(my.envelope_to[i])) my.envelope_to[i] = '_';
 542         }
 543         if (haschar(my.envelope_to, '@') == 0) {
 544                 strcat(my.envelope_to, "@");
 545                 strcat(my.envelope_to, CtdlGetConfigStr("c_fqdn"));
 546         }
 547
 548         CM_Free(msg);
 549
 550         syslog(LOG_DEBUG, "Calling sieve2_execute()");
 551         res = sieve2_execute(sieve2_context, &my);
 552         if (res != SIEVE2_OK) {
 553                 syslog(LOG_ERR, "sieve2_execute() returned %d: %s", res, sieve2_errstr(res));
 554         }
 555
 556         free(my.rfc822headers);
 557         my.rfc822headers = NULL;
 558
 559         /*
 560          * Delete the message from the inbox unless either we were told not to, or
 561          * if no other action was successfully taken.
 562          */
 563         if ( (!my.keep) && (my.cancel_implicit_keep) ) {
 564                 syslog(LOG_DEBUG, "keep is 0 -- deleting message from inbox");
 565                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "");
 566         }
 567
 568         syslog(LOG_DEBUG, "Completed sieve processing on msg <%ld>", msgnum);
 569         u->lastproc = msgnum;
 570
 571         return;
 572 }
 573
 574
 575
 576 /*
 577  * Given the on-disk representation of our Sieve config, load
 578  * it into an in-memory data structure.
 579  */
 580 void parse_sieve_config(char *conf, struct sdm_userdata *u) {
 581         char *ptr;
 582         char *c, *vacrec;
 583         char keyword[256];
 584         struct sdm_script *sptr;
 585         struct sdm_vacation *vptr;
 586
 587         ptr = conf;
 588         while (c = ptr, ptr = bmstrcasestr(ptr, CTDLSIEVECONFIGSEPARATOR), ptr != NULL) {
 589                 *ptr = 0;
 590                 ptr += strlen(CTDLSIEVECONFIGSEPARATOR);
 591
 592                 extract_token(keyword, c, 0, '|', sizeof keyword);
 593
 594                 if (!strcasecmp(keyword, "lastproc")) {
 595                         u->lastproc = extract_long(c, 1);
 596                 }
 597
 598                 else if (!strcasecmp(keyword, "script")) {
 599                         sptr = malloc(sizeof(struct sdm_script));
 600                         extract_token(sptr->script_name, c, 1, '|', sizeof sptr->script_name);
 601                         sptr->script_active = extract_int(c, 2);
 602                         remove_token(c, 0, '|');
 603                         remove_token(c, 0, '|');
 604                         remove_token(c, 0, '|');
 605                         sptr->script_content = strdup(c);
 606                         sptr->next = u->first_script;
 607                         u->first_script = sptr;
 608                 }
 609
 610                 else if (!strcasecmp(keyword, "vacation")) {
 611
 612                         if (c != NULL) while (vacrec=c, c=strchr(c, '\n'), (c != NULL)) {
 613
 614                                 *c = 0;
 615                                 ++c;
 616
 617                                 if (strncasecmp(vacrec, "vacation|", 9)) {
 618                                         vptr = malloc(sizeof(struct sdm_vacation));
 619                                         extract_token(vptr->fromaddr, vacrec, 0, '|', sizeof vptr->fromaddr);
 620                                         vptr->timestamp = extract_long(vacrec, 1);
 621                                         vptr->next = u->first_vacation;
 622                                         u->first_vacation = vptr;
 623                                 }
 624                         }
 625                 }
 626
 627                 /* ignore unknown keywords */
 628         }
 629 }
 630
 631
 632
 633
 634
 635 /*
 636  * Write our citadel sieve config back to disk
 637  *
 638  * (Set yes_write_to_disk to nonzero to make it actually write the config;
 639  * otherwise it just frees the data structures.)
 640  */
 641 void rewrite_ctdl_sieve_config(struct sdm_userdata *u, int yes_write_to_disk) {
 642         StrBuf *text;
 643         struct sdm_script *sptr;
 644         struct sdm_vacation *vptr;
 645
 646         text = NewStrBufPlain(NULL, SIZ);
 647         StrBufPrintf(text,
 648                      "Content-type: application/x-citadel-sieve-config\n"
 649                      "\n"
 650                      CTDLSIEVECONFIGSEPARATOR
 651                      "lastproc|%ld"
 652                      CTDLSIEVECONFIGSEPARATOR
 653                      ,
 654                      u->lastproc
 655                 );
 656
 657         while (u->first_script != NULL) {
 658                 StrBufAppendPrintf(text,
 659                                    "script|%s|%d|%s" CTDLSIEVECONFIGSEPARATOR,
 660                                    u->first_script->script_name,
 661                                    u->first_script->script_active,
 662                                    u->first_script->script_content
 663                         );
 664                 sptr = u->first_script;
 665                 u->first_script = u->first_script->next;
 666                 free(sptr->script_content);
 667                 free(sptr);
 668         }
 669
 670         if (u->first_vacation != NULL) {
 671
 672                 StrBufAppendPrintf(text, "vacation|\n");
 673                 while (u->first_vacation != NULL) {
 674                         if ( (time(NULL) - u->first_vacation->timestamp) < (MAX_VACATION * 86400)) {
 675                                 StrBufAppendPrintf(text, "%s|%ld\n",
 676                                                    u->first_vacation->fromaddr,
 677                                                    u->first_vacation->timestamp
 678                                         );
 679                         }
 680                         vptr = u->first_vacation;
 681                         u->first_vacation = u->first_vacation->next;
 682                         free(vptr);
 683                 }
 684                 StrBufAppendPrintf(text, CTDLSIEVECONFIGSEPARATOR);
 685         }
 686
 687         if (yes_write_to_disk)
 688         {
 689                 /* Save the config */
 690                 quickie_message("Citadel", NULL, NULL, u->config_roomname,
 691                                 ChrPtr(text),
 692                                 4,
 693                                 "Sieve configuration"
 694                 );
 695
 696                 /* And delete the old one */
 697                 if (u->config_msgnum > 0) {
 698                         CtdlDeleteMessages(u->config_roomname, &u->config_msgnum, 1, "");
 699                 }
 700         }
 701
 702         FreeStrBuf (&text);
 703
 704 }
 705
 706
 707 /*
 708  * This is our callback registration table for libSieve.
 709  */
 710 sieve2_callback_t ctdl_sieve_callbacks[] = {
 711         { SIEVE2_ACTION_REJECT,         ctdl_reject             },
 712         { SIEVE2_ACTION_VACATION,       ctdl_vacation           },
 713         { SIEVE2_ERRCALL_PARSE,         ctdl_errparse           },
 714         { SIEVE2_ERRCALL_RUNTIME,       ctdl_errexec            },
 715         { SIEVE2_ACTION_FILEINTO,       ctdl_fileinto           },
 716         { SIEVE2_ACTION_REDIRECT,       ctdl_redirect           },
 717         { SIEVE2_ACTION_DISCARD,        ctdl_discard            },
 718         { SIEVE2_ACTION_KEEP,           ctdl_keep               },
 719         { SIEVE2_SCRIPT_GETSCRIPT,      ctdl_getscript          },
 720         { SIEVE2_DEBUG_TRACE,           ctdl_debug              },
 721         { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders         },
 722         { SIEVE2_MESSAGE_GETSIZE,       ctdl_getsize            },
 723         { SIEVE2_MESSAGE_GETENVELOPE,   ctdl_getenvelope        },
 724         { 0 }
 725 };
 726
 727
 728 /*
 729  * Perform sieve processing for a single room
 730  */
 731 void sieve_do_room(char *roomname) {
 732
 733         struct sdm_userdata u;
 734         sieve2_context_t *sieve2_context = NULL;        /* Context for sieve parser */
 735         int res;                                        /* Return code from libsieve calls */
 736         long orig_lastproc = 0;
 737
 738         memset(&u, 0, sizeof u);
 739
 740         /* See if the user who owns this 'mailbox' has any Sieve scripts that
 741          * require execution.
 742          */
 743         snprintf(u.config_roomname, sizeof u.config_roomname, "%010ld.%s", atol(roomname), USERCONFIGROOM);
 744         if (CtdlGetRoom(&CC->room, u.config_roomname) != 0) {
 745                 syslog(LOG_DEBUG, "<%s> does not exist.  No processing is required.", u.config_roomname);
 746                 return;
 747         }
 748
 749         /*
 750          * Find the sieve scripts and control record and do something
 751          */
 752         u.config_msgnum = (-1);
 753         CtdlForEachMessage(MSGS_LAST, 1, NULL, SIEVECONFIG, NULL, get_sieve_config_backend, (void *)&u );
 754
 755         if (u.config_msgnum < 0) {
 756                 syslog(LOG_DEBUG, "No Sieve rules exist.  No processing is required.");
 757                 return;
 758         }
 759
 760         /*
 761          * Check to see whether the script is empty and should not be processed.
 762          * A script is considered non-empty if it contains at least one semicolon.
 763          */
 764         if (
 765                 (get_active_script(&u) == NULL)
 766                 || (strchr(get_active_script(&u), ';') == NULL)
 767         ) {
 768                 syslog(LOG_DEBUG, "Sieve script is empty.  No processing is required.");
 769                 return;
 770         }
 771
 772         syslog(LOG_DEBUG, "Rules found.  Performing Sieve processing for <%s>", roomname);
 773
 774         if (CtdlGetRoom(&CC->room, roomname) != 0) {
 775                 syslog(LOG_ERR, "ERROR: cannot load <%s>", roomname);
 776                 return;
 777         }
 778
 779         /* Initialize the Sieve parser */
 780
 781         res = sieve2_alloc(&sieve2_context);
 782         if (res != SIEVE2_OK) {
 783                 syslog(LOG_ERR, "sieve2_alloc() returned %d: %s", res, sieve2_errstr(res));
 784                 return;
 785         }
 786
 787         res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks);
 788         if (res != SIEVE2_OK) {
 789                 syslog(LOG_ERR, "sieve2_callbacks() returned %d: %s", res, sieve2_errstr(res));
 790                 goto BAIL;
 791         }
 792
 793         /* Validate the script */
 794
 795         struct ctdl_sieve my;           /* dummy ctdl_sieve struct just to pass "u" along */
 796         memset(&my, 0, sizeof my);
 797         my.u = &u;
 798         res = sieve2_validate(sieve2_context, &my);
 799         if (res != SIEVE2_OK) {
 800                 syslog(LOG_ERR, "sieve2_validate() returned %d: %s", res, sieve2_errstr(res));
 801                 goto BAIL;
 802         }
 803
 804         /* Do something useful */
 805         u.sieve2_context = sieve2_context;
 806         orig_lastproc = u.lastproc;
 807         CtdlForEachMessage(MSGS_GT, u.lastproc, NULL, NULL, NULL, sieve_do_msg, (void *) &u);
 808
 809 BAIL:
 810         res = sieve2_free(&sieve2_context);
 811         if (res != SIEVE2_OK) {
 812                 syslog(LOG_ERR, "sieve2_free() returned %d: %s", res, sieve2_errstr(res));
 813         }
 814
 815         /* Rewrite the config if we have to (we're not the user right now) */
 816         rewrite_ctdl_sieve_config(&u, (u.lastproc > orig_lastproc) ) ;
 817 }
 818
 819 #endif
 820
 821
 822
 823 /*
 824  * A user account is identified as requring inbox processing.
 825  * Do it.
 826  */
 827 void do_inbox_processing_for_user(long usernum) {
 828         if (CtdlGetUserByNumber(&CC->user, usernum) == 0) {
 829                 TRACE;
 830                 if (CC->user.msgnum_inboxrules <= 0) {
 831                         return;                                         // this user has no inbox rules
 832                 }
 833
 834                 struct CtdlMessage *msg;
 835                 char *conf;
 836                 long conflen;
 837
 838                 msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
 839                 if (msg == NULL) {
 840                         return;                                         // config msgnum is set but that message does not exist
 841                 }
 842
 843                 CM_GetAsField(msg, eMesageText, &conf, &conflen);
 844                 CM_Free(msg);
 845
 846                 if (conf == NULL) {
 847                         return;                                         // config message exists but body is null
 848                 }
 849
 850
 851                 syslog(LOG_DEBUG, "RULEZ for %s", CC->user.fullname);
 852                 syslog(LOG_DEBUG, "%s", conf);
 853
 854                 // do something now
 855
 856                 free(conf);
 857         }
 858 }
 859
 860
 861 /*
 862  * Here is an array of users (by number) who have received messages in their inbox and may require processing.
 863 */
 864 long *users_requiring_inbox_processing = NULL;
 865 int num_urip = 0;
 866 int num_urip_alloc = 0;
 867
 868
 869 /*
 870  * Perform inbox processing for all rooms which require it
 871  */
 872 void perform_inbox_processing(void) {
 873         if (num_urip == 0) {
 874                 return;                                                                                 // no action required
 875         }
 876
 877         for (int i=0; i<num_urip; ++i) {
 878                 do_inbox_processing_for_user(users_requiring_inbox_processing[i]);
 879         }
 880
 881         free(users_requiring_inbox_processing);
 882         users_requiring_inbox_processing = NULL;
 883         num_urip = 0;
 884         num_urip_alloc = 0;
 885 }
 886
 887
 888 /*
 889  * This function is called after a message is saved to a room.
 890  * If it's someone's inbox, we have to check for inbox rules
 891  */
 892 int serv_inboxrules_roomhook(struct ctdlroom *room) {
 893
 894         // Is this someone's inbox?
 895         if (!strcasecmp(&room->QRname[11], MAILROOM)) {
 896                 long usernum = atol(room->QRname);
 897                 if (usernum > 0) {
 898
 899                         // first check to see if this user is already on the list
 900                         if (num_urip > 0) {
 901                                 for (int i=0; i<=num_urip; ++i) {
 902                                         if (users_requiring_inbox_processing[i] == usernum) {           // already on the list!
 903                                                 return(0);
 904                                         }
 905                                 }
 906                         }
 907
 908                         // make room if we need to
 909                         if (num_urip_alloc == 0) {
 910                                 num_urip_alloc = 100;
 911                                 users_requiring_inbox_processing = malloc(sizeof(long) * num_urip_alloc);
 912                         }
 913                         else if (num_urip >= num_urip_alloc) {
 914                                 num_urip_alloc += 100;
 915                                 users_requiring_inbox_processing = realloc(users_requiring_inbox_processing, (sizeof(long) * num_urip_alloc));
 916                         }
 917
 918                         // now add the user to the list
 919                         users_requiring_inbox_processing[num_urip++] = usernum;
 920                 }
 921         }
 922
 923         // No errors are possible from this function.
 924         return(0);
 925 }
 926
 927
 928 struct irule {
 929         int field_compare_op;
 930         char *compared_field;
 931         char *compared_value;
 932         int size_compare_op;
 933         long compared_size;
 934         int action;
 935         char *file_into;
 936         char *redirect_to;
 937         char *autoreply_message;
 938         int final_action;
 939 };
 940
 941 struct inboxrules {
 942         long lastproc;
 943         int num_rules;
 944         struct irule *rules;
 945 };
 946
 947
 948 void free_inbox_rules(struct inboxrules *ibr) {
 949         int i;
 950
 951         if (ibr->num_rules > 0) {
 952                 for (i=0; i<ibr->num_rules; ++i) {
 953                         if (ibr->rules[i].compared_field)       free(ibr->rules[i].compared_field);
 954                         if (ibr->rules[i].compared_value)       free(ibr->rules[i].compared_value);
 955                         if (ibr->rules[i].file_into)            free(ibr->rules[i].file_into);
 956                         if (ibr->rules[i].redirect_to)          free(ibr->rules[i].autoreply_message);
 957                         if (ibr->rules[i].autoreply_message)    free(ibr->rules[i].autoreply_message);
 958                 }
 959         }
 960
 961         free(ibr->rules);
 962         free(ibr);
 963 }
 964
 965
 966 /*
 967  * Convert the serialized inbox rules message to a data type.
 968  */
 969 struct inboxrules *deserialize_inbox_rules(char *serialized_rules) {
 970
 971         if (!serialized_rules) {
 972                 return NULL;
 973         }
 974
 975         /* Make a copy of the supplied buffer because we're going to shit all over it with strtok_r() */
 976         char *sr = strdup(serialized_rules);
 977         if (!sr) {
 978                 return NULL;
 979         }
 980
 981         struct inboxrules *ibr = malloc(sizeof(struct inboxrules));
 982         if (ibr == NULL) {
 983                 return NULL;
 984         }
 985         memset(ibr, 0, sizeof(struct inboxrules));
 986
 987         char *token;
 988         char *rest = sr;
 989         while ((token = strtok_r(rest, "\n", &rest))) {
 990
 991                 // For backwards compatibility, "# WEBCIT_RULE" is an alias for "rule".
 992                 // Prior to version 930, WebCit converted its rules to Sieve scripts, but saved the rules as comments for later re-editing.
 993                 // Now, the rules hidden in the comments are the real rules.
 994                 if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
 995                         strcpy(token, "rule|");
 996                         strcpy(&token[5], &token[14]);
 997                 }
 998
 999                 // Lines containing actual rules are double-serialized with Base64.  It seemed like a good idea at the time :(
1000                 if (!strncasecmp(token, "rule|", 5)) {
1001                         syslog(LOG_DEBUG, "rule: %s", &token[5]);
1002                         remove_token(&token[5], 0, '|');
1003                         char *decoded_rule = malloc(strlen(token));
1004                         CtdlDecodeBase64(decoded_rule, &token[5], strlen(&token[5]));
1005                         TRACE;
1006                         syslog(LOG_DEBUG, "%s", decoded_rule);
1007
1008                         ibr->num_rules++;
1009                         ibr->rules = realloc(ibr->rules, (sizeof(struct irule) * ibr->num_rules));
1010                         struct irule *new_rule = &ibr->rules[ibr->num_rules - 1];
1011                         memset(new_rule, 0, sizeof(struct irule));
1012
1013                         free(decoded_rule);
1014                 }
1015
1016                 // "lastproc" indicates the newest message number in the inbox that was previously processed by our inbox rules.
1017                 else if (!strncasecmp(token, "lastproc|", 5)) {
1018                         ibr->lastproc = atol(&token[9]);
1019                         syslog(LOG_DEBUG, "lastsent: %ld", ibr->lastproc);
1020                 }
1021
1022         }
1023
1024         free(sr);               // free our copy of the source buffer that has now been trashed with null bytes...
1025         return(ibr);            // and return our complex data type to the caller.
1026 }
1027
1028
1029 /*
1030  * Get InBox Rules
1031  *
1032  * This is a client-facing function which fetches the user's inbox rules -- it omits all lines containing anything other than a rule.
1033  */
1034 void cmd_gibr(char *argbuf) {
1035
1036         if (CtdlAccessCheck(ac_logged_in)) return;
1037
1038         cprintf("%d inbox rules for %s\n", LISTING_FOLLOWS, CC->user.fullname);
1039
1040         struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
1041         if (msg != NULL) {
1042                 if (!CM_IsEmpty(msg, eMesageText)) {
1043
1044
1045                         struct inboxrules *ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]);
1046                         free_inbox_rules(ii);
1047
1048                         char *token;
1049                         char *rest = msg->cm_fields[eMesageText];
1050                         while ((token = strtok_r(rest, "\n", &rest))) {
1051
1052                                 // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
1053                                 if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
1054                                         strcpy(token, "rule|");
1055                                         strcpy(&token[5], &token[14]);
1056                                 }
1057
1058                                 // Output only lines containing rules.
1059                                 if (!strncasecmp(token, "rule|", 5)) {
1060                                         cprintf("%s\n", token);
1061                                 }
1062                         }
1063                 }
1064                 CM_Free(msg);
1065         }
1066         cprintf("000\n");
1067 }
1068
1069
1070 /*
1071  * Put InBox Rules
1072  *
1073  * User transmits the new inbox rules for the account.  They are inserted into the account, replacing the ones already there.
1074  */
1075 void cmd_pibr(char *argbuf) {
1076         if (CtdlAccessCheck(ac_logged_in)) return;
1077
1078         unbuffer_output();
1079         cprintf("%d send new rules\n", SEND_LISTING);
1080         char *newrules = CtdlReadMessageBody(HKEY("000"), CtdlGetConfigLong("c_maxmsglen"), NULL, 0);
1081         StrBuf *NewConfig = NewStrBufPlain("Content-type: application/x-citadel-sieve-config; charset=UTF-8\nContent-transfer-encoding: 8bit\n\n", -1);
1082
1083         char *token;
1084         char *rest = newrules;
1085         while ((token = strtok_r(rest, "\n", &rest))) {
1086                 // Accept only lines containing rules
1087                 if (!strncasecmp(token, "rule|", 5)) {
1088                         StrBufAppendBufPlain(NewConfig, token, -1, 0);
1089                         StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
1090                 }
1091         }
1092         free(newrules);
1093
1094         // Fetch the existing config so we can merge in anything that is NOT a rule
1095         // (Does not start with "rule|" but has at least one vertical bar)
1096         struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
1097         if (msg != NULL) {
1098                 if (!CM_IsEmpty(msg, eMesageText)) {
1099                         rest = msg->cm_fields[eMesageText];
1100                         while ((token = strtok_r(rest, "\n", &rest))) {
1101                                 // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
1102                                 if ((strncasecmp(token, "# WEBCIT_RULE|", 14)) && (strncasecmp(token, "rule|", 5)) && (haschar(token, '|'))) {
1103                                         StrBufAppendBufPlain(NewConfig, token, -1, 0);
1104                                         StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
1105                                 }
1106                         }
1107                 }
1108                 CM_Free(msg);
1109         }
1110
1111         /* we have composed the new configuration , now save it */
1112         long old_msgnum = CC->user.msgnum_inboxrules;
1113         char userconfigroomname[ROOMNAMELEN];
1114         CtdlMailboxName(userconfigroomname, sizeof userconfigroomname, &CC->user, USERCONFIGROOM);
1115         long new_msgnum = quickie_message("Citadel", NULL, NULL, userconfigroomname, ChrPtr(NewConfig), FMT_RFC822, "inbox rules configuration");
1116         FreeStrBuf(&NewConfig);
1117         CtdlGetUserLock(&CC->user, CC->curr_user);
1118         CC->user.msgnum_inboxrules = new_msgnum;
1119         CtdlPutUserLock(&CC->user);
1120         if (old_msgnum > 0) {
1121                 syslog(LOG_DEBUG, "Deleting old message %ld from %s", old_msgnum, userconfigroomname);
1122                 CtdlDeleteMessages(userconfigroomname, &old_msgnum, 1, "");
1123         }
1124 }
1125
1126
1127 CTDL_MODULE_INIT(sieve)
1128 {
1129         if (!threading)
1130         {
1131                 CtdlRegisterProtoHook(cmd_gibr, "GIBR", "Get InBox Rules");
1132                 CtdlRegisterProtoHook(cmd_pibr, "PIBR", "Put InBox Rules");
1133                 CtdlRegisterRoomHook(serv_inboxrules_roomhook);
1134                 CtdlRegisterSessionHook(perform_inbox_processing, EVT_HOUSE, PRIO_HOUSE + 10);
1135         }
1136
1137         /* return our module name for the log */
1138         return "inboxrules";
1139 }