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 /*
  52  * The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration.
  53  */
  54
  55 // Fields to be compared
  56 enum {
  57         field_from,
  58         field_tocc,
  59         field_subject,
  60         field_replyto,
  61         field_sender,
  62         field_resentfrom,
  63         field_resentto,
  64         field_envfrom,
  65         field_envto,
  66         field_xmailer,
  67         field_xspamflag,
  68         field_xspamstatus,
  69         field_listid,
  70         field_size,
  71         field_all
  72 };
  73 char *field_keys[] = {
  74         "from",
  75         "tocc",
  76         "subject",
  77         "replyto",
  78         "sender",
  79         "resentfrom",
  80         "resentto",
  81         "envfrom",
  82         "envto",
  83         "xmailer",
  84         "xspamflag",
  85         "xspamstatus",
  86         "listid",
  87         "size",
  88         "all"
  89 };
  90
  91 // Field comparison operators
  92 enum {
  93         fcomp_contains,
  94         fcomp_notcontains,
  95         fcomp_is,
  96         fcomp_isnot,
  97         fcomp_matches,
  98         fcomp_notmatches
  99 };
 100 char *fcomp_keys[] = {
 101         "contains",
 102         "notcontains",
 103         "is",
 104         "isnot",
 105         "matches",
 106         "notmatches"
 107 };
 108
 109 // Actions
 110 enum {
 111         action_keep,
 112         action_discard,
 113         action_reject,
 114         action_fileinto,
 115         action_redirect,
 116         action_vacation
 117 };
 118 char *action_keys[] = {
 119         "keep",
 120         "discard",
 121         "reject",
 122         "fileinto",
 123         "redirect",
 124         "vacation"
 125 };
 126
 127 // Size comparison operators
 128 enum {
 129         scomp_larger,
 130         scomp_smaller
 131 };
 132 char *scomp_keys[] = {
 133         "larger",
 134         "smaller"
 135 };
 136
 137 // Final actions
 138 enum {
 139         final_continue,
 140         final_stop
 141 };
 142 char *final_keys[] = {
 143         "continue",
 144         "stop"
 145 };
 146
 147 // This data structure represents ONE inbox rule within the configuration.
 148 struct irule {
 149         int compared_field;
 150         int field_compare_op;
 151         char compared_value[128];
 152         int size_compare_op;
 153         long compared_size;
 154         int action;
 155         char file_into[ROOMNAMELEN];
 156         char redirect_to[1024];
 157         char autoreply_message[SIZ];
 158         int final_action;
 159 };
 160
 161 // This data structure represents the entire inbox rules configuration AND current state for a single user.
 162 struct inboxrules {
 163         long lastproc;
 164         int num_rules;
 165         struct irule *rules;
 166 };
 167
 168
 169 // Destructor for 'struct inboxrules'
 170 void free_inbox_rules(struct inboxrules *ibr) {
 171         free(ibr->rules);
 172         free(ibr);
 173 }
 174
 175
 176 // Constructor for 'struct inboxrules' that deserializes the configuration from text input.
 177 struct inboxrules *deserialize_inbox_rules(char *serialized_rules) {
 178         int i;
 179
 180         if (!serialized_rules) {
 181                 return NULL;
 182         }
 183
 184         /* Make a copy of the supplied buffer because we're going to shit all over it with strtok_r() */
 185         char *sr = strdup(serialized_rules);
 186         if (!sr) {
 187                 return NULL;
 188         }
 189
 190         struct inboxrules *ibr = malloc(sizeof(struct inboxrules));
 191         if (ibr == NULL) {
 192                 return NULL;
 193         }
 194         memset(ibr, 0, sizeof(struct inboxrules));
 195
 196         char *token;
 197         char *rest = sr;
 198         while ((token = strtok_r(rest, "\n", &rest))) {
 199
 200                 // For backwards compatibility, "# WEBCIT_RULE" is an alias for "rule".
 201                 // Prior to version 930, WebCit converted its rules to Sieve scripts, but saved the rules as comments for later re-editing.
 202                 // Now, the rules hidden in the comments become the real rules.
 203                 if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
 204                         strcpy(token, "rule|");
 205                         strcpy(&token[5], &token[14]);
 206                 }
 207
 208                 // Lines containing actual rules are double-serialized with Base64.  It seemed like a good idea at the time :(
 209                 if (!strncasecmp(token, "rule|", 5)) {
 210                         remove_token(&token[5], 0, '|');
 211                         char *decoded_rule = malloc(strlen(token));
 212                         CtdlDecodeBase64(decoded_rule, &token[5], strlen(&token[5]));
 213                         ibr->num_rules++;
 214                         ibr->rules = realloc(ibr->rules, (sizeof(struct irule) * ibr->num_rules));
 215                         struct irule *new_rule = &ibr->rules[ibr->num_rules - 1];
 216                         memset(new_rule, 0, sizeof(struct irule));
 217
 218                         // We have a rule , now parse it
 219                         char rtoken[SIZ];
 220                         int nt = num_tokens(decoded_rule, '|');
 221                         for (int t=0; t<nt; ++t) {
 222                                 extract_token(rtoken, decoded_rule, t, '|', sizeof(rtoken));
 223                                 striplt(rtoken);
 224                                 switch(t) {
 225                                         case 1:                                                         // field to compare
 226                                                 for (i=0; i<=field_all; ++i) {
 227                                                         if (!strcasecmp(rtoken, field_keys[i])) {
 228                                                                 new_rule->compared_field = i;
 229                                                         }
 230                                                 }
 231                                                 break;
 232                                         case 2:                                                         // field comparison operation
 233                                                 for (i=0; i<=fcomp_notmatches; ++i) {
 234                                                         if (!strcasecmp(rtoken, fcomp_keys[i])) {
 235                                                                 new_rule->field_compare_op = i;
 236                                                         }
 237                                                 }
 238                                                 break;
 239                                         case 3:                                                         // field comparison value
 240                                                 safestrncpy(new_rule->compared_value, rtoken, sizeof(new_rule->compared_value));
 241                                                 break;
 242                                         case 4:                                                         // size comparison operation
 243                                                 for (i=0; i<=scomp_smaller; ++i) {
 244                                                         if (!strcasecmp(rtoken, scomp_keys[i])) {
 245                                                                 new_rule->size_compare_op = i;
 246                                                         }
 247                                                 }
 248                                                 break;
 249                                         case 5:                                                         // size comparison value
 250                                                 new_rule->compared_size = atol(rtoken);
 251                                                 break;
 252                                         case 6:                                                         // action
 253                                                 for (i=0; i<=action_vacation; ++i) {
 254                                                         if (!strcasecmp(rtoken, action_keys[i])) {
 255                                                                 new_rule->action = i;
 256                                                         }
 257                                                 }
 258                                                 break;
 259                                         case 7:                                                         // file into (target room)
 260                                                 safestrncpy(new_rule->file_into, rtoken, sizeof(new_rule->file_into));
 261                                                 break;
 262                                         case 8:                                                         // redirect to (target address)
 263                                                 safestrncpy(new_rule->redirect_to, rtoken, sizeof(new_rule->redirect_to));
 264                                                 break;
 265                                         case 9:                                                         // autoreply message
 266                                                 safestrncpy(new_rule->autoreply_message, rtoken, sizeof(new_rule->autoreply_message));
 267                                                 break;
 268                                         case 10:                                                        // final_action;
 269                                                 for (i=0; i<=final_stop; ++i) {
 270                                                         if (!strcasecmp(rtoken, final_keys[i])) {
 271                                                                 new_rule->final_action = i;
 272                                                         }
 273                                                 }
 274                                                 break;
 275                                         default:
 276                                                 break;
 277                                 }
 278                         }
 279                         free(decoded_rule);
 280                 }
 281
 282                 // "lastproc" indicates the newest message number in the inbox that was previously processed by our inbox rules.
 283                 // This is a legacy location for this value and will only be used if it's the only one present.
 284                 else if (!strncasecmp(token, "lastproc|", 5)) {
 285                         ibr->lastproc = atol(&token[9]);
 286                 }
 287
 288                 // Lines which do not contain a recognizable token must be IGNORED.  These lines may be left over
 289                 // from a previous version and will disappear when we rewrite the config.
 290
 291         }
 292
 293         free(sr);               // free our copy of the source buffer that has now been trashed with null bytes...
 294         return(ibr);            // and return our complex data type to the caller.
 295 }
 296
 297
 298 // Perform the "fileinto" action (save the message in another room)
 299 // Returns: 1 or 0 to tell the caller to keep (1) or delete (0) the inbox copy of the message.
 300 //
 301 int inbox_do_fileinto(struct irule *rule, long msgnum) {
 302         char *dest_folder = rule->file_into;
 303         char original_room_name[ROOMNAMELEN];
 304         char foldername[ROOMNAMELEN];
 305         int c;
 306
 307         // Situations where we want to just keep the message in the inbox:
 308         if (
 309                 (IsEmptyStr(dest_folder))                       // no destination room was specified
 310                 || (!strcasecmp(dest_folder, "INBOX"))          // fileinto inbox is the same as keep
 311                 || (!strcasecmp(dest_folder, MAILROOM))         // fileinto "Mail" is the same as keep
 312         ) {
 313                 return(1);                                      // don't delete the inbox copy if this failed
 314         }
 315
 316         // Remember what room we came from
 317         safestrncpy(original_room_name, CC->room.QRname, sizeof original_room_name);
 318
 319         // First try a mailbox name match (check personal mail folders first)
 320         strcpy(foldername, original_room_name);                                 // This keeps the user namespace of the inbox
 321         snprintf(&foldername[10], sizeof(foldername)-10, ".%s", dest_folder);   // And this tacks on the target room name
 322         c = CtdlGetRoom(&CC->room, foldername);
 323
 324         // Then a regular room name match (public and private rooms)
 325         if (c != 0) {
 326                 safestrncpy(foldername, dest_folder, sizeof foldername);
 327                 c = CtdlGetRoom(&CC->room, foldername);
 328         }
 329
 330         if (c != 0) {
 331                 syslog(LOG_WARNING, "inboxrules: target <%s> does not exist", dest_folder);
 332                 return(1);                                      // don't delete the inbox copy if this failed
 333         }
 334
 335         // Yes, we actually have to go there
 336         CtdlUserGoto(NULL, 0, 0, NULL, NULL, NULL, NULL);
 337
 338         c = CtdlSaveMsgPointersInRoom(NULL, &msgnum, 1, 0, NULL, 0);
 339
 340         // Go back to the room we came from
 341         if (strcasecmp(original_room_name, CC->room.QRname)) {
 342                 CtdlUserGoto(original_room_name, 0, 0, NULL, NULL, NULL, NULL);
 343         }
 344
 345         return(0);                                              // delete the inbox copy
 346 }
 347
 348
 349 // Perform the "redirect" action (divert the message to another email address)
 350 // Returns: 1 or 0 to tell the caller to keep (1) or delete (0) the inbox copy of the message.
 351 //
 352 int inbox_do_redirect(struct irule *rule, long msgnum) {
 353         if (IsEmptyStr(rule->redirect_to)) {
 354                 syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
 355                 return(1);                                      // don't delete the inbox copy if this failed
 356         }
 357
 358         recptypes *valid = validate_recipients(rule->redirect_to, NULL, 0);
 359         if (valid == NULL) {
 360                 syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
 361                 return(1);                                      // don't delete the inbox copy if this failed
 362         }
 363         if (valid->num_error > 0) {
 364                 free_recipients(valid);
 365                 syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
 366                 return(1);                                      // don't delete the inbox copy if this failed
 367         }
 368
 369         struct CtdlMessage *msg = CtdlFetchMessage(msgnum, 1);
 370         if (msg == NULL) {
 371                 free_recipients(valid);
 372                 syslog(LOG_WARNING, "inboxrules: cannot reload message %ld for forwarding", msgnum);
 373                 return(1);                                      // don't delete the inbox copy if this failed
 374         }
 375
 376         CtdlSubmitMsg(msg, valid, NULL, 0);                     // send the message to the new recipient
 377         free_recipients(valid);
 378         CM_Free(msg);
 379         return(0);                                              // delete the inbox copy
 380 }
 381
 382
 383 /*
 384  * Perform the "reject" action (delete the message, and tell the sender we deleted it)
 385  */
 386 void inbox_do_reject(struct irule *rule, struct CtdlMessage *msg) {
 387         syslog(LOG_DEBUG, "inbox_do_reject: sender: <%s>, reject message: <%s>",
 388                 msg->cm_fields[erFc822Addr],
 389                 rule->autoreply_message
 390         );
 391
 392         // If we can't determine who sent the message, reject silently.
 393         char *sender;
 394         if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
 395                 sender = msg->cm_fields[eMessagePath];
 396         }
 397         else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
 398                 sender = msg->cm_fields[erFc822Addr];
 399         }
 400         else {
 401                 return;
 402         }
 403
 404         // Assemble the reject message.
 405         char *reject_text = malloc(strlen(rule->autoreply_message) + 1024);
 406         if (reject_text == NULL) {
 407                 return;
 408         }
 409         sprintf(reject_text,
 410                 "Content-type: text/plain\n"
 411                 "\n"
 412                 "The message was refused by the recipient's mail filtering program.\n"
 413                 "The reason given was as follows:\n"
 414                 "\n"
 415                 "%s\n"
 416                 "\n"
 417         ,
 418                 rule->autoreply_message
 419         );
 420
 421         // Deliver the message
 422         quickie_message(
 423                 NULL,
 424                 msg->cm_fields[eenVelopeTo],
 425                 sender,
 426                 NULL,
 427                 reject_text,
 428                 FMT_RFC822,
 429                 "Delivery status notification"
 430         );
 431         free(reject_text);
 432 }
 433
 434
 435 /*
 436  * Perform the "vacation" action (send an automatic response)
 437  */
 438 void inbox_do_vacation(struct irule *rule, struct CtdlMessage *msg) {
 439         syslog(LOG_DEBUG, "inbox_do_vacation: sender: <%s>, vacation message: <%s>",
 440                 msg->cm_fields[erFc822Addr],
 441                 rule->autoreply_message
 442         );
 443
 444         // If we can't determine who sent the message, no auto-reply can be sent.
 445         char *sender;
 446         if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
 447                 sender = msg->cm_fields[eMessagePath];
 448         }
 449         else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
 450                 sender = msg->cm_fields[erFc822Addr];
 451         }
 452         else {
 453                 return;
 454         }
 455
 456         // Avoid repeatedly sending auto-replies to the same correspondent over and over again by creating
 457         // a hash of the user, correspondent, and reply text, and hitting the S_USETABLE database.
 458         StrBuf *u = NewStrBuf();
 459         StrBufPrintf(u, "vacation/%x/%x/%x",
 460                 HashLittle(sender, strlen(sender)),
 461                 HashLittle(msg->cm_fields[eenVelopeTo], msg->cm_lengths[eenVelopeTo]),
 462                 HashLittle(rule->autoreply_message, strlen(rule->autoreply_message))
 463         );
 464         int already_seen = CheckIfAlreadySeen(u);
 465         FreeStrBuf(&u);
 466
 467         if (!already_seen) {
 468                 // Assemble the auto-reply message.
 469                 StrBuf *reject_text = NewStrBuf();
 470                 if (reject_text == NULL) {
 471                         return;
 472                 }
 473
 474                 StrBufPrintf(reject_text,
 475                         "Content-type: text/plain\n"
 476                         "\n"
 477                         "%s\n"
 478                         "\n"
 479                 ,
 480                         rule->autoreply_message
 481                 );
 482
 483                 // Deliver the auto-reply.
 484                 quickie_message(
 485                         NULL,
 486                         msg->cm_fields[eenVelopeTo],
 487                         sender,
 488                         NULL,
 489                         ChrPtr(reject_text),
 490                         FMT_RFC822,
 491                         "Delivery status notification"
 492                 );
 493                 FreeStrBuf(&reject_text);
 494         }
 495 }
 496
 497
 498 /*
 499  * Process a single message.  We know the room, the user, the rules, the message number, etc.
 500  */
 501 void inbox_do_msg(long msgnum, void *userdata) {
 502         struct inboxrules *ii = (struct inboxrules *) userdata;
 503         struct CtdlMessage *msg = NULL;         // If we are loading a message to process, put it here.
 504         int headers_loaded = 0;                 // Did we load the headers yet?  Do it only once.
 505         int body_loaded = 0;                    // Did we load the message body yet?  Do it only once.
 506         int metadata_loaded = 0;                // Did we load the metadata yet?  Do it only once.
 507         struct MetaData smi;                    // If we are loading the metadata to compare, put it here.
 508         int rule_activated = 0;                 // On each rule, this is set if the compare succeeds and the rule activates.
 509         char compare_me[SIZ];                   // On each rule, we will store the field to be compared here.
 510         int keep_message = 1;                   // Nonzero to keep the message in the inbox after processing, 0 to delete it.
 511         int i;
 512
 513         syslog(LOG_DEBUG, "inboxrules: processing message #%ld which is higher than %ld, we are in %s", msgnum, ii->lastproc, CC->room.QRname);
 514
 515         if (ii->num_rules <= 0) {
 516                 syslog(LOG_DEBUG, "inboxrules: rule set is empty");
 517                 return;
 518         }
 519
 520         for (i=0; i<ii->num_rules; ++i) {
 521                 syslog(LOG_DEBUG, "inboxrules: processing rule %d is %s", i, field_keys[ ii->rules[i].compared_field ]);
 522                 rule_activated = 0;
 523
 524                 // Before doing a field compare, check to see if we have the correct parts of the message in memory.
 525
 526                 switch(ii->rules[i].compared_field) {
 527                         // These fields require loading only the top-level headers
 528                         case field_from:                // From:
 529                         case field_tocc:                // To: or Cc:
 530                         case field_subject:             // Subject:
 531                         case field_replyto:             // Reply-to:
 532                         case field_listid:              // List-ID:
 533                         case field_envto:               // Envelope-to:
 534                         case field_envfrom:             // Return-path:
 535                                 if (!headers_loaded) {
 536                                         syslog(LOG_DEBUG, "inboxrules: loading headers for message %ld", msgnum);
 537                                         msg = CtdlFetchMessage(msgnum, 0);
 538                                         if (!msg) {
 539                                                 return;
 540                                         }
 541                                         headers_loaded = 1;
 542                                 }
 543                                 break;
 544                         // These fields are not stored as Citadel headers, and therefore require a full message load.
 545                         case field_sender:
 546                         case field_resentfrom:
 547                         case field_resentto:
 548                         case field_xmailer:
 549                         case field_xspamflag:
 550                         case field_xspamstatus:
 551                                 if (!body_loaded) {
 552                                         syslog(LOG_DEBUG, "inboxrules: loading all of message %ld", msgnum);
 553                                         if (msg != NULL) {
 554                                                 CM_Free(msg);
 555                                         }
 556                                         msg = CtdlFetchMessage(msgnum, 1);
 557                                         if (!msg) {
 558                                                 return;
 559                                         }
 560                                         headers_loaded = 1;
 561                                         body_loaded = 1;
 562                                 }
 563                                 break;
 564                         case field_size:
 565                                 if (!metadata_loaded) {
 566                                         syslog(LOG_DEBUG, "inboxrules: loading metadata for message %ld", msgnum);
 567                                         GetMetaData(&smi, msgnum);
 568                                         metadata_loaded = 1;
 569                                 }
 570                                 break;
 571                         case field_all:
 572                                 syslog(LOG_DEBUG, "inboxrules: this is an always-on rule");
 573                                 break;
 574                         default:
 575                                 syslog(LOG_DEBUG, "inboxrules: unknown rule key");
 576                 }
 577
 578                 // If the rule involves a field comparison, load the field to be compared.
 579                 compare_me[0] = 0;
 580                 switch(ii->rules[i].compared_field) {
 581
 582                         case field_from:                // From:
 583                                 if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
 584                                         safestrncpy(compare_me, msg->cm_fields[erFc822Addr], sizeof compare_me);
 585                                 }
 586                                 break;
 587                         case field_tocc:                // To: or Cc:
 588                                 if (!IsEmptyStr(msg->cm_fields[eRecipient])) {
 589                                         safestrncpy(compare_me, msg->cm_fields[eRecipient], sizeof compare_me);
 590                                 }
 591                                 if (!IsEmptyStr(msg->cm_fields[eCarbonCopY])) {
 592                                         if (!IsEmptyStr(compare_me)) {
 593                                                 strcat(compare_me, ",");
 594                                         }
 595                                         safestrncpy(&compare_me[strlen(compare_me)], msg->cm_fields[eCarbonCopY], (sizeof compare_me - strlen(compare_me)));
 596                                 }
 597                                 break;
 598                         case field_subject:             // Subject:
 599                                 if (!IsEmptyStr(msg->cm_fields[eMsgSubject])) {
 600                                         safestrncpy(compare_me, msg->cm_fields[eMsgSubject], sizeof compare_me);
 601                                 }
 602                                 break;
 603                         case field_replyto:             // Reply-to:
 604                                 if (!IsEmptyStr(msg->cm_fields[eReplyTo])) {
 605                                         safestrncpy(compare_me, msg->cm_fields[eReplyTo], sizeof compare_me);
 606                                 }
 607                                 break;
 608                         case field_listid:              // List-ID:
 609                                 if (!IsEmptyStr(msg->cm_fields[eListID])) {
 610                                         safestrncpy(compare_me, msg->cm_fields[eListID], sizeof compare_me);
 611                                 }
 612                                 break;
 613                         case field_envto:               // Envelope-to:
 614                                 if (!IsEmptyStr(msg->cm_fields[eenVelopeTo])) {
 615                                         safestrncpy(compare_me, msg->cm_fields[eenVelopeTo], sizeof compare_me);
 616                                 }
 617                                 break;
 618                         case field_envfrom:             // Return-path:
 619                                 if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
 620                                         safestrncpy(compare_me, msg->cm_fields[eMessagePath], sizeof compare_me);
 621                                 }
 622                                 break;
 623
 624                         case field_sender:
 625                         case field_resentfrom:
 626                         case field_resentto:
 627                         case field_xmailer:
 628                         case field_xspamflag:
 629                         case field_xspamstatus:
 630
 631                         default:
 632                                 break;
 633                 }
 634
 635                 // Message data to compare is loaded, now do something.
 636                 switch(ii->rules[i].compared_field) {
 637                         case field_from:                // From:
 638                         case field_tocc:                // To: or Cc:
 639                         case field_subject:             // Subject:
 640                         case field_replyto:             // Reply-to:
 641                         case field_listid:              // List-ID:
 642                         case field_envto:               // Envelope-to:
 643                         case field_envfrom:             // Return-path:
 644                         case field_sender:
 645                         case field_resentfrom:
 646                         case field_resentto:
 647                         case field_xmailer:
 648                         case field_xspamflag:
 649                         case field_xspamstatus:
 650
 651                                 // For all of the above fields, we can compare the field we've loaded into the buffer.
 652                                 syslog(LOG_DEBUG, "Value of field to compare is: <%s>", compare_me);
 653                                 switch(ii->rules[i].field_compare_op) {
 654                                         case fcomp_contains:
 655                                         case fcomp_matches:
 656                                                 rule_activated = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 1 : 0);
 657                                                 syslog(LOG_DEBUG, "Does %s contain %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no");
 658                                                 break;
 659                                         case fcomp_notcontains:
 660                                         case fcomp_notmatches:
 661                                                 rule_activated = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 0 : 1);
 662                                                 syslog(LOG_DEBUG, "Does %s contain %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no");
 663                                                 break;
 664                                         case fcomp_is:
 665                                                 rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 0 : 1);
 666                                                 syslog(LOG_DEBUG, "Does %s equal %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no");
 667                                                 break;
 668                                         case fcomp_isnot:
 669                                                 rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 1 : 0);
 670                                                 syslog(LOG_DEBUG, "Does %s equal %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no");
 671                                                 break;
 672                                 }
 673                                 break;
 674
 675                         case field_size:
 676                                 rule_activated = 0;
 677                                 syslog(LOG_DEBUG, "comparing actual message size %ld to rule message size %ld", smi.meta_rfc822_length, ii->rules[i].compared_size);
 678                                 switch(ii->rules[i].field_compare_op) {
 679                                         case scomp_larger:
 680                                                 rule_activated = ((smi.meta_rfc822_length > ii->rules[i].compared_size) ? 1 : 0);
 681                                                 syslog(LOG_DEBUG, "Is %ld larger than %ld? %s", smi.meta_rfc822_length, ii->rules[i].compared_size, (smi.meta_rfc822_length > ii->rules[i].compared_size) ? "yes":"no");
 682                                                 break;
 683                                         case scomp_smaller:
 684                                                 rule_activated = ((smi.meta_rfc822_length < ii->rules[i].compared_size) ? 1 : 0);
 685                                                 syslog(LOG_DEBUG, "Is %ld smaller than %ld? %s", smi.meta_rfc822_length, ii->rules[i].compared_size, (smi.meta_rfc822_length < ii->rules[i].compared_size) ? "yes":"no");
 686                                                 break;
 687                                 }
 688                                 break;
 689                         case field_all:                 // The "all messages" rule ALWAYS triggers
 690                                 rule_activated = 1;
 691                                 break;
 692                         default:                        // no matches, fall through and do nothing
 693                                 syslog(LOG_DEBUG, "inboxrules: an unknown field comparison was encountered");
 694                                 rule_activated = 0;
 695                                 break;
 696                 }
 697
 698                 // If the rule matched, perform the requested action.
 699                 if (rule_activated) {
 700                         syslog(LOG_DEBUG, "inboxrules: rule activated");
 701
 702                         // Perform the requested action
 703                         switch(ii->rules[i].action) {
 704                                 case action_keep:
 705                                         keep_message = 1;
 706                                         break;
 707                                 case action_discard:
 708                                         keep_message = 0;
 709                                         break;
 710                                 case action_reject:
 711                                         inbox_do_reject(&ii->rules[i], msg);
 712                                         keep_message = 0;
 713                                         break;
 714                                 case action_fileinto:
 715                                         keep_message = inbox_do_fileinto(&ii->rules[i], msgnum);
 716                                         break;
 717                                 case action_redirect:
 718                                         keep_message = inbox_do_redirect(&ii->rules[i], msgnum);
 719                                         break;
 720                                 case action_vacation:
 721                                         inbox_do_vacation(&ii->rules[i], msg);
 722                                         keep_message = 1;
 723                                         break;
 724                         }
 725
 726                         // Now perform the "final" action (anything other than "stop" means continue)
 727                         if (ii->rules[i].final_action == final_stop) {
 728                                 syslog(LOG_DEBUG, "inboxrules: stop processing");
 729                                 i = ii->num_rules + 1;                                  // throw us out of scope to stop
 730                         }
 731
 732
 733                 }
 734                 else {
 735                         syslog(LOG_DEBUG, "inboxrules: rule not activated");
 736                 }
 737         }
 738
 739         if (msg != NULL) {              // Delete the copy of the message that is currently in memory.  We don't need it anymore.
 740                 CM_Free(msg);
 741         }
 742
 743         if (!keep_message) {            // Delete the copy of the message that is currently in the inbox, if rules dictated that.
 744                 syslog(LOG_DEBUG, "inboxrules: delete %ld from inbox", msgnum);
 745                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "");                    // we're in the inbox already
 746         }
 747
 748         ii->lastproc = msgnum;          // make note of the last message we processed, so we don't scan the whole inbox again
 749 }
 750
 751
 752 /*
 753  * A user account is identified as requring inbox processing.
 754  * Do it.
 755  */
 756 void do_inbox_processing_for_user(long usernum) {
 757         struct CtdlMessage *msg;
 758         struct inboxrules *ii;
 759         char roomname[ROOMNAMELEN];
 760         char username[64];
 761
 762         if (CtdlGetUserByNumber(&CC->user, usernum) != 0) {     // grab the user record
 763                 return;                                         // and bail out if we were given an invalid user
 764         }
 765
 766         strcpy(username, CC->user.fullname);                    // save the user name so we can fetch it later and lock it
 767
 768         if (CC->user.msgnum_inboxrules <= 0) {
 769                 return;                                         // this user has no inbox rules
 770         }
 771
 772         msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
 773         if (msg == NULL) {
 774                 return;                                         // config msgnum is set but that message does not exist
 775         }
 776
 777         ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]);
 778         CM_Free(msg);
 779
 780         if (ii == NULL) {
 781                 return;                                         // config message exists but body is null
 782         }
 783
 784
 785         syslog(LOG_DEBUG, "ii->lastproc                 %ld", ii->lastproc);
 786         syslog(LOG_DEBUG, "CC->user.lastproc_inboxrules %ld", CC->user.lastproc_inboxrules);
 787
 788         if (ii->lastproc > CC->user.lastproc_inboxrules) {      // There might be a "last message processed" number left over
 789                 CC->user.lastproc_inboxrules = ii->lastproc;    // in the ruleset from a previous version.  Use this if it is
 790         }                                                       // a higher number.
 791         else {
 792                 ii->lastproc = CC->user.lastproc_inboxrules;
 793         }
 794
 795         long original_lastproc = ii->lastproc;
 796         syslog(LOG_DEBUG, "inboxrules: for %s, messages newer than %ld", CC->user.fullname, original_lastproc);
 797
 798         // Go to the user's inbox room and process all new messages
 799         snprintf(roomname, sizeof roomname, "%010ld.%s", usernum, MAILROOM);
 800         if (CtdlGetRoom(&CC->room, roomname) == 0) {
 801                 CtdlForEachMessage(MSGS_GT, ii->lastproc, NULL, NULL, NULL, inbox_do_msg, (void *) ii);
 802         }
 803
 804         // Record the number of the last message we processed
 805         if (ii->lastproc > original_lastproc) {
 806                 CtdlGetUserLock(&CC->user, username);
 807                 CC->user.lastproc_inboxrules = ii->lastproc;    // Avoid processing the entire inbox next time
 808                 CtdlPutUserLock(&CC->user);
 809         }
 810
 811         // And free the memory.
 812         free_inbox_rules(ii);
 813 }
 814
 815
 816 /*
 817  * Here is an array of users (by number) who have received messages in their inbox and may require processing.
 818  */
 819 long *users_requiring_inbox_processing = NULL;
 820 int num_urip = 0;
 821 int num_urip_alloc = 0;
 822
 823
 824 /*
 825  * Perform inbox processing for all rooms which require it
 826  */
 827 void perform_inbox_processing(void) {
 828         if (num_urip == 0) {
 829                 return;                                                                                 // no action required
 830         }
 831
 832         for (int i=0; i<num_urip; ++i) {
 833                 do_inbox_processing_for_user(users_requiring_inbox_processing[i]);
 834         }
 835
 836         free(users_requiring_inbox_processing);
 837         users_requiring_inbox_processing = NULL;
 838         num_urip = 0;
 839         num_urip_alloc = 0;
 840 }
 841
 842
 843 /*
 844  * This function is called after a message is saved to a room.
 845  * If it's someone's inbox, we have to check for inbox rules
 846  */
 847 int serv_inboxrules_roomhook(struct ctdlroom *room) {
 848
 849         // Is this someone's inbox?
 850         if (!strcasecmp(&room->QRname[11], MAILROOM)) {
 851                 long usernum = atol(room->QRname);
 852                 if (usernum > 0) {
 853
 854                         // first check to see if this user is already on the list
 855                         if (num_urip > 0) {
 856                                 for (int i=0; i<=num_urip; ++i) {
 857                                         if (users_requiring_inbox_processing[i] == usernum) {           // already on the list!
 858                                                 return(0);
 859                                         }
 860                                 }
 861                         }
 862
 863                         // make room if we need to
 864                         if (num_urip_alloc == 0) {
 865                                 num_urip_alloc = 100;
 866                                 users_requiring_inbox_processing = malloc(sizeof(long) * num_urip_alloc);
 867                         }
 868                         else if (num_urip >= num_urip_alloc) {
 869                                 num_urip_alloc += 100;
 870                                 users_requiring_inbox_processing = realloc(users_requiring_inbox_processing, (sizeof(long) * num_urip_alloc));
 871                         }
 872
 873                         // now add the user to the list
 874                         users_requiring_inbox_processing[num_urip++] = usernum;
 875                 }
 876         }
 877
 878         // No errors are possible from this function.
 879         return(0);
 880 }
 881
 882
 883
 884 /*
 885  * Get InBox Rules
 886  *
 887  * This is a client-facing function which fetches the user's inbox rules -- it omits all lines containing anything other than a rule.
 888  *
 889  * hmmmmm ... should we try to rebuild this in terms of deserialize_inbox_rules() instread?
 890  */
 891 void cmd_gibr(char *argbuf) {
 892
 893         if (CtdlAccessCheck(ac_logged_in)) return;
 894
 895         cprintf("%d inbox rules for %s\n", LISTING_FOLLOWS, CC->user.fullname);
 896
 897         struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
 898         if (msg != NULL) {
 899                 if (!CM_IsEmpty(msg, eMesageText)) {
 900                         char *token;
 901                         char *rest = msg->cm_fields[eMesageText];
 902                         while ((token = strtok_r(rest, "\n", &rest))) {
 903
 904                                 // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
 905                                 if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
 906                                         strcpy(token, "rule|");
 907                                         strcpy(&token[5], &token[14]);
 908                                 }
 909
 910                                 // Output only lines containing rules.
 911                                 if (!strncasecmp(token, "rule|", 5)) {
 912                                         cprintf("%s\n", token);
 913                                 }
 914                                 else {
 915                                         cprintf("# invalid rule found : %s\n", token);
 916                                 }
 917                         }
 918                 }
 919                 CM_Free(msg);
 920         }
 921         cprintf("000\n");
 922 }
 923
 924
 925 /*
 926  * Rewrite the rule set to disk after it has been modified
 927  * Called by cmd_pibr()
 928  * Returns the msgnum of the new rules message
 929  */
 930 void rewrite_rules_to_disk(const char *new_config) {
 931         long old_msgnum = CC->user.msgnum_inboxrules;
 932         char userconfigroomname[ROOMNAMELEN];
 933         CtdlMailboxName(userconfigroomname, sizeof userconfigroomname, &CC->user, USERCONFIGROOM);
 934         long new_msgnum = quickie_message("Citadel", NULL, NULL, userconfigroomname, new_config, FMT_RFC822, "inbox rules configuration");
 935         CtdlGetUserLock(&CC->user, CC->curr_user);
 936         CC->user.msgnum_inboxrules = new_msgnum;                // Now we know where to get the rules next time
 937         CC->user.lastproc_inboxrules = new_msgnum;              // Avoid processing the entire inbox next time
 938         CtdlPutUserLock(&CC->user);
 939         if (old_msgnum > 0) {
 940                 syslog(LOG_DEBUG, "Deleting old message %ld from %s", old_msgnum, userconfigroomname);
 941                 CtdlDeleteMessages(userconfigroomname, &old_msgnum, 1, "");
 942         }
 943 }
 944
 945
 946 /*
 947  * Put InBox Rules
 948  *
 949  * User transmits the new inbox rules for the account.  They are inserted into the account, replacing the ones already there.
 950  */
 951 void cmd_pibr(char *argbuf) {
 952         if (CtdlAccessCheck(ac_logged_in)) return;
 953
 954         unbuffer_output();
 955         cprintf("%d send new rules\n", SEND_LISTING);
 956         char *newrules = CtdlReadMessageBody(HKEY("000"), CtdlGetConfigLong("c_maxmsglen"), NULL, 0);
 957         StrBuf *NewConfig = NewStrBufPlain("Content-type: application/x-citadel-sieve-config; charset=UTF-8\nContent-transfer-encoding: 8bit\n\n", -1);
 958
 959         char *token;
 960         char *rest = newrules;
 961         while ((token = strtok_r(rest, "\n", &rest))) {
 962                 // Accept only lines containing rules
 963                 if (!strncasecmp(token, "rule|", 5)) {
 964                         StrBufAppendBufPlain(NewConfig, token, -1, 0);
 965                         StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
 966                 }
 967         }
 968         free(newrules);
 969         rewrite_rules_to_disk(ChrPtr(NewConfig));
 970         FreeStrBuf(&NewConfig);
 971 }
 972
 973
 974 CTDL_MODULE_INIT(sieve)
 975 {
 976         if (!threading)
 977         {
 978                 CtdlRegisterProtoHook(cmd_gibr, "GIBR", "Get InBox Rules");
 979                 CtdlRegisterProtoHook(cmd_pibr, "PIBR", "Put InBox Rules");
 980                 CtdlRegisterRoomHook(serv_inboxrules_roomhook);
 981                 CtdlRegisterSessionHook(perform_inbox_processing, EVT_HOUSE, PRIO_HOUSE + 10);
 982         }
 983
 984         /* return our module name for the log */
 985         return "inboxrules";
 986 }