From eb1d5f12ab841a754c3e226f5b114da079cb1aef Mon Sep 17 00:00:00 2001 From: NotZed Date: Tue, 16 May 2000 00:12:03 +0000 Subject: Removed filter-driver test program, now just part of libfilter. 2000-05-15 NotZed * Makefile.am: Removed filter-driver test program, now just part of libfilter. * filter-driver.c: Made an object, with an api and everything, can apply a filter to a given mailbox. svn path=/trunk/; revision=3050 --- filter/ChangeLog | 8 + filter/Makefile.am | 25 +-- filter/filter-driver.c | 498 ++++++++++++++++++++++++++++++++++--------------- filter/filter-driver.h | 58 ++++++ 4 files changed, 417 insertions(+), 172 deletions(-) create mode 100644 filter/filter-driver.h diff --git a/filter/ChangeLog b/filter/ChangeLog index f2ea5f61b7..3526765b40 100644 --- a/filter/ChangeLog +++ b/filter/ChangeLog @@ -1,3 +1,11 @@ +2000-05-15 NotZed + + * Makefile.am: Removed filter-driver test program, now just part + of libfilter. + + * filter-driver.c: Made an object, with an api and everything, can + apply a filter to a given mailbox. + 2000-05-10 Christopher James Lahey * filter-arg.h: Changed tree.h to gnome-xml/tree.h. diff --git a/filter/Makefile.am b/filter/Makefile.am index 685c8d0b75..17cac3ccf0 100644 --- a/filter/Makefile.am +++ b/filter/Makefile.am @@ -9,30 +9,9 @@ INCLUDES = \ -DG_LOG_DOMAIN=\"filter\" ## -noinst_PROGRAMS = \ - filter-driver - noinst_LTLIBRARIES = \ libfilter.la -## - -filter_driver_SOURCES = \ - filter-driver.c - -filter_driver_LDADD = \ - libfilter.la \ - ../camel/libcamel.la \ - ../e-util/libeutil.la \ - ../libibex/libibex.la \ - $(GNOME_LIBDIR) \ - $(GNOMEUI_LIBS) \ - $(INTLLIBS) \ - $(PTHREAD_LIB) \ - $(EXTRA_GNOME_LIBS) - -## - libfilter_la_SOURCES = \ filter-arg-types.c \ filter-arg-types.h \ @@ -45,6 +24,8 @@ libfilter_la_SOURCES = \ filter-druid.c \ filter-druid.h \ filter-editor.c \ - filter-editor.h + filter-editor.h \ + filter-driver.c \ + filter-driver.h EXTRA_DIST = blank.xpm check.xpm diff --git a/filter/filter-driver.c b/filter/filter-driver.c index ff8b0a6fda..94c69c93b0 100644 --- a/filter/filter-driver.c +++ b/filter/filter-driver.c @@ -1,3 +1,25 @@ +/* + * Copyright (C) 2000 Helix Code Inc. + * + * Authors: Michael Zucchi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +#include "filter-driver.h" #include #include @@ -14,23 +36,190 @@ #include -extern int filter_find_arg(FilterArg *a, char *name); - -struct exec_context { +struct _FilterDriverPrivate { + GList *rules, *options; GHashTable *globals; /* global variables */ + /* run-time data */ + GHashTable *folders; /* currently open folders */ GList *matches; /* all messages which match current rule */ - - GList *deleted; /* messages to be deleted */ GHashTable *terminated; /* messages for which processing is terminated */ GHashTable *processed; /* all messages that were processed in some way */ - CamelSession *session; - CamelStore *store; - CamelFolder *folder; /* temporary input folder */ + CamelFolder *source; /* temporary input folder */ + CamelException *ex; + + /* evaluator */ + ESExp *eval; }; +#define _PRIVATE(o) (((FilterDriver *)(o))->priv) + +static void filter_driver_class_init (FilterDriverClass *klass); +static void filter_driver_init (FilterDriver *obj); +static void filter_driver_finalise (GtkObject *obj); + +static CamelFolder *open_folder(FilterDriver *d, const char *folder_url); +static int close_folders(FilterDriver *d); + +static ESExpResult *do_delete(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *); +static ESExpResult *do_forward(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *); +static ESExpResult *do_copy(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *); +static ESExpResult *do_stop(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *); + +static struct { + char *name; + ESExpFunc *func; + int type; /* set to 1 if a function can perform shortcut evaluation, or + doesn't execute everything, 0 otherwise */ +} symbols[] = { + { "delete", (ESExpFunc *)do_delete, 0 }, + { "forward-to", (ESExpFunc *)do_forward, 0 }, + { "copy-to", (ESExpFunc *)do_copy, 0 }, + { "stop", (ESExpFunc *)do_stop, 0 }, +}; + +static GtkObjectClass *filter_driver_parent; + +enum SIGNALS { + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL] = { 0 }; + +guint +filter_driver_get_type (void) +{ + static guint type = 0; + + if (!type) { + GtkTypeInfo type_info = { + "FilterDriver", + sizeof (FilterDriver), + sizeof (FilterDriverClass), + (GtkClassInitFunc) filter_driver_class_init, + (GtkObjectInitFunc) filter_driver_init, + (GtkArgSetFunc) NULL, + (GtkArgGetFunc) NULL + }; + + type = gtk_type_unique (gtk_object_get_type (), &type_info); + } + + return type; +} + +static void +filter_driver_class_init (FilterDriverClass *klass) +{ + GtkObjectClass *object_class = (GtkObjectClass *) klass; + + filter_driver_parent = gtk_type_class (gtk_object_get_type ()); + + object_class->finalize = filter_driver_finalise; + + gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); +} + +static void +filter_driver_init (FilterDriver *obj) +{ + struct _FilterDriverPrivate *p; + int i; + + p = _PRIVATE(obj) = g_malloc0(sizeof(*p)); + + p->eval = e_sexp_new(); + /* Load in builtin symbols */ + for(i=0;ieval, 0, symbols[i].name, (ESExpIFunc *)symbols[i].func, obj); + } else { + e_sexp_add_function(p->eval, 0, symbols[i].name, symbols[i].func, obj); + } + } + + p->globals = g_hash_table_new(g_str_hash, g_str_equal); + + p->ex = camel_exception_new (); +} + +static void +free_hash_strings(void *key, void *value, void *data) +{ + g_free(key); + g_free(value); +} + +static void +filter_driver_finalise (GtkObject *obj) +{ + FilterDriver *d = (FilterDriver *)obj; + struct _FilterDriverPrivate *p = _PRIVATE(d); + + g_hash_table_foreach(p->globals, free_hash_strings, d); + g_hash_table_destroy(p->globals); + + gtk_object_unref((GtkObject *)p->eval); + + ((GtkObjectClass *)(filter_driver_parent))->finalize((GtkObject *)obj); +} + +/** + * filter_driver_new: + * + * Create a new FilterDriver object. + * + * Return value: A new FilterDriver widget. + **/ +FilterDriver * +filter_driver_new (void) +{ + FilterDriver *new = FILTER_DRIVER ( gtk_type_new (filter_driver_get_type ())); + return new; +} + + +void filter_driver_set_session(FilterDriver *d, CamelSession *s) +{ + if (d->session) + gtk_object_unref((GtkObject *)s); + d->session = s; + if (s) + gtk_object_ref((GtkObject *)s); +} + +int filter_driver_set_rules(FilterDriver *d, const char *description, const char *filter) +{ + struct _FilterDriverPrivate *p = _PRIVATE(d); + xmlDocPtr desc, filt; + +#warning "fix leaks, free xml docs here" + desc = xmlParseFile(description); + p->rules = filter_load_ruleset(desc); + + filt = xmlParseFile(filter); + p->options = filter_load_optionset(filt, p->rules); + + return 0; +} + +void filter_driver_set_global(FilterDriver *d, const char *name, const char *value) +{ + struct _FilterDriverPrivate *p = _PRIVATE(d); + char *oldkey, *oldvalue; + + if (g_hash_table_lookup_extended(p->globals, name, (void *)&oldkey, (void *)&oldvalue)) { + g_free(oldvalue); + g_hash_table_insert(p->globals, oldkey, g_strdup(value)); + } else { + g_hash_table_insert(p->globals, g_strdup(name), g_strdup(value)); + } +} + +extern int filter_find_arg(FilterArg *a, char *name); + /* foreach rule @@ -44,7 +233,7 @@ struct exec_context { /* splices ${cc} lines into a single string */ -int +static int expand_variables(GString *out, char *source, GList *args, GHashTable *globals) { GList *argl; @@ -111,15 +300,11 @@ expand_variables(GString *out, char *source, GList *args, GHashTable *globals) build an expression for the filter */ static void -expand_filter_option(GString *s, GString *action, struct filter_option *op) +expand_filter_option(FilterDriver *d, GString *s, GString *action, struct filter_option *op) { GList *optionl; FilterArg *arg; - GHashTable *globals; - - globals = g_hash_table_new(g_str_hash, g_str_equal); - - g_hash_table_insert(globals, "self-email", "mzucchi@dehaa.sa.gov.au"); + struct _FilterDriverPrivate *p = _PRIVATE(d); g_string_append(s, "(and "); optionl = op->options; @@ -133,7 +318,7 @@ expand_filter_option(GString *s, GString *action, struct filter_option *op) printf("arg = %s\n", arg->name); } } - expand_variables(s, or->rule->code, or->args, globals); + expand_variables(s, or->rule->code, or->args, p->globals); } optionl = g_list_next(optionl); } @@ -145,7 +330,7 @@ expand_filter_option(GString *s, GString *action, struct filter_option *op) while (optionl) { struct filter_optionrule *or = optionl->data; if (or->rule->type == FILTER_XML_ACTION) { - expand_variables(action, or->rule->code, or->args, globals); + expand_variables(action, or->rule->code, or->args, p->globals); g_string_append(action, " "); } optionl = g_list_next(optionl); @@ -156,57 +341,51 @@ expand_filter_option(GString *s, GString *action, struct filter_option *op) printf("combined action '%s'\n", action->str); } -struct filter_optionrule * -find_optionrule(struct filter_option *option, char *name) -{ - GList *optionrulel; - struct filter_optionrule *or; - - optionrulel = option->options; - while (optionrulel) { - or = optionrulel->data; - if (!strcmp(or->rule->name, name)) { - return or; - } - optionrulel = g_list_next(optionrulel); - } - return NULL; -} - static ESExpResult * -do_delete(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x) +do_delete(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *d) { + struct _FilterDriverPrivate *p = _PRIVATE(d); GList *m; printf("doing delete\n"); - m = x->matches; + m = p->matches; while (m) { - printf(" %s\n", m->data); - x->deleted = g_list_append(x->deleted, g_strdup(m->data)); + CamelMimeMessage *mm; + + printf(" %s\n", (char *)m->data); + + mm = camel_folder_get_message_by_uid(p->source, m->data, p->ex); + if (mm) { + camel_mime_message_set_flags(mm, CAMEL_MESSAGE_DELETED, CAMEL_MESSAGE_DELETED); + gtk_object_unref((GtkObject *)mm); + } + m = m->next; } return NULL; } static ESExpResult * -do_forward(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x) +do_forward(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *d) { + struct _FilterDriverPrivate *p = _PRIVATE(d); GList *m; printf("doing forward on the following messages:\n"); - m = x->matches; + m = p->matches; while (m) { - printf(" %s\n", m->data); + printf(" %s\n", (char *)m->data); m = m->next; } return NULL; } static ESExpResult * -do_copy(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x) +do_copy(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *d) { GList *m; int i; + struct _FilterDriverPrivate *p = _PRIVATE(d); printf("doing copy on the following messages to:"); for (i=0;istore, folder, x->ex); - if (!camel_folder_exists(outbox, x->ex)) { - camel_folder_create(outbox, x->ex); + outbox = open_folder(d, folder); + if (outbox == NULL) { + g_warning("Cannot open folder: %s", folder); + continue; } - - camel_folder_open (outbox, FOLDER_OPEN_WRITE, x->ex); - m = x->matches; + m = p->matches; while (m) { CamelMimeMessage *mm; - printf("appending message %s\n", m->data); + printf("appending message %s\n", (char *)m->data); - mm = camel_folder_get_message_by_uid(x->folder, m->data, x->ex); - camel_folder_append_message(outbox, mm, x->ex); + mm = camel_folder_get_message_by_uid(p->source, m->data, p->ex); + camel_folder_append_message(outbox, mm, p->ex); gtk_object_unref((GtkObject *)mm); - printf(" %s\n", m->data); + printf(" %s\n", (char *)m->data); m = m->next; } - camel_folder_close (outbox, FALSE, x->ex); } } @@ -245,159 +422,180 @@ do_copy(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_cont } static ESExpResult * -do_stop(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x) +do_stop(struct _ESExp *f, int argc, struct _ESExpResult **argv, FilterDriver *d) { GList *m; + struct _FilterDriverPrivate *p = _PRIVATE(d); printf("doing stop on the following messages:\n"); - m = x->matches; + m = p->matches; while (m) { - printf(" %s\n", m->data); - g_hash_table_insert(x->terminated, g_strdup(m->data), (void *)1); + printf(" %s\n", (char *)m->data); + g_hash_table_insert(p->terminated, g_strdup(m->data), (void *)1); m = m->next; } return NULL; } -static struct { - char *name; - ESExpFunc *func; - int type; /* set to 1 if a function can perform shortcut evaluation, or - doesn't execute everything, 0 otherwise */ -} symbols[] = { - { "delete", (ESExpFunc *)do_delete, 0 }, - { "forward-to", (ESExpFunc *)do_forward, 0 }, - { "copy-to", (ESExpFunc *)do_copy, 0 }, - { "stop", (ESExpFunc *)do_stop, 0 }, -}; - -static char * -auth_callback(char *prompt, gboolean secret, - CamelService *service, char *item, - CamelException *ex) +static CamelFolder * +open_folder(FilterDriver *d, const char *folder_url) { - printf ("auth_callback called: %s\n", prompt); + char *folder, *store; + CamelStore *camelstore; + CamelFolder *camelfolder; + struct _FilterDriverPrivate *p = _PRIVATE(d); + + /* we have a lookup table of currently open folders */ + camelfolder = g_hash_table_lookup(p->folders, folder_url); + if (camelfolder) + return camelfolder; + + store = g_strdup(folder_url); + folder = strrchr(store, '/'); + if (folder == NULL || folder == store || folder[1]==0) + goto fail; + + *folder++ = 0; + camelstore = camel_session_get_store (d->session, store, p->ex); + if (camel_exception_get_id (p->ex)) { + printf ("Could not open store: %s: %s", store, camel_exception_get_description (p->ex)); + goto fail; + } + + camelfolder = camel_store_get_folder (camelstore, folder, p->ex); + if (camel_exception_get_id (p->ex)) { + printf ("Could not open folder: %s: %s", folder, camel_exception_get_description (p->ex)); + goto fail; + } + + g_free(store); + + if (!camel_folder_exists(camelfolder, p->ex)) { + camel_folder_create(camelfolder, p->ex); + } + + g_hash_table_insert(p->folders, g_strdup(folder_url), camelfolder); + + return camelfolder; + +fail: + g_free(store); return NULL; } -static struct exec_context * -start(void) +static void +close_folder(void *key, void *value, void *data) { - struct exec_context *x; - char *store_url = "mbox:///tmp/evmail"; - - x = g_malloc0(sizeof(*x)); - - /* just hack up this for now */ - x->ex = camel_exception_new (); - x->session = camel_session_new (auth_callback); - printf("session = %p\n", x->session); - x->store = camel_session_get_store (x->session, store_url, x->ex); - printf("store = %p\n", x->store); - if (camel_exception_get_id (x->ex)) { - printf ("Exception caught in camel_store_get_folder\n" - "Full description : %s\n", camel_exception_get_description (x->ex)); - return NULL; - } - x->folder = camel_store_get_folder (x->store, "Inbox", x->ex); - if (camel_exception_get_id (x->ex)) { - printf ("Exception caught in camel_store_get_folder\n" - "Full description : %s\n", camel_exception_get_description (x->ex)); - return NULL; - } - camel_folder_open (x->folder, FOLDER_OPEN_READ, x->ex); - x->terminated = g_hash_table_new(g_str_hash, g_str_equal); - x->processed = g_hash_table_new(g_str_hash, g_str_equal); - return x; + CamelFolder *f = value; + FilterDriver *d = data; + struct _FilterDriverPrivate *p = _PRIVATE(d); + + g_free(key); + camel_folder_close(f, TRUE, p->ex); + gtk_object_unref((GtkObject *)f); +} + +/* flush/close all folders */ +static int +close_folders(FilterDriver *d) +{ + struct _FilterDriverPrivate *p = _PRIVATE(d); + + g_hash_table_foreach(p->folders, close_folder, d); + g_hash_table_destroy(p->folders); + p->folders = g_hash_table_new(g_str_hash, g_str_equal); + + /* FIXME: status from d */ + return 0; } -int main(int argc, char **argv) +int +filter_driver_run(FilterDriver *d, CamelFolder *source, CamelFolder *inbox) { - ESExp *f; + struct _FilterDriverPrivate *p = _PRIVATE(d); ESExpResult *r; - GList *rules, *options, *options2; - xmlDocPtr doc, out; + GList *options; GString *s, *a; GList *all, *m; - struct exec_context *x; - int i; - ESExp *eval; - gnome_init("Test", "0.0", argc, argv); - camel_init(); + p->source = source; - doc = xmlParseFile("filterdescription.xml"); - rules = filter_load_ruleset(doc); - options2 = filter_load_optionset(doc, rules); + /* setup runtime data */ + p->folders = g_hash_table_new(g_str_hash, g_str_equal); + p->terminated = g_hash_table_new(g_str_hash, g_str_equal); + p->processed = g_hash_table_new(g_str_hash, g_str_equal); - out = xmlParseFile("saveoptions.xml"); - options = filter_load_optionset(out, rules); - - x = start(); - - eval = e_sexp_new(); - /* Load in builtin symbols? */ - for(i=0;iex); + options = p->options; while (options) { struct filter_option *fo = options->data; - int id; s = g_string_new(""); a = g_string_new(""); - expand_filter_option(s, a, fo); + expand_filter_option(d, s, a, fo); printf("searching expression %s\n", s->str); - x->matches = camel_folder_search_by_expression (x->folder, s->str, x->ex); + p->matches = camel_folder_search_by_expression (p->source, s->str, p->ex); /* remove uid's for which processing is complete ... */ - m = x->matches; + m = p->matches; while (m) { GList *n = m->next; /* for all matching id's, so we can work out what to default */ - if (g_hash_table_lookup(x->processed, m->data) == NULL) { - g_hash_table_insert(x->processed, g_strdup(m->data), (void *)1); + if (g_hash_table_lookup(p->processed, m->data) == NULL) { + g_hash_table_insert(p->processed, g_strdup(m->data), (void *)1); } - if (g_hash_table_lookup(x->terminated, m->data)) { - printf("removing terminated message %s\n", m->data); - x->matches = g_list_remove_link(x->matches, m); + if (g_hash_table_lookup(p->terminated, m->data)) { + printf("removing terminated message %s\n", (char *)m->data); + p->matches = g_list_remove_link(p->matches, m); } m = n; } printf("applying actions ... '%s'\n", a->str); - e_sexp_input_text(eval, a->str, strlen(a->str)); - e_sexp_parse(eval); - r = e_sexp_eval(eval); + e_sexp_input_text(p->eval, a->str, strlen(a->str)); + e_sexp_parse(p->eval); + r = e_sexp_eval(p->eval); e_sexp_result_free(r); g_string_free(s, TRUE); g_string_free(a, TRUE); - g_list_free(x->matches); + g_list_free(p->matches); options = g_list_next(options); } - /* now apply 'default' rule */ - all = camel_folder_get_uid_list(x->folder, x->ex); - m = all; - while (m) { - char *uid = m->data; - if (g_hash_table_lookup(x->processed, uid) == NULL) { - printf("Applying default rule to message %s\n", uid); + /* apply the default of copying to an inbox, if we are given one */ + if (inbox) { + all = camel_folder_get_uid_list(p->source, p->ex); + m = all; + while (m) { + char *uid = m->data; + + if (g_hash_table_lookup(p->processed, uid) == NULL) { + CamelMimeMessage *mm; + + printf("Applying default rule to message %s\n", uid); + + mm = camel_folder_get_message_by_uid(p->source, m->data, p->ex); + camel_folder_append_message(inbox, mm, p->ex); + gtk_object_unref((GtkObject *)mm); + + } + m = m->next; } - m = m->next; + g_list_free(all); } - g_list_free(all); + + g_hash_table_destroy(p->processed); + g_hash_table_destroy(p->terminated); + g_hash_table_destroy(p->folders); + + close_folders(d); return 0; } diff --git a/filter/filter-driver.h b/filter/filter-driver.h new file mode 100644 index 0000000000..0d87a4586a --- /dev/null +++ b/filter/filter-driver.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2000 Helix Code Inc. + * + * Authors: Michael Zucchi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +#ifndef _FILTER_DRIVER_H +#define _FILTER_DRIVER_H + +#include +#include +#include + +#define FILTER_DRIVER(obj) GTK_CHECK_CAST (obj, filter_driver_get_type (), FilterDriver) +#define FILTER_DRIVER_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, filter_driver_get_type (), FilterDriverClass) +#define IS_FILTER_DRIVER(obj) GTK_CHECK_TYPE (obj, filter_driver_get_type ()) + +typedef struct _FilterDriver FilterDriver; +typedef struct _FilterDriverClass FilterDriverClass; + +struct _FilterDriver { + GtkObject parent; + + struct _FilterDriverPrivate *priv; + + CamelSession *session; +}; + +struct _FilterDriverClass { + GtkObjectClass parent_class; +}; + +guint filter_driver_get_type (void); +FilterDriver *filter_driver_new (void); + +void filter_driver_set_session(FilterDriver *, CamelSession *); +int filter_driver_set_rules(FilterDriver *, const char *description, const char *filter); +void filter_driver_set_global(FilterDriver *, const char *name, const char *value); + +/* apply rules to a folder, unmatched messages goto inbox, if not NULL */ +int filter_driver_run(FilterDriver *d, CamelFolder *source, CamelFolder *inbox); + +#endif /* ! _FILTER_DRIVER_H */ -- cgit