SylFilter

/* SylFilter - a message filter

 *

 * Copyright (C) 2011 Hiroyuki Yamamoto

 * Copyright (C) 2011 Sylpheed Development Team

 */

#include "config.h"

#ifdef USE_GDBM

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <glib.h>

#include <gdbm.h>

#include "filter-kvs.h"

#include "filter-kvs-gdbm.h"

static XFilterKVS *xf_gdbm_open(const char *dbfile);

static int xf_gdbm_close(XFilterKVS *kvs);

static int xf_gdbm_insert(XFilterKVS *kvs, const char *key, void *value, int size);

static int xf_gdbm_delete(XFilterKVS *kvs, const char *key);

static int xf_gdbm_update(XFilterKVS *kvs, const char *key, void *value, int size);

static int xf_gdbm_fetch(XFilterKVS *kvs, const char *key, void *vbuf, int vsize);

static int xf_gdbm_size(XFilterKVS *kvs);

static int xf_gdbm_foreach(XFilterKVS *kvs, XFilterKVSForeachFunc func, void *data);

int xfilter_kvs_gdbm_set_engine(void)

{

        XFilterKVSEngine engine = {

                xf_gdbm_open,

                xf_gdbm_close,

                xf_gdbm_insert,

                xf_gdbm_delete,

                xf_gdbm_update,

                xf_gdbm_fetch,

                NULL,

                NULL,

                xf_gdbm_size,

                xf_gdbm_foreach

        };

        return xfilter_kvs_set_engine(&engine);

}

static XFilterKVS *xf_gdbm_open(const char *dbfile)

{

        GDBM_FILE dbf;

        dbf = gdbm_open((char *)dbfile, 0, GDBM_WRCREAT, 0600, 0);

        if (!dbf) {

                fprintf(stderr, "xf_gdbm_open: %s: %s\n",

                        dbfile, gdbm_strerror(gdbm_errno));

                return NULL;

        }

        return xfilter_kvs_new(dbfile, (void *)dbf);

}

static int xf_gdbm_close(XFilterKVS *kvs)

{

        gdbm_close((GDBM_FILE)xfilter_kvs_get_handle(kvs));

        return 0;

}

static int xf_gdbm_insert(XFilterKVS *kvs, const char *key, void *value, int size)

{

        GDBM_FILE dbf;

        datum dkey, dvalue;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        dkey.dptr = (char *)key;

        dkey.dsize = strlen(key);

        dvalue.dptr = (char *)value;

        dvalue.dsize = size;

        if (gdbm_store(dbf, dkey, dvalue, GDBM_INSERT) != 0)

                return -1;

        return 0;

}

static int xf_gdbm_delete(XFilterKVS *kvs, const char *key)

{

        GDBM_FILE dbf;

        datum dkey;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        dkey.dptr = (char *)key;

        dkey.dsize = strlen(key);

        if (gdbm_delete(dbf, dkey) != 0)

                return -1;

        return 0;

}

static int xf_gdbm_update(XFilterKVS *kvs, const char *key, void *value, int size)

{

        GDBM_FILE dbf;

        datum dkey, dvalue;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        dkey.dptr = (char *)key;

        dkey.dsize = strlen(key);

        dvalue.dptr = (char *)value;

        dvalue.dsize = size;

        if (gdbm_store(dbf, dkey, dvalue, GDBM_REPLACE) != 0)

                return -1;

        return 0;

}

static int xf_gdbm_fetch(XFilterKVS *kvs, const char *key, void *vbuf, int vsize)

{

        GDBM_FILE dbf;

        datum dkey, dvalue;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        dkey.dptr = (char *)key;

        dkey.dsize = strlen(key);

        dvalue = gdbm_fetch(dbf, dkey);

        if (!dvalue.dptr)

                return -1;

        memcpy(vbuf, dvalue.dptr, MIN(vsize, dvalue.dsize));

        free(dvalue.dptr);

        return dvalue.dsize;

}

static int xf_gdbm_size(XFilterKVS *kvs)

{

        GDBM_FILE dbf;

        datum dkey, nkey;

        int size = 0;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        for (dkey = gdbm_firstkey(dbf); dkey.dptr; size++) {

                nkey = gdbm_nextkey(dbf, dkey);

                free(dkey.dptr);

                dkey = nkey;

        }

        return size;

}

static int xf_gdbm_foreach(XFilterKVS *kvs, XFilterKVSForeachFunc func, void *data)

{

        GDBM_FILE dbf;

        datum dkey, dvalue, nkey;

        char key[1024];

        int ksize;

        dbf = (GDBM_FILE)xfilter_kvs_get_handle(kvs);

        dkey = gdbm_firstkey(dbf);

        for (dkey = gdbm_firstkey(dbf); dkey.dptr; ) {

                int r;

                dvalue = gdbm_fetch(dbf, dkey);

                if (!dvalue.dptr) {

                        free(dkey.dptr);

                        break;

                }

                ksize = MIN(sizeof(key) - 1, dkey.dsize);

                memcpy(key, dkey.dptr, ksize);

                key[ksize] = '\0';

                r = func(kvs, key, dvalue.dptr, dvalue.dsize, data);

                if (r < 0) {

                        free(dvalue.dptr);

                        free(dkey.dptr);

                        break;

                }

                nkey = gdbm_nextkey(dbf, dkey);

                free(dvalue.dptr);

                free(dkey.dptr);

                dkey = nkey;

        }

        return 0;

}

#endif /* USE_GDBM */