X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Finboxrules%2Fserv_inboxrules.c;h=ccc0cfe10aa57c37aad07d4ae2b9ea2adb23b076;hb=5cc2621128ffba5fd5a31fcb7b6048f65316b8a4;hp=3705c9508e3f44dc0821c10ff9bb081cdf0fd54b;hpb=bfecf1bd874e7dc697631d430711415d9c8905ee;p=citadel.git

diff --git a/citadel/modules/inboxrules/serv_inboxrules.c b/citadel/modules/inboxrules/serv_inboxrules.c
index 3705c9508..ccc0cfe10 100644
--- a/citadel/modules/inboxrules/serv_inboxrules.c
+++ b/citadel/modules/inboxrules/serv_inboxrules.c
@@ -424,7 +424,6 @@ int ctdl_getheaders(sieve2_context_t *s, void *my) {
 }
 
 
-
 /*
  * Perform sieve processing for one message (called by sieve_do_room() for each message)
  */
@@ -725,98 +724,285 @@ sieve2_callback_t ctdl_sieve_callbacks[] = {
 };
 
 
+
+
+
+
+
+
+
+
+
+#endif
+
+
 /*
- * Perform sieve processing for a single room
+ * The next sections are enums and keys that drive the serialize/deserialize functions for the inbox rules/state configuration.
  */
-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);
+// 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"
+};
 
-	/* 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;
-	}
+// 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"
+};
 
-	/*
-	 * 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 );
+// Actions
+enum {
+	action_keep,
+	action_discard,
+	action_reject,
+	action_fileinto,
+	action_redirect,
+	action_vacation
+};
+char *action_keys[] = {
+	"keep",
+	"discard",
+	"reject",
+	"fileinto",
+	"redirect",
+	"vacation"
+};
 
-	if (u.config_msgnum < 0) {
-		syslog(LOG_DEBUG, "No Sieve rules exist.  No processing is required.");
-		return;
-	}
+// Size comparison operators
+enum {
+	scomp_larger,
+	scomp_smaller
+};
+char *scomp_keys[] = {
+	"larger",
+	"smaller"
+};
 
-	/*
-	 * 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;
-	}
+// 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 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;
+};
 
-	syslog(LOG_DEBUG, "Rules found.  Performing Sieve processing for <%s>", roomname);
+// 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;
+};
 
-	if (CtdlGetRoom(&CC->room, roomname) != 0) {
-		syslog(LOG_ERR, "ERROR: cannot load <%s>", roomname);
-		return;
+
+// 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;
 	}
 
-	/* 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;
+	/* 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;
 	}
 
-	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;
+	struct inboxrules *ibr = malloc(sizeof(struct inboxrules));
+	if (ibr == NULL) {
+		return NULL;
 	}
+	memset(ibr, 0, sizeof(struct inboxrules));
 
-	/* Validate the script */
+	char *token; 
+	char *rest = sr;
+	while ((token = strtok_r(rest, "\n", &rest))) {
 
-	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;
-	}
+		// For backwards compatibility, "# WEBCIT_RULE" is an alias for "rule".
+		// Prior to version 930, WebCit converted its rules to Sieve scripts, but saved the rules as comments for later re-editing.
+		// Now, the rules hidden in the comments become the real rules.
+		if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
+			strcpy(token, "rule|");	
+			strcpy(&token[5], &token[14]);
+		}
+
+		// Lines containing actual rules are double-serialized with Base64.  It seemed like a good idea at the time :(
+		if (!strncasecmp(token, "rule|", 5)) {
+			remove_token(&token[5], 0, '|');
+			char *decoded_rule = malloc(strlen(token));
+			CtdlDecodeBase64(decoded_rule, &token[5], strlen(&token[5]));
+			ibr->num_rules++;
+			ibr->rules = realloc(ibr->rules, (sizeof(struct irule) * ibr->num_rules));
+			struct irule *new_rule = &ibr->rules[ibr->num_rules - 1];
+			memset(new_rule, 0, sizeof(struct irule));
 
-	/* 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);
+			// We have a rule , now parse it
+			char rtoken[SIZ];
+			int nt = num_tokens(decoded_rule, '|');
+			for (int t=0; t<nt; ++t) {
+				extract_token(rtoken, decoded_rule, t, '|', sizeof(rtoken));
+				striplt(rtoken);
+				switch(t) {
+					case 1:									// field to compare
+						for (i=0; i<=field_all; ++i) {
+							if (!strcasecmp(rtoken, field_keys[i])) {
+								new_rule->compared_field = i;
+							}
+						}
+						break;
+					case 2:									// field comparison operation
+						for (i=0; i<=fcomp_notmatches; ++i) {
+							if (!strcasecmp(rtoken, fcomp_keys[i])) {
+								new_rule->field_compare_op = i;
+							}
+						}
+						break;
+					case 3:									// field comparison value
+						safestrncpy(new_rule->compared_value, rtoken, sizeof(new_rule->compared_value));
+						break;
+					case 4:									// size comparison operation
+						for (i=0; i<=scomp_smaller; ++i) {
+							if (!strcasecmp(rtoken, scomp_keys[i])) {
+								new_rule->size_compare_op = i;
+							}
+						}
+						break;
+					case 5:									// size comparison value
+						new_rule->compared_size = atol(rtoken);
+						break;
+					case 6:									// action
+						for (i=0; i<=action_vacation; ++i) {
+							if (!strcasecmp(rtoken, action_keys[i])) {
+								new_rule->action = i;
+							}
+						}
+						break;
+					case 7:									// file into (target room)
+						safestrncpy(new_rule->file_into, rtoken, sizeof(new_rule->file_into));
+						break;
+					case 8:									// redirect to (target address)
+						safestrncpy(new_rule->redirect_to, rtoken, sizeof(new_rule->redirect_to));
+						break;
+					case 9:									// autoreply message
+						safestrncpy(new_rule->autoreply_message, rtoken, sizeof(new_rule->autoreply_message));
+						break;
+					case 10:								// final_action;
+						for (i=0; i<=final_stop; ++i) {
+							if (!strcasecmp(rtoken, final_keys[i])) {
+								new_rule->final_action = i;
+							}
+						}
+						break;
+					default:
+						break;
+				}
+			}
+			free(decoded_rule);
+
+			// 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]
+			//);
+			// 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.
+		else if (!strncasecmp(token, "lastproc|", 5)) {
+			ibr->lastproc = atol(&token[9]);
+		}
 
-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) ) ;
+	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.
+}
+
+
+/*
+ * rename this
+ */
+void sieve_do_msg(long msgnum, void *userdata) {
+	struct inboxrules *ii = (struct sdm_userdata *) userdata;
+	syslog(LOG_DEBUG, "inboxrules: processing message #%ld which is higher than %ld, we are in %s", msgnum, ii->lastproc, CC->room.QRname);
 }
 
-#endif
 
 
 
@@ -825,35 +1011,43 @@ BAIL:
  * 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) {
-		TRACE;
 		if (CC->user.msgnum_inboxrules <= 0) {
 			return;						// this user has no inbox rules
 		}
 
-		struct CtdlMessage *msg;
-		char *conf;
-		long conflen;
-	
 		msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
 		if (msg == NULL) {
 			return;						// config msgnum is set but that message does not exist
 		}
 	
-		CM_GetAsField(msg, eMesageText, &conf, &conflen);
+		ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]);
 		CM_Free(msg);
 	
-		if (conf == NULL) {
+		if (ii == NULL) {
 			return;						// config message exists but body is null
 		}
 
+		TRACE;
+		syslog(LOG_DEBUG, "inboxrules: for %s", CC->user.fullname);
+
+		// do something now FIXME actually write this
 
-		syslog(LOG_DEBUG, "RULEZ for %s", CC->user.fullname);
-		syslog(LOG_DEBUG, "%s", conf);
+		snprintf(roomname, sizeof roomname, "%010ld.%s", usernum, MAILROOM);
+		if (CtdlGetRoom(&CC->room, roomname) == 0) {
+			syslog(LOG_DEBUG, "GOT DA ROOM!  WE R000000000L!");
 
-		// do something now
+				/* Do something useful */
+				CtdlForEachMessage(MSGS_GT, ii->lastproc, NULL, NULL, NULL, sieve_do_msg, (void *) ii);
 
-		free(conf);
+		}
+
+		// FIXME reserialize our inbox rules/state and write changes back to the config room
+		free_inbox_rules(ii);
 	}
 }
 
@@ -925,111 +1119,13 @@ int serv_inboxrules_roomhook(struct ctdlroom *room) {
 }
 
 
-struct irule {
-	int field_compare_op;
-	char *compared_field;
-	char *compared_value;
-	int size_compare_op;
-	long compared_size;
-	int action;
-	char *file_into;
-	char *redirect_to;
-	char *autoreply_message;
-	int final_action;
-};
-
-struct inboxrules {
-	long lastproc;
-	int num_rules;
-	struct irule *rules;
-};
-
-
-void free_inbox_rules(struct inboxrules *ibr) {
-	int i;
-
-	if (ibr->num_rules > 0) {
-		for (i=0; i<ibr->num_rules; ++i) {
-			if (ibr->rules[i].compared_field)	free(ibr->rules[i].compared_field);
-			if (ibr->rules[i].compared_value)	free(ibr->rules[i].compared_value);
-			if (ibr->rules[i].file_into)		free(ibr->rules[i].file_into);
-			if (ibr->rules[i].redirect_to)		free(ibr->rules[i].autoreply_message);
-			if (ibr->rules[i].autoreply_message)	free(ibr->rules[i].autoreply_message);
-		}
-	}
-
-	free(ibr->rules);
-	free(ibr);
-}
-
-
-/*
- * Convert the serialized inbox rules message to a data type.
- */
-struct inboxrules *deserialize_inbox_rules(char *serialized_rules) {
-
-	if (!serialized_rules) {
-		return NULL;
-	}
-
-	/* Make a copy of the supplied buffer because we're going to shit all over it with strtok_r() */
-	char *sr = strdup(serialized_rules);
-	if (!sr) {
-		return NULL;
-	}
-
-	struct inboxrules *ibr = malloc(sizeof(struct inboxrules));
-	if (ibr == NULL) {
-		return NULL;
-	}
-	memset(ibr, 0, sizeof(struct inboxrules));
-
-	char *token; 
-	char *rest = sr;
-	while ((token = strtok_r(rest, "\n", &rest))) {
-
-		// For backwards compatibility, "# WEBCIT_RULE" is an alias for "rule".
-		// Prior to version 930, WebCit converted its rules to Sieve scripts, but saved the rules as comments for later re-editing.
-		// Now, the rules hidden in the comments are the real rules.
-		if (!strncasecmp(token, "# WEBCIT_RULE|", 14)) {
-			strcpy(token, "rule|");	
-			strcpy(&token[5], &token[14]);
-		}
-
-		// Lines containing actual rules are double-serialized with Base64.  It seemed like a good idea at the time :(
-		if (!strncasecmp(token, "rule|", 5)) {
-        		syslog(LOG_DEBUG, "rule: %s", &token[5]);
-			remove_token(&token[5], 0, '|');
-			char *decoded_rule = malloc(strlen(token));
-			CtdlDecodeBase64(decoded_rule, &token[5], strlen(&token[5]));
-			TRACE;
-			syslog(LOG_DEBUG, "%s", decoded_rule);	
-
-			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));
-
-			free(decoded_rule);
-		}
-
-		// "lastproc" indicates the newest message number in the inbox that was previously processed by our inbox rules.
-		else if (!strncasecmp(token, "lastproc|", 5)) {
-			ibr->lastproc = atol(&token[9]);
-			syslog(LOG_DEBUG, "lastsent: %ld", ibr->lastproc);
-		}
-
-	}
-
-	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.
-}
-
 
 /*
  * 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) {
 
@@ -1040,11 +1136,6 @@ void cmd_gibr(char *argbuf) {
 	struct CtdlMessage *msg = CtdlFetchMessage(CC->user.msgnum_inboxrules, 1, 1);
 	if (msg != NULL) {
 		if (!CM_IsEmpty(msg, eMesageText)) {
-
-
-			struct inboxrules *ii = deserialize_inbox_rules(msg->cm_fields[eMesageText]);
-			free_inbox_rules(ii);
-
 			char *token; 
 			char *rest = msg->cm_fields[eMesageText];
 			while ((token = strtok_r(rest, "\n", &rest))) {