return SIEVE2_ERROR_BADARGS;
}
- msg = CtdlFetchMessage(cs->msgnum, 1, 1);
+ msg = CtdlFetchMessage(cs->msgnum, 1);
if (msg == NULL) {
syslog(LOG_WARNING, "REDIRECT failed: unable to fetch msg %ld", cs->msgnum);
free_recipients(valid);
/*
* Perform sieve processing for one message (called by sieve_do_room() for each message)
*/
-void sieve_do_msg(long msgnum, void *userdata) {
+void inbox_do_msg(long msgnum, void *userdata) {
struct sdm_userdata *u = (struct sdm_userdata *) userdata;
sieve2_context_t *sieve2_context;
struct ctdl_sieve my;
/*
* Make sure you include message body so you can get those second-level headers ;)
*/
- msg = CtdlFetchMessage(msgnum, 1, 1);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) return;
/*
};
-/*
- * 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) ) ;
-}
#endif
// This data structure represents ONE inbox rule within the configuration.
struct irule {
- int field_compare_op;
int compared_field;
+ int field_compare_op;
char compared_value[128];
int size_compare_op;
long compared_size;
free(decoded_rule);
// if we re-serialized this now, what would it look like?
- //syslog(LOG_DEBUG, "test reserialize: 0|%s|%s|%s|%s|%ld|%s|%s|%s|%s|%s",
- //field_keys[new_rule->compared_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]
- //);
+ syslog(LOG_DEBUG, "test reserialize: 0|%s|%s|%s|%s|%ld|%s|%s|%s|%s|%s",
+ field_keys[new_rule->compared_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
}
}
+/*
+ * 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;
+ int headers_loaded = 0;
+ int body_loaded = 0;
+ int metadata_loaded = 0;
+ 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 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);
+ // FIXME do this
+ metadata_loaded = 1;
+ }
+ break;
+ case field_all:
+ syslog(LOG_DEBUG, "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;
+ switch(ii->rules[i].compared_field) {
+
+ case field_from: // From:
+
+ // FIXME we actually need the rfc822 address
+ syslog(LOG_DEBUG, "eAuthor is <%s>", 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:
+ safestrncpy(compare_me, msg->cm_fields[eMsgSubject], sizeof compare_me);
+ break;
+ case field_replyto: // Reply-to:
+ safestrncpy(compare_me, msg->cm_fields[eReplyTo], sizeof compare_me);
+ break;
+ case field_listid: // List-ID:
+ safestrncpy(compare_me, msg->cm_fields[eListID], sizeof compare_me);
+ break;
+ case field_envto: // Envelope-to:
+ safestrncpy(compare_me, msg->cm_fields[eenVelopeTo], sizeof compare_me);
+ break;
+ case field_envfrom: // Return-path:
+ 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.
+ // FIXME you are here YOU ARE HERE
+ syslog(LOG_DEBUG, "Value of field to compare is: <%s>", compare_me);
+ 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);
+ break;
+ case fcomp_notcontains:
+ case fcomp_notmatches:
+ rule_activated = (bmstrcasestr(compare_me, ii->rules[i].compared_value) ? 0 : 1);
+ break;
+ case fcomp_is:
+ rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 0 : 1);
+ break;
+ case fcomp_isnot:
+ rule_activated = (strcasecmp(compare_me, ii->rules[i].compared_value) ? 1 : 0);
+ break;
+ }
+
+ case field_size:
+ rule_activated = 0; // FIXME
+ break;
+ case field_all: // This rule always triggers
+ rule_activated = 1;
+ break;
+ default:
+ TRACE;
+ break;
+ }
+
+ if (rule_activated) {
+ syslog(LOG_DEBUG, "rule activated");
+ }
+ else {
+ syslog(LOG_DEBUG, "rule NOT activated");
+ }
+
+
+ }
+
+ TRACE;
+ if (msg != NULL) {
+ CM_Free(msg);
+ }
+
+//struct irule {
+ //int field_compare_op;
+ //int compared_field;
+ //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;
+//};
+
+//struct inboxrules {
+ //long lastproc;
+ //int num_rules;
+ //struct irule *rules;
+
+
+ // Fetch the message, including the body, we need all of it to run our rules.
+ //msg = CtdlFetchMessage(msgnum, 0);
+ //CM_Free(msg);
+
+}
+
+
/*
* 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];
if (CtdlGetUserByNumber(&CC->user, usernum) == 0) {
if (CC->user.msgnum_inboxrules <= 0) {
return; // this user has no inbox rules
}
- msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
+ msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
if (msg == NULL) {
return; // config msgnum is set but that message does not exist
}
}
TRACE;
- syslog(LOG_DEBUG, "RULEZ for %s", CC->user.fullname);
+ syslog(LOG_DEBUG, "inboxrules: for %s", CC->user.fullname);
// do something now FIXME actually write this
+
+ snprintf(roomname, sizeof roomname, "%010ld.%s", usernum, MAILROOM);
+ if (CtdlGetRoom(&CC->room, roomname) == 0) {
+ syslog(LOG_DEBUG, "GOT DA ROOM! WE R000000000L!");
+
+ /* Do something useful */
+ CtdlForEachMessage(MSGS_GT, ii->lastproc, NULL, NULL, NULL, inbox_do_msg, (void *) ii);
+
+ }
+
+ // FIXME reserialize our inbox rules/state and write changes back to the config room
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;
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;
// 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);
+ struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1);
if (msg != NULL) {
if (!CM_IsEmpty(msg, eMesageText)) {
rest = msg->cm_fields[eMesageText];
projects / citadel.git / blobdiff