X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=citadel%2Fmodules%2Finboxrules%2Fserv_inboxrules.c;h=4979e57150e74f64900535fef0bd7de83e26c0bf;hp=30feea856624410a99285e52999396070bf0acc4;hb=0387f48886a9395d89eaca01cd40ab751610426f;hpb=3101d92471592f0f1ffaf19fcd7f779b02057ef7 diff --git a/citadel/modules/inboxrules/serv_inboxrules.c b/citadel/modules/inboxrules/serv_inboxrules.c index 30feea856..4979e5715 100644 --- a/citadel/modules/inboxrules/serv_inboxrules.c +++ b/citadel/modules/inboxrules/serv_inboxrules.c @@ -48,158 +48,361 @@ #include "ctdl_module.h" -#if 0 - /* - * Callback function to redirect a message to a different folder + * The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration. */ -int ctdl_redirect(void) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - struct CtdlMessage *msg = NULL; - recptypes *valid = NULL; - char recp[256]; - safestrncpy(recp, sieve2_getvalue_string(s, "address"), sizeof recp); +// 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" +}; - syslog(LOG_DEBUG, "Action is REDIRECT, recipient <%s>", recp); +// Actions +enum { + action_keep, + action_discard, + action_reject, + action_fileinto, + action_redirect, + action_vacation +}; +char *action_keys[] = { + "keep", + "discard", + "reject", + "fileinto", + "redirect", + "vacation" +}; - valid = validate_recipients(recp, NULL, 0); - if (valid == NULL) { - syslog(LOG_WARNING, "REDIRECT failed: bad recipient <%s>", recp); - return SIEVE2_ERROR_BADARGS; +// 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; } - if (valid->num_error > 0) { - syslog(LOG_WARNING, "REDIRECT failed: bad recipient <%s>", recp); - free_recipients(valid); - return SIEVE2_ERROR_BADARGS; + + /* 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; } - msg = CtdlFetchMessage(cs->msgnum, 1, 1); - if (msg == NULL) { - syslog(LOG_WARNING, "REDIRECT failed: unable to fetch msg %ld", cs->msgnum); - free_recipients(valid); - return SIEVE2_ERROR_BADARGS; + struct inboxrules *ibr = malloc(sizeof(struct inboxrules)); + if (ibr == NULL) { + return NULL; } + memset(ibr, 0, sizeof(struct inboxrules)); - CtdlSubmitMsg(msg, valid, NULL, 0); - cs->cancel_implicit_keep = 1; - free_recipients(valid); - CM_Free(msg); - return SIEVE2_OK; -} + 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]); + } -/* - * Callback function to indicate that a message *will* be kept in the inbox - */ -int ctdl_keep(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - - syslog(LOG_DEBUG, "Action is KEEP"); + // 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, '|'); + for (int t=0; tcompared_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. + + } - cs->keep = 1; - cs->cancel_implicit_keep = 1; - return SIEVE2_OK; + 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. } -/* - * Callback function to file a message into a different mailbox - */ -int ctdl_fileinto(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - const char *dest_folder = sieve2_getvalue_string(s, "mailbox"); - int c; - char foldername[256]; +// 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; - syslog(LOG_DEBUG, "Action is FILEINTO, destination is <%s>", dest_folder); - - /* FILEINTO 'INBOX' is the same thing as KEEP */ - if ( (!strcasecmp(dest_folder, "INBOX")) || (!strcasecmp(dest_folder, MAILROOM)) ) { - cs->keep = 1; - cs->cancel_implicit_keep = 1; - return SIEVE2_OK; + // 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 */ + // 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) */ - snprintf(foldername, sizeof foldername, "%010ld.%s", cs->usernum, dest_folder); + // 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) */ + // 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, "FILEINTO failed: target <%s> does not exist", dest_folder); - return SIEVE2_ERROR_BADARGS; + 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 */ + // Yes, we actually have to go there CtdlUserGoto(NULL, 0, 0, NULL, NULL, NULL, NULL); - c = CtdlSaveMsgPointersInRoom(NULL, &cs->msgnum, 1, 0, NULL, 0); + c = CtdlSaveMsgPointersInRoom(NULL, &msgnum, 1, 0, NULL, 0); - /* Go back to the room we came from */ + // 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); } - if (c == 0) { - cs->cancel_implicit_keep = 1; - return SIEVE2_OK; - } - else { - return SIEVE2_ERROR_BADARGS; - } + return(0); // delete the inbox copy } -/* - * Callback function to indicate that a message should be discarded. - */ -int ctdl_discard(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; +// 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 + } - syslog(LOG_DEBUG, "Action is DISCARD"); + 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 + } - /* Cancel the implicit keep. That's all there is to it. */ - cs->cancel_implicit_keep = 1; - return SIEVE2_OK; + 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 } /* - * Callback function to indicate that a message should be rejected + * Perform the "reject" action (delete the message, and tell the sender we deleted it) */ -int ctdl_reject(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - char *reject_text = NULL; +void inbox_do_reject(struct irule *rule, struct CtdlMessage *msg) { + syslog(LOG_DEBUG, "inbox_do_reject: sender: <%s>, reject", msg->cm_fields[erFc822Addr]); - syslog(LOG_DEBUG, "Action is REJECT"); - - /* If we don't know who sent the message, do a DISCARD instead. */ - if (IsEmptyStr(cs->sender)) { - syslog(LOG_INFO, "Unknown sender. Doing DISCARD instead of REJECT."); - return ctdl_discard(s, my); + // 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. */ - reject_text = malloc(strlen(sieve2_getvalue_string(s, "message")) + 1024); + // Assemble the reject message. + char *reject_text = malloc(strlen(rule->autoreply_message) + 1024); if (reject_text == NULL) { - return SIEVE2_ERROR_FAIL; + return; } - sprintf(reject_text, "Content-type: text/plain\n" "\n" @@ -209,650 +412,492 @@ int ctdl_reject(sieve2_context_t *s, void *my) "%s\n" "\n" , - sieve2_getvalue_string(s, "message") + rule->autoreply_message ); - quickie_message( /* This delivers the message */ - NULL, - cs->envelope_to, - cs->sender, - NULL, + // Deliver the message + quickie_message( + " ", + msg->cm_fields[eenVelopeTo], + sender, + MAILROOM, reject_text, FMT_RFC822, "Delivery status notification" ); - free(reject_text); - cs->cancel_implicit_keep = 1; - return SIEVE2_OK; } /* - * Callback function to indicate that a vacation message should be generated + * Perform the "vacation" action (send an automatic response) */ -int ctdl_vacation(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - struct sdm_vacation *vptr; - int days = 1; - const char *message; - char *vacamsg_text = NULL; - char vacamsg_subject[1024]; - - syslog(LOG_DEBUG, "Action is VACATION"); +void inbox_do_vacation(struct irule *rule, struct CtdlMessage *msg) { + syslog(LOG_DEBUG, "inbox_do_vacation: sender: <%s>, vacation", msg->cm_fields[erFc822Addr]); - message = sieve2_getvalue_string(s, "message"); - if (message == NULL) return SIEVE2_ERROR_BADARGS; - - if (sieve2_getvalue_string(s, "subject") != NULL) { - safestrncpy(vacamsg_subject, sieve2_getvalue_string(s, "subject"), sizeof vacamsg_subject); - } - else { - snprintf(vacamsg_subject, sizeof vacamsg_subject, "Re: %s", cs->subject); + // 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]; } - - days = sieve2_getvalue_int(s, "days"); - if (days < 1) days = 1; - if (days > MAX_VACATION) days = MAX_VACATION; - - /* Check to see whether we've already alerted this sender that we're on vacation. */ - for (vptr = cs->u->first_vacation; vptr != NULL; vptr = vptr->next) { - if (!strcasecmp(vptr->fromaddr, cs->sender)) { - if ( (time(NULL) - vptr->timestamp) < (days * 86400) ) { - syslog(LOG_DEBUG, "Already alerted <%s> recently.", cs->sender); - return SIEVE2_OK; - } - } + else if (!IsEmptyStr(msg->cm_fields[erFc822Addr])) { + sender = msg->cm_fields[erFc822Addr]; } - - /* Assemble the reject message. */ - vacamsg_text = malloc(strlen(message) + 1024); - if (vacamsg_text == NULL) { - return SIEVE2_ERROR_FAIL; + else { + return; } - sprintf(vacamsg_text, - "Content-type: text/plain charset=utf-8\n" - "\n" - "%s\n" - "\n" - , - message - ); - - quickie_message( /* This delivers the message */ - NULL, - cs->envelope_to, - cs->sender, - NULL, - vacamsg_text, - FMT_RFC822, - vacamsg_subject + // 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)) ); - - free(vacamsg_text); - - /* Now update the list to reflect the fact that we've alerted this sender. - * If they're already in the list, just update the timestamp. - */ - for (vptr = cs->u->first_vacation; vptr != NULL; vptr = vptr->next) { - if (!strcasecmp(vptr->fromaddr, cs->sender)) { - vptr->timestamp = time(NULL); - return SIEVE2_OK; + int already_seen = CheckIfAlreadySeen(u); + FreeStrBuf(&u); + + if (!already_seen) { + // Assemble the auto-reply message. + StrBuf *reject_text = NewStrBuf(); + if (reject_text == NULL) { + return; } - } - /* If we get to this point, create a new record. - */ - vptr = malloc(sizeof(struct sdm_vacation)); - memset(vptr, 0, sizeof(struct sdm_vacation)); - vptr->timestamp = time(NULL); - safestrncpy(vptr->fromaddr, cs->sender, sizeof vptr->fromaddr); - vptr->next = cs->u->first_vacation; - cs->u->first_vacation = vptr; - - return SIEVE2_OK; + 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); + } } /* - * Callback function to parse message envelope + * Process a single message. We know the room, the user, the rules, the message number, etc. */ -int ctdl_getenvelope(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; +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, "Action is GETENVELOPE"); - syslog(LOG_DEBUG, "EnvFrom: %s", cs->envelope_from); - syslog(LOG_DEBUG, "EnvTo: %s", cs->envelope_to); + syslog(LOG_DEBUG, "inboxrules: processing message #%ld which is higher than %ld, we are in %s", msgnum, ii->lastproc, CC->room.QRname); - if (cs->envelope_from != NULL) { - if ((cs->envelope_from[0] != '@')&&(cs->envelope_from[strlen(cs->envelope_from)-1] != '@')) { - sieve2_setvalue_string(s, "from", cs->envelope_from); - } - else { - sieve2_setvalue_string(s, "from", "invalid_envelope_from@example.org"); - } - } - else { - sieve2_setvalue_string(s, "from", "null_envelope_from@example.org"); + if (ii->num_rules <= 0) { + syslog(LOG_DEBUG, "inboxrules: rule set is empty"); + return; } - - if (cs->envelope_to != NULL) { - if ((cs->envelope_to[0] != '@') && (cs->envelope_to[strlen(cs->envelope_to)-1] != '@')) { - sieve2_setvalue_string(s, "to", cs->envelope_to); - } - else { - sieve2_setvalue_string(s, "to", "invalid_envelope_to@example.org"); + for (i=0; inum_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"); } - } - else { - sieve2_setvalue_string(s, "to", "null_envelope_to@example.org"); - } - - return SIEVE2_OK; -} + // 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: -/* - * Callback function to fetch message size - */ -int ctdl_getsize(sieve2_context_t *s, void *my) -{ - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - struct MetaData smi; + default: + break; + } - GetMetaData(&smi, cs->msgnum); - - if (smi.meta_rfc822_length > 0L) { - sieve2_setvalue_int(s, "size", (int)smi.meta_rfc822_length); - return SIEVE2_OK; - } + // 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; + } - return SIEVE2_ERROR_UNSUPPORTED; -} + // 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 + } -/* - * Return a pointer to the active Sieve script. - * (Caller does NOT own the memory and should not free the returned pointer.) - */ -char *get_active_script(struct sdm_userdata *u) { - struct sdm_script *sptr; - for (sptr=u->first_script; sptr!=NULL; sptr=sptr->next) { - if (sptr->script_active > 0) { - syslog(LOG_DEBUG, "get_active_script() is using script '%s'", sptr->script_name); - return(sptr->script_content); + } + else { + syslog(LOG_DEBUG, "inboxrules: rule not activated"); } } - syslog(LOG_DEBUG, "get_active_script() found no active script"); - return(NULL); -} - - -/* - * Callback function to retrieve the sieve script - */ -int ctdl_getscript(sieve2_context_t *s, void *my) { - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; - - char *active_script = get_active_script(cs->u); - if (active_script != NULL) { - sieve2_setvalue_string(s, "script", active_script); - return SIEVE2_OK; + if (msg != NULL) { // Delete the copy of the message that is currently in memory. We don't need it anymore. + CM_Free(msg); } - return SIEVE2_ERROR_GETSCRIPT; -} - - -/* - * Callback function to retrieve message headers - */ -int ctdl_getheaders(sieve2_context_t *s, void *my) { - - struct ctdl_sieve *cs = (struct ctdl_sieve *)my; + 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 + } - syslog(LOG_DEBUG, "ctdl_getheaders() was called"); - sieve2_setvalue_string(s, "allheaders", cs->rfc822headers); - return SIEVE2_OK; + ii->lastproc = msgnum; // make note of the last message we processed, so we don't scan the whole inbox again } - /* - * Perform sieve processing for one message (called by sieve_do_room() for each message) + * A user account is identified as requring inbox processing. + * Do it. */ -void sieve_do_msg(long msgnum, void *userdata) { - struct sdm_userdata *u = (struct sdm_userdata *) userdata; - sieve2_context_t *sieve2_context; - struct ctdl_sieve my; - int res; +void do_inbox_processing_for_user(long usernum) { struct CtdlMessage *msg; - int i; - size_t headers_len = 0; - int len = 0; - - if (u == NULL) { - syslog(LOG_ERR, "Can't process message <%ld> without userdata!", msgnum); - return; - } + struct inboxrules *ii; + char roomname[ROOMNAMELEN]; + char username[64]; - sieve2_context = u->sieve2_context; - - syslog(LOG_DEBUG, "Performing sieve processing on msg <%ld>", msgnum); - - /* - * Make sure you include message body so you can get those second-level headers ;) - */ - msg = CtdlFetchMessage(msgnum, 1, 1); - if (msg == NULL) return; - - /* - * Grab the message headers so we can feed them to libSieve. - * Use HEADERS_ONLY rather than HEADERS_FAST in order to include second-level headers. - */ - CC->redirect_buffer = NewStrBufPlain(NULL, SIZ); - CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ONLY, 0, 1, 0); - headers_len = StrLength(CC->redirect_buffer); - my.rfc822headers = SmashStrBuf(&CC->redirect_buffer); - - /* - * libSieve clobbers the stack if it encounters badly formed - * headers. Sanitize our headers by stripping nonprintable - * characters. - */ - for (i=0; iuser, usernum) != 0) { // grab the user record + return; // and bail out if we were given an invalid user } - my.keep = 0; /* Set to 1 to declare an *explicit* keep */ - my.cancel_implicit_keep = 0; /* Some actions will cancel the implicit keep */ - my.usernum = atol(CC->room.QRname); /* Keep track of the owner of the room's namespace */ - my.msgnum = msgnum; /* Keep track of the message number in our local store */ - my.u = u; /* Hand off a pointer to the rest of this info */ - - /* Keep track of the recipient so we can do handling based on it later */ - process_rfc822_addr(msg->cm_fields[eRecipient], my.recp_user, my.recp_node, my.recp_name); + strcpy(username, CC->user.fullname); // save the user name so we can fetch it later and lock it - /* Keep track of the sender so we can use it for REJECT and VACATION responses */ - if (!CM_IsEmpty(msg, erFc822Addr)) { - safestrncpy(my.sender, msg->cm_fields[erFc822Addr], sizeof my.sender); - } - else if (!CM_IsEmpty(msg, eAuthor)) { - safestrncpy(my.sender, msg->cm_fields[eAuthor], sizeof my.sender); - } - else { - strcpy(my.sender, ""); + if (CC->user.msgnum_inboxrules <= 0) { + return; // this user has no inbox rules } - /* Keep track of the subject so we can use it for VACATION responses */ - if (!CM_IsEmpty(msg, eMsgSubject)) { - safestrncpy(my.subject, msg->cm_fields[eMsgSubject], sizeof my.subject); - } - else { - strcpy(my.subject, ""); + msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1); + if (msg == NULL) { + return; // config msgnum is set but that message does not exist } - /* Keep track of the envelope-from address (use body-from if not found) */ - if (!CM_IsEmpty(msg, eMessagePath)) { - safestrncpy(my.envelope_from, msg->cm_fields[eMessagePath], sizeof my.envelope_from); - stripallbut(my.envelope_from, '<', '>'); - } - else if (!CM_IsEmpty(msg, erFc822Addr)) { - safestrncpy(my.envelope_from, msg->cm_fields[erFc822Addr], sizeof my.envelope_from); - stripallbut(my.envelope_from, '<', '>'); - } - else { - strcpy(my.envelope_from, ""); - } + ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]); + CM_Free(msg); - len = strlen(my.envelope_from); - for (i=0; icm_fields[eenVelopeTo], sizeof my.envelope_to); - stripallbut(my.envelope_to, '<', '>'); - } - else if (!CM_IsEmpty(msg, eRecipient)) { - safestrncpy(my.envelope_to, msg->cm_fields[eRecipient], sizeof my.envelope_to); - stripallbut(my.envelope_to, '<', '>'); - } + 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 { - strcpy(my.envelope_to, ""); + ii->lastproc = CC->user.lastproc_inboxrules; } - len = strlen(my.envelope_to); - for (i=0; ilastproc; + syslog(LOG_DEBUG, "inboxrules: for %s, messages newer than %ld", CC->user.fullname, original_lastproc); - CM_Free(msg); - - syslog(LOG_DEBUG, "Calling sieve2_execute()"); - res = sieve2_execute(sieve2_context, &my); - if (res != SIEVE2_OK) { - syslog(LOG_ERR, "sieve2_execute() returned %d: %s", res, sieve2_errstr(res)); + // 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); } - free(my.rfc822headers); - my.rfc822headers = NULL; - - /* - * Delete the message from the inbox unless either we were told not to, or - * if no other action was successfully taken. - */ - if ( (!my.keep) && (my.cancel_implicit_keep) ) { - syslog(LOG_DEBUG, "keep is 0 -- deleting message from inbox"); - CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, ""); + // 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); } - syslog(LOG_DEBUG, "Completed sieve processing on msg <%ld>", msgnum); - u->lastproc = msgnum; - - return; + // And free the memory. + free_inbox_rules(ii); } - /* - * Given the on-disk representation of our Sieve config, load - * it into an in-memory data structure. + * Here is an array of users (by number) who have received messages in their inbox and may require processing. */ -void parse_sieve_config(char *conf, struct sdm_userdata *u) { - char *ptr; - char *c, *vacrec; - char keyword[256]; - struct sdm_script *sptr; - struct sdm_vacation *vptr; - - ptr = conf; - while (c = ptr, ptr = bmstrcasestr(ptr, CTDLSIEVECONFIGSEPARATOR), ptr != NULL) { - *ptr = 0; - ptr += strlen(CTDLSIEVECONFIGSEPARATOR); - - extract_token(keyword, c, 0, '|', sizeof keyword); - - if (!strcasecmp(keyword, "lastproc")) { - u->lastproc = extract_long(c, 1); - } - - else if (!strcasecmp(keyword, "script")) { - sptr = malloc(sizeof(struct sdm_script)); - extract_token(sptr->script_name, c, 1, '|', sizeof sptr->script_name); - sptr->script_active = extract_int(c, 2); - remove_token(c, 0, '|'); - remove_token(c, 0, '|'); - remove_token(c, 0, '|'); - sptr->script_content = strdup(c); - sptr->next = u->first_script; - u->first_script = sptr; - } - - else if (!strcasecmp(keyword, "vacation")) { - - if (c != NULL) while (vacrec=c, c=strchr(c, '\n'), (c != NULL)) { - - *c = 0; - ++c; +long *users_requiring_inbox_processing = NULL; +int num_urip = 0; +int num_urip_alloc = 0; - if (strncasecmp(vacrec, "vacation|", 9)) { - vptr = malloc(sizeof(struct sdm_vacation)); - extract_token(vptr->fromaddr, vacrec, 0, '|', sizeof vptr->fromaddr); - vptr->timestamp = extract_long(vacrec, 1); - vptr->next = u->first_vacation; - u->first_vacation = vptr; - } - } - } - - /* ignore unknown keywords */ - } -} /* - * We found the Sieve configuration for this user. - * Now do something with it. + * Perform inbox processing for all rooms which require it */ -void get_sieve_config_backend(long msgnum, void *userdata) { - struct sdm_userdata *u = (struct sdm_userdata *) userdata; - struct CtdlMessage *msg; - char *conf; - long conflen; - - u->config_msgnum = msgnum; - msg = CtdlFetchMessage(msgnum, 1, 1); - if (msg == NULL) { - u->config_msgnum = (-1) ; - return; +void perform_inbox_processing(void) { + if (num_urip == 0) { + return; // no action required } - CM_GetAsField(msg, eMesageText, &conf, &conflen); - - CM_Free(msg); - - if (conf != NULL) { - parse_sieve_config(conf, u); - free(conf); + for (int i=0; ilastproc - ); - - while (u->first_script != NULL) { - StrBufAppendPrintf(text, - "script|%s|%d|%s" CTDLSIEVECONFIGSEPARATOR, - u->first_script->script_name, - u->first_script->script_active, - u->first_script->script_content - ); - sptr = u->first_script; - u->first_script = u->first_script->next; - free(sptr->script_content); - free(sptr); - } - - if (u->first_vacation != NULL) { - - StrBufAppendPrintf(text, "vacation|\n"); - while (u->first_vacation != NULL) { - if ( (time(NULL) - u->first_vacation->timestamp) < (MAX_VACATION * 86400)) { - StrBufAppendPrintf(text, "%s|%ld\n", - u->first_vacation->fromaddr, - u->first_vacation->timestamp - ); +int serv_inboxrules_roomhook(struct ctdlroom *room) { + + // 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 (int i=0; i<=num_urip; ++i) { + if (users_requiring_inbox_processing[i] == usernum) { // already on the list! + return(0); + } + } } - vptr = u->first_vacation; - u->first_vacation = u->first_vacation->next; - free(vptr); - } - StrBufAppendPrintf(text, CTDLSIEVECONFIGSEPARATOR); - } - if (yes_write_to_disk) - { - /* Save the config */ - quickie_message("Citadel", NULL, NULL, u->config_roomname, - ChrPtr(text), - 4, - "Sieve configuration" - ); - - /* And delete the old one */ - if (u->config_msgnum > 0) { - CtdlDeleteMessages(u->config_roomname, &u->config_msgnum, 1, ""); + // 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; } } - FreeStrBuf (&text); - -} - - -/* - * This is our callback registration table for libSieve. - */ -sieve2_callback_t ctdl_sieve_callbacks[] = { - { SIEVE2_ACTION_REJECT, ctdl_reject }, - { SIEVE2_ACTION_VACATION, ctdl_vacation }, - { SIEVE2_ERRCALL_PARSE, ctdl_errparse }, - { SIEVE2_ERRCALL_RUNTIME, ctdl_errexec }, - { SIEVE2_ACTION_FILEINTO, ctdl_fileinto }, - { SIEVE2_ACTION_REDIRECT, ctdl_redirect }, - { SIEVE2_ACTION_DISCARD, ctdl_discard }, - { SIEVE2_ACTION_KEEP, ctdl_keep }, - { SIEVE2_SCRIPT_GETSCRIPT, ctdl_getscript }, - { SIEVE2_DEBUG_TRACE, ctdl_debug }, - { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders }, - { SIEVE2_MESSAGE_GETSIZE, ctdl_getsize }, - { SIEVE2_MESSAGE_GETENVELOPE, ctdl_getenvelope }, - { 0 } -}; - - -/* - * Perform sieve processing for a single room - */ -void sieve_do_room(char *roomname) { - - struct sdm_userdata u; - sieve2_context_t *sieve2_context = NULL; /* Context for sieve parser */ - int res; /* Return code from libsieve calls */ - long orig_lastproc = 0; - - memset(&u, 0, sizeof u); - - /* See if the user who owns this 'mailbox' has any Sieve scripts that - * require execution. - */ - snprintf(u.config_roomname, sizeof u.config_roomname, "%010ld.%s", atol(roomname), USERCONFIGROOM); - if (CtdlGetRoom(&CC->room, u.config_roomname) != 0) { - syslog(LOG_DEBUG, "<%s> does not exist. No processing is required.", u.config_roomname); - return; - } - - /* - * Find the sieve scripts and control record and do something - */ - u.config_msgnum = (-1); - CtdlForEachMessage(MSGS_LAST, 1, NULL, SIEVECONFIG, NULL, get_sieve_config_backend, (void *)&u ); - - if (u.config_msgnum < 0) { - syslog(LOG_DEBUG, "No Sieve rules exist. No processing is required."); - return; - } - - /* - * Check to see whether the script is empty and should not be processed. - * A script is considered non-empty if it contains at least one semicolon. - */ - if ( - (get_active_script(&u) == NULL) - || (strchr(get_active_script(&u), ';') == NULL) - ) { - syslog(LOG_DEBUG, "Sieve script is empty. No processing is required."); - return; - } - - syslog(LOG_DEBUG, "Rules found. Performing Sieve processing for <%s>", roomname); - - if (CtdlGetRoom(&CC->room, roomname) != 0) { - syslog(LOG_ERR, "ERROR: cannot load <%s>", roomname); - return; - } - - /* Initialize the Sieve parser */ - - res = sieve2_alloc(&sieve2_context); - if (res != SIEVE2_OK) { - syslog(LOG_ERR, "sieve2_alloc() returned %d: %s", res, sieve2_errstr(res)); - return; - } - - res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks); - if (res != SIEVE2_OK) { - syslog(LOG_ERR, "sieve2_callbacks() returned %d: %s", res, sieve2_errstr(res)); - goto BAIL; - } - - /* Validate the script */ - - struct ctdl_sieve my; /* dummy ctdl_sieve struct just to pass "u" along */ - memset(&my, 0, sizeof my); - my.u = &u; - res = sieve2_validate(sieve2_context, &my); - if (res != SIEVE2_OK) { - syslog(LOG_ERR, "sieve2_validate() returned %d: %s", res, sieve2_errstr(res)); - goto BAIL; - } - - /* Do something useful */ - u.sieve2_context = sieve2_context; - orig_lastproc = u.lastproc; - CtdlForEachMessage(MSGS_GT, u.lastproc, NULL, NULL, NULL, sieve_do_msg, (void *) &u); - -BAIL: - res = sieve2_free(&sieve2_context); - if (res != SIEVE2_OK) { - syslog(LOG_ERR, "sieve2_free() returned %d: %s", res, sieve2_errstr(res)); - } - - /* Rewrite the config if we have to (we're not the user right now) */ - rewrite_ctdl_sieve_config(&u, (u.lastproc > orig_lastproc) ) ; + // No errors are possible from this function. + return(0); } - -#endif - - - - /* * 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) { @@ -860,7 +905,7 @@ void cmd_gibr(char *argbuf) { cprintf("%d inbox rules for %s\n", LISTING_FOLLOWS, CC->user.fullname); - struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1); + struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1); if (msg != NULL) { if (!CM_IsEmpty(msg, eMesageText)) { char *token; @@ -877,6 +922,9 @@ void cmd_gibr(char *argbuf) { if (!strncasecmp(token, "rule|", 5)) { cprintf("%s\n", token); } + else { + cprintf("# invalid rule found : %s\n", token); + } } } CM_Free(msg); @@ -885,6 +933,27 @@ void cmd_gibr(char *argbuf) { } +/* + * 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 * @@ -908,37 +977,8 @@ void cmd_pibr(char *argbuf) { } } free(newrules); - - // Fetch the existing config so we can merge in anything that is NOT a rule - // (Does not start with "rule|" but has at least one vertical bar) - struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1); - if (msg != NULL) { - if (!CM_IsEmpty(msg, eMesageText)) { - 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)) && (strncasecmp(token, "rule|", 5)) && (haschar(token, '|'))) { - StrBufAppendBufPlain(NewConfig, token, -1, 0); - StrBufAppendBufPlain(NewConfig, HKEY("\n"), 0); - } - } - } - CM_Free(msg); - } - - /* we have composed the new configuration , now save it */ - 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, ChrPtr(NewConfig), FMT_RFC822, "inbox rules configuration"); + rewrite_rules_to_disk(ChrPtr(NewConfig)); FreeStrBuf(&NewConfig); - CtdlGetUserLock(&CC->user, CC->curr_user); - CC->user.msgnum_inboxrules = new_msgnum; - CtdlPutUserLock(&CC->user); - if (old_msgnum > 0) { - syslog(LOG_DEBUG, "Deleting old message %ld from %s", old_msgnum, userconfigroomname); - CtdlDeleteMessages(userconfigroomname, &old_msgnum, 1, ""); - } } @@ -946,11 +986,10 @@ CTDL_MODULE_INIT(sieve) { if (!threading) { - // ctdl_sieve_init(); CtdlRegisterProtoHook(cmd_gibr, "GIBR", "Get InBox Rules"); CtdlRegisterProtoHook(cmd_pibr, "PIBR", "Put InBox Rules"); - // CtdlRegisterSessionHook(perform_sieve_processing, EVT_HOUSE, PRIO_HOUSE + 10); - // CtdlRegisterCleanupHook(cleanup_sieve); + CtdlRegisterRoomHook(serv_inboxrules_roomhook); + CtdlRegisterSessionHook(perform_inbox_processing, EVT_HOUSE, PRIO_HOUSE + 10); } /* return our module name for the log */