path: root/filter/filter-xml.c

/* -*- Mode: C; c-file-style: "linux"; indent-tabs-mode: t; c-basic-offset: 8; -*- */

#include <glib.h>
#include <gtk/gtk.h>
#include <gnome.h>
#include <gtkhtml/gtkhtml.h>

#include <gnome-xml/tree.h>
#include <gnome-xml/parser.h>

#include "filter-arg-types.h"
#include "filter-xml.h"

struct token_tab {
    char *name;
    enum filter_xml_token token;
};

struct token_tab token_table[] = {
    { "action", FILTER_XML_ACTION },
    { "address", FILTER_XML_ADDRESS },
    { "code", FILTER_XML_CODE },
    { "description", FILTER_XML_DESC },
    { "except", FILTER_XML_EXCEPT },
    { "folder", FILTER_XML_FOLDER },
    { "match", FILTER_XML_MATCH },
    { "name", FILTER_XML_NAME },
    { "option", FILTER_XML_OPTION },
    { "optionrule", FILTER_XML_OPTIONRULE },
    { "optionset", FILTER_XML_OPTIONSET },
    { "optionvalue", FILTER_XML_OPTIONVALUE },
    { "receive", FILTER_XML_RECEIVE },
    { "rule", FILTER_XML_RULE },
    { "ruleset", FILTER_XML_RULESET },
    { "send", FILTER_XML_SEND },
    { "source", FILTER_XML_SOURCE },
    { "text", FILTER_XML_TEXT },
};

/* convert a name to a token value */
static int
tokenise(const char *name)
{
    int i;
    int len = sizeof(token_table)/sizeof(token_table[0]);

    if (name) {
        for (i=0;i<len;i++) {
            if (strcmp(name, token_table[i].name) == 0)
                return token_table[i].token;
        }
    }
    return -1;
}

static char *
detokenise(int token)
{
    int i;
    int len = sizeof(token_table)/sizeof(token_table[0]);

    if (token>=0) {
        for (i=0;i<len;i++) {
            if (token_table[i].token == token)
                return token_table[i].name;
        }
    }
    return "<unknown>";
}


xmlNodePtr find_node(xmlNodePtr start, char *name)
{
    printf("trying to find node '%s'\n", name);
    while (start && strcmp(start->name, name))
        start = start->next;
    printf("node = %p\n", start);
    return start;
}

xmlNodePtr find_node_attr(xmlNodePtr start, char *name, char *attrname, char *attrvalue)
{
    xmlNodePtr node;
    char *s;

    printf("looking for node named %s with attribute %s=%s\n", name, attrname, attrvalue);

    while ( start && (start = find_node(start, name)) ) {
        s = xmlGetProp(start, attrname);
        printf("   comparing '%s' to '%s'\n", s, attrvalue);
        if (s && !strcmp(s, attrvalue))
            break;
        start = start->next;
    }
    return start;
}

static int
find_arg(FilterArg *a, char *name)
{
    printf("finding, is %s = %s?\n", a->name, name);
    return strcmp(a->name, name);
}

static int
find_rule(struct filter_rule *a, char *name)
{
    printf("finding, is %s = %s?\n", a->name, name);
    return strcmp(a->name, name);
}

static int display_order[] = { FILTER_XML_MATCH, FILTER_XML_ACTION, FILTER_XML_EXCEPT };

static struct filter_option *
option_clone(struct filter_option *source)
{
    struct filter_option *dest = g_malloc0(sizeof(*dest));
    GList *loptions;
    struct filter_optionrule *old, *new;

    dest->type = source->type;
    dest->description = source->description;
    loptions = dest->options;
    while (loptions) {
        old = loptions->data;
        new = g_malloc0(sizeof(*new));
        new->rule = old->rule;
        /* FIXME: need to copy any args as well!!! */
        dest->options = g_list_append(dest->options, new);
        loptions = g_list_next(loptions);
    }
    return dest;
}



struct description_decode_lambda {
    GString *str;
    GList *args;
    GtkHTML *html;
    GtkHTMLStreamHandle *stream;
};

static char *
arg_text(FilterArg *arg)
{
    char *out = NULL;
    GList *value, *next;
    GString *str;

    value = arg->values;

    if (value == NULL)
        return NULL;

    str = g_string_new("");
    filter_arg_write_text(arg, str);
    out = str->str;
    g_string_free(str, FALSE);
    return out;
}

static void
description_decode_text(struct filter_desc *d, struct description_decode_lambda *l)
{
    GList *list;
    char *txt;

    switch (d->type) {
    case FILTER_XML_TEXT:
    case FILTER_XML_DESC:
    dotext:
        printf("appending '%s'\n", d->data);
        printf("vartype = %s\n", detokenise(d->vartype));
        printf("varname = %s\n", d->varname);
        if (d->vartype !=-1 && d->varname
            && (list = g_list_find_custom(l->args, d->varname, (GCompareFunc) find_arg))
            && (txt = arg_text(list->data))) {
        } else {
            txt = d->data;
        }
        g_string_append(l->str, txt);
        break;
    default:
        printf("WARN: unknown desc text type '%s' = %s\n", detokenise(d->type), d->data);
        goto dotext;
    }
}

static char *
description_text(GList *description, GList *args)
{
    char *txt;
    struct description_decode_lambda l;

    printf("\ndecoding ...\n");

    l.str = g_string_new("");
    l.args = args;
    g_list_foreach(description, (GFunc) description_decode_text, &l);

    printf("string is '%s'\n", l.str->str);

    txt = l.str->str;
    g_string_free(l.str, FALSE);

    return txt; 
}

static void
html_write(GtkHTML *html, GtkHTMLStreamHandle *stream, char *s)
{
    printf("appending html '%s'\n", s);
    gtk_html_write(html, stream, s, strlen(s));
}


static void
description_decode_html(struct filter_desc *d, struct description_decode_lambda *l)
{
    GList *list;
    char *txt, *end;
    int free;

    switch (d->type) {
    case FILTER_XML_TEXT:
    case FILTER_XML_DESC:
    dotext:
        printf("appending '%s'\n", d->data);
        printf("vartype = %s\n", detokenise(d->vartype));
        printf("varname = %s\n", d->varname);
        free = FALSE;
        if (d->vartype !=-1 && d->varname) {
            char *link;
            list = g_list_find_custom(l->args, d->varname, (GCompareFunc) find_arg);
            end = "</a>";
            if (list) {
                txt = arg_text(list->data);
                if (txt == NULL)
                    txt = d->data;
                else
                    free = TRUE;
                link = g_strdup_printf("<a href=\"arg:%p %p\">", d, list->data);
            } else {
                printf("cannot find arg '%s'\n", d->varname);
                link = g_strdup_printf("<a href=\"arg:%p %p\">", d, NULL);
                txt = d->data;
            }
            html_write(l->html, l->stream, link);
            g_free(link);
        } else {
            txt = d->data;
            end = NULL;
        }
        html_write(l->html, l->stream, txt);
        if (end) {
            html_write(l->html, l->stream, end);
        }
        if (free)
            g_free(txt);
        break;
    default:
        printf("WARN: unknown desc text type '%s' = %s\n", detokenise(d->type), d->data);
        goto dotext;
    }
}

static void
description_html_write(GList *description, GList *args, GtkHTML *html, GtkHTMLStreamHandle *stream)
{
    char *txt;
    struct description_decode_lambda l;

    printf("\ndecoding ...\n");

    l.str = NULL;
    l.args = args;
    l.html = html;
    l.stream = stream;
    g_list_foreach(description, (GFunc) description_decode_html, &l);
}


static GList *
load_desc(xmlNodePtr node, int type, int vartype, char *varname)
{
    struct filter_desc *desc;
    xmlNodePtr n;
    int newtype;
    int newvartype;
    char *newvarname;
    GList *list = NULL;

    while (node) {
        if (node->content) {
            desc = g_malloc0(sizeof(*desc));
            desc->data = node->content;
            desc->type = type;
            desc->vartype = vartype;
            desc->varname = varname?g_strdup(varname):0;
            printf(" **** node name = %s var name = %s  var type = %s\n", node->name, varname, detokenise(vartype));
            list = g_list_append(list, desc);
            printf("appending '%s'\n", node->content);
            newtype = type;
            newvartype = -1;
            newvarname = NULL;
        } else {
            newtype = tokenise(node->name);
            newvartype = tokenise(xmlGetProp(node, "type"));
            newvarname = xmlGetProp(node, "name");
        }
        n = node->childs;
        while (n) {
            printf("adding child '%s'\n", n->name);
            list = g_list_concat(list, load_desc(n, newtype, newvartype, newvarname));
            n = n->next;
        }
        node = node->next;
    }
    return list;
}

GList *
load_ruleset(xmlDocPtr doc)
{
    xmlNodePtr ruleset, rule, n;
    struct filter_rule *r;
    int type;
    int ruletype;
    GList *rules = NULL;

    g_return_val_if_fail(doc!=NULL, NULL);

    ruleset = find_node(doc->root->childs, "ruleset");

    while (ruleset) {

        rule = ruleset->childs;
        
        ruletype = tokenise(xmlGetProp(ruleset, "type"));

        printf("ruleset, name = %s\n", ruleset->name);

        while (rule) {

            n = rule->childs;
            r = g_malloc0(sizeof(*r));
            r->type = ruletype;
            r->name = xmlGetProp(rule, "name");

            printf(" rule, name = %s\n", r->name);

            while (n) {
                type = tokenise(n->name);
                printf("  n, name = %s\n", n->name);
                printf("  ncontent = %s\n", n->content);
                printf("  childs = %p\n", n->childs);
                if (n->childs) {
                    printf(" childs content = %s\n", n->childs->content);
                }
                switch(type) {
                case FILTER_XML_CODE:
                    r->code = xmlNodeGetContent(n);
                    break;
                case FILTER_XML_DESC:
                    printf(" ** loading description\n");
                    r->description = load_desc(n->childs, type, -1, NULL);
                    printf(" ** done loading description\n");
                    description_text(r->description, 0);
                    printf(" ** done dumping description\n");
                    break;
                default:
                    printf("warning, unknown token encountered\n");
                    break;
                }
                n = n->next;
            }
            if (r)
                rules = g_list_append(rules, r);
            rule = rule->next;
        }
        ruleset = find_node(ruleset->next, "ruleset");
    }
    return rules;
}

int
filter_find_rule(struct filter_rule *a, char *name)
{
    printf("finding, is %s = %s?\n", a->name, name);
    return strcmp(a->name, name);
}

int
filter_find_arg(FilterArg *a, char *name)
{
    printf("finding, is %s = %s?\n", a->name, name);
    return strcmp(a->name, name);
}

static FilterArg *
load_optionvalue(struct filter_desc *desc, xmlNodePtr node)
{
    xmlNodePtr n;
    int token;
    int lasttoken = -2;
    FilterArg *arg = NULL;
    char *name;

    printf("creating arg entry for '%s'\n", desc->varname);

    switch(desc->vartype) {
    case FILTER_XML_ADDRESS:
        arg = filter_arg_address_new(name);
        break;
    case FILTER_XML_FOLDER:
        arg = filter_arg_folder_new(name);
        break;
    default:
        printf("ok, maybe we're not\n");
        /* unknown arg type, drop it */
        return NULL;
    }

    if (node == NULL)
        return arg;

    filter_arg_values_add_xml(arg, node);

    return arg;
}

/* loads a blank (empty args) optionrule from a rule */
static struct filter_optionrule *
optionrule_new(struct filter_rule *rule)
{
    GList *ldesc;
    struct filter_desc *desc;
    struct filter_optionrule *optionrule;

    optionrule = g_malloc0(sizeof(*optionrule));
    optionrule->rule = rule;

    ldesc = rule->description;
    while (ldesc) {
        desc = ldesc->data;
        if (desc->varname && desc->vartype!=-1) {
            FilterArg *arg;
            arg = load_optionvalue(desc, NULL);
            if (arg)
                optionrule->args = g_list_append(optionrule->args, arg);
        }
        ldesc = g_list_next(ldesc);
    }
    return optionrule;
}

GList *
load_optionset(xmlDocPtr doc, GList *rules)
{
    xmlNodePtr optionset, option, o, or;
    struct filter_option *op;
    struct filter_optionrule *optionrule;
    struct filter_rule *fr;
    struct filter_desc *desc;
    int type, token;
    GList *l = NULL;
    GList *lrule;
    GList *ldesc;

    g_return_val_if_fail(doc!=NULL, NULL);

    optionset = find_node(doc->root->childs, "optionset");
    if (optionset == NULL) {
        printf("optionset not found\n");
        return;
    }
    option = find_node(optionset->childs, "option");
    while (option) {
        o = option->childs;
        op = g_malloc0(sizeof(*op));
        printf("option = %s\n", o->name);
        printf("option, type=%s\n", xmlGetProp(option, "type"));
        op->type = tokenise(xmlGetProp(option, "type"));
        while (o) {
            type = tokenise(o->name);
            switch (type) {
            case FILTER_XML_OPTIONRULE:
                lrule = g_list_find_custom(rules, xmlGetProp(o, "rule"), (GCompareFunc) filter_find_rule);
                if (lrule) {
                    fr = lrule->data;
                    printf("found rule : %s\n", fr->name);
                    optionrule = g_malloc0(sizeof(*optionrule));
                    optionrule->rule = fr;
                    op->options = g_list_append(op->options, optionrule);

                    /* scan through all variables required, setup blank variables if they do not exist */
                    ldesc = fr->description;
                    while (ldesc) {
                        desc = ldesc->data;
                        if (desc->varname && desc->vartype!=-1) {
                            FilterArg *arg;
                            /* try and see if there is a setting for this value */
                            or = find_node_attr(o->childs, "optionvalue", "name", desc->varname);
                            arg = load_optionvalue(desc, or);
                            if (arg)
                                optionrule->args = g_list_append(optionrule->args, arg);
                        }
                        ldesc = g_list_next(ldesc);
                    }
                } else {
                    printf("Cannot find rule: %s\n", xmlGetProp(o, "rule"));
                }
                break;
            case FILTER_XML_DESC:
                printf("loading option descriptiong\n");
                op->description = load_desc(option->childs, type, -1, NULL);
                break;
            }
            o = o->next;
        }
        l = g_list_append(l, op);
        option = find_node(option->next, "option");
    }
    return l;
}

static xmlNodePtr
save_optionset(xmlDocPtr doc, GList *optionl)
{
    xmlNodePtr root, cur, option, optionrule, optionvalue;
    GList *optionrulel, *argl;
    struct filter_optionrule *or;

    root = xmlNewDocNode(doc, NULL, "optionset", NULL);

    /* for all options */
    while (optionl) {
        struct filter_option *op = optionl->data;

        option = xmlNewDocNode(doc, NULL, "option", NULL);
        xmlSetProp(option, "type", detokenise(op->type));

        optionrulel = op->options;
        while (optionrulel) {
            or = optionrulel->data;

            optionrule = xmlNewDocNode(doc, NULL, "optionrule", NULL);
            xmlSetProp(optionrule, "type", detokenise(or->rule->type));
            xmlSetProp(optionrule, "rule", or->rule->name);

            argl = or->args;
            while (argl) {
                FilterArg *arg = argl->data;

                optionvalue = filter_arg_values_get_xml(arg);
                if (optionvalue)
                    xmlAddChild(optionrule, optionvalue);

                argl = g_list_next(argl);
            }

            xmlAddChild(option, optionrule);

            optionrulel = g_list_next(optionrulel);
        }

        xmlAddChild(root, option);
        optionl = g_list_next(optionl);
    }

    return root;
}



/*
  build an expression for the filter
*/
static void
filterme(struct filter_option *op)
{
    GList *optionl;
    GString *s;

    s = g_string_new("(if (and ");
    optionl = op->options;
    while (optionl) {
        struct filter_optionrule *or = optionl->data;
        if (or->rule->type == FILTER_XML_MATCH) {
            g_string_append(s, "(match \"");
            g_string_append(s, or->rule->name);
            g_string_append(s, "\" ");
            g_string_append(s, or->rule->code);
            g_string_append(s, ") ");
        }
        optionl = g_list_next(optionl);
    }
    optionl = op->options;
    while (optionl) {
        struct filter_optionrule *or = optionl->data;
        if (or->rule->type == FILTER_XML_EXCEPT) {
            g_string_append(s, " (except \"");
            g_string_append(s, or->rule->name);
            g_string_append(s, "\" ");
            g_string_append(s, or->rule->code);
            g_string_append(s, " ) ");
        }
        optionl = g_list_next(optionl);
    }
    g_string_append(s, ") (begin ");
    optionl = op->options;
    while (optionl) {
        struct filter_optionrule *or = optionl->data;
        if (or->rule->type == FILTER_XML_ACTION) {
            g_string_append(s, or->rule->code);
            g_string_append(s, " ");
        }
        optionl = g_list_next(optionl);
    }
    g_string_append(s, "))");
    printf("combined rule '%s'\n", s->str);
}

#ifdef TESTER
int main(int argc, char **argv)
{
    GList *rules, *options;
    xmlDocPtr doc, out, optionset, filteroptions;

    gnome_init("Test", "0.0", argc, argv);

    doc = xmlParseFile("filterdescription.xml");

    rules = load_ruleset(doc);
    options = load_optionset(doc, rules);

    out = xmlParseFile("saveoptions.xml");
    options = load_optionset(doc, rules);

    while (options) {
        printf("applying a rule ...\n");
        filterme(options->data);
        options = g_list_next(options);
    }

#if 0
    out = xmlNewDoc("1.0");
    optionset = save_optionset(out, options);
    filteroptions = xmlNewDocNode(out, NULL, "filteroptions", NULL);
    xmlAddChild(filteroptions, optionset);
    xmlDocSetRootElement(out, filteroptions);
    xmlSaveFile("saveoptions.xml", out);
#endif
    return 0;
}
#endif