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  * We found the Sieve configuration for this user.
 633  * Now do something with it.
 634  */
 635 void get_sieve_config_backend(long msgnum, void *userdata) {
 636         struct sdm_userdata *u = (struct sdm_userdata *) userdata;
 637         struct CtdlMessage *msg;
 638         char *conf;
 639         long conflen;
 640
 641         u->config_msgnum = msgnum;
 642         msg = CtdlFetchMessage(msgnum, 1, 1);
 643         if (msg == NULL) {
 644                 u->config_msgnum = (-1) ;
 645                 return;
 646         }
 647
 648         CM_GetAsField(msg, eMesageText, &conf, &conflen);
 649
 650         CM_Free(msg);
 651
 652         if (conf != NULL) {
 653                 parse_sieve_config(conf, u);
 654                 free(conf);
 655         }
 656
 657 }
 658
 659
 660 /*
 661  * Write our citadel sieve config back to disk
 662  *
 663  * (Set yes_write_to_disk to nonzero to make it actually write the config;
 664  * otherwise it just frees the data structures.)
 665  */
 666 void rewrite_ctdl_sieve_config(struct sdm_userdata *u, int yes_write_to_disk) {
 667         StrBuf *text;
 668         struct sdm_script *sptr;
 669         struct sdm_vacation *vptr;
 670
 671         text = NewStrBufPlain(NULL, SIZ);
 672         StrBufPrintf(text,
 673                      "Content-type: application/x-citadel-sieve-config\n"
 674                      "\n"
 675                      CTDLSIEVECONFIGSEPARATOR
 676                      "lastproc|%ld"
 677                      CTDLSIEVECONFIGSEPARATOR
 678                      ,
 679                      u->lastproc
 680                 );
 681
 682         while (u->first_script != NULL) {
 683                 StrBufAppendPrintf(text,
 684                                    "script|%s|%d|%s" CTDLSIEVECONFIGSEPARATOR,
 685                                    u->first_script->script_name,
 686                                    u->first_script->script_active,
 687                                    u->first_script->script_content
 688                         );
 689                 sptr = u->first_script;
 690                 u->first_script = u->first_script->next;
 691                 free(sptr->script_content);
 692                 free(sptr);
 693         }
 694
 695         if (u->first_vacation != NULL) {
 696
 697                 StrBufAppendPrintf(text, "vacation|\n");
 698                 while (u->first_vacation != NULL) {
 699                         if ( (time(NULL) - u->first_vacation->timestamp) < (MAX_VACATION * 86400)) {
 700                                 StrBufAppendPrintf(text, "%s|%ld\n",
 701                                                    u->first_vacation->fromaddr,
 702                                                    u->first_vacation->timestamp
 703                                         );
 704                         }
 705                         vptr = u->first_vacation;
 706                         u->first_vacation = u->first_vacation->next;
 707                         free(vptr);
 708                 }
 709                 StrBufAppendPrintf(text, CTDLSIEVECONFIGSEPARATOR);
 710         }
 711
 712         if (yes_write_to_disk)
 713         {
 714                 /* Save the config */
 715                 quickie_message("Citadel", NULL, NULL, u->config_roomname,
 716                                 ChrPtr(text),
 717                                 4,
 718                                 "Sieve configuration"
 719                 );
 720
 721                 /* And delete the old one */
 722                 if (u->config_msgnum > 0) {
 723                         CtdlDeleteMessages(u->config_roomname, &u->config_msgnum, 1, "");
 724                 }
 725         }
 726
 727         FreeStrBuf (&text);
 728
 729 }
 730
 731
 732 /*
 733  * This is our callback registration table for libSieve.
 734  */
 735 sieve2_callback_t ctdl_sieve_callbacks[] = {
 736         { SIEVE2_ACTION_REJECT,         ctdl_reject             },
 737         { SIEVE2_ACTION_VACATION,       ctdl_vacation           },
 738         { SIEVE2_ERRCALL_PARSE,         ctdl_errparse           },
 739         { SIEVE2_ERRCALL_RUNTIME,       ctdl_errexec            },
 740         { SIEVE2_ACTION_FILEINTO,       ctdl_fileinto           },
 741         { SIEVE2_ACTION_REDIRECT,       ctdl_redirect           },
 742         { SIEVE2_ACTION_DISCARD,        ctdl_discard            },
 743         { SIEVE2_ACTION_KEEP,           ctdl_keep               },
 744         { SIEVE2_SCRIPT_GETSCRIPT,      ctdl_getscript          },
 745         { SIEVE2_DEBUG_TRACE,           ctdl_debug              },
 746         { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders         },
 747         { SIEVE2_MESSAGE_GETSIZE,       ctdl_getsize            },
 748         { SIEVE2_MESSAGE_GETENVELOPE,   ctdl_getenvelope        },
 749         { 0 }
 750 };
 751
 752
 753 /*
 754  * Perform sieve processing for a single room
 755  */
 756 void sieve_do_room(char *roomname) {
 757
 758         struct sdm_userdata u;
 759         sieve2_context_t *sieve2_context = NULL;        /* Context for sieve parser */
 760         int res;                                        /* Return code from libsieve calls */
 761         long orig_lastproc = 0;
 762
 763         memset(&u, 0, sizeof u);
 764
 765         /* See if the user who owns this 'mailbox' has any Sieve scripts that
 766          * require execution.
 767          */
 768         snprintf(u.config_roomname, sizeof u.config_roomname, "%010ld.%s", atol(roomname), USERCONFIGROOM);
 769         if (CtdlGetRoom(&CC->room, u.config_roomname) != 0) {
 770                 syslog(LOG_DEBUG, "<%s> does not exist.  No processing is required.", u.config_roomname);
 771                 return;
 772         }
 773
 774         /*
 775          * Find the sieve scripts and control record and do something
 776          */
 777         u.config_msgnum = (-1);
 778         CtdlForEachMessage(MSGS_LAST, 1, NULL, SIEVECONFIG, NULL, get_sieve_config_backend, (void *)&u );
 779
 780         if (u.config_msgnum < 0) {
 781                 syslog(LOG_DEBUG, "No Sieve rules exist.  No processing is required.");
 782                 return;
 783         }
 784
 785         /*
 786          * Check to see whether the script is empty and should not be processed.
 787          * A script is considered non-empty if it contains at least one semicolon.
 788          */
 789         if (
 790                 (get_active_script(&u) == NULL)
 791                 || (strchr(get_active_script(&u), ';') == NULL)
 792         ) {
 793                 syslog(LOG_DEBUG, "Sieve script is empty.  No processing is required.");
 794                 return;
 795         }
 796
 797         syslog(LOG_DEBUG, "Rules found.  Performing Sieve processing for <%s>", roomname);
 798
 799         if (CtdlGetRoom(&CC->room, roomname) != 0) {
 800                 syslog(LOG_ERR, "ERROR: cannot load <%s>", roomname);
 801                 return;
 802         }
 803
 804         /* Initialize the Sieve parser */
 805
 806         res = sieve2_alloc(&sieve2_context);
 807         if (res != SIEVE2_OK) {
 808                 syslog(LOG_ERR, "sieve2_alloc() returned %d: %s", res, sieve2_errstr(res));
 809                 return;
 810         }
 811
 812         res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks);
 813         if (res != SIEVE2_OK) {
 814                 syslog(LOG_ERR, "sieve2_callbacks() returned %d: %s", res, sieve2_errstr(res));
 815                 goto BAIL;
 816         }
 817
 818         /* Validate the script */
 819
 820         struct ctdl_sieve my;           /* dummy ctdl_sieve struct just to pass "u" along */
 821         memset(&my, 0, sizeof my);
 822         my.u = &u;
 823         res = sieve2_validate(sieve2_context, &my);
 824         if (res != SIEVE2_OK) {
 825                 syslog(LOG_ERR, "sieve2_validate() returned %d: %s", res, sieve2_errstr(res));
 826                 goto BAIL;
 827         }
 828
 829         /* Do something useful */
 830         u.sieve2_context = sieve2_context;
 831         orig_lastproc = u.lastproc;
 832         CtdlForEachMessage(MSGS_GT, u.lastproc, NULL, NULL, NULL, sieve_do_msg, (void *) &u);
 833
 834 BAIL:
 835         res = sieve2_free(&sieve2_context);
 836         if (res != SIEVE2_OK) {
 837                 syslog(LOG_ERR, "sieve2_free() returned %d: %s", res, sieve2_errstr(res));
 838         }
 839
 840         /* Rewrite the config if we have to (we're not the user right now) */
 841         rewrite_ctdl_sieve_config(&u, (u.lastproc > orig_lastproc) ) ;
 842 }
 843
 844
 845
 846
 847 #endif
 848
 849
 850
 851
 852 /*
 853  * Get InBox Rules
 854  *
 855  * This is a client-facing function which fetches the user's inbox rules -- it omits all lines containing anything other than a rule.
 856  */
 857 void cmd_gibr(char *argbuf) {
 858
 859         if (CtdlAccessCheck(ac_logged_in)) return;
 860
 861         cprintf("%d inbox rules for %s\n", LISTING_FOLLOWS, CC->user.fullname);
 862
 863         struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
 864         if (msg != NULL) {
 865                 if (!CM_IsEmpty(msg, eMesageText)) {
 866                         char *token;
 867                         char *rest = msg->cm_fields[eMesageText];
 868                         while ((token = strtok_r(rest, "\n", &rest))) {
 869
 870                                 // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
 871                                 if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
 872                                         strcpy(token, "rule|");
 873                                         strcpy(&token[5], &token[14]);
 874                                 }
 875
 876                                 // Output only lines containing rules.
 877                                 if (!strncasecmp(token, "rule|", 5)) {
 878                                         cprintf("%s\n", token);
 879                                 }
 880                         }
 881                 }
 882                 CM_Free(msg);
 883         }
 884         cprintf("000\n");
 885 }
 886
 887
 888 /*
 889  * Put InBox Rules
 890  *
 891  * User transmits the new inbox rules for the account.  They are inserted into the account, replacing the ones already there.
 892  */
 893 void cmd_pibr(char *argbuf) {
 894         if (CtdlAccessCheck(ac_logged_in)) return;
 895
 896         unbuffer_output();
 897         cprintf("%d send new rules\n", SEND_LISTING);
 898         char *newrules = CtdlReadMessageBody(HKEY("000"), CtdlGetConfigLong("c_maxmsglen"), NULL, 0);
 899         StrBuf *NewConfig = NewStrBufPlain("Content-type: application/x-citadel-sieve-config; charset=UTF-8\nContent-transfer-encoding: 8bit\n\n", -1);
 900
 901         char *token;
 902         char *rest = newrules;
 903         while ((token = strtok_r(rest, "\n", &rest))) {
 904                 // Accept only lines containing rules
 905                 if (!strncasecmp(token, "rule|", 5)) {
 906                         StrBufAppendBufPlain(NewConfig, token, -1, 0);
 907                         StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
 908                 }
 909         }
 910         free(newrules);
 911
 912         // Fetch the existing config so we can merge in anything that is NOT a rule
 913         // (Does not start with "rule|" but has at least one vertical bar)
 914         struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
 915         if (msg != NULL) {
 916                 if (!CM_IsEmpty(msg, eMesageText)) {
 917                         rest = msg->cm_fields[eMesageText];
 918                         while ((token = strtok_r(rest, "\n", &rest))) {
 919                                 // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
 920                                 if ((strncasecmp(token, "# WEBCIT_RULE|", 14)) && (strncasecmp(token, "rule|", 5)) && (haschar(token, '|'))) {
 921                                         StrBufAppendBufPlain(NewConfig, token, -1, 0);
 922                                         StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
 923                                 }
 924                         }
 925                 }
 926                 CM_Free(msg);
 927         }
 928
 929         /* we have composed the new configuration , now save it */
 930         long old_msgnum = CC->user.msgnum_inboxrules;
 931         char userconfigroomname[ROOMNAMELEN];
 932         CtdlMailboxName(userconfigroomname, sizeof userconfigroomname, &CC->user, USERCONFIGROOM);
 933         long new_msgnum = quickie_message("Citadel", NULL, NULL, userconfigroomname, ChrPtr(NewConfig), FMT_RFC822, "inbox rules configuration");
 934         FreeStrBuf(&NewConfig);
 935         CtdlGetUserLock(&CC->user, CC->curr_user);
 936         CC->user.msgnum_inboxrules = new_msgnum;
 937         CtdlPutUserLock(&CC->user);
 938         if (old_msgnum > 0) {
 939                 syslog(LOG_DEBUG, "Deleting old message %ld from %s", old_msgnum, userconfigroomname);
 940                 CtdlDeleteMessages(userconfigroomname, &old_msgnum, 1, "");
 941         }
 942 }
 943
 944
 945 CTDL_MODULE_INIT(sieve)
 946 {
 947         if (!threading)
 948         {
 949                 // ctdl_sieve_init();
 950                 CtdlRegisterProtoHook(cmd_gibr, "GIBR", "Get InBox Rules");
 951                 CtdlRegisterProtoHook(cmd_pibr, "PIBR", "Put InBox Rules");
 952                 // CtdlRegisterSessionHook(perform_sieve_processing, EVT_HOUSE, PRIO_HOUSE + 10);
 953                 // CtdlRegisterCleanupHook(cleanup_sieve);
 954         }
 955
 956         /* return our module name for the log */
 957         return "inboxrules";
 958 }