--- /dev/null
+// Inbox handling rules
+//
+// Copyright (c) 1987-2022 by the citadel.org team
+//
+// This program is open source software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 3.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+#include "../../sysdep.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <time.h>
+#include <sys/wait.h>
+#include <string.h>
+#include <limits.h>
+#include <libcitadel.h>
+#include "../../citadel.h"
+#include "../../server.h"
+#include "../../citserver.h"
+#include "../../support.h"
+#include "../../config.h"
+#include "../../database.h"
+#include "../../msgbase.h"
+#include "../../internet_addressing.h"
+#include "../../ctdl_module.h"
+
+
+// The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration.
+
+// Fields to be compared
+enum {
+ field_from,
+ field_tocc,
+ field_subject,
+ field_replyto,
+ field_sender,
+ field_resentfrom,
+ field_resentto,
+ field_envfrom,
+ field_envto,
+ field_xmailer,
+ field_xspamflag,
+ field_xspamstatus,
+ field_listid,
+ field_size,
+ field_all
+};
+char *field_keys[] = {
+ "from",
+ "tocc",
+ "subject",
+ "replyto",
+ "sender",
+ "resentfrom",
+ "resentto",
+ "envfrom",
+ "envto",
+ "xmailer",
+ "xspamflag",
+ "xspamstatus",
+ "listid",
+ "size",
+ "all"
+};
+
+// Field comparison operators
+enum {
+ fcomp_contains,
+ fcomp_notcontains,
+ fcomp_is,
+ fcomp_isnot,
+ fcomp_matches,
+ fcomp_notmatches
+};
+char *fcomp_keys[] = {
+ "contains",
+ "notcontains",
+ "is",
+ "isnot",
+ "matches",
+ "notmatches"
+};
+
+// Actions
+enum {
+ action_keep,
+ action_discard,
+ action_reject,
+ action_fileinto,
+ action_redirect,
+ action_vacation
+};
+char *action_keys[] = {
+ "keep",
+ "discard",
+ "reject",
+ "fileinto",
+ "redirect",
+ "vacation"
+};
+
+// Size comparison operators
+enum {
+ scomp_larger,
+ scomp_smaller
+};
+char *scomp_keys[] = {
+ "larger",
+ "smaller"
+};
+
+// Final actions
+enum {
+ final_continue,
+ final_stop
+};
+char *final_keys[] = {
+ "continue",
+ "stop"
+};
+
+// This data structure represents ONE inbox rule within the configuration.
+struct irule {
+ int compared_field;
+ int field_compare_op;
+ char compared_value[128];
+ int size_compare_op;
+ long compared_size;
+ int action;
+ char file_into[ROOMNAMELEN];
+ char redirect_to[1024];
+ char autoreply_message[SIZ];
+ int final_action;
+};
+
+// This data structure represents the entire inbox rules configuration AND current state for a single user.
+struct inboxrules {
+ long lastproc;
+ int num_rules;
+ struct irule *rules;
+};
+
+
+// Destructor for 'struct inboxrules'
+void free_inbox_rules(struct inboxrules *ibr) {
+ free(ibr->rules);
+ free(ibr);
+}
+
+
+// Constructor for 'struct inboxrules' that deserializes the configuration from text input.
+struct inboxrules *deserialize_inbox_rules(char *serialized_rules) {
+ int i;
+
+ if (!serialized_rules) {
+ return NULL;
+ }
+
+ // Make a copy of the supplied buffer because we're going to shit all over it with strtok_r()
+ char *sr = strdup(serialized_rules);
+ if (!sr) {
+ return NULL;
+ }
+
+ struct inboxrules *ibr = malloc(sizeof(struct inboxrules));
+ if (ibr == NULL) {
+ return NULL;
+ }
+ memset(ibr, 0, sizeof(struct inboxrules));
+
+ char *token;
+ char *rest = sr;
+ while ((token = strtok_r(rest, "\n", &rest))) {
+
+ // For backwards compatibility, "# WEBCIT_RULE" is an alias for "rule".
+ // Prior to version 930, WebCit converted its rules to Sieve scripts, but saved the rules as comments for
+ // later re-editing. Now, the rules hidden in the comments become the real rules.
+ if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
+ strcpy(token, "rule|");
+ strcpy(&token[5], &token[14]);
+ }
+
+ // Lines containing actual rules are double-serialized with Base64. It seemed like a good idea at the time :(
+ if (!strncasecmp(token, "rule|", 5)) {
+ remove_token(&token[5], 0, '|');
+ char *decoded_rule = malloc(strlen(token));
+ CtdlDecodeBase64(decoded_rule, &token[5], strlen(&token[5]));
+ ibr->num_rules++;
+ ibr->rules = realloc(ibr->rules, (sizeof(struct irule) * ibr->num_rules));
+ struct irule *new_rule = &ibr->rules[ibr->num_rules - 1];
+ memset(new_rule, 0, sizeof(struct irule));
+
+ // We have a rule , now parse it
+ char rtoken[SIZ];
+ int nt = num_tokens(decoded_rule, '|');
+ int t = 0;
+ for (t=0; t<nt; ++t) {
+ extract_token(rtoken, decoded_rule, t, '|', sizeof(rtoken));
+ striplt(rtoken);
+ switch(t) {
+ case 1: // field to compare
+ for (i=0; i<=field_all; ++i) {
+ if (!strcasecmp(rtoken, field_keys[i])) {
+ new_rule->compared_field = i;
+ }
+ }
+ break;
+ case 2: // field comparison operation
+ for (i=0; i<=fcomp_notmatches; ++i) {
+ if (!strcasecmp(rtoken, fcomp_keys[i])) {
+ new_rule->field_compare_op = i;
+ }
+ }
+ break;
+ case 3: // field comparison value
+ safestrncpy(new_rule->compared_value, rtoken, sizeof(new_rule->compared_value));
+ break;
+ case 4: // size comparison operation
+ for (i=0; i<=scomp_smaller; ++i) {
+ if (!strcasecmp(rtoken, scomp_keys[i])) {
+ new_rule->size_compare_op = i;
+ }
+ }
+ break;
+ case 5: // size comparison value
+ new_rule->compared_size = atol(rtoken);
+ break;
+ case 6: // action
+ for (i=0; i<=action_vacation; ++i) {
+ if (!strcasecmp(rtoken, action_keys[i])) {
+ new_rule->action = i;
+ }
+ }
+ break;
+ case 7: // file into (target room)
+ safestrncpy(new_rule->file_into, rtoken, sizeof(new_rule->file_into));
+ break;
+ case 8: // redirect to (target address)
+ safestrncpy(new_rule->redirect_to, rtoken, sizeof(new_rule->redirect_to));
+ break;
+ case 9: // autoreply message
+ safestrncpy(new_rule->autoreply_message, rtoken, sizeof(new_rule->autoreply_message));
+ break;
+ case 10: // final_action;
+ for (i=0; i<=final_stop; ++i) {
+ if (!strcasecmp(rtoken, final_keys[i])) {
+ new_rule->final_action = i;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ free(decoded_rule);
+ }
+
+ // "lastproc" indicates the newest message number in the inbox that was previously processed by our inbox rules.
+ // This is a legacy location for this value and will only be used if it's the only one present.
+ else if (!strncasecmp(token, "lastproc|", 5)) {
+ ibr->lastproc = atol(&token[9]);
+ }
+
+ // Lines which do not contain a recognizable token must be IGNORED. These lines may be left over
+ // from a previous version and will disappear when we rewrite the config.
+
+ }
+
+ free(sr); // free our copy of the source buffer that has now been trashed with null bytes...
+ return(ibr); // and return our complex data type to the caller.
+}
+
+
+// Perform the "fileinto" action (save the message in another room)
+// Returns: 1 or 0 to tell the caller to keep (1) or delete (0) the inbox copy of the message.
+//
+int inbox_do_fileinto(struct irule *rule, long msgnum) {
+ char *dest_folder = rule->file_into;
+ char original_room_name[ROOMNAMELEN];
+ char foldername[ROOMNAMELEN];
+ int c;
+
+ // Situations where we want to just keep the message in the inbox:
+ if (
+ (IsEmptyStr(dest_folder)) // no destination room was specified
+ || (!strcasecmp(dest_folder, "INBOX")) // fileinto inbox is the same as keep
+ || (!strcasecmp(dest_folder, MAILROOM)) // fileinto "Mail" is the same as keep
+ ) {
+ return(1); // don't delete the inbox copy if this failed
+ }
+
+ // Remember what room we came from
+ safestrncpy(original_room_name, CC->room.QRname, sizeof original_room_name);
+
+ // First try a mailbox name match (check personal mail folders first)
+ strcpy(foldername, original_room_name); // This keeps the user namespace of the inbox
+ snprintf(&foldername[10], sizeof(foldername)-10, ".%s", dest_folder); // And this tacks on the target room name
+ c = CtdlGetRoom(&CC->room, foldername);
+
+ // Then a regular room name match (public and private rooms)
+ if (c != 0) {
+ safestrncpy(foldername, dest_folder, sizeof foldername);
+ c = CtdlGetRoom(&CC->room, foldername);
+ }
+
+ if (c != 0) {
+ syslog(LOG_WARNING, "inboxrules: target <%s> does not exist", dest_folder);
+ return(1); // don't delete the inbox copy if this failed
+ }
+
+ // Yes, we actually have to go there
+ CtdlUserGoto(NULL, 0, 0, NULL, NULL, NULL, NULL);
+
+ c = CtdlSaveMsgPointersInRoom(NULL, &msgnum, 1, 0, NULL, 0);
+
+ // Go back to the room we came from
+ if (strcasecmp(original_room_name, CC->room.QRname)) {
+ CtdlUserGoto(original_room_name, 0, 0, NULL, NULL, NULL, NULL);
+ }
+
+ return(0); // delete the inbox copy
+}
+
+
+// Perform the "redirect" action (divert the message to another email address)
+// Returns: 1 or 0 to tell the caller to keep (1) or delete (0) the inbox copy of the message.
+//
+int inbox_do_redirect(struct irule *rule, long msgnum) {
+ if (IsEmptyStr(rule->redirect_to)) {
+ syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
+ return(1); // don't delete the inbox copy if this failed
+ }
+
+ struct recptypes *valid = validate_recipients(rule->redirect_to, NULL, 0);
+ if (valid == NULL) {
+ syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
+ return(1); // don't delete the inbox copy if this failed
+ }
+ if (valid->num_error > 0) {
+ free_recipients(valid);
+ syslog(LOG_WARNING, "inboxrules: inbox_do_redirect() invalid recipient <%s>", rule->redirect_to);
+ return(1); // don't delete the inbox copy if this failed
+ }
+
+ struct CtdlMessage *msg = CtdlFetchMessage(msgnum, 1);
+ if (msg == NULL) {
+ free_recipients(valid);
+ syslog(LOG_WARNING, "inboxrules: cannot reload message %ld for forwarding", msgnum);
+ return(1); // don't delete the inbox copy if this failed
+ }
+
+ CtdlSubmitMsg(msg, valid, NULL); // send the message to the new recipient
+ free_recipients(valid);
+ CM_Free(msg);
+ return(0); // delete the inbox copy
+}
+
+
+// Perform the "reject" action (delete the message, and tell the sender we deleted it)
+void inbox_do_reject(struct irule *rule, struct CtdlMessage *msg) {
+ syslog(LOG_DEBUG, "inbox_do_reject: sender: <%s>, reject", msg->cm_fields[erFc822Addr]);
+
+ // If we can't determine who sent the message, reject silently.
+ char *sender;
+ if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
+ sender = msg->cm_fields[eMessagePath];
+ }
+ else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
+ sender = msg->cm_fields[erFc822Addr];
+ }
+ else {
+ return;
+ }
+
+ // Assemble the reject message.
+ char *reject_text = malloc(strlen(rule->autoreply_message) + 1024);
+ if (reject_text == NULL) {
+ return;
+ }
+ sprintf(reject_text,
+ "Content-type: text/plain\n"
+ "\n"
+ "The message was refused by the recipient's mail filtering program.\n"
+ "The reason given was as follows:\n"
+ "\n"
+ "%s\n"
+ "\n"
+ ,
+ rule->autoreply_message
+ );
+
+ // Deliver the message
+ quickie_message(
+ " ",
+ msg->cm_fields[eenVelopeTo],
+ sender,
+ MAILROOM,
+ reject_text,
+ FMT_RFC822,
+ "Delivery status notification"
+ );
+ free(reject_text);
+}
+
+
+// Perform the "vacation" action (send an automatic response)
+void inbox_do_vacation(struct irule *rule, struct CtdlMessage *msg) {
+ syslog(LOG_DEBUG, "inbox_do_vacation: sender: <%s>, vacation", msg->cm_fields[erFc822Addr]);
+
+ // If we can't determine who sent the message, no auto-reply can be sent.
+ char *sender;
+ if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
+ sender = msg->cm_fields[eMessagePath];
+ }
+ else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
+ sender = msg->cm_fields[erFc822Addr];
+ }
+ else {
+ return;
+ }
+
+ // Avoid repeatedly sending auto-replies to the same correspondent over and over again by creating
+ // a hash of the user, correspondent, and reply text, and hitting the S_USETABLE database.
+ StrBuf *u = NewStrBuf();
+ StrBufPrintf(u, "vacation/%x/%x/%x",
+ HashLittle(sender, strlen(sender)),
+ HashLittle(msg->cm_fields[eenVelopeTo], msg->cm_lengths[eenVelopeTo]),
+ HashLittle(rule->autoreply_message, strlen(rule->autoreply_message))
+ );
+ int already_seen = CheckIfAlreadySeen(u);
+ FreeStrBuf(&u);
+
+ if (!already_seen) {
+ // Assemble the auto-reply message.
+ StrBuf *reject_text = NewStrBuf();
+ if (reject_text == NULL) {
+ return;
+ }
+
+ StrBufPrintf(reject_text,
+ "Content-type: text/plain\n"
+ "\n"
+ "%s\n"
+ "\n"
+ ,
+ rule->autoreply_message
+ );
+
+ // Deliver the auto-reply.
+ quickie_message(
+ "",
+ msg->cm_fields[eenVelopeTo],
+ sender,
+ MAILROOM,
+ ChrPtr(reject_text),
+ FMT_RFC822,
+ "Delivery status notification"
+ );
+ FreeStrBuf(&reject_text);
+ }
+}
+
+
+/*
+ * Process a single message. We know the room, the user, the rules, the message number, etc.
+ */
+void inbox_do_msg(long msgnum, void *userdata) {
+ struct inboxrules *ii = (struct inboxrules *) userdata;
+ struct CtdlMessage *msg = NULL; // If we are loading a message to process, put it here.
+ int headers_loaded = 0; // Did we load the headers yet? Do it only once.
+ int body_loaded = 0; // Did we load the message body yet? Do it only once.
+ int metadata_loaded = 0; // Did we load the metadata yet? Do it only once.
+ struct MetaData smi; // If we are loading the metadata to compare, put it here.
+ int rule_activated = 0; // On each rule, this is set if the compare succeeds and the rule activates.
+ char compare_me[SIZ]; // On each rule, we will store the field to be compared here.
+ int compare_compound = 0; // Set to 1 when we are comparing both display name and email address
+ int keep_message = 1; // Nonzero to keep the message in the inbox after processing, 0 to delete it.
+ int i;
+
+ syslog(LOG_DEBUG, "inboxrules: processing message #%ld which is higher than %ld, we are in %s", msgnum, ii->lastproc, CC->room.QRname);
+
+ if (ii->num_rules <= 0) {
+ syslog(LOG_DEBUG, "inboxrules: rule set is empty");
+ return;
+ }
+
+ for (i=0; i<ii->num_rules; ++i) {
+ syslog(LOG_DEBUG, "inboxrules: processing rule %d is %s", i, field_keys[ ii->rules[i].compared_field ]);
+ rule_activated = 0;
+
+ // Before doing a field compare, check to see if we have the correct parts of the message in memory.
+
+ switch(ii->rules[i].compared_field) {
+ // These fields require loading only the top-level headers
+ case field_from: // From:
+ case field_tocc: // To: or Cc:
+ case field_subject: // Subject:
+ case field_replyto: // Reply-to:
+ case field_listid: // List-ID:
+ case field_envto: // Envelope-to:
+ case field_envfrom: // Return-path:
+ if (!headers_loaded) {
+ syslog(LOG_DEBUG, "inboxrules: loading headers for message %ld", msgnum);
+ msg = CtdlFetchMessage(msgnum, 0);
+ if (!msg) {
+ return;
+ }
+ headers_loaded = 1;
+ }
+ break;
+ // These fields are not stored as Citadel headers, and therefore require a full message load.
+ case field_sender:
+ case field_resentfrom:
+ case field_resentto:
+ case field_xmailer:
+ case field_xspamflag:
+ case field_xspamstatus:
+ if (!body_loaded) {
+ syslog(LOG_DEBUG, "inboxrules: loading all of message %ld", msgnum);
+ if (msg != NULL) {
+ CM_Free(msg);
+ }
+ msg = CtdlFetchMessage(msgnum, 1);
+ if (!msg) {
+ return;
+ }
+ headers_loaded = 1;
+ body_loaded = 1;
+ }
+ break;
+ case field_size:
+ if (!metadata_loaded) {
+ syslog(LOG_DEBUG, "inboxrules: loading metadata for message %ld", msgnum);
+ GetMetaData(&smi, msgnum);
+ metadata_loaded = 1;
+ }
+ break;
+ case field_all:
+ syslog(LOG_DEBUG, "inboxrules: this is an always-on rule");
+ break;
+ default:
+ syslog(LOG_DEBUG, "inboxrules: unknown rule key");
+ }
+
+ // If the rule involves a field comparison, load the field to be compared.
+ compare_me[0] = 0;
+ compare_compound = 0;
+ switch(ii->rules[i].compared_field) {
+ case field_from: // From:
+ if ( (!IsEmptyStr(msg->cm_fields[erFc822Addr])) && (!IsEmptyStr(msg->cm_fields[erFc822Addr])) ) {
+ snprintf(compare_me, sizeof compare_me, "%s|%s",
+ msg->cm_fields[eAuthor],
+ msg->cm_fields[erFc822Addr]
+ );
+ compare_compound = 1; // there will be two fields to compare "name|address"
+ }
+ else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) {
+ safestrncpy(compare_me, msg->cm_fields[erFc822Addr], sizeof compare_me);
+ }
+ else if (!IsEmptyStr(msg->cm_fields[eAuthor])) {
+ safestrncpy(compare_me, msg->cm_fields[eAuthor], sizeof compare_me);
+ }
+ break;
+ case field_tocc: // To: or Cc:
+ if (!IsEmptyStr(msg->cm_fields[eRecipient])) {
+ safestrncpy(compare_me, msg->cm_fields[eRecipient], sizeof compare_me);
+ }
+ if (!IsEmptyStr(msg->cm_fields[eCarbonCopY])) {
+ if (!IsEmptyStr(compare_me)) {
+ strcat(compare_me, ",");
+ }
+ safestrncpy(&compare_me[strlen(compare_me)], msg->cm_fields[eCarbonCopY], (sizeof compare_me - strlen(compare_me)));
+ }
+ break;
+ case field_subject: // Subject:
+ if (!IsEmptyStr(msg->cm_fields[eMsgSubject])) {
+ safestrncpy(compare_me, msg->cm_fields[eMsgSubject], sizeof compare_me);
+ }
+ break;
+ case field_replyto: // Reply-to:
+ if (!IsEmptyStr(msg->cm_fields[eReplyTo])) {
+ safestrncpy(compare_me, msg->cm_fields[eReplyTo], sizeof compare_me);
+ }
+ break;
+ case field_listid: // List-ID:
+ if (!IsEmptyStr(msg->cm_fields[eListID])) {
+ safestrncpy(compare_me, msg->cm_fields[eListID], sizeof compare_me);
+ }
+ break;
+ case field_envto: // Envelope-to:
+ if (!IsEmptyStr(msg->cm_fields[eenVelopeTo])) {
+ safestrncpy(compare_me, msg->cm_fields[eenVelopeTo], sizeof compare_me);
+ }
+ break;
+ case field_envfrom: // Return-path:
+ if (!IsEmptyStr(msg->cm_fields[eMessagePath])) {
+ safestrncpy(compare_me, msg->cm_fields[eMessagePath], sizeof compare_me);
+ }
+ break;
+
+ case field_sender:
+ case field_resentfrom:
+ case field_resentto:
+ case field_xmailer:
+ case field_xspamflag:
+ case field_xspamstatus:
+
+ default:
+ break;
+ }
+
+ // Message data to compare is loaded, now do something.
+ switch(ii->rules[i].compared_field) {
+ case field_from: // From:
+ case field_tocc: // To: or Cc:
+ case field_subject: // Subject:
+ case field_replyto: // Reply-to:
+ case field_listid: // List-ID:
+ case field_envto: // Envelope-to:
+ case field_envfrom: // Return-path:
+ case field_sender:
+ case field_resentfrom:
+ case field_resentto:
+ case field_xmailer:
+ case field_xspamflag:
+ case field_xspamstatus:
+
+ // For all of the above fields, we can compare the field we've loaded into the buffer.
+ syslog(LOG_DEBUG, "Value of field to compare is: <%s>", compare_me);
+ int substring_match = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 1 : 0);
+ int exact_match = 0;
+ if (compare_compound) {
+ char *sep = strchr(compare_me, '|');
+ if (sep) {
+ *sep = 0;
+ exact_match =
+ (strcasecmp(compare_me, ii->rules[i].compared_value) ? 0 : 1)
+ + (strcasecmp(++sep, ii->rules[i].compared_value) ? 0 : 1)
+ ;
+ }
+ }
+ else {
+ exact_match = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 0 : 1);
+ }
+ syslog(LOG_DEBUG, "substring match: %d", substring_match);
+ syslog(LOG_DEBUG, "exact match: %d", exact_match);
+ switch(ii->rules[i].field_compare_op) {
+ case fcomp_contains:
+ case fcomp_matches:
+ rule_activated = substring_match;
+ break;
+ case fcomp_notcontains:
+ case fcomp_notmatches:
+ rule_activated = !substring_match;
+ break;
+ case fcomp_is:
+ rule_activated = exact_match;
+ break;
+ case fcomp_isnot:
+ rule_activated = !exact_match;
+ break;
+ }
+ break;
+
+ case field_size:
+ rule_activated = 0;
+ switch(ii->rules[i].field_compare_op) {
+ case scomp_larger:
+ rule_activated = ((smi.meta_rfc822_length > ii->rules[i].compared_size) ? 1 : 0);
+ break;
+ case scomp_smaller:
+ rule_activated = ((smi.meta_rfc822_length < ii->rules[i].compared_size) ? 1 : 0);
+ break;
+ }
+ break;
+ case field_all: // The "all messages" rule ALWAYS triggers
+ rule_activated = 1;
+ break;
+ default: // no matches, fall through and do nothing
+ syslog(LOG_WARNING, "inboxrules: an unknown field comparison was encountered");
+ rule_activated = 0;
+ break;
+ }
+
+ // If the rule matched, perform the requested action.
+ if (rule_activated) {
+ syslog(LOG_DEBUG, "inboxrules: rule activated");
+
+ // Perform the requested action
+ switch(ii->rules[i].action) {
+ case action_keep:
+ keep_message = 1;
+ break;
+ case action_discard:
+ keep_message = 0;
+ break;
+ case action_reject:
+ inbox_do_reject(&ii->rules[i], msg);
+ keep_message = 0;
+ break;
+ case action_fileinto:
+ keep_message = inbox_do_fileinto(&ii->rules[i], msgnum);
+ break;
+ case action_redirect:
+ keep_message = inbox_do_redirect(&ii->rules[i], msgnum);
+ break;
+ case action_vacation:
+ inbox_do_vacation(&ii->rules[i], msg);
+ keep_message = 1;
+ break;
+ }
+
+ // Now perform the "final" action (anything other than "stop" means continue)
+ if (ii->rules[i].final_action == final_stop) {
+ syslog(LOG_DEBUG, "inboxrules: stop processing");
+ i = ii->num_rules + 1; // throw us out of scope to stop
+ }
+
+
+ }
+ else {
+ syslog(LOG_DEBUG, "inboxrules: rule not activated");
+ }
+ }
+
+ if (msg != NULL) { // Delete the copy of the message that is currently in memory. We don't need it anymore.
+ CM_Free(msg);
+ }
+
+ if (!keep_message) { // Delete the copy of the message that is currently in the inbox, if rules dictated that.
+ syslog(LOG_DEBUG, "inboxrules: delete %ld from inbox", msgnum);
+ CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, ""); // we're in the inbox already
+ }
+
+ ii->lastproc = msgnum; // make note of the last message we processed, so we don't scan the whole inbox again
+}
+
+
+/*
+ * A user account is identified as requring inbox processing.
+ * Do it.
+ */
+void do_inbox_processing_for_user(long usernum) {
+ struct CtdlMessage *msg;
+ struct inboxrules *ii;
+ char roomname[ROOMNAMELEN];
+ char username[64];
+
+ if (CtdlGetUserByNumber(&CC->user, usernum) != 0) { // grab the user record
+ return; // and bail out if we were given an invalid user
+ }
+
+ strcpy(username, CC->user.fullname); // save the user name so we can fetch it later and lock it
+
+ if (CC->user.msgnum_inboxrules <= 0) {
+ return; // this user has no inbox rules
+ }
+
+ msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
+ if (msg == NULL) {
+ return; // config msgnum is set but that message does not exist
+ }
+
+ ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]);
+ CM_Free(msg);
+
+ if (ii == NULL) {
+ return; // config message exists but body is null
+ }
+
+ if (ii->lastproc > CC->user.lastproc_inboxrules) { // There might be a "last message processed" number left over
+ CC->user.lastproc_inboxrules = ii->lastproc; // in the ruleset from a previous version. Use this if it is
+ } // a higher number.
+ else {
+ ii->lastproc = CC->user.lastproc_inboxrules;
+ }
+
+ long original_lastproc = ii->lastproc;
+ syslog(LOG_DEBUG, "inboxrules: for %s, messages newer than %ld", CC->user.fullname, original_lastproc);
+
+ // Go to the user's inbox room and process all new messages
+ snprintf(roomname, sizeof roomname, "%010ld.%s", usernum, MAILROOM);
+ if (CtdlGetRoom(&CC->room, roomname) == 0) {
+ CtdlForEachMessage(MSGS_GT, ii->lastproc, NULL, NULL, NULL, inbox_do_msg, (void *) ii);
+ }
+
+ // Record the number of the last message we processed
+ if (ii->lastproc > original_lastproc) {
+ CtdlGetUserLock(&CC->user, username);
+ CC->user.lastproc_inboxrules = ii->lastproc; // Avoid processing the entire inbox next time
+ CtdlPutUserLock(&CC->user);
+ }
+
+ // And free the memory.
+ free_inbox_rules(ii);
+}
+
+
+/*
+ * Here is an array of users (by number) who have received messages in their inbox and may require processing.
+ */
+long *users_requiring_inbox_processing = NULL;
+int num_urip = 0;
+int num_urip_alloc = 0;
+
+
+/*
+ * Perform inbox processing for all rooms which require it
+ */
+void perform_inbox_processing(void) {
+ int i = 0;
+
+ if (num_urip == 0) {
+ return; // no action required
+ }
+
+ for (i=0; i<num_urip; ++i) {
+ do_inbox_processing_for_user(users_requiring_inbox_processing[i]);
+ }
+
+ free(users_requiring_inbox_processing);
+ users_requiring_inbox_processing = NULL;
+ num_urip = 0;
+ num_urip_alloc = 0;
+}
+
+
+/*
+ * This function is called after a message is saved to a room.
+ * If it's someone's inbox, we have to check for inbox rules
+ */
+int serv_inboxrules_roomhook(struct ctdlroom *room) {
+ int i = 0;
+
+ // Is this someone's inbox?
+ if (!strcasecmp(&room->QRname[11], MAILROOM)) {
+ long usernum = atol(room->QRname);
+ if (usernum > 0) {
+
+ // first check to see if this user is already on the list
+ if (num_urip > 0) {
+ for (i=0; i<=num_urip; ++i) {
+ if (users_requiring_inbox_processing[i] == usernum) { // already on the list!
+ return(0);
+ }
+ }
+ }
+
+ // make room if we need to
+ if (num_urip_alloc == 0) {
+ num_urip_alloc = 100;
+ users_requiring_inbox_processing = malloc(sizeof(long) * num_urip_alloc);
+ }
+ else if (num_urip >= num_urip_alloc) {
+ num_urip_alloc += 100;
+ users_requiring_inbox_processing = realloc(users_requiring_inbox_processing, (sizeof(long) * num_urip_alloc));
+ }
+
+ // now add the user to the list
+ users_requiring_inbox_processing[num_urip++] = usernum;
+ }
+ }
+
+ // No errors are possible from this function.
+ return(0);
+}
+
+
+
+/*
+ * Get InBox Rules
+ *
+ * This is a client-facing function which fetches the user's inbox rules -- it omits all lines containing anything other than a rule.
+ *
+ * hmmmmm ... should we try to rebuild this in terms of deserialize_inbox_rules() instread?
+ */
+void cmd_gibr(char *argbuf) {
+
+ if (CtdlAccessCheck(ac_logged_in)) return;
+
+ cprintf("%d inbox rules for %s\n", LISTING_FOLLOWS, CC->user.fullname);
+
+ struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
+ if (msg != NULL) {
+ if (!CM_IsEmpty(msg, eMesageText)) {
+ char *token;
+ char *rest = msg->cm_fields[eMesageText];
+ while ((token = strtok_r(rest, "\n", &rest))) {
+
+ // for backwards compatibility, "# WEBCIT_RULE" is an alias for "rule"
+ if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
+ strcpy(token, "rule|");
+ strcpy(&token[5], &token[14]);
+ }
+
+ // Output only lines containing rules.
+ if (!strncasecmp(token, "rule|", 5)) {
+ cprintf("%s\n", token);
+ }
+ else {
+ cprintf("# invalid rule found : %s\n", token);
+ }
+ }
+ }
+ CM_Free(msg);
+ }
+ cprintf("000\n");
+}
+
+
+/*
+ * Rewrite the rule set to disk after it has been modified
+ * Called by cmd_pibr()
+ * Returns the msgnum of the new rules message
+ */
+void rewrite_rules_to_disk(const char *new_config) {
+ long old_msgnum = CC->user.msgnum_inboxrules;
+ char userconfigroomname[ROOMNAMELEN];
+ CtdlMailboxName(userconfigroomname, sizeof userconfigroomname, &CC->user, USERCONFIGROOM);
+ long new_msgnum = quickie_message("Citadel", NULL, NULL, userconfigroomname, new_config, FMT_RFC822, "inbox rules configuration");
+ CtdlGetUserLock(&CC->user, CC->curr_user);
+ CC->user.msgnum_inboxrules = new_msgnum; // Now we know where to get the rules next time
+ CC->user.lastproc_inboxrules = new_msgnum; // Avoid processing the entire inbox next time
+ CtdlPutUserLock(&CC->user);
+ if (old_msgnum > 0) {
+ syslog(LOG_DEBUG, "Deleting old message %ld from %s", old_msgnum, userconfigroomname);
+ CtdlDeleteMessages(userconfigroomname, &old_msgnum, 1, "");
+ }
+}
+
+
+/*
+ * Put InBox Rules
+ *
+ * User transmits the new inbox rules for the account. They are inserted into the account, replacing the ones already there.
+ */
+void cmd_pibr(char *argbuf) {
+ if (CtdlAccessCheck(ac_logged_in)) return;
+
+ unbuffer_output();
+ cprintf("%d send new rules\n", SEND_LISTING);
+ char *newrules = CtdlReadMessageBody(HKEY("000"), CtdlGetConfigLong("c_maxmsglen"), NULL, 0);
+ StrBuf *NewConfig = NewStrBufPlain("Content-type: application/x-citadel-sieve-config; charset=UTF-8\nContent-transfer-encoding: 8bit\n\n", -1);
+
+ char *token;
+ char *rest = newrules;
+ while ((token = strtok_r(rest, "\n", &rest))) {
+ // Accept only lines containing rules
+ if (!strncasecmp(token, "rule|", 5)) {
+ StrBufAppendBufPlain(NewConfig, token, -1, 0);
+ StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0);
+ }
+ }
+ free(newrules);
+ rewrite_rules_to_disk(ChrPtr(NewConfig));
+ FreeStrBuf(&NewConfig);
+}
+
+
+char *ctdl_module_init_sieve(void) {
+ if (!threading) {
+ CtdlRegisterProtoHook(cmd_gibr, "GIBR", "Get InBox Rules");
+ CtdlRegisterProtoHook(cmd_pibr, "PIBR", "Put InBox Rules");
+ CtdlRegisterRoomHook(serv_inboxrules_roomhook);
+ CtdlRegisterSessionHook(perform_inbox_processing, EVT_HOUSE, PRIO_HOUSE + 10);
+ }
+
+ /* return our module name for the log */
+ return "inboxrules";
+}
projects / citadel.git / blobdiff