X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Finboxrules%2Fserv_inboxrules.c;h=b7e01278f4d63cdb3975809c9bfd612ab9b1b4cb;hb=882ff5a53c3b4e440520a073cf07dc60b2671876;hp=9541c35ecba643f07ad3130722f6e9b0a95c682d;hpb=da4781d94d4d6113879899312ef6e5e3c8b0b9f0;p=citadel.git diff --git a/citadel/modules/inboxrules/serv_inboxrules.c b/citadel/modules/inboxrules/serv_inboxrules.c index 9541c35ec..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,105 +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; -} - - - -#endif - - /* * The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration. */ @@ -317,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; tredirect_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 @@ -472,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; @@ -518,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" @@ -530,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. */ @@ -542,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; @@ -612,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])) { @@ -685,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; @@ -725,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; } @@ -753,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; } @@ -816,10 +786,6 @@ void do_inbox_processing_for_user(long usernum) { return; // config message exists but body is null } - - syslog(LOG_DEBUG, "ii->lastproc %ld", ii->lastproc); - syslog(LOG_DEBUG, "CC->user.lastproc_inboxrules %ld", CC->user.lastproc_inboxrules); - 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. @@ -860,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)) { @@ -888,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); }