bdb.c

Go to the documentation of this file.

 
#include "config.h"
#include <db.h>
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "lib.h"
 
struct StoreDbCtx
{
  DB_ENV *env;
  DB *db;
  int fd;
  struct Buffer lockfile;
};
 
static void dbt_init(DBT *dbt, void *data, size_t len)
{
  dbt->data = data;
  dbt->size = len;
  dbt->ulen = len;
  dbt->dlen = 0;
  dbt->doff = 0;
  dbt->flags = DB_DBT_USERMEM;
}
 
static void dbt_empty_init(DBT *dbt)
{
  dbt->data = NULL;
  dbt->size = 0;
  dbt->ulen = 0;
  dbt->dlen = 0;
  dbt->doff = 0;
  dbt->flags = 0;
}
 
static void *store_bdb_open(const char *path)
{
  if (!path)
    return NULL;
 
  struct stat st = { 0 };
  int rc;
  uint32_t createflags = DB_CREATE;
 
  struct StoreDbCtx *ctx = mutt_mem_malloc(sizeof(struct StoreDbCtx));
 
  const int pagesize = 512;
 
  ctx->lockfile = mutt_buffer_make(128);
  mutt_buffer_printf(&ctx->lockfile, "%s-lock-hack", path);
 
  ctx->fd = open(mutt_buffer_string(&ctx->lockfile), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
  if (ctx->fd < 0)
  {
    FREE(&ctx);
    return NULL;
  }
 
  if (mutt_file_lock(ctx->fd, true, true))
    goto fail_close;
 
  rc = db_env_create(&ctx->env, 0);
  if (rc)
    goto fail_unlock;
 
  rc = (*ctx->env->open)(ctx->env, NULL, DB_INIT_MPOOL | DB_CREATE | DB_PRIVATE, 0600);
  if (rc)
    goto fail_env;
 
  ctx->db = NULL;
  rc = db_create(&ctx->db, ctx->env, 0);
  if (rc)
    goto fail_env;
 
  if ((stat(path, &st) != 0) && (errno == ENOENT))
  {
    createflags |= DB_EXCL;
    ctx->db->set_pagesize(ctx->db, pagesize);
  }
 
  rc = (*ctx->db->open)(ctx->db, NULL, path, NULL, DB_BTREE, createflags, 0600);
  if (rc)
    goto fail_db;
 
  return ctx;
 
fail_db:
  ctx->db->close(ctx->db, 0);
fail_env:
  ctx->env->close(ctx->env, 0);
fail_unlock:
  mutt_file_unlock(ctx->fd);
fail_close:
  close(ctx->fd);
  unlink(mutt_buffer_string(&ctx->lockfile));
  mutt_buffer_dealloc(&ctx->lockfile);
  FREE(&ctx);
 
  return NULL;
}
 
static void *store_bdb_fetch(void *store, const char *key, size_t klen, size_t *vlen)
{
  if (!store)
    return NULL;
 
  DBT dkey;
  DBT data;
 
  struct StoreDbCtx *ctx = store;
 
  dbt_init(&dkey, (void *) key, klen);
  dbt_empty_init(&data);
  data.flags = DB_DBT_MALLOC;
 
  ctx->db->get(ctx->db, NULL, &dkey, &data, 0);
 
  *vlen = data.size;
  return data.data;
}
 
static void store_bdb_free(void *store, void **ptr)
{
  FREE(ptr);
}
 
static int store_bdb_store(void *store, const char *key, size_t klen, void *value, size_t vlen)
{
  if (!store)
    return -1;
 
  DBT dkey;
  DBT databuf;
 
  struct StoreDbCtx *ctx = store;
 
  dbt_init(&dkey, (void *) key, klen);
  dbt_empty_init(&databuf);
  databuf.flags = DB_DBT_USERMEM;
  databuf.data = value;
  databuf.size = vlen;
  databuf.ulen = vlen;
 
  return ctx->db->put(ctx->db, NULL, &dkey, &databuf, 0);
}
 
static int store_bdb_delete_record(void *store, const char *key, size_t klen)
{
  if (!store)
    return -1;
 
  DBT dkey;
 
  struct StoreDbCtx *ctx = store;
 
  dbt_init(&dkey, (void *) key, klen);
  return ctx->db->del(ctx->db, NULL, &dkey, 0);
}
 
static void store_bdb_close(void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct StoreDbCtx *db = *ptr;
 
  db->db->close(db->db, 0);
  db->env->close(db->env, 0);
  mutt_file_unlock(db->fd);
  close(db->fd);
  unlink(mutt_buffer_string(&db->lockfile));
  mutt_buffer_dealloc(&db->lockfile);
  FREE(ptr);
}
 
static const char *store_bdb_version(void)
{
  return DB_VERSION_STRING;
}
 
STORE_BACKEND_OPS(bdb)