lib-mx/hcache.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 2004 Thomas Glanzmann <sithglan@stud.uni-erlangen.de>
   4  * Copyright (C) 2004 Tobias Werth <sitowert@stud.uni-erlangen.de>
   5  * Copyright (C) 2004 Brian Fundakowski Feldman <green@FreeBSD.org>
   6  *
   7  * This file is part of mutt-ng, see http://www.muttng.org/.
   8  * It's licensed under the GNU General Public License,
   9  * please see the file GPL in the top level source directory.
  10  */
  11
  12 #include <lib-lib/lib-lib.h>
  13
  14 #ifdef USE_HCACHE
  15
  16 #if defined(HAVE_QDBM)
  17 #include <depot.h>
  18 #include <cabin.h>
  19 #include <villa.h>
  20 #elif defined(HAVE_GDBM)
  21 #include <gdbm.h>
  22 #else
  23 #error neither HAVE_QDBM nor HAVE_GDBM are set ?!
  24 #endif
  25
  26 #include "charset.h"
  27 #include "mutt.h"
  28 #include "hcache.h"
  29
  30 struct hcache_t {
  31 #if defined(HAVE_QDBM)
  32     VILLA *db;
  33 #elif defined(HAVE_GDBM)
  34     GDBM_FILE db;
  35 #endif
  36     char *folder;
  37     unsigned int crc;
  38 };
  39
  40 static unsigned int crc32(unsigned int crc, const void *src, ssize_t len)
  41 {
  42     int i;
  43     const unsigned char *p = src;
  44
  45     while (len--) {
  46         crc ^= *p++;
  47         for (i = 0; i < 8; i++)
  48             crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
  49     }
  50     return crc;
  51 }
  52
  53 static int generate_crc32(void)
  54 {
  55     static int crc = 0;
  56
  57     crc = crc32(crc, "madmutt.2007.05.13", m_strlen("madmutt.2007.05.13"));
  58 #ifdef HAVE_LANGINFO_CODESET
  59     crc = crc32(crc, MCharset.charset, m_strlen(MCharset.charset));
  60     crc = crc32(crc, "HAVE_LANGINFO_CODESET",
  61                 m_strlen("HAVE_LANGINFO_CODESET"));
  62 #endif
  63     crc = crc32(crc, "USE_POP",   m_strlen("USE_POP"));
  64     crc = crc32(crc, "MIXMASTER", m_strlen("MIXMASTER"));
  65     crc = crc32(crc, "USE_IMAP",  m_strlen("USE_IMAP"));
  66 #ifdef USE_NNTP
  67     crc = crc32(crc, "USE_NNTP",  m_strlen("USE_NNTP"));
  68 #endif
  69     return crc;
  70 }
  71
  72 static const char *
  73 mutt_hcache_per_folder(const char *path, const char *folder)
  74 {
  75     static char buf[_POSIX_PATH_MAX];
  76     struct stat st;
  77     int pos;
  78
  79     if (stat(path, &st) < 0 || !S_ISDIR(st.st_mode)) {
  80         return path;
  81     }
  82
  83     pos  = m_strcpy(buf, sizeof(buf), path);
  84     pos += m_strputc(buf + pos, sizeof(buf) - pos, '/');
  85
  86     while (*folder) {
  87         if (isalnum((unsigned char)*folder) || *folder == '.') {
  88             pos += m_strputc(buf + pos, sizeof(buf) - pos, *folder);
  89         } else {
  90             pos += m_strputc(buf + pos, sizeof(buf) - pos, '_');
  91         }
  92         folder++;
  93     }
  94     pos += m_strcpy(buf + pos, sizeof(buf) - pos, ".hdb");
  95     return buf;
  96 }
  97
  98 /* store and restore things {{{ */
  99
 100 static const void *restore_int(const char *d, int *i)
 101 {
 102     memcpy(i, d, sizeof(*i));
 103     return d + sizeof(*i);
 104 }
 105
 106 static void dump_cstr(buffer_t *buf, const char *s)
 107 {
 108     int size = 0;
 109
 110     if (m_strisempty(s)) {
 111         buffer_add(buf, &size, sizeof(size));
 112         return;
 113     }
 114
 115     size = strlen(s) + 1;
 116     buffer_add(buf, &size, sizeof(size));
 117     buffer_add(buf, s, size);
 118 }
 119
 120 static const void *restore_cstr(const char *d, char **c)
 121 {
 122     int size;
 123
 124     d  = restore_int(d, &size);
 125     *c = p_dup(d, size);
 126     return d + size;
 127 }
 128
 129 static void dump_address(buffer_t *buf, address_t *a)
 130 {
 131     int counter = 0, pos = buf->len;
 132
 133     buffer_add(buf, &counter, sizeof(counter));
 134
 135     for (; a; a = a->next, counter++) {
 136         dump_cstr(buf, a->personal);
 137         dump_cstr(buf, a->mailbox);
 138         buffer_add(buf, &a->group, sizeof(a->group));
 139     }
 140
 141     memcpy(buf->data + pos, &counter, sizeof(counter));
 142 }
 143
 144 static const void *restore_address(const char *d, address_t **a)
 145 {
 146     int counter;
 147
 148     d = restore_int(d, &counter);
 149
 150     for (; counter > 0; counter--) {
 151         *a = address_new();
 152         d = restore_cstr(d, &(*a)->personal);
 153         d = restore_cstr(d, &(*a)->mailbox);
 154         d = restore_int(d, &(*a)->group);
 155         a = &(*a)->next;
 156     }
 157
 158     *a = NULL;
 159     return d;
 160 }
 161
 162 static void dump_list(buffer_t *buf, string_list_t *l)
 163 {
 164     int pos = buf->len;
 165     int counter = 0;
 166
 167     buffer_add(buf, &counter, sizeof(counter));
 168
 169     for (; l; l = l->next, counter++) {
 170         dump_cstr(buf, l->data);
 171     }
 172
 173     memcpy(buf->data + pos, &counter, sizeof(counter));
 174 }
 175
 176 static const void *restore_list(const char *d, string_list_t **l)
 177 {
 178     int counter;
 179
 180     d = restore_int(d, &counter);
 181
 182     for (; counter > 0; counter--) {
 183         *l = string_item_new();
 184         d = restore_cstr(d, &(*l)->data);
 185         l = &(*l)->next;
 186     }
 187
 188     *l = NULL;
 189     return d;
 190 }
 191
 192 static void dump_parameter(buffer_t *buf, parameter_t *p)
 193 {
 194     int pos = buf->len, counter = 0;
 195
 196     buffer_add(buf, &counter, sizeof(counter));
 197
 198     for (; p; p = p->next, counter++) {
 199         dump_cstr(buf, p->attribute);
 200         dump_cstr(buf, p->value);
 201     }
 202
 203     memcpy(buf->data + pos, &counter, sizeof(counter));
 204 }
 205
 206 static const void *restore_parameter(const char *d, parameter_t ** p)
 207 {
 208     int counter;
 209
 210     d = restore_int(d, &counter);
 211
 212     for (; counter > 0; counter--) {
 213         *p = parameter_new();
 214         d  = restore_cstr(d, &(*p)->attribute);
 215         d  = restore_cstr(d, &(*p)->value);
 216         p  = &(*p)->next;
 217     }
 218
 219     *p = NULL;
 220     return d;
 221 }
 222
 223 static void dump_body(buffer_t *buf, BODY *b)
 224 {
 225     buffer_add(buf, b, sizeof(*b));
 226     dump_cstr(buf, b->xtype);
 227     dump_cstr(buf, b->subtype);
 228
 229     dump_parameter(buf, b->parameter);
 230
 231     dump_cstr(buf, b->description);
 232     dump_cstr(buf, b->form_name);
 233     dump_cstr(buf, b->filename);
 234     dump_cstr(buf, b->d_filename);
 235 }
 236
 237 static const void *restore_body(const char *d, BODY *c)
 238 {
 239     memcpy(c, d, sizeof(*c));
 240     d += sizeof(*c);
 241
 242     d = restore_cstr(d, &c->xtype);
 243     d = restore_cstr(d, &c->subtype);
 244
 245     d = restore_parameter(d, &c->parameter);
 246
 247     d = restore_cstr(d, &c->description);
 248     d = restore_cstr(d, &c->form_name);
 249     d = restore_cstr(d, &c->filename);
 250     d = restore_cstr(d, &c->d_filename);
 251     return d;
 252 }
 253
 254 static void dump_envelope(buffer_t *buf, ENVELOPE * e)
 255 {
 256     int n;
 257
 258     dump_address(buf, e->return_path);
 259     dump_address(buf, e->from);
 260     dump_address(buf, e->to);
 261     dump_address(buf, e->cc);
 262     dump_address(buf, e->bcc);
 263     dump_address(buf, e->sender);
 264     dump_address(buf, e->reply_to);
 265     dump_address(buf, e->mail_followup_to);
 266
 267     dump_cstr(buf, e->subject);
 268     n = e->real_subj ? e->real_subj - e->subject : -1;
 269     buffer_add(buf, &n, sizeof(n));
 270
 271     dump_cstr(buf, e->message_id);
 272     dump_cstr(buf, e->supersedes);
 273     dump_cstr(buf, e->date);
 274     dump_cstr(buf, e->x_label);
 275     dump_cstr(buf, e->list_post);
 276
 277 #ifdef USE_NNTP
 278     dump_cstr(buf, e->newsgroups);
 279     dump_cstr(buf, e->xref);
 280     dump_cstr(buf, e->followup_to);
 281     dump_cstr(buf, e->x_comment_to);
 282 #endif
 283
 284     dump_list(buf, e->references);
 285     dump_list(buf, e->in_reply_to);
 286     dump_list(buf, e->userhdrs);
 287 }
 288
 289 static const void *restore_envelope(const char *d, ENVELOPE *e)
 290 {
 291     int real_subj_off;
 292
 293     d = restore_address(d, &e->return_path);
 294     d = restore_address(d, &e->from);
 295     d = restore_address(d, &e->to);
 296     d = restore_address(d, &e->cc);
 297     d = restore_address(d, &e->bcc);
 298     d = restore_address(d, &e->sender);
 299     d = restore_address(d, &e->reply_to);
 300     d = restore_address(d, &e->mail_followup_to);
 301
 302     d = restore_cstr(d, &e->subject);
 303     d = restore_int(d, &real_subj_off);
 304     if (real_subj_off >= 0) {
 305         e->real_subj = e->subject + real_subj_off;
 306     } else {
 307         e->real_subj = NULL;
 308     }
 309     d = restore_cstr(d, &e->message_id);
 310     d = restore_cstr(d, &e->supersedes);
 311     d = restore_cstr(d, &e->date);
 312     d = restore_cstr(d, &e->x_label);
 313     d = restore_cstr(d, &e->list_post);
 314
 315 #ifdef USE_NNTP
 316     d = restore_cstr(d, &e->newsgroups);
 317     d = restore_cstr(d, &e->xref);
 318     d = restore_cstr(d, &e->followup_to);
 319     d = restore_cstr(d, &e->x_comment_to);
 320 #endif
 321
 322     d = restore_list(d, &e->references);
 323     d = restore_list(d, &e->in_reply_to);
 324     d = restore_list(d, &e->userhdrs);
 325
 326     return d;
 327 }
 328
 329 static buffer_t *mutt_hcache_dump(hcache_t *db, HEADER *h, long uid_validity)
 330 {
 331     buffer_t *res = buffer_new();
 332
 333     if (!uid_validity) {
 334         uid_validity = time(NULL);
 335     }
 336     buffer_add(res, &uid_validity, sizeof(uid_validity));
 337     buffer_add(res, &db->crc, sizeof(db->crc));
 338     buffer_add(res, h, sizeof(*h));
 339
 340     dump_envelope(res, h->env);
 341     dump_body(res, h->content);
 342     dump_cstr(res, h->maildir_flags);
 343     return res;
 344 }
 345
 346 HEADER *mutt_hcache_restore(const void *_d, HEADER **oh)
 347 {
 348     const char *d = _d;
 349     HEADER *h = header_new();
 350
 351     /* skip uid_validity + crc */
 352     d += sizeof(long) + sizeof(int);
 353
 354     memcpy(h, d, sizeof(*h));
 355     d += sizeof(*h);
 356
 357     h->env = envelope_new();
 358     d = restore_envelope(d, h->env);
 359
 360     h->content = body_new();
 361     d = restore_body(d, h->content);
 362
 363     d = restore_cstr(d, &h->maildir_flags);
 364
 365     /* this is needed for maildir style mailboxes */
 366     if (oh) {
 367         h->old = (*oh)->old;
 368         h->path = m_strdup((*oh)->path);
 369         header_delete(oh);
 370     }
 371
 372     return h;
 373 }
 374
 375 /* }}} */
 376
 377 hcache_t *mutt_hcache_open(const char *path, const char *folder)
 378 {
 379     hcache_t *h = p_new(hcache_t, 1);
 380
 381     h->folder = m_strdup(folder);
 382     h->crc = generate_crc32();
 383
 384     if (m_strisempty(path)) {
 385         p_delete(&h->folder);
 386         p_delete(&h);
 387         return NULL;
 388     }
 389
 390     path = mutt_hcache_per_folder(path, folder);
 391
 392     {
 393 #if defined(HAVE_QDBM)
 394         int flags = VL_OWRITER | VL_OCREAT;
 395         if (option(OPTHCACHECOMPRESS))
 396             flags |= VL_OZCOMP;
 397
 398         h->db = vlopen(path, flags, VL_CMPLEX);
 399 #elif defined(HAVE_GDBM)
 400         int pagesize = atoi(HeaderCachePageSize) ?: 16384;
 401
 402         h->db = gdbm_open((char *) path, pagesize, GDBM_WRCREAT, 00600, NULL);
 403 #endif
 404     }
 405
 406     if (!h->db) {
 407         p_delete(&h->folder);
 408         p_delete(&h);
 409     }
 410     return h;
 411 }
 412
 413 void mutt_hcache_close(hcache_t **db)
 414 {
 415     if (!*db)
 416         return;
 417
 418 #if defined(HAVE_QDBM)
 419     vlclose((*db)->db);
 420 #elif defined(HAVE_GDBM)
 421     gdbm_close((*db)->db);
 422 #endif
 423
 424     p_delete(&(*db)->folder);
 425     p_delete(db);
 426 }
 427
 428 void *mutt_hcache_fetch(hcache_t *db, const char *filename,
 429                         ssize_t (*keylen)(const char *fn))
 430 {
 431     char path[_POSIX_PATH_MAX];
 432     void *data = NULL;
 433
 434     if (!db)
 435         return NULL;
 436
 437     snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 438
 439     {
 440 #if defined(HAVE_QDBM)
 441         int ksize = strlen(db->folder) + keylen(path + strlen(db->folder));
 442         data  = vlget(db->db, path, ksize, NULL);
 443 #elif defined(HAVE_GDBM)
 444         datum k = { .dptr = path, .dsize = keylen(path) };
 445
 446         data = gdbm_fetch(db->db, k).dtpr;
 447 #endif
 448     }
 449
 450     if (data) {
 451         unsigned crc = 0;
 452
 453         restore_int(data + sizeof(long), (int *)&crc);
 454         if (crc != db->crc)
 455             p_delete(&data);
 456     }
 457
 458     return data;
 459 }
 460
 461 int mutt_hcache_store(hcache_t *db, const char *filename, HEADER *header,
 462                       long uid_validity, ssize_t (*keylen)(const char *fn))
 463 {
 464     char path[_POSIX_PATH_MAX];
 465     buffer_t *data;
 466     int ret;
 467
 468     if (!db)
 469         return -1;
 470
 471     snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 472     data = mutt_hcache_dump(db, header, uid_validity);
 473
 474     {
 475 #if defined(HAVE_QDBM)
 476         int ksize = strlen(db->folder) + keylen(path + strlen(db->folder));
 477
 478         ret = vlput(db->db, path, ksize, data->data, data->len, VL_DOVER);
 479 #elif defined(HAVE_GDBM)
 480         datum k = { .dptr = path, .dsize = keylen(path) };
 481         datum v = { .dptr = data->data, .dsize = data->len };
 482
 483         ret = gdbm_store(db->db, k, v, GDBM_REPLACE);
 484 #endif
 485     }
 486
 487     buffer_delete(&data);
 488     return ret;
 489 }
 490
 491 int mutt_hcache_delete(hcache_t *db, const char *filename,
 492                        ssize_t (*keylen)(const char *fn))
 493 {
 494     char path[_POSIX_PATH_MAX];
 495
 496     if (!db)
 497         return -1;
 498
 499     snprintf(path, sizeof(path), "%s%s", db->folder, filename);
 500
 501     {
 502 #if defined(HAVE_QDBM)
 503         int ksize = strlen(db->folder) + keylen(path + strlen(db->folder));
 504         return vlout(db->db, path, ksize);
 505 #elif defined(HAVE_GDBM)
 506         datum k = { .dptr = path, .dsize = keylen(path) };
 507         return gdbm_delete(db->db, k);
 508 #endif
 509     }
 510 }
 511
 512 #endif /* USE_HCACHE */