X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Finboxrules%2Fserv_inboxrules.c;h=b7e01278f4d63cdb3975809c9bfd612ab9b1b4cb;hb=882ff5a53c3b4e440520a073cf07dc60b2671876;hp=1a979a9bb55de7377126c1170bb01a26d048f872;hpb=2a3cf0f17c573862e8fdfe944b7f5d7bb34204c3;p=citadel.git diff --git a/citadel/modules/inboxrules/serv_inboxrules.c b/citadel/modules/inboxrules/serv_inboxrules.c index 1a979a9bb..b7e01278f 100644 --- a/citadel/modules/inboxrules/serv_inboxrules.c +++ b/citadel/modules/inboxrules/serv_inboxrules.c @@ -21,18 +21,7 @@ #include #include #include - -#if TIME_WITH_SYS_TIME -# include -# include -#else -# if HAVE_SYS_TIME_H -# include -# else -# include -# endif -#endif - +#include #include #include #include @@ -48,235 +37,6 @@ #include "ctdl_module.h" -#if 0 - - - - - - -/* - * Callback function to indicate that a vacation message should be generated - */ -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"); - - 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); - } - - 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; - } - } - } - - /* Assemble the reject message. */ - vacamsg_text = malloc(strlen(message) + 1024); - if (vacamsg_text == NULL) { - return SIEVE2_ERROR_FAIL; - } - - 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 - ); - - 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; - } - } - - /* 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; -} - - -/* - * Given the on-disk representation of our Sieve config, load - * it into an in-memory data structure. - */ -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; - - 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 */ - } -} - - - - - -/* - * Write our citadel sieve config back to disk - * - * (Set yes_write_to_disk to nonzero to make it actually write the config; - * otherwise it just frees the data structures.) - */ -void rewrite_ctdl_sieve_config(struct sdm_userdata *u, int yes_write_to_disk) { - StrBuf *text; - struct sdm_script *sptr; - struct sdm_vacation *vptr; - - text = NewStrBufPlain(NULL, SIZ); - StrBufPrintf(text, - "Content-type: application/x-citadel-sieve-config\n" - "\n" - CTDLSIEVECONFIGSEPARATOR - "lastproc|%ld" - CTDLSIEVECONFIGSEPARATOR - , - u->lastproc - ); - - 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 - ); - } - 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, ""); - } - } - - FreeStrBuf (&text); - -} - - -#endif - - /* * The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration. */ @@ -447,7 +207,8 @@ struct inboxrules *deserialize_inbox_rules(char *serialized_rules) { // We have a rule , now parse it char rtoken[SIZ]; int nt = num_tokens(decoded_rule, '|'); - for (int t=0; tcompared_field], - fcomp_keys[new_rule->field_compare_op], - new_rule->compared_value, - scomp_keys[new_rule->size_compare_op], - new_rule->compared_size, - action_keys[new_rule->action], - new_rule->file_into, - new_rule->redirect_to, - new_rule->autoreply_message, - final_keys[new_rule->final_action] - ); - // delete the above after moving it to a reserialize function - } // "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... @@ -596,7 +345,7 @@ int inbox_do_redirect(struct irule *rule, long msgnum) { return(1); // don't delete the inbox copy if this failed } - recptypes *valid = validate_recipients(rule->redirect_to, NULL, 0); + 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 @@ -614,20 +363,18 @@ int inbox_do_redirect(struct irule *rule, long msgnum) { return(1); // don't delete the inbox copy if this failed } - CtdlSubmitMsg(msg, valid, NULL, 0); // send the message to the new recipient + 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) -// +/* + * 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 message: <%s>", - msg->cm_fields[erFc822Addr], - rule->autoreply_message - ); + 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; @@ -660,10 +407,10 @@ void inbox_do_reject(struct irule *rule, struct CtdlMessage *msg) { // Deliver the message quickie_message( - NULL, + " ", msg->cm_fields[eenVelopeTo], sender, - NULL, + MAILROOM, reject_text, FMT_RFC822, "Delivery status notification" @@ -672,6 +419,66 @@ void inbox_do_reject(struct irule *rule, struct CtdlMessage *msg) { } +/* + * 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. */ @@ -684,6 +491,7 @@ void inbox_do_msg(long msgnum, void *userdata) { 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; @@ -754,12 +562,22 @@ void inbox_do_msg(long msgnum, void *userdata) { // 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])) { + 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])) { @@ -827,39 +645,49 @@ void inbox_do_msg(long msgnum, void *userdata) { // 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 = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 1 : 0); - syslog(LOG_DEBUG, "Does %s contain %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no"); + rule_activated = substring_match; break; case fcomp_notcontains: case fcomp_notmatches: - rule_activated = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 0 : 1); - syslog(LOG_DEBUG, "Does %s contain %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no"); + rule_activated = !substring_match; break; case fcomp_is: - rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 0 : 1); - syslog(LOG_DEBUG, "Does %s equal %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no"); + rule_activated = exact_match; break; case fcomp_isnot: - rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 1 : 0); - syslog(LOG_DEBUG, "Does %s equal %s? %s", compare_me, ii->rules[i].compared_value, rule_activated?"yes":"no"); + rule_activated = !exact_match; break; } break; case field_size: rule_activated = 0; - syslog(LOG_DEBUG, "comparing actual message size %ld to rule message size %ld", smi.meta_rfc822_length, ii->rules[i].compared_size); switch(ii->rules[i].field_compare_op) { case scomp_larger: rule_activated = ((smi.meta_rfc822_length > ii->rules[i].compared_size) ? 1 : 0); - 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"); break; case scomp_smaller: rule_activated = ((smi.meta_rfc822_length < ii->rules[i].compared_size) ? 1 : 0); - 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"); break; } break; @@ -867,7 +695,7 @@ void inbox_do_msg(long msgnum, void *userdata) { rule_activated = 1; break; default: // no matches, fall through and do nothing - syslog(LOG_DEBUG, "inboxrules: an unknown field comparison was encountered"); + syslog(LOG_WARNING, "inboxrules: an unknown field comparison was encountered"); rule_activated = 0; break; } @@ -895,7 +723,7 @@ void inbox_do_msg(long msgnum, void *userdata) { keep_message = inbox_do_redirect(&ii->rules[i], msgnum); break; case action_vacation: - // inbox_do_vacation(&ii->rules[i], msg); + inbox_do_vacation(&ii->rules[i], msg); keep_message = 1; break; } @@ -934,35 +762,55 @@ 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) { - if (CC->user.msgnum_inboxrules <= 0) { - return; // this user has no inbox rules - } + if (CtdlGetUserByNumber(&CC->user, usernum) != 0) { // grab the user record + return; // and bail out if we were given an invalid user + } - 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 - } + strcpy(username, CC->user.fullname); // save the user name so we can fetch it later and lock it - syslog(LOG_DEBUG, "inboxrules: for %s", CC->user.fullname); + if (CC->user.msgnum_inboxrules <= 0) { + return; // this user has no inbox rules + } - // 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); - } + 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); - // FIXME reserialize our inbox rules/state and write changes back to the config room - free_inbox_rules(ii); + 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); } @@ -978,11 +826,13 @@ 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 (int i=0; iQRname[11], MAILROOM)) { @@ -1006,7 +857,7 @@ int serv_inboxrules_roomhook(struct ctdlroom *room) { // first check to see if this user is already on the list if (num_urip > 0) { - for (int i=0; i<=num_urip; ++i) { + for (i=0; i<=num_urip; ++i) { if (users_requiring_inbox_processing[i] == usernum) { // already on the list! return(0); } @@ -1064,6 +915,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); @@ -1072,6 +926,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 * @@ -1095,37 +970,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); - 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, ""); - } }