Begin to work on a pop reimplementation, using jobs and the event loop
[apps/madmutt.git] / lib-mx / hcache.c
index bdbeeb9..01db5bd 100644 (file)
 
 #ifdef USE_HCACHE
 
-#define MUTTNG_HCACHE_ID        "0x004"
-
-#if defined(HAVE_QDBM)
-#include <depot.h>
-#include <cabin.h>
-#include <villa.h>
+#if defined(HAVE_TOKYOCABINET)
+#include <tcutil.h>
+#include <tchdb.h>
 #elif defined(HAVE_GDBM)
 #include <gdbm.h>
-#elif defined(HAVE_DB4)
-#include <db.h>
+#else
+#error no supported DB library found ?
 #endif
 
-#include <lib-hash/hash.h>
-#include <lib-mime/mime.h>
-
-#include <imap/message.h>
-
 #include "charset.h"
 #include "mutt.h"
 #include "hcache.h"
 
-struct header_cache {
-#if defined(HAVE_QDBM)
-  VILLA *db;
-  char *folder;
-  unsigned int crc;
+struct hcache_t {
+#if defined(HAVE_TOKYOCABINET)
+    TCHDB *db;
 #elif defined(HAVE_GDBM)
-  GDBM_FILE db;
-  char *folder;
-  unsigned int crc;
-#elif defined(HAVE_DB4)
-  DB_ENV *env;
-  DB *db;
-  unsigned int crc;
-  int fd;
-  char lockfile[_POSIX_PATH_MAX];
+    GDBM_FILE db;
 #endif
+    char *folder;
+    unsigned int crc;
 };
 
-typedef union {
-  struct timeval timeval;
-  unsigned long uid_validity;
-} validate;
-
-#define UPPER4K(i)  ((i & ~(4096 - 1)) + 4096)
-
-static unsigned char *lazy_malloc(ssize_t siz)
+static unsigned int crc32(unsigned int crc, const void *src, ssize_t len)
 {
-    return p_new(unsigned char, UPPER4K(siz));
-}
+    int i;
+    const unsigned char *p = src;
 
-static void lazy_realloc(unsigned char **p, ssize_t siz)
-{
-    p_realloc(p, UPPER4K(siz));
+    while (len--) {
+        crc ^= *p++;
+        for (i = 0; i < 8; i++)
+            crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+    }
+    return crc;
 }
 
-static unsigned char *dump_int (unsigned int i, unsigned char *d, int *off)
+static int generate_crc32(void)
 {
-  lazy_realloc (&d, *off + sizeof (int));
-  memcpy (d + *off, &i, sizeof (int));
-  (*off) += sizeof (int);
-
-  return d;
-}
+    int crc = 0;
 
-static void restore_int (unsigned int *i, const unsigned char *d, int *off)
-{
-  memcpy (i, d + *off, sizeof (int));
-  (*off) += sizeof (int);
+    crc = crc32(crc, "madmutt.2007.05.13", m_strlen("madmutt.2007.05.13"));
+#ifdef HAVE_LANGINFO_H
+    crc = crc32(crc, mod_cset.charset, m_strlen(mod_cset.charset));
+#endif
+    crc = crc32(crc, "USE_POP",   m_strlen("USE_POP"));
+    crc = crc32(crc, "USE_IMAP",  m_strlen("USE_IMAP"));
+    return crc;
 }
 
-static unsigned char *dump_char (char *c, unsigned char *d, int *off)
+static const char *
+mutt_hcache_per_folder(const char *path, const char *folder)
 {
-  unsigned int size;
+    static char buf[_POSIX_PATH_MAX];
+    struct stat st;
+    int pos;
 
-  if (c == NULL) {
-    size = 0;
-    d = dump_int (size, d, off);
-    return d;
-  }
+    if (stat(path, &st) < 0 || !S_ISDIR(st.st_mode)) {
+        return path;
+    }
 
-  size = m_strlen(c) + 1;
-  d = dump_int (size, d, off);
-  lazy_realloc (&d, *off + size);
-  memcpy (d + *off, c, size);
-  *off += size;
+    pos  = m_strcpy(buf, sizeof(buf), path);
+    pos += m_strputc(buf + pos, sizeof(buf) - pos, '/');
 
-  return d;
+    while (*folder) {
+        if (isalnum((unsigned char)*folder) || *folder == '.') {
+            pos += m_strputc(buf + pos, sizeof(buf) - pos, *folder);
+        } else {
+            pos += m_strputc(buf + pos, sizeof(buf) - pos, '_');
+        }
+        folder++;
+    }
+    pos += m_strcpy(buf + pos, sizeof(buf) - pos, ".hdb");
+    return buf;
 }
 
-static void restore_char (char **c, const unsigned char *d, int *off)
-{
-  unsigned int size;
-
-  restore_int (&size, d, off);
+/* store and restore things {{{ */
 
-  if (size == 0) {
-    *c = NULL;
-    return;
-  }
-
-  *c = p_dup(d + *off, size);
-  *off += size;
-}
-
-static unsigned char *dump_address (address_t * a, unsigned char *d, int *off)
+static void dump_int(buffer_t *buf, int i)
 {
-  unsigned int counter = 0;
-  unsigned int start_off = *off;
-
-  d = dump_int (0xdeadbeef, d, off);
-
-  while (a) {
-    d = dump_char (a->personal, d, off);
-    d = dump_char (a->mailbox, d, off);
-    d = dump_int (a->group, d, off);
-    a = a->next;
-    counter++;
-  }
-
-  memcpy (d + start_off, &counter, sizeof (int));
-
-  return d;
+    buffer_add(buf, &i, sizeof(i));
 }
 
-static void restore_address (address_t ** a, const unsigned char *d, int *off)
+static const void *restore_int(const char *d, int *i)
 {
-  unsigned int counter;
-
-  restore_int (&counter, d, off);
-
-  while (counter) {
-    *a = p_new(address_t, 1);
-    restore_char (&(*a)->personal, d, off);
-    restore_char (&(*a)->mailbox, d, off);
-    restore_int ((unsigned int *) &(*a)->group, d, off);
-    a = &(*a)->next;
-    counter--;
-  }
-
-  *a = NULL;
+    memcpy(i, d, sizeof(*i));
+    return d + sizeof(*i);
 }
 
-static unsigned char *dump_list (string_list_t * l, unsigned char *d, int *off)
+static void dump_cstr(buffer_t *buf, const char *s)
 {
-  unsigned int counter = 0;
-  unsigned int start_off = *off;
-
-  d = dump_int (0xdeadbeef, d, off);
+    int size = 0;
 
-  while (l) {
-    d = dump_char (l->data, d, off);
-    l = l->next;
-    counter++;
-  }
-
-  memcpy (d + start_off, &counter, sizeof (int));
+    if (m_strisempty(s)) {
+        dump_int(buf, size);
+        return;
+    }
 
-  return d;
+    size = strlen(s) + 1;
+    dump_int(buf, size);
+    buffer_add(buf, s, size);
 }
 
-static void restore_list (string_list_t ** l, const unsigned char *d, int *off)
+static const void *restore_cstr(const char *d, char **c)
 {
-  unsigned int counter;
-
-  restore_int (&counter, d, off);
+    int size;
 
-  while (counter) {
-    *l = p_new(string_list_t, 1);
-    restore_char (&(*l)->data, d, off);
-    l = &(*l)->next;
-    counter--;
-  }
-
-  *l = NULL;
+    d  = restore_int(d, &size);
+    *c = p_dup(d, size);
+    return d + size;
 }
 
-static unsigned char *dump_parameter (parameter_t * p, unsigned char *d,
-                                      int *off)
+static void dump_address(buffer_t *buf, address_t *a)
 {
-  unsigned int counter = 0;
-  unsigned int start_off = *off;
-
-  d = dump_int (0xdeadbeef, d, off);
-
-  while (p) {
-    d = dump_char (p->attribute, d, off);
-    d = dump_char (p->value, d, off);
-    p = p->next;
-    counter++;
-  }
-
-  memcpy (d + start_off, &counter, sizeof (int));
-
-  return d;
-}
+    int counter = 0, pos = buf->len;
 
-static void
-restore_parameter (parameter_t ** p, const unsigned char *d, int *off)
-{
-  unsigned int counter;
+    dump_int(buf, counter);
 
-  restore_int (&counter, d, off);
+    for (; a; a = a->next, counter++) {
+        dump_cstr(buf, a->personal);
+        dump_cstr(buf, a->mailbox);
+        dump_int(buf, a->group);
+    }
 
-  while (counter) {
-    *p = parameter_new();
-    restore_char (&(*p)->attribute, d, off);
-    restore_char (&(*p)->value, d, off);
-    p = &(*p)->next;
-    counter--;
-  }
+    memcpy(buf->data + pos, &counter, sizeof(counter));
 }
 
-static unsigned char *dump_body (BODY * c, unsigned char *d, int *off)
+static const void *restore_address(const char *d, address_t **a)
 {
-  lazy_realloc (&d, *off + sizeof (BODY));
-  memcpy (d + *off, c, sizeof (BODY));
-  *off += sizeof (BODY);
-
-  d = dump_char (c->xtype, d, off);
-  d = dump_char (c->subtype, d, off);
+    int counter;
 
-  d = dump_parameter (c->parameter, d, off);
+    d = restore_int(d, &counter);
 
-  d = dump_char (c->description, d, off);
-  d = dump_char (c->form_name, d, off);
-  d = dump_char (c->filename, d, off);
-  d = dump_char (c->d_filename, d, off);
+    for (; counter > 0; counter--) {
+        *a = address_new();
+        d = restore_cstr(d, &(*a)->personal);
+        d = restore_cstr(d, &(*a)->mailbox);
+        d = restore_int(d, &(*a)->group);
+        a = &(*a)->next;
+    }
 
-  return d;
+    *a = NULL;
+    return d;
 }
 
-static void restore_body (BODY * c, const unsigned char *d, int *off)
+static void dump_list(buffer_t *buf, string_list_t *l)
 {
-  memcpy (c, d + *off, sizeof (BODY));
-  *off += sizeof (BODY);
+    int pos = buf->len;
+    int counter = 0;
 
-  restore_char (&c->xtype, d, off);
-  restore_char (&c->subtype, d, off);
+    dump_int(buf, counter);
 
-  restore_parameter (&c->parameter, d, off);
+    for (; l; l = l->next, counter++) {
+        dump_cstr(buf, l->data);
+    }
 
-  restore_char (&c->description, d, off);
-  restore_char (&c->form_name, d, off);
-  restore_char (&c->filename, d, off);
-  restore_char (&c->d_filename, d, off);
+    memcpy(buf->data + pos, &counter, sizeof(counter));
 }
 
-static unsigned char *dump_envelope (ENVELOPE * e, unsigned char *d, int *off)
+static const void *restore_list(const char *d, string_list_t **l)
 {
-  d = dump_address (e->return_path, d, off);
-  d = dump_address (e->from, d, off);
-  d = dump_address (e->to, d, off);
-  d = dump_address (e->cc, d, off);
-  d = dump_address (e->bcc, d, off);
-  d = dump_address (e->sender, d, off);
-  d = dump_address (e->reply_to, d, off);
-  d = dump_address (e->mail_followup_to, d, off);
-
-  d = dump_char (e->subject, d, off);
-  if (e->real_subj) {
-    d = dump_int (e->real_subj - e->subject, d, off);
-  }
-  else {
-    d = dump_int (-1, d, off);
-  }
-  d = dump_char (e->message_id, d, off);
-  d = dump_char (e->supersedes, d, off);
-  d = dump_char (e->date, d, off);
-  d = dump_char (e->x_label, d, off);
-  d = dump_char (e->list_post, d, off);
-
-#ifdef USE_NNTP
-  d = dump_char (e->newsgroups, d, off);
-  d = dump_char (e->xref, d, off);
-  d = dump_char (e->followup_to, d, off);
-  d = dump_char (e->x_comment_to, d, off);
-#endif
+    int counter;
 
-  d = dump_list (e->references, d, off);
-  d = dump_list (e->in_reply_to, d, off);
-  d = dump_list (e->userhdrs, d, off);
+    d = restore_int(d, &counter);
 
-  return d;
-}
-
-static void restore_envelope (ENVELOPE * e, const unsigned char *d, int *off)
-{
-  int real_subj_off;
-
-  restore_address (&e->return_path, d, off);
-  restore_address (&e->from, d, off);
-  restore_address (&e->to, d, off);
-  restore_address (&e->cc, d, off);
-  restore_address (&e->bcc, d, off);
-  restore_address (&e->sender, d, off);
-  restore_address (&e->reply_to, d, off);
-  restore_address (&e->mail_followup_to, d, off);
-
-  restore_char (&e->subject, d, off);
-  restore_int ((unsigned int *) (&real_subj_off), d, off);
-  if (0 <= real_subj_off) {
-    e->real_subj = e->subject + real_subj_off;
-  }
-  else {
-    e->real_subj = NULL;
-  }
-  restore_char (&e->message_id, d, off);
-  restore_char (&e->supersedes, d, off);
-  restore_char (&e->date, d, off);
-  restore_char (&e->x_label, d, off);
-  restore_char (&e->list_post, d, off);
-
-#ifdef USE_NNTP
-  restore_char (&e->newsgroups, d, off);
-  restore_char (&e->xref, d, off);
-  restore_char (&e->followup_to, d, off);
-  restore_char (&e->x_comment_to, d, off);
-#endif
-
-  restore_list (&e->references, d, off);
-  restore_list (&e->in_reply_to, d, off);
-  restore_list (&e->userhdrs, d, off);
-}
+    for (; counter > 0; counter--) {
+        *l = string_item_new();
+        d = restore_cstr(d, &(*l)->data);
+        l = &(*l)->next;
+    }
 
-static
-unsigned int crc32 (unsigned int crc, unsigned char const *p, ssize_t len)
-{
-  int i;
-
-  while (len--) {
-    crc ^= *p++;
-    for (i = 0; i < 8; i++)
-      crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
-  }
-  return crc;
+    *l = NULL;
+    return d;
 }
 
-static int generate_crc32 ()
+static void dump_parameter(buffer_t *buf, parameter_t *p)
 {
-  int crc = 0;
-
-  crc = crc32 (crc, (unsigned char const *)
-               MUTTNG_HCACHE_ID "sithglan@stud.uni-erlangen.de[sithglan]|hcache.c|20041108231548|29613",
-               m_strlen
-               (MUTTNG_HCACHE_ID "sithglan@stud.uni-erlangen.de[sithglan]|hcache.c|20041108231548|29613"));
-
-#ifdef HAVE_LANGINFO_CODESET
-  crc = crc32(crc, (unsigned char const *) MCharset.charset, m_strlen(MCharset.charset));
-  crc = crc32(crc, (unsigned char const *) "HAVE_LANGINFO_CODESET",
-              m_strlen("HAVE_LANGINFO_CODESET"));
-#endif
+    int pos = buf->len, counter = 0;
 
-  crc = crc32(crc, (unsigned char const *) "USE_POP", m_strlen("USE_POP"));
+    dump_int(buf, counter);
 
-  crc = crc32(crc, (unsigned char const *) "MIXMASTER",
-              m_strlen("MIXMASTER"));
-
-  crc = crc32(crc, (unsigned char const *) "USE_IMAP", m_strlen("USE_IMAP"));
+    for (; p; p = p->next, counter++) {
+        dump_cstr(buf, p->attribute);
+        dump_cstr(buf, p->value);
+    }
 
-#ifdef USE_NNTP
-  crc = crc32(crc, (unsigned char const *) "USE_NNTP", m_strlen("USE_NNTP"));
-#endif
-  return crc;
+    memcpy(buf->data + pos, &counter, sizeof(counter));
 }
 
-static int crc32_matches (const char *d, unsigned int crc)
+static const void *restore_parameter(const char *d, parameter_t ** p)
 {
-  int off = sizeof (validate);
-  unsigned int mycrc = 0;
+    int counter;
 
-  if (!d) {
-    return 0;
-  }
+    d = restore_int(d, &counter);
 
-  restore_int (&mycrc, (unsigned char *) d, &off);
-
-  return (crc == mycrc);
-}
+    for (; counter > 0; counter--) {
+        *p = parameter_new();
+        d  = restore_cstr(d, &(*p)->attribute);
+        d  = restore_cstr(d, &(*p)->value);
+        p  = &(*p)->next;
+    }
 
-/* Append md5sumed folder to path if path is a directory. */
-static const char *mutt_hcache_per_folder (const char *path,
-                                           const char *folder)
-{
-  static char mutt_hcache_per_folder_path[_POSIX_PATH_MAX];
-  struct stat path_stat;
-  MD5_CTX md5;
-  unsigned char md5sum[16];
-  int ret;
-
-  ret = stat (path, &path_stat);
-  if (ret < 0) {
-    return path;
-  }
-
-  if (!S_ISDIR (path_stat.st_mode)) {
-    return path;
-  }
-
-  MD5Init (&md5);
-  MD5Update (&md5, (unsigned char *) folder, m_strlen(folder));
-  MD5Final (md5sum, &md5);
-
-  ret = snprintf (mutt_hcache_per_folder_path, _POSIX_PATH_MAX,
-                  "%s/%02x%02x%02x%02x%02x%02x%02x%02x"
-                  "%02x%02x%02x%02x%02x%02x%02x%02x",
-                  path, md5sum[0], md5sum[1], md5sum[2], md5sum[3],
-                  md5sum[4], md5sum[5], md5sum[6], md5sum[7], md5sum[8],
-                  md5sum[9], md5sum[10], md5sum[11], md5sum[12],
-                  md5sum[13], md5sum[14], md5sum[15]);
-
-  if (ret <= 0) {
-    return path;
-  }
-
-  return mutt_hcache_per_folder_path;
+    *p = NULL;
+    return d;
 }
 
-/* This function transforms a header into a char so that it is useable by
- * db_store */
-static void *mutt_hcache_dump (void *_db, HEADER * h, int *off,
-                               unsigned long uid_validity)
+static void dump_body(buffer_t *buf, BODY *b)
 {
-  struct header_cache *db = _db;
-  unsigned char *d = NULL;
-
-  *off = 0;
+    buffer_add(buf, b, sizeof(*b));
+    dump_cstr(buf, b->xtype);
+    dump_cstr(buf, b->subtype);
 
-  d = lazy_malloc (sizeof (validate));
+    dump_parameter(buf, b->parameter);
 
-  if (uid_validity) {
-    memcpy (d, &uid_validity, sizeof (unsigned long));
-  }
-  else {
-    struct timeval now;
-
-    gettimeofday (&now, NULL);
-    memcpy (d, &now, sizeof (struct timeval));
-  }
-  *off += sizeof (validate);
-
-  d = dump_int (db->crc, d, off);
-
-  lazy_realloc (&d, *off + sizeof (HEADER));
-  memcpy (d + *off, h, sizeof (HEADER));
-  *off += sizeof (HEADER);
-
-  d = dump_envelope (h->env, d, off);
-  d = dump_body (h->content, d, off);
-  d = dump_char (h->maildir_flags, d, off);
-
-  return d;
+    dump_cstr(buf, b->description);
+    dump_cstr(buf, b->form_name);
+    dump_cstr(buf, b->filename);
+    dump_cstr(buf, b->d_filename);
 }
 
-HEADER *mutt_hcache_restore (const unsigned char *d, HEADER ** oh)
+static const void *restore_body(const char *d, BODY *c)
 {
-  int off = 0;
-  HEADER *h = header_new();
-
-  /* skip validate */
-  off += sizeof (validate);
-
-  /* skip crc */
-  off += sizeof (unsigned int);
-
-  memcpy (h, d + off, sizeof (HEADER));
-  off += sizeof (HEADER);
-
-  h->env = envelope_new();
-  restore_envelope (h->env, d, &off);
+    memcpy(c, d, sizeof(*c));
+    d += sizeof(*c);
 
-  h->content = body_new();
-  restore_body (h->content, d, &off);
+    d = restore_cstr(d, &c->xtype);
+    d = restore_cstr(d, &c->subtype);
 
-  restore_char (&h->maildir_flags, d, &off);
+    d = restore_parameter(d, &c->parameter);
 
-  /* this is needed for maildir style mailboxes */
-  if (oh) {
-    h->old = (*oh)->old;
-    h->path = m_strdup((*oh)->path);
-    header_delete(oh);
-  }
-
-  return h;
+    d = restore_cstr(d, &c->description);
+    d = restore_cstr(d, &c->form_name);
+    d = restore_cstr(d, &c->filename);
+    d = restore_cstr(d, &c->d_filename);
+    return d;
 }
 
-#if defined(HAVE_QDBM)
-void *
-mutt_hcache_open(const char *path, const char *folder)
+static void dump_envelope(buffer_t *buf, ENVELOPE * e)
 {
-  struct header_cache *h = p_new(struct header_cache, 1);
-  int    flags = VL_OWRITER | VL_OCREAT;
-  h->db = NULL;
-  h->folder = m_strdup(folder);
-  h->crc = generate_crc32();
-
-  if (!path || path[0] == '\0')
-  {
-    p_delete(&h->folder);
-    p_delete(&h);
-    return NULL;
-  }
-
-  path = mutt_hcache_per_folder(path, folder);
-
-  if (option(OPTHCACHECOMPRESS))
-    flags |= VL_OZCOMP;
-
-  h->db = vlopen(path, flags, VL_CMPLEX);
-  if (h->db)
-    return h;
-  else
-  {
-    p_delete(&h->folder);
-    p_delete(&h);
+    int n;
 
-    return NULL;
-  }
-}
+    dump_address(buf, e->return_path);
+    dump_address(buf, e->from);
+    dump_address(buf, e->to);
+    dump_address(buf, e->cc);
+    dump_address(buf, e->bcc);
+    dump_address(buf, e->sender);
+    dump_address(buf, e->reply_to);
+    dump_address(buf, e->mail_followup_to);
 
-void
-mutt_hcache_close(void *db)
-{
-  struct header_cache *h = db;
+    dump_cstr(buf, e->subject);
+    n = e->real_subj ? e->real_subj - e->subject : -1;
+    dump_int(buf, n);
 
-  if (!h)
-    return;
+    dump_cstr(buf, e->message_id);
+    dump_cstr(buf, e->supersedes);
+    dump_cstr(buf, e->date);
+    dump_cstr(buf, e->x_label);
+    dump_cstr(buf, e->list_post);
 
-  vlclose(h->db);
-  p_delete(&h->folder);
-  p_delete(&h);
+    dump_list(buf, e->references);
+    dump_list(buf, e->in_reply_to);
+    dump_list(buf, e->userhdrs);
 }
 
-void *
-mutt_hcache_fetch(void *db, const char *filename,
-                 ssize_t(*keylen) (const char *fn))
+static const void *restore_envelope(const char *d, ENVELOPE *e)
 {
-  struct header_cache *h = db;
-  char path[_POSIX_PATH_MAX];
-  int ksize;
-  char *data = NULL;
+    int real_subj_off;
 
-  if (!h)
-    return NULL;
+    d = restore_address(d, &e->return_path);
+    d = restore_address(d, &e->from);
+    d = restore_address(d, &e->to);
+    d = restore_address(d, &e->cc);
+    d = restore_address(d, &e->bcc);
+    d = restore_address(d, &e->sender);
+    d = restore_address(d, &e->reply_to);
+    d = restore_address(d, &e->mail_followup_to);
 
-  m_strcpy(path, sizeof(path), h->folder);
-  m_strcat(path, sizeof(path), filename);
-
-  ksize = strlen(h->folder) + keylen(path + strlen(h->folder));
-
-  data = vlget(h->db, path, ksize, NULL);
-
-  if (!crc32_matches(data, h->crc))
-  {
-    p_delete(&data);
-    return NULL;
-  }
-
-  return data;
+    d = restore_cstr(d, &e->subject);
+    d = restore_int(d, &real_subj_off);
+    if (real_subj_off >= 0) {
+        e->real_subj = e->subject + real_subj_off;
+    } else {
+        e->real_subj = NULL;
+    }
+    d = restore_cstr(d, &e->message_id);
+    d = restore_cstr(d, &e->supersedes);
+    d = restore_cstr(d, &e->date);
+    d = restore_cstr(d, &e->x_label);
+    d = restore_cstr(d, &e->list_post);
+
+    d = restore_list(d, &e->references);
+    d = restore_list(d, &e->in_reply_to);
+    d = restore_list(d, &e->userhdrs);
+    return d;
 }
 
-int
-mutt_hcache_store(void *db, const char *filename, HEADER * header,
-                 unsigned long uid_validity,
-                 ssize_t(*keylen) (const char *fn))
+static buffer_t *mutt_hcache_dump(hcache_t *db, HEADER *h, long uid_validity)
 {
-  struct header_cache *h = db;
-  char path[_POSIX_PATH_MAX];
-  int ret;
-  int ksize, dsize;
-  char *data = NULL;
-
-  if (!h)
-    return -1;
-
-  m_strcpy(path, sizeof(path), h->folder);
-  m_strcat(path, sizeof(path), filename);
-
-  ksize = strlen(h->folder) + keylen(path + strlen(h->folder));
-
-  data  = mutt_hcache_dump(db, header, &dsize, uid_validity);
+    buffer_t *res = buffer_new();
 
-  ret = vlput(h->db, path, ksize, data, dsize, VL_DOVER);
-
-  p_delete(&data);
+    if (!uid_validity) {
+        uid_validity = time(NULL);
+    }
+    buffer_add(res, &uid_validity, sizeof(uid_validity));
+    dump_int(res, db->crc);
+    buffer_add(res, h, sizeof(*h));
 
-  return ret;
+    dump_envelope(res, h->env);
+    dump_body(res, h->content);
+    dump_cstr(res, h->maildir_flags);
+    return res;
 }
 
-int
-mutt_hcache_delete(void *db, const char *filename,
-                  ssize_t(*keylen) (const char *fn))
+HEADER *mutt_hcache_restore(const void *_d, HEADER **oh)
 {
-  struct header_cache *h = db;
-  char path[_POSIX_PATH_MAX];
-  int ksize;
+    const char *d = _d;
+    HEADER *h = header_new();
 
-  if (!h)
-    return -1;
+    /* skip uid_validity + crc */
+    d += sizeof(long) + sizeof(int);
 
-  m_strcpy(path, sizeof(path), h->folder);
-  m_strcat(path, sizeof(path), filename);
+    memcpy(h, d, sizeof(*h));
+    d += sizeof(*h);
 
-  ksize = strlen(h->folder) + keylen(path + strlen(h->folder));
+    h->env = envelope_new();
+    d = restore_envelope(d, h->env);
 
-  return vlout(h->db, path, ksize);
-}
+    h->content = body_new();
+    d = restore_body(d, h->content);
 
-#elif defined(HAVE_GDBM)
+    d = restore_cstr(d, &h->maildir_flags);
 
-void *mutt_hcache_open (const char *path, const char *folder)
-{
-  struct header_cache *h = p_new(struct header_cache, 1);
-  int pagesize =
-    atoi (HeaderCachePageSize) ? atoi (HeaderCachePageSize) : 16384;
-  h->db = NULL;
-  h->folder = m_strdup(folder);
-  h->crc = generate_crc32 ();
-
-  if (!path || path[0] == '\0') {
-    p_delete(&h->folder);
-    p_delete(&h);
-    return NULL;
-  }
-
-  path = mutt_hcache_per_folder (path, folder);
-
-  h->db = gdbm_open ((char *) path, pagesize, GDBM_WRCREAT, 00600, NULL);
-  if (h->db) {
-    return h;
-  }
+    /* this is needed for maildir style mailboxes */
+    if (oh) {
+        h->old = (*oh)->old;
+        h->path = m_strdup((*oh)->path);
+        header_delete(oh);
+    }
 
-  /* if rw failed try ro */
-  h->db = gdbm_open ((char *) path, pagesize, GDBM_READER, 00600, NULL);
-  if (h->db) {
     return h;
-  }
-  else {
-    p_delete(&h->folder);
-    p_delete(&h);
-
-    return NULL;
-  }
 }
 
-void mutt_hcache_close (void *db)
-{
-  struct header_cache *h = db;
+/* }}} */
 
-  if (!h) {
-    return;
-  }
-
-  gdbm_close (h->db);
-  p_delete(&h->folder);
-  p_delete(&h);
-}
-
-void *mutt_hcache_fetch (void *db, const char *filename,
-                         ssize_t (*keylen) (const char *fn))
+hcache_t *mutt_hcache_open(const char *folder)
 {
-  struct header_cache *h = db;
-  datum key;
-  datum data;
-  char path[_POSIX_PATH_MAX];
-
-  if (!h) {
-    return NULL;
-  }
+    const char *path;
+    hcache_t *h;
 
-  m_strcpy(path, sizeof(path), h->folder);
-  strncat (path, filename, sizeof (path) - m_strlen(path));
+    if (m_strisempty(mod_core.cachedir)) {
+        return NULL;
+    }
 
-  key.dptr = path;
-  key.dsize = keylen (path);
+    h = p_new(hcache_t, 1);
+    h->folder = m_strdup(folder);
+    h->crc    = generate_crc32();
 
-  data = gdbm_fetch (h->db, key);
+    path = mutt_hcache_per_folder(mod_core.cachedir, folder);
 
-  if (!crc32_matches (data.dptr, h->crc)) {
-    p_delete(&data.dptr);
-    return NULL;
-  }
+    {
+#if defined(HAVE_TOKYOCABINET)
+        h->db = tchdbnew();
+        if (!tchdbopen(h->db, path, HDBOWRITER | HDBOCREAT)) {
+            tchdbdel(h->db);
+            h->db = NULL;
+        }
+#elif defined(HAVE_GDBM)
+        h->db = gdbm_open((char *) path, 16384, GDBM_WRCREAT, 00600, NULL);
+#endif
+    }
 
-  return data.dptr;
+    if (!h->db) {
+        p_delete(&h->folder);
+        p_delete(&h);
+    }
+    return h;
 }
 
-int
-mutt_hcache_store (void *db, const char *filename, HEADER * header,
-                   unsigned long uid_validity, ssize_t (*keylen) (const char *fn))
+void mutt_hcache_close(hcache_t **db)
 {
-  struct header_cache *h = db;
-  datum key;
-  datum data;
-  char path[_POSIX_PATH_MAX];
-  int ret;
-
-  if (!h) {
-    return -1;
-  }
-
-  m_strcpy(path, sizeof(path), h->folder);
-  strncat (path, filename, sizeof (path) - m_strlen(path));
-
-  key.dptr = path;
-  key.dsize = keylen (path);
+    if (!*db)
+        return;
 
-  data.dptr = mutt_hcache_dump (db, header, &data.dsize, uid_validity);
-
-  ret = gdbm_store (h->db, key, data, GDBM_REPLACE);
-
-  p_delete(&data.dptr);
+#if defined(HAVE_TOKYOCABINET)
+    tchdbdel((*db)->db);
+    (*db)->db = NULL;
+#elif defined(HAVE_GDBM)
+    gdbm_close((*db)->db);
+#endif
 
-  return ret;
+    p_delete(&(*db)->folder);
+    p_delete(db);
 }
 
-int
-mutt_hcache_delete (void *db, const char *filename,
-                    ssize_t (*keylen) (const char *fn))
+void *mutt_hcache_fetch(hcache_t *db, const char *filename,
+                        ssize_t (*keylen)(const char *fn))
 {
-  datum key;
-  struct header_cache *h = db;
-  char path[_POSIX_PATH_MAX];
-
-  if (!h) {
-    return -1;
-  }
+    char path[_POSIX_PATH_MAX];
+    char *data = NULL;
 
-  m_strcpy(path, sizeof(path), h->folder);
-  strncat (path, filename, sizeof (path) - m_strlen(path));
+    if (!db)
+        return NULL;
 
-  key.dptr = path;
-  key.dsize = keylen (path);
-
-  return gdbm_delete (h->db, key);
-}
-#elif defined(HAVE_DB4)
-
-static void mutt_hcache_dbt_init (DBT * dbt, void *data, ssize_t len)
-{
-  dbt->data = data;
-  dbt->size = dbt->ulen = len;
-  dbt->dlen = dbt->doff = 0;
-  dbt->flags = DB_DBT_USERMEM;
-}
+    snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 
-static void mutt_hcache_dbt_empty_init (DBT * dbt)
-{
-  dbt->data = NULL;
-  dbt->size = dbt->ulen = dbt->dlen = dbt->doff = 0;
-  dbt->flags = 0;
-}
+    {
+        int ksize = keylen(path);
+#if defined(HAVE_TOKYOCABINET)
+        int unused;
+        data  = tchdbget(db->db, path, ksize, &unused);
+#elif defined(HAVE_GDBM)
+        datum k = { .dptr = path, .dsize = ksize };
 
-void *mutt_hcache_open (const char *path, const char *folder)
-{
-  struct stat sb;
-  u_int32_t createflags = DB_CREATE;
-  int ret;
-  struct header_cache *h = p_new(struct header_cache, 1);
-  int pagesize = atoi (HeaderCachePageSize);
-
-
-  h->crc = generate_crc32 ();
-
-  if (!path || path[0] == '\0') {
-    p_delete(&h);
-    return NULL;
-  }
-
-  path = mutt_hcache_per_folder (path, folder);
-
-  snprintf (h->lockfile, _POSIX_PATH_MAX, "%s-lock-hack", path);
-
-  h->fd = open (h->lockfile, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
-  if (h->fd < 0) {
-    p_delete(&h);
-    return NULL;
-  }
-
-  if (mx_lock_file (h->lockfile, h->fd, 1, 0, 5)) {
-    close (h->fd);
-    p_delete(&h);
-    return NULL;
-  }
-
-  ret = db_env_create (&h->env, 0);
-  if (ret) {
-    mx_unlock_file (h->lockfile, h->fd, 0);
-    close (h->fd);
-    p_delete(&h);
-    return NULL;
-  }
-
-  ret =
-    (h->env->open)(h->env, NULL, DB_INIT_MPOOL | DB_CREATE | DB_PRIVATE, 0600);
-  if (!ret) {
-    ret = db_create (&h->db, h->env, 0);
-    if (ret) {
-      h->env->close (h->env, 0);
-      mx_unlock_file (h->lockfile, h->fd, 0);
-      close (h->fd);
-      p_delete(&h);
-      return NULL;
+        data = gdbm_fetch(db->db, k).dtpr;
+#endif
     }
-  }
-
-  if (stat (path, &sb) != 0 && errno == ENOENT) {
-    createflags |= DB_EXCL;
-    h->db->set_pagesize (h->db, pagesize);
-  }
-
-  ret = (h->db->open)(h->db, NULL, path, folder, DB_BTREE, createflags, 0600);
-  if (ret) {
-    h->db->close (h->db, 0);
-    h->env->close (h->env, 0);
-    mx_unlock_file (h->lockfile, h->fd, 0);
-    close (h->fd);
-    p_delete(&h);
-    return NULL;
-  }
-
-  return h;
-}
-
-void mutt_hcache_close (void *db)
-{
-  struct header_cache *h = db;
 
-  if (!h) {
-    return;
-  }
+    if (data) {
+        unsigned crc = 0;
 
-  h->db->close (h->db, 0);
-  h->env->close (h->env, 0);
-  mx_unlock_file (h->lockfile, h->fd, 0);
-  close (h->fd);
-  p_delete(&h);
-}
-
-void *mutt_hcache_fetch (void *db, const char *filename,
-                         ssize_t (*keylen) (const char *fn))
-{
-  DBT key;
-  DBT data;
-  struct header_cache *h = db;
-
-  if (!h) {
-    return NULL;
-  }
-
-  filename++;                   /* skip '/' */
-
-  mutt_hcache_dbt_init (&key, (void *) filename, keylen (filename));
-  mutt_hcache_dbt_empty_init (&data);
-  data.flags = DB_DBT_MALLOC;
-
-  h->db->get (h->db, NULL, &key, &data, 0);
-
-  if (!crc32_matches (data.data, h->crc)) {
-    p_delete(&data.data);
-    return NULL;
-  }
+        restore_int(data + sizeof(long), (int *)&crc);
+        if (crc != db->crc)
+            p_delete(&data);
+    }
 
-  return data.data;
+    return data;
 }
 
-int
-mutt_hcache_store (void *db, const char *filename, HEADER * header,
-                   unsigned long uid_validity, ssize_t (*keylen) (const char *fn))
+int mutt_hcache_store(hcache_t *db, const char *filename, HEADER *header,
+                      long uid_validity, ssize_t (*keylen)(const char *fn))
 {
-  DBT key;
-  DBT data;
-  int ret;
-  struct header_cache *h = db;
+    char path[_POSIX_PATH_MAX];
+    buffer_t *data;
+    int ret;
 
-  if (!h) {
-    return -1;
-  }
+    if (!db)
+        return -1;
 
-  filename++;                   /* skip '/' */
+    snprintf(path, sizeof(path), "%s%s", db->folder, filename);
+    data = mutt_hcache_dump(db, header, uid_validity);
 
-  mutt_hcache_dbt_init (&key, (void *) filename, keylen (filename));
-
-  mutt_hcache_dbt_empty_init (&data);
-  data.flags = DB_DBT_USERMEM;
-  data.data =
-    mutt_hcache_dump (db, header, (signed int *) &data.size, uid_validity);
-  data.ulen = data.size;
-
-  ret = h->db->put (h->db, NULL, &key, &data, 0);
+    {
+        int ksize = keylen(path);
+#if defined(HAVE_TOKYOCABINET)
+        ret = !!tchdbput(db->db, path, ksize, data->data, data->len) - 1;
+#elif defined(HAVE_GDBM)
+        datum k = { .dptr = path, .dsize = ksize };
+        datum v = { .dptr = data->data, .dsize = data->len };
 
-  p_delete(&data.data);
+        ret = gdbm_store(db->db, k, v, GDBM_REPLACE);
+#endif
+    }
 
-  return ret;
+    buffer_delete(&data);
+    return ret;
 }
 
-int
-mutt_hcache_delete (void *db, const char *filename,
-                    ssize_t (*keylen) (const char *fn))
+void mutt_hcache_delete(hcache_t *db, const char *filename,
+                       ssize_t (*keylen)(const char *fn))
 {
-  DBT key;
-  struct header_cache *h = db;
+    char path[_POSIX_PATH_MAX];
 
-  if (!h) {
-    return -1;
-  }
+    if (!db)
+        return;
 
-  filename++;                   /* skip '/' */
+    snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 
-  mutt_hcache_dbt_init (&key, (void *) filename, keylen (filename));
-  return h->db->del (h->db, NULL, &key, 0);
-}
+    {
+        int ksize = keylen(path);
+#if defined(HAVE_TOKYOCABINET)
+        tchdbout(db->db, path, ksize);
+#elif defined(HAVE_GDBM)
+        datum k = { .dptr = path, .dsize = ksize };
+        gdbm_delete(db->db, k);
 #endif
+    }
+}
 
 #endif /* USE_HCACHE */