hcache.c File Reference

Header cache multiplexor. More...

#include "config.h"
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "compress/lib.h"
#include "store/lib.h"
#include "hcache/hcversion.h"
#include "muttlib.h"
#include "serialize.h"

Include dependency graph for hcache.c:

Go to the source code of this file.

Data Structures
struct	RealKey
	Hcache key name (including compression method) More...

Functions
static size_t	header_size (void)
	Compute the size of the header with uuid validity and crc. More...
static void *	dump (struct HeaderCache *hc, const struct Email *e, int *off, uint32_t uidvalidity)
	Serialise an Email object. More...
static struct Email *	restore (const unsigned char *d)
	Restore an Email from data retrieved from the cache. More...
static struct RealKey *	realkey (const char *key, size_t keylen)
	Compute the real key used in the backend, taking into account the compression method. More...
static bool	create_hcache_dir (const char *path)
	Create parent dirs for the hcache database. More...
static void	hcache_per_folder (struct Buffer *hcpath, const char *path, const char *folder, hcache_namer_t namer)
	Generate the hcache pathname. More...
static char *	get_foldername (const char *folder)
	Where should the cache be stored? More...
static void *	fetch_raw (struct HeaderCache *hc, const char *key, size_t keylen, size_t *dlen)
	Fetch a message's header from the cache. More...
static void	free_raw (struct HeaderCache *hc, void **data)
	Multiplexor for StoreOps::free. More...
struct HeaderCache *	mutt_hcache_open (const char *path, const char *folder, hcache_namer_t namer)
	Multiplexor for StoreOps::open. More...
void	mutt_hcache_close (struct HeaderCache *hc)
	Multiplexor for StoreOps::close. More...
struct HCacheEntry	mutt_hcache_fetch (struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
	Multiplexor for StoreOps::fetch. More...
bool	mutt_hcache_fetch_obj_ (struct HeaderCache *hc, const char *key, size_t keylen, void *dst, size_t dstlen)
	Fetch a message's header from the cache into a destination object. More...
char *	mutt_hcache_fetch_str (struct HeaderCache *hc, const char *key, size_t keylen)
	Fetch a string from the cache. More...
int	mutt_hcache_store (struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
	Multiplexor for StoreOps::store. 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...
int	mutt_hcache_delete_record (struct HeaderCache *hc, const char *key, size_t keylen)
	Multiplexor for StoreOps::delete_record. More...

Variables
static unsigned int	HcacheVer = 0x0
	Header Cache version. More...

Detailed Description

Header cache multiplexor.

Authors

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

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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 hcache.c.

Function Documentation

header_size()

static size_t header_size ( void  )

static

Compute the size of the header with uuid validity and crc.

Return values

num	Size of the header

Definition at line 70 of file hcache.c.

{
  return sizeof(int) + sizeof(uint32_t);
}

Here is the caller graph for this function:

dump()

static void * dump ( struct HeaderCache *  hc, const struct Email *  e, int *  off, uint32_t  uidvalidity  )

static

Serialise an Email object.

Parameters

hc	Header cache handle
e	Email to serialise
off	Size of the binary blob
uidvalidity	IMAP server identifier

Return values

ptr	Binary blob representing the Email

This function transforms an Email into a binary string so that it can be saved to a database.

Definition at line 86 of file hcache.c.

{
  struct Email e_dump;
  bool convert = !CharsetIsUtf8;
 
  *off = 0;
  unsigned char *d = mutt_mem_malloc(4096);
 
  d = serial_dump_uint32_t((uidvalidity != 0) ? uidvalidity : mutt_date_now(), d, off);
  d = serial_dump_int(hc->crc, d, off);
 
  assert((size_t) *off == header_size());
 
  lazy_realloc(&d, *off + sizeof(struct Email));
  memcpy(&e_dump, e, sizeof(struct Email));
 
  /* some fields are not safe to cache */
  e_dump.tagged = false;
  e_dump.changed = false;
  e_dump.threaded = false;
  e_dump.recip_valid = false;
  e_dump.searched = false;
  e_dump.matched = false;
  e_dump.collapsed = false;
  e_dump.visible = true;
  e_dump.num_hidden = 0;
  e_dump.recipient = 0;
  e_dump.attr_color = NULL;
  e_dump.attach_valid = false;
  e_dump.path = NULL;
  e_dump.tree = NULL;
  e_dump.thread = NULL;
  e_dump.sequence = 0;
  e_dump.notify = NULL;
  STAILQ_INIT(&e_dump.tags);
#ifdef MIXMASTER
  STAILQ_INIT(&e_dump.chain);
#endif
  e_dump.edata = NULL;
 
  memcpy(d + *off, &e_dump, sizeof(struct Email));
  *off += sizeof(struct Email);
 
  d = serial_dump_envelope(e_dump.env, d, off, convert);
  d = serial_dump_body(e_dump.body, d, off, convert);
  d = serial_dump_tags(&e->tags, d, off);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

restore()

static struct Email * restore ( const unsigned char *  d )

static

Restore an Email from data retrieved from the cache.

Parameters

d	Data retrieved using mutt_hcache_dump

Return values

ptr	Success, the restored header (can't be NULL)

Note

The returned Email must be free'd by caller code with email_free()

Definition at line 144 of file hcache.c.

{
  int off = 0;
  struct Email *e = email_new();
  bool convert = !CharsetIsUtf8;
 
  /* skip validate */
  off += sizeof(uint32_t);
 
  /* skip crc */
  off += sizeof(unsigned int);
 
  size_t sequence = e->sequence;
  struct Notify *notify = e->notify;
  memcpy(e, d + off, sizeof(struct Email));
  off += sizeof(struct Email);
  e->sequence = sequence;
  e->notify = notify;
 
  STAILQ_INIT(&e->tags);
#ifdef MIXMASTER
  STAILQ_INIT(&e->chain);
#endif
 
  e->env = mutt_env_new();
  serial_restore_envelope(e->env, d, &off, convert);
 
  e->body = mutt_body_new();
  serial_restore_body(e->body, d, &off, convert);
  serial_restore_tags(&e->tags, d, &off);
 
  return e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

realkey()

static struct RealKey * realkey ( const char *  key, size_t  keylen  )

static

Compute the real key used in the backend, taking into account the compression method.

Parameters

key	Original key
keylen	Length of original key

Return values

ptr	Static location holding data and length of the real key

Definition at line 193 of file hcache.c.

{
  static struct RealKey rk;
#ifdef USE_HCACHE_COMPRESSION
  const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
  if (c_header_cache_compress_method)
  {
    const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
 
    rk.len = snprintf(rk.key, sizeof(rk.key), "%s-%s", key, cops->name);
  }
  else
#endif
  {
    memcpy(rk.key, key, keylen + 1); // Including NUL byte
    rk.len = keylen;
  }
  return &rk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_hcache_dir()

static bool create_hcache_dir ( const char *  path )

static

Create parent dirs for the hcache database.

Parameters

path	Database filename

Return values

true	Success
false	Failure (errno set)

Definition at line 219 of file hcache.c.

{
  char *dir = mutt_str_dup(path);
  if (!dir)
    return false;
 
  char *p = strrchr(dir, '/');
  if (!p)
  {
    FREE(&dir);
    return true;
  }
 
  *p = '\0';
 
  int rc = mutt_file_mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO);
  if (rc != 0)
    mutt_error(_("Can't create %s: %s"), dir, strerror(errno));
 
  FREE(&dir);
  return (rc == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

hcache_per_folder()

static void hcache_per_folder ( struct Buffer *  hcpath, const char *  path, const char *  folder, hcache_namer_t  namer  )

static

Generate the hcache pathname.

Parameters

hcpath	Buffer for the result
path	Base directory, from $header_cache
folder	Mailbox name (including protocol)
namer	Callback to generate database filename - Implements hcache_namer_t

Generate the pathname for the hcache database, it will be of the form: BASE/FOLDER/NAME

• BASE: Base directory (path)
• FOLDER: Mailbox name (folder)
• NAME: Create by namer, or md5sum of folder

This function will create any parent directories needed, so the caller just needs to create the database file.

If path exists and is a directory, it is used. If path has a trailing '/' it is assumed to be a directory. Otherwise path is assumed to be a file.

Definition at line 263 of file hcache.c.

{
  struct stat st = { 0 };
 
  int plen = mutt_str_len(path);
  int rc = stat(path, &st);
  bool slash = (path[plen - 1] == '/');
 
  if (((rc == 0) && !S_ISDIR(st.st_mode)) || ((rc == -1) && !slash))
  {
    /* An existing file or a non-existing path not ending with a slash */
    mutt_encode_path(hcpath, path);
    create_hcache_dir(buf_string(hcpath));
    return;
  }
 
  /* We have a directory - no matter whether it exists, or not */
  struct Buffer *hcfile = buf_pool_get();
  if (namer)
  {
    namer(folder, hcfile);
    buf_concat_path(hcpath, path, buf_string(hcfile));
  }
  else
  {
    unsigned char m[16]; /* binary md5sum */
    struct Buffer *name = buf_pool_get();
 
    const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
    const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
    if (!ops)
      return;
 
#ifdef USE_HCACHE_COMPRESSION
    const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
    const char *cm = c_header_cache_compress_method;
    buf_printf(name, "%s|%s%s", ops->name, folder, cm ? cm : "");
#else
    buf_printf(name, "%s|%s", ops->name, folder);
#endif
    mutt_md5(buf_string(name), m);
    buf_reset(name);
    mutt_md5_toascii(m, name->data);
    buf_printf(hcpath, "%s%s%s", path, slash ? "" : "/", buf_string(name));
    buf_pool_release(&name);
  }
 
  mutt_encode_path(hcpath, buf_string(hcpath));
  create_hcache_dir(buf_string(hcpath));
  buf_pool_release(&hcfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_foldername()

static char * get_foldername ( const char *  folder )

static

Where should the cache be stored?

Parameters

folder

Path to be canonicalised

Return values

ptr	New string with canonical path

Definition at line 321 of file hcache.c.

{
  /* if the folder is local, canonify the path to avoid
   * to ensure equivalent paths share the hcache */
  char *p = mutt_mem_malloc(PATH_MAX + 1);
  if (!realpath(folder, p))
    mutt_str_replace(&p, folder);
 
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_raw()

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

static

Fetch a message's header from the cache.

Parameters

[in]	hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()
[in]	key	Message identification string
[in]	keylen	Length of the string pointed to by key
[out]	dlen	Length of the fetched data

Return values

ptr	Success, the data if found
NULL	Otherwise

Note

This function does not perform any check on the validity of the data found.

The returned data must be free with free_raw().

Definition at line 344 of file hcache.c.

{
  if (!hc)
    return NULL;
 
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
 
  if (!ops)
    return NULL;
 
  struct Buffer path = buf_make(1024);
  keylen = buf_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
  void *blob = ops->fetch(hc->ctx, buf_string(&path), keylen, dlen);
  buf_dealloc(&path);
  return blob;
}

Here is the call graph for this function:

Here is the caller graph for this function:

free_raw()

static void free_raw ( struct HeaderCache *  hc, void **  data  )

static

Multiplexor for StoreOps::free.

Definition at line 365 of file hcache.c.

{
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
 
  if (!hc || !ops || !data || !*data)
    return;
 
  ops->free(hc->ctx, data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hcache_open()

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

Multiplexor for StoreOps::open.

Open the connection to the header cache.

< MD5 digest as a string

< MD5 digest as an integer

Definition at line 379 of file hcache.c.

{
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
  if (!ops)
    return NULL;
 
  struct HeaderCache *hc = mutt_mem_calloc(1, sizeof(struct HeaderCache));
 
  /* Calculate the current hcache version from dynamic configuration */
  if (HcacheVer == 0x0)
  {
    union
    {
      unsigned char charval[16]; 
      unsigned int intval;       
    } digest;
    struct Md5Ctx md5ctx;
 
    HcacheVer = HCACHEVER;
 
    mutt_md5_init_ctx(&md5ctx);
 
    /* Seed with the compiled-in header structure hash */
    mutt_md5_process_bytes(&HcacheVer, sizeof(HcacheVer), &md5ctx);
 
    /* Mix in user's spam list */
    struct Replace *sp = NULL;
    STAILQ_FOREACH(sp, &SpamList, entries)
    {
      mutt_md5_process(sp->regex->pattern, &md5ctx);
      mutt_md5_process(sp->templ, &md5ctx);
    }
 
    /* Mix in user's nospam list */
    struct RegexNode *np = NULL;
    STAILQ_FOREACH(np, &NoSpamList, entries)
    {
      mutt_md5_process(np->regex->pattern, &md5ctx);
    }
 
    /* Get a hash and take its bytes as an (unsigned int) hash version */
    mutt_md5_finish_ctx(&md5ctx, digest.charval);
    HcacheVer = digest.intval;
  }
 
  const struct ComprOps *cops = NULL;
#ifdef USE_HCACHE_COMPRESSION
  const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
  if (c_header_cache_compress_method)
  {
    cops = compress_get_ops(c_header_cache_compress_method);
 
    const short c_header_cache_compress_level = cs_subset_number(NeoMutt->sub, "header_cache_compress_level");
    hc->cctx = cops->open(c_header_cache_compress_level);
    if (!hc->cctx)
    {
      FREE(&hc);
      return NULL;
    }
 
    /* remember the buffer of database backend */
    mutt_debug(LL_DEBUG3, "Header cache will use %s compression\n", cops->name);
  }
#endif
 
  hc->folder = get_foldername(folder);
  hc->crc = HcacheVer;
 
  if (!path || (path[0] == '\0'))
  {
    if (cops)
    {
      cops->close(&hc->cctx);
    }
 
    FREE(&hc->folder);
    FREE(&hc);
    return NULL;
  }
 
  struct Buffer *hcpath = buf_pool_get();
  hcache_per_folder(hcpath, path, hc->folder, namer);
 
  hc->ctx = ops->open(buf_string(hcpath));
  if (!hc->ctx)
  {
    /* remove a possibly incompatible version */
    if (unlink(buf_string(hcpath)) == 0)
    {
      hc->ctx = ops->open(buf_string(hcpath));
      if (!hc->ctx)
      {
        if (cops)
        {
          cops->close(&hc->cctx);
        }
        FREE(&hc->folder);
        FREE(&hc);
      }
    }
  }
 
  buf_pool_release(&hcpath);
  return hc;
}

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

)

Multiplexor for StoreOps::close.

Close the connection to the header cache.

Definition at line 489 of file hcache.c.

{
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
  if (!hc || !ops)
    return;
 
#ifdef USE_HCACHE_COMPRESSION
  const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
  if (c_header_cache_compress_method)
  {
    const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
    cops->close(&hc->cctx);
  }
#endif
 
  ops->close(&hc->ctx);
  FREE(&hc->folder);
  FREE(&hc);
}

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
	)

Multiplexor for StoreOps::fetch.

Fetch and validate a message's header from the cache.

Definition at line 513 of file hcache.c.

{
  struct RealKey *rk = realkey(key, keylen);
  struct HCacheEntry entry = { 0 };
 
  size_t dlen;
  void *data = fetch_raw(hc, rk->key, rk->len, &dlen);
  void *to_free = data;
  if (!data)
  {
    goto end;
  }
 
  /* restore uidvalidity and crc */
  size_t hlen = header_size();
  if (hlen > dlen)
  {
    goto end;
  }
  int off = 0;
  serial_restore_uint32_t(&entry.uidvalidity, data, &off);
  serial_restore_int(&entry.crc, data, &off);
  assert((size_t) off == hlen);
  if (entry.crc != hc->crc || ((uidvalidity != 0) && uidvalidity != entry.uidvalidity))
  {
    goto end;
  }
 
#ifdef USE_HCACHE_COMPRESSION
  const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
  if (c_header_cache_compress_method)
  {
    const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
 
    void *dblob = cops->decompress(hc->cctx, (char *) data + hlen, dlen - hlen);
    if (!dblob)
    {
      goto end;
    }
    data = (char *) dblob - hlen; /* restore skips uidvalidity and crc */
  }
#endif
 
  entry.email = restore(data);
 
end:
  free_raw(hc, &to_free);
  return entry;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hcache_fetch_obj_()

bool mutt_hcache_fetch_obj_	(	struct HeaderCache *	hc,
		const char *	key,
		size_t	keylen,
		void *	dst,
		size_t	dstlen
	)

Fetch a message's header from the cache into a destination object.

Parameters

[in]	hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()
[in]	key	Message identification string
[in]	keylen	Length of the string pointed to by key
[out]	dst	Pointer to the destination object
[in]	dstlen	Size of the destination object

Return values

true	Success, the data was found and the length matches
false	Otherwise

Definition at line 574 of file hcache.c.

{
  bool rc = true;
  size_t srclen = 0;
  void *src = fetch_raw(hc, key, keylen, &srclen);
  if (src && srclen == dstlen)
  {
    memcpy(dst, src, dstlen);
  }
  else
  {
    rc = false;
  }
  free_raw(hc, &src);
  return rc;
}

Here is the call graph for this function:

mutt_hcache_fetch_str()

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

Fetch a string from the cache.

Parameters

[in]	hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()
[in]	key	Message identification string
[in]	keylen	Length of the string pointed to by key

Return values

ptr	Success, the data if found
NULL	Otherwise

Definition at line 600 of file hcache.c.

{
  char *res = NULL;
  size_t dlen = 0;
  void *data = fetch_raw(hc, key, keylen, &dlen);
  if (data)
  {
    res = mutt_strn_dup(data, dlen);
    free_raw(hc, &data);
  }
  return res;
}

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
	)

Multiplexor for StoreOps::store.

Store a Header along with a validity datum.

Definition at line 616 of file hcache.c.

{
  if (!hc)
    return -1;
 
  int dlen = 0;
  char *data = dump(hc, e, &dlen, uidvalidity);
 
#ifdef USE_HCACHE_COMPRESSION
  const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
  if (c_header_cache_compress_method)
  {
    /* We don't compress uidvalidity and the crc, so we can check them before
     * decompressing on fetch().  */
    size_t hlen = header_size();
 
    const struct ComprOps *cops = compress_get_ops(c_header_cache_compress_method);
 
    /* data / dlen gets ptr to compressed data here */
    size_t clen = dlen;
    void *cdata = cops->compress(hc->cctx, data + hlen, dlen - hlen, &clen);
    if (!cdata)
    {
      FREE(&data);
      return -1;
    }
 
    char *whole = mutt_mem_malloc(hlen + clen);
    memcpy(whole, data, hlen);
    memcpy(whole + hlen, cdata, clen);
 
    FREE(&data);
 
    data = whole;
    dlen = hlen + clen;
  }
#endif
 
  /* store uncompressed data */
  struct RealKey *rk = realkey(key, keylen);
  int rc = mutt_hcache_store_raw(hc, rk->key, rk->len, data, dlen);
 
  FREE(&data);
 
  return rc;
}

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

hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()
key	Message identification string
keylen	Length of the string pointed to by key
data	Payload to associate with key
dlen	Length of the buffer pointed to by the data parameter

Return values

0	Success
num	Generic or backend-specific error code otherwise

Definition at line 674 of file hcache.c.

{
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
 
  if (!hc || !ops)
    return -1;
 
  struct Buffer path = buf_make(1024);
 
  keylen = buf_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
  int rc = ops->store(hc->ctx, buf_string(&path), keylen, data, dlen);
  buf_dealloc(&path);
 
  return rc;
}

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
	)

Multiplexor for StoreOps::delete_record.

Delete a key / data pair.

Definition at line 695 of file hcache.c.

{
  if (!hc)
    return -1;
 
  const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
  const struct StoreOps *ops = store_get_backend_ops(c_header_cache_backend);
  if (!ops)
    return -1;
 
  struct Buffer path = buf_make(1024);
 
  keylen = buf_printf(&path, "%s%s", hc->folder, key);
 
  int rc = ops->delete_record(hc->ctx, buf_string(&path), keylen);
  buf_dealloc(&path);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

HcacheVer

unsigned int HcacheVer = 0x0

static

Header Cache version.

Definition at line 64 of file hcache.c.