lib.h File Reference

Header cache multiplexor. More...

#include <stddef.h>
#include <stdbool.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...

Macros
#define	mutt_hcache_fetch_obj(hc, key, keylen, dst)   mutt_hcache_fetch_obj_(hc, key, keylen, dst, sizeof(*dst))

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

Functions
struct HeaderCache *	mutt_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...
char *	mutt_hcache_fetch_str (struct HeaderCache *hc, const char *key, size_t keylen)
	Fetch a string from the cache. 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...
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)
	Delete a key / data pair. 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 lib.h.

Macro Definition Documentation

mutt_hcache_fetch_obj

#define mutt_hcache_fetch_obj	(		hc,
			key,
			keylen,
			dst
	)		mutt_hcache_fetch_obj_(hc, key, keylen, dst, sizeof(*dst))

Definition at line 160 of file lib.h.

Typedef Documentation

hcache_namer_t

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

Definition at line 113 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

path	Location of the header cache (often as specified by the user)
folder	Name of the folder containing the messages
namer	Optional (might be NULL) client-specific function to form the final name of the hcache database file.

Return values

ptr	Success, struct HeaderCache struct
NULL	Otherwise

Open the connection to the header cache.

< MD5 digest as a string

< MD5 digest as an integer

Definition at line 373 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 = mutt_buffer_pool_get();
  hcache_per_folder(hcpath, path, hc->folder, namer);
 
  hc->ctx = ops->open(mutt_buffer_string(hcpath));
  if (!hc->ctx)
  {
    /* remove a possibly incompatible version */
    if (unlink(mutt_buffer_string(hcpath)) == 0)
    {
      hc->ctx = ops->open(mutt_buffer_string(hcpath));
      if (!hc->ctx)
      {
        if (cops)
        {
          cops->close(&hc->cctx);
        }
        FREE(&hc->folder);
        FREE(&hc);
      }
    }
  }
 
  mutt_buffer_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

)

Close the connection to the header cache.

Parameters

hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()

Close the connection to the header cache.

Definition at line 483 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_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

hc	Pointer to the struct HeaderCache structure got by mutt_hcache_open()
key	Message identification string
keylen	Length of the key string
e	Email to store
uidvalidity	IMAP-specific UIDVALIDITY value, or 0 to use the current time

Return values

0	Success
num	Generic or backend-specific error code otherwise

Store a Header along with a validity datum.

Definition at line 610 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_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

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
uidvalidity	Only restore if it matches the stored uidvalidity

Return values

obj	HCacheEntry 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 507 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_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 594 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_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 568 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_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 668 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 = mutt_buffer_make(1024);
 
  keylen = mutt_buffer_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
  int rc = ops->store(hc->ctx, mutt_buffer_string(&path), keylen, data, dlen);
  mutt_buffer_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
	)

Delete 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

Return values

0	Success
num	Generic or backend-specific error code otherwise

Delete a key / data pair.

Definition at line 689 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);
 
  struct Buffer path = mutt_buffer_make(1024);
 
  keylen = mutt_buffer_printf(&path, "%s%s", hc->folder, key);
 
  int rc = ops->delete_record(hc->ctx, mutt_buffer_string(&path), keylen);
  mutt_buffer_dealloc(&path);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function: