NeoMutt  2021-02-05-666-ge300cd
Teaching an old dog new tricks
DOXYGEN
lib.h File Reference

Header cache multiplexor. More...

#include <stddef.h>
#include <stdint.h>
+ Include dependency graph for lib.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  HeaderCache
 header cache structure More...
 
struct  HCacheEntry
 Wrapper for Email retrieved from the header cache. More...
 

Typedefs

typedef void(* hcache_namer_t) (const char *path, struct Buffer *dest)
 Prototype for function to compose hcache file names. More...
 

Functions

struct HeaderCachemutt_hcache_open (const char *path, const char *folder, hcache_namer_t namer)
 open the connection to the header cache More...
 
void mutt_hcache_close (struct HeaderCache *hc)
 close the connection to the header cache More...
 
int mutt_hcache_store (struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
 store a Header along with a validity datum More...
 
struct HCacheEntry mutt_hcache_fetch (struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
 fetch and validate a message's header from the cache More...
 
int mutt_hcache_store_raw (struct HeaderCache *hc, const char *key, size_t keylen, void *data, size_t dlen)
 store a key / data pair More...
 
void * mutt_hcache_fetch_raw (struct HeaderCache *hc, const char *key, size_t keylen, size_t *dlen)
 Fetch a message's header from the cache. More...
 
void mutt_hcache_free_raw (struct HeaderCache *hc, void **data)
 free data fetched with mutt_hcache_fetch_raw() More...
 
int mutt_hcache_delete_record (struct HeaderCache *hc, const char *key, size_t keylen)
 delete a key / data pair More...
 

Detailed Description

Header cache multiplexor.

Authors
  • Thomas Glanzmann
  • Tobias Werth
  • Brian Fundakowski Feldman
  • Pietro Cerutti
  • Tino Reichardt

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file lib.h.

Typedef Documentation

◆ hcache_namer_t

typedef void(* hcache_namer_t) (const char *path, struct Buffer *dest)

Prototype for function to compose hcache file names.

Parameters
pathPath of message
destBuffer for filename

Definition at line 107 of file lib.h.

Function Documentation

◆ mutt_hcache_open()

struct HeaderCache* mutt_hcache_open ( const char *  path,
const char *  folder,
hcache_namer_t  namer 
)

open the connection to the header cache

Parameters
pathLocation of the header cache (often as specified by the user)
folderName of the folder containing the messages
namerOptional (might be NULL) client-specific function to form the final name of the hcache database file.
Return values
ptrSuccess, struct HeaderCache struct
NULLOtherwise

open the connection to the header cache

Definition at line 332 of file hcache.c.

333 {
334  const char *const c_header_cache_backend =
335  cs_subset_string(NeoMutt->sub, "header_cache_backend");
336  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
337  if (!ops)
338  return NULL;
339 
340  struct HeaderCache *hc = mutt_mem_calloc(1, sizeof(struct HeaderCache));
341 
342  /* Calculate the current hcache version from dynamic configuration */
343  if (hcachever == 0x0)
344  {
345  union
346  {
347  unsigned char charval[16];
348  unsigned int intval;
349  } digest;
350  struct Md5Ctx md5ctx;
351 
352  hcachever = HCACHEVER;
353 
354  mutt_md5_init_ctx(&md5ctx);
355 
356  /* Seed with the compiled-in header structure hash */
357  mutt_md5_process_bytes(&hcachever, sizeof(hcachever), &md5ctx);
358 
359  /* Mix in user's spam list */
360  struct Replace *sp = NULL;
361  STAILQ_FOREACH(sp, &SpamList, entries)
362  {
363  mutt_md5_process(sp->regex->pattern, &md5ctx);
364  mutt_md5_process(sp->templ, &md5ctx);
365  }
366 
367  /* Mix in user's nospam list */
368  struct RegexNode *np = NULL;
369  STAILQ_FOREACH(np, &NoSpamList, entries)
370  {
371  mutt_md5_process(np->regex->pattern, &md5ctx);
372  }
373 
374  /* Get a hash and take its bytes as an (unsigned int) hash version */
375  mutt_md5_finish_ctx(&md5ctx, digest.charval);
376  hcachever = digest.intval;
377  }
378 
379 #ifdef USE_HCACHE_COMPRESSION
380  const char *const c_header_cache_compress_method =
381  cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
382  if (c_header_cache_compress_method)
383  {
384  const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
385 
386  const short c_header_cache_compress_level =
387  cs_subset_number(NeoMutt->sub, "header_cache_compress_level");
388  hc->cctx = cops->open(c_header_cache_compress_level);
389  if (!hc->cctx)
390  {
391  FREE(&hc);
392  return NULL;
393  }
394 
395  /* remember the buffer of database backend */
396  mutt_debug(LL_DEBUG3, "Header cache will use %s compression\n", cops->name);
397  }
398 #endif
399 
400  hc->folder = get_foldername(folder);
401  hc->crc = hcachever;
402 
403  if (!path || (path[0] == '\0'))
404  {
405  FREE(&hc->folder);
406  FREE(&hc);
407  return NULL;
408  }
409 
410  struct Buffer *hcpath = mutt_buffer_pool_get();
411  hcache_per_folder(hcpath, path, hc->folder, namer);
412 
413  hc->ctx = ops->open(mutt_buffer_string(hcpath));
414  if (!hc->ctx)
415  {
416  /* remove a possibly incompatible version */
417  if (unlink(mutt_buffer_string(hcpath)) == 0)
418  {
419  hc->ctx = ops->open(mutt_buffer_string(hcpath));
420  if (!hc->ctx)
421  {
422  FREE(&hc->folder);
423  FREE(&hc);
424  }
425  }
426  }
427 
428  mutt_buffer_pool_release(&hcpath);
429  return hc;
430 }
char * templ
Template to match.
Definition: regex3.h:113
void * cctx
Definition: lib.h:89
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
Cursor for the MD5 hashing.
Definition: md5.h:36
const struct ComprOps * compress_get_ops(const char *compr)
Get the API functions for a compress backend.
Definition: compress.c:80
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
void mutt_md5_process(const char *str, struct Md5Ctx *md5ctx)
Process a NULL-terminated string.
Definition: md5.c:355
header cache structure
Definition: lib.h:84
String manipulation buffer.
Definition: buffer.h:33
void mutt_md5_init_ctx(struct Md5Ctx *md5ctx)
Initialise the MD5 computation.
Definition: md5.c:262
static char * get_foldername(const char *folder)
Where should the cache be stored?
Definition: hcache.c:318
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
const char * name
Compression name.
Definition: lib.h:61
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
Container for Accounts, Notifications.
Definition: neomutt.h:36
List of regular expressions.
Definition: regex3.h:109
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:111
unsigned int crc
Definition: lib.h:87
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
void * mutt_md5_finish_ctx(struct Md5Ctx *md5ctx, void *resbuf)
Process the remaining bytes in the buffer.
Definition: md5.c:286
void *(* open)(const char *path)
Definition: lib.h:80
struct RegexList NoSpamList
List of regexes to whitelist non-spam emails.
Definition: globals.c:33
static void hcache_per_folder(struct Buffer *hcpath, const char *path, const char *folder, hcache_namer_t namer)
Generate the hcache pathname.
Definition: hcache.c:260
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:101
static unsigned int hcachever
Definition: hcache.c:63
void *(* open)(short level)
Definition: lib.h:74
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
List of regular expressions.
Definition: regex3.h:99
struct ReplaceList SpamList
List of regexes and patterns to match spam emails.
Definition: globals.c:34
void mutt_md5_process_bytes(const void *buf, size_t buflen, struct Md5Ctx *md5ctx)
Process a block of data.
Definition: md5.c:373
Definition: lib.h:59
#define FREE(x)
Definition: memory.h:40
char * folder
Definition: lib.h:86
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
char * pattern
printable version
Definition: regex3.h:91
Log at debug level 3.
Definition: logging.h:42
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_close()

void mutt_hcache_close ( struct HeaderCache hc)

close the connection to the header cache

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()

close the connection to the header cache

Definition at line 435 of file hcache.c.

436 {
437  const char *const c_header_cache_backend =
438  cs_subset_string(NeoMutt->sub, "header_cache_backend");
439  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
440  if (!hc || !ops)
441  return;
442 
443 #ifdef USE_HCACHE_COMPRESSION
444  const char *const c_header_cache_compress_method =
445  cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
446  if (c_header_cache_compress_method)
447  {
448  const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
449  cops->close(&hc->cctx);
450  }
451 #endif
452 
453  ops->close(&hc->ctx);
454  FREE(&hc->folder);
455  FREE(&hc);
456 }
void * cctx
Definition: lib.h:89
const struct ComprOps * compress_get_ops(const char *compr)
Get the API functions for a compress backend.
Definition: compress.c:80
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
Container for Accounts, Notifications.
Definition: neomutt.h:36
void(* close)(void **ptr)
Definition: lib.h:141
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
Definition: lib.h:59
void(* close)(void **cctx)
Definition: lib.h:119
#define FREE(x)
Definition: memory.h:40
char * folder
Definition: lib.h:86
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_store()

int mutt_hcache_store ( struct HeaderCache hc,
const char *  key,
size_t  keylen,
struct Email e,
uint32_t  uidvalidity 
)

store a Header along with a validity datum

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
keyMessage identification string
keylenLength of the key string
eEmail to store
uidvalidityIMAP-specific UIDVALIDITY value, or 0 to use the current time
Return values
0Success
numGeneric or backend-specific error code otherwise

store a Header along with a validity datum

Definition at line 556 of file hcache.c.

558 {
559  if (!hc)
560  return -1;
561 
562  int dlen = 0;
563  char *data = dump(hc, e, &dlen, uidvalidity);
564 
565 #ifdef USE_HCACHE_COMPRESSION
566  const char *const c_header_cache_compress_method =
567  cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
568  if (c_header_cache_compress_method)
569  {
570  /* We don't compress uidvalidity and the crc, so we can check them before
571  * decompressing on fetch(). */
572  size_t hlen = header_size();
573 
574  const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
575 
576  /* data / dlen gets ptr to compressed data here */
577  size_t clen = dlen;
578  void *cdata = cops->compress(hc->cctx, data + hlen, dlen - hlen, &clen);
579  if (!cdata)
580  {
581  FREE(&data);
582  return -1;
583  }
584 
585  char *whole = mutt_mem_malloc(hlen + clen);
586  memcpy(whole, data, hlen);
587  memcpy(whole + hlen, cdata, clen);
588 
589  FREE(&data);
590 
591  data = whole;
592  dlen = hlen + clen;
593  }
594 #endif
595 
596  /* store uncompressed data */
597  struct RealKey *rk = realkey(key, keylen);
598  int rc = mutt_hcache_store_raw(hc, rk->key, rk->len, data, dlen);
599 
600  FREE(&data);
601 
602  return rc;
603 }
void * cctx
Definition: lib.h:89
static struct RealKey * realkey(const char *key, size_t keylen)
Compute the real key used in the backend, taking into account the compression method.
Definition: hcache.c:189
const struct ComprOps * compress_get_ops(const char *compr)
Get the API functions for a compress backend.
Definition: compress.c:80
size_t len
Definition: hcache.c:180
static size_t header_size(void)
Compute the size of the header with uuid validity and crc.
Definition: hcache.c:69
void *(* compress)(void *cctx, const char *data, size_t dlen, size_t *clen)
Definition: lib.h:91
Container for Accounts, Notifications.
Definition: neomutt.h:36
static void * dump(struct HeaderCache *hc, const struct Email *e, int *off, uint32_t uidvalidity)
Serialise an Email object.
Definition: hcache.c:85
char key[1024]
Definition: hcache.c:179
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
Definition: lib.h:59
#define FREE(x)
Definition: memory.h:40
int mutt_hcache_store_raw(struct HeaderCache *hc, const char *key, size_t keylen, void *data, size_t dlen)
store a key / data pair
Definition: hcache.c:615
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_fetch()

struct HCacheEntry mutt_hcache_fetch ( struct HeaderCache hc,
const char *  key,
size_t  keylen,
uint32_t  uidvalidity 
)

fetch and validate a message's header from the cache

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
keyMessage identification string
keylenLength of the string pointed to by key
uidvalidityOnly restore if it matches the stored uidvalidity
Return values
objHCacheEntry containing an Email, empty on failure
Note
This function performs a check on the validity of the data found by comparing it with the crc value of the struct HeaderCache structure.

fetch and validate a message's header from the cache

Definition at line 461 of file hcache.c.

463 {
464  struct RealKey *rk = realkey(key, keylen);
465  struct HCacheEntry entry = { 0 };
466 
467  size_t dlen;
468  void *data = mutt_hcache_fetch_raw(hc, rk->key, rk->len, &dlen);
469  void *to_free = data;
470  if (!data)
471  {
472  goto end;
473  }
474 
475  /* restore uidvalidity and crc */
476  size_t hlen = header_size();
477  int off = 0;
478  serial_restore_uint32_t(&entry.uidvalidity, data, &off);
479  serial_restore_int(&entry.crc, data, &off);
480  assert((size_t) off == hlen);
481  if (entry.crc != hc->crc || ((uidvalidity != 0) && uidvalidity != entry.uidvalidity))
482  {
483  goto end;
484  }
485 
486 #ifdef USE_HCACHE_COMPRESSION
487  const char *const c_header_cache_compress_method =
488  cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
489  if (c_header_cache_compress_method)
490  {
491  const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
492 
493  void *dblob = cops->decompress(hc->cctx, (char *) data + hlen, dlen - hlen);
494  if (!dblob)
495  {
496  goto end;
497  }
498  data = (char *) dblob - hlen; /* restore skips uidvalidity and crc */
499  }
500 #endif
501 
502  entry.email = restore(data);
503 
504 end:
505  mutt_hcache_free_raw(hc, &to_free);
506  return entry;
507 }
void * cctx
Definition: lib.h:89
static struct RealKey * realkey(const char *key, size_t keylen)
Compute the real key used in the backend, taking into account the compression method.
Definition: hcache.c:189
Wrapper for Email retrieved from the header cache.
Definition: lib.h:95
const struct ComprOps * compress_get_ops(const char *compr)
Get the API functions for a compress backend.
Definition: compress.c:80
size_t len
Definition: hcache.c:180
static size_t header_size(void)
Compute the size of the header with uuid validity and crc.
Definition: hcache.c:69
uint32_t uidvalidity
IMAP-specific UIDVALIDITY.
Definition: lib.h:97
void serial_restore_int(unsigned int *i, const unsigned char *d, int *off)
Unpack an integer from a binary blob.
Definition: serialize.c:98
void mutt_hcache_free_raw(struct HeaderCache *hc, void **data)
Multiplexor for StoreOps::free.
Definition: hcache.c:541
Container for Accounts, Notifications.
Definition: neomutt.h:36
void serial_restore_uint32_t(uint32_t *s, const unsigned char *d, int *off)
Unpack an uint32_t from a binary blob.
Definition: serialize.c:110
unsigned int crc
Definition: lib.h:87
char key[1024]
Definition: hcache.c:179
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
Definition: lib.h:59
unsigned int crc
CRC of Email/Body/etc structs.
Definition: lib.h:98
void *(* decompress)(void *cctx, const char *cbuf, size_t clen)
Definition: lib.h:107
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
struct Email * email
Retrieved email.
Definition: lib.h:99
void * mutt_hcache_fetch_raw(struct HeaderCache *hc, const char *key, size_t keylen, size_t *dlen)
Fetch a message&#39;s header from the cache.
Definition: hcache.c:521
static struct Email * restore(const unsigned char *d)
Restore an Email from data retrieved from the cache.
Definition: hcache.c:143
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_store_raw()

int mutt_hcache_store_raw ( struct HeaderCache hc,
const char *  key,
size_t  keylen,
void *  data,
size_t  dlen 
)

store a key / data pair

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
keyMessage identification string
keylenLength of the string pointed to by key
dataPayload to associate with key
dlenLength of the buffer pointed to by the data parameter
Return values
0Success
numGeneric or backend-specific error code otherwise

Definition at line 615 of file hcache.c.

617 {
618  const char *const c_header_cache_backend =
619  cs_subset_string(NeoMutt->sub, "header_cache_backend");
620  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
621 
622  if (!hc || !ops)
623  return -1;
624 
625  struct Buffer path = mutt_buffer_make(1024);
626 
627  keylen = mutt_buffer_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
628  int rc = ops->store(hc->ctx, mutt_buffer_string(&path), keylen, data, dlen);
629  mutt_buffer_dealloc(&path);
630 
631  return rc;
632 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
Container for Accounts, Notifications.
Definition: neomutt.h:36
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
int(* store)(void *store, const char *key, size_t klen, void *value, size_t vlen)
Definition: lib.h:119
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
char * data
Pointer to data.
Definition: buffer.h:35
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
char * folder
Definition: lib.h:86
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_fetch_raw()

void* mutt_hcache_fetch_raw ( struct HeaderCache hc,
const char *  key,
size_t  keylen,
size_t *  dlen 
)

Fetch a message's header from the cache.

Parameters
[in]hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
[in]keyMessage identification string
[in]keylenLength of the string pointed to by key
[out]dlenLength of the fetched data
Return values
ptrSuccess, the data if found
NULLOtherwise
Note
This function does not perform any check on the validity of the data found.
The returned data must be free with mutt_hcache_free_raw().

Definition at line 521 of file hcache.c.

523 {
524  const char *const c_header_cache_backend =
525  cs_subset_string(NeoMutt->sub, "header_cache_backend");
526  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
527 
528  if (!hc || !ops)
529  return NULL;
530 
531  struct Buffer path = mutt_buffer_make(1024);
532  keylen = mutt_buffer_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
533  void *blob = ops->fetch(hc->ctx, mutt_buffer_string(&path), keylen, dlen);
534  mutt_buffer_dealloc(&path);
535  return blob;
536 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
void *(* fetch)(void *store, const char *key, size_t klen, size_t *vlen)
Definition: lib.h:94
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
Container for Accounts, Notifications.
Definition: neomutt.h:36
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
char * folder
Definition: lib.h:86
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_free_raw()

void mutt_hcache_free_raw ( struct HeaderCache hc,
void **  data 
)

free data fetched with mutt_hcache_fetch_raw()

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
dataPointer to the data got using mutt_hcache_fetch_raw

free data fetched with mutt_hcache_fetch_raw()

Definition at line 541 of file hcache.c.

542 {
543  const char *const c_header_cache_backend =
544  cs_subset_string(NeoMutt->sub, "header_cache_backend");
545  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
546 
547  if (!hc || !ops || !data || !*data)
548  return;
549 
550  ops->free(hc->ctx, data);
551 }
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
Container for Accounts, Notifications.
Definition: neomutt.h:36
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
void(* free)(void *store, void **ptr)
Definition: lib.h:104
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_hcache_delete_record()

int mutt_hcache_delete_record ( struct HeaderCache hc,
const char *  key,
size_t  keylen 
)

delete a key / data pair

Parameters
hcPointer to the struct HeaderCache structure got by mutt_hcache_open()
keyMessage identification string
keylenLength of the string pointed to by key
Return values
0Success
numGeneric or backend-specific error code otherwise

delete a key / data pair

Definition at line 637 of file hcache.c.

638 {
639  if (!hc)
640  return -1;
641 
642  const char *const c_header_cache_backend =
643  cs_subset_string(NeoMutt->sub, "header_cache_backend");
644  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
645 
646  struct Buffer path = mutt_buffer_make(1024);
647 
648  keylen = mutt_buffer_printf(&path, "%s%s", hc->folder, key);
649 
650  int rc = ops->delete_record(hc->ctx, mutt_buffer_string(&path), keylen);
651  mutt_buffer_dealloc(&path);
652  return rc;
653 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:107
Definition: lib.h:63
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
Container for Accounts, Notifications.
Definition: neomutt.h:36
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
int(* delete_record)(void *store, const char *key, size_t klen)
Definition: lib.h:132
char * folder
Definition: lib.h:86
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
void * ctx
Definition: lib.h:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function: