SylFilter

#include <stdio.h>

#include <glib.h>

#include "filter.h"

#include "filter-private.h"

#include "filter-utils.h"

static int xfilter_debug_mode = 1;

int xfilter_init(void)

{

        return 0;

}

void xfilter_done(void)

{

}

XFilter *xfilter_new(XFilterType type, const char *name)

{

        XFilter *filter;

        if (type == XF_CONTENT) {

                filter = XFILTER(g_new0(XContentFilter, 1));

        } else {

                filter = XFILTER(g_new0(XTestFilter, 1));

        }

        filter->type = type;

        filter->name = g_strdup(name);

        return filter;

}

void xfilter_free(XFilter *filter)

{

        if (!filter)

                return;

        g_free(filter->name);

        g_free(filter);

}

XFilterType xfilter_get_type(XFilter *filter)

{

        g_return_val_if_fail(filter != NULL, -1);

        return filter->type;

}

const char *xfilter_get_name(XFilter *filter)

{

        g_return_val_if_fail(filter != NULL, NULL);

        return filter->name;

}

void xfilter_set_input_mime_types(XFilter *filter, const char **types)

{

}

void xfilter_set_output_mime_type(XFilter *filter, const char *type)

{

}

XMessageData *xfilter_message_data_new(const char *src, const char *mime_type)

{

        XMessageData *data;

        g_return_val_if_fail(mime_type != NULL, NULL);

        data = g_new0(XMessageData, 1);

        data->content = g_strdup(src);

        data->mime_type = g_strdup(mime_type);

        return data;

}

XMessageData *xfilter_message_data_read_file(const char *file, const char *mime_type)

{

        XMessageData *data;

        char *content;

        g_return_val_if_fail(file != NULL, NULL);

        g_return_val_if_fail(mime_type != NULL, NULL);

        content = xfilter_utils_get_file_contents(file);

        if (!content)

                return NULL;

        data = g_new0(XMessageData, 1);

        data->content = content;

        data->mime_type = g_strdup(mime_type);

        return data;

}

void xfilter_message_data_free(XMessageData *msgdata)

{

        if (!msgdata)

                return;

        g_free(msgdata->mime_type);

        g_free(msgdata->content);

        g_free(msgdata);

}

void xfilter_message_data_set_content(XMessageData *msgdata, char *content)

{

        msgdata->content = content;

}

const char *xfilter_message_data_get_mime_type(const XMessageData *msgdata)

{

        g_return_val_if_fail(msgdata != NULL, NULL);

        return msgdata->mime_type;

}

const char *xfilter_message_data_get_content(const XMessageData *msgdata)

{

        g_return_val_if_fail(msgdata != NULL, NULL);

        return msgdata->content;

}

void xfilter_set_content_filter_func(XContentFilter *filter, XContentFilterFunc func)

{

        g_return_if_fail(XFILTER(filter)->type == XF_CONTENT);

        filter->content_filter_func = func;

}

void xfilter_set_test_filter_func(XTestFilter *filter, XTestFilterFunc func)

{

        g_return_if_fail(XFILTER(filter)->type == XF_TEST);

        filter->test_filter_func = func;

}

XFilterStatus xfilter_exec(XFilter *filter, const XMessageData *msgdata, XFilterResult *result)

{

        g_return_val_if_fail(filter != NULL, XF_ERROR);

        g_return_val_if_fail(msgdata != NULL, XF_ERROR);

        if (filter->type == XF_CONTENT) {

                if (!X_CONTENT_FILTER(filter)->content_filter_func)

                        return XF_ERROR;

                return X_CONTENT_FILTER(filter)->content_filter_func(filter, msgdata, result);

        } else {

                if (!X_TEST_FILTER(filter)->test_filter_func)

                        return XF_ERROR;

                return X_TEST_FILTER(filter)->test_filter_func(filter, msgdata, result);

        }

}

void xfilter_result_print(XFilterResult *result)

{

        printf("XFilterResult: status = %d, probability = %f\n", result->status, result->probability);

}

XFilterResult *xfilter_result_new(void)

{

        XFilterResult *res;

        res = g_new0(XFilterResult, 1);

        res->status = XF_NONE;

        res->probability = 0.5;

        return res;

}

void xfilter_result_set_status(XFilterResult *result, XFilterStatus status)

{

        result->status = status;

}

void xfilter_result_set_message_data(XFilterResult *result, XMessageData *msgdata)

{

        if (result->msgdata)

                xfilter_message_data_free(result->msgdata);

        result->msgdata = msgdata;

}

void xfilter_result_set_probability(XFilterResult *result, double prob)

{

        result->probability = prob;

}

XFilterStatus xfilter_result_get_status(XFilterResult *result)

{

        g_return_val_if_fail(result != NULL, XF_ERROR);

        return result->status;

}

XMessageData *xfilter_result_get_message_data(XFilterResult *result)

{

        g_return_val_if_fail(result != NULL, NULL);

        return result->msgdata;

}

double xfilter_result_get_probability(XFilterResult *result)

{

        g_return_val_if_fail(result != NULL, 0.0);

        return result->probability;

}

void xfilter_result_free(XFilterResult *result)

{

        if (!result)

                return;

        xfilter_message_data_free(result->msgdata);

        g_free(result);

}

void xfilter_debug_print(const char *format, ...)

{

        va_list args;

        char buf[1024];

        if (!xfilter_debug_mode)

                return;

        va_start(args, format);

        g_vsnprintf(buf, sizeof(buf), format, args);

        va_end(args);

        fputs(buf, stderr);

}