NeoMutt  2020-11-20
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...
 
bool config_init_hcache (struct ConfigSet *cs)
 Register hcache config variables - Implements module_init_config_t. More...
 

Variables

char * C_HeaderCache
 Config: (hcache) Directory/file for the header cache database. More...
 
char * C_HeaderCacheBackend
 Config: (hcache) Header cache backend to use. More...
 
short C_HeaderCacheCompressLevel
 Config: (hcache) Level of compression for method. More...
 
char * C_HeaderCacheCompressMethod
 Config: (hcache) Enable generic hcache database compression. 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 108 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 320 of file hcache.c.

321 {
322  const struct StoreOps *ops = hcache_get_ops();
323  if (!ops)
324  return NULL;
325 
326  struct HeaderCache *hc = mutt_mem_calloc(1, sizeof(struct HeaderCache));
327 
328  /* Calculate the current hcache version from dynamic configuration */
329  if (hcachever == 0x0)
330  {
331  union
332  {
333  unsigned char charval[16];
334  unsigned int intval;
335  } digest;
336  struct Md5Ctx md5ctx;
337 
338  hcachever = HCACHEVER;
339 
340  mutt_md5_init_ctx(&md5ctx);
341 
342  /* Seed with the compiled-in header structure hash */
343  mutt_md5_process_bytes(&hcachever, sizeof(hcachever), &md5ctx);
344 
345  /* Mix in user's spam list */
346  struct Replace *sp = NULL;
347  STAILQ_FOREACH(sp, &SpamList, entries)
348  {
349  mutt_md5_process(sp->regex->pattern, &md5ctx);
350  mutt_md5_process(sp->templ, &md5ctx);
351  }
352 
353  /* Mix in user's nospam list */
354  struct RegexNode *np = NULL;
355  STAILQ_FOREACH(np, &NoSpamList, entries)
356  {
357  mutt_md5_process(np->regex->pattern, &md5ctx);
358  }
359 
360  /* Get a hash and take its bytes as an (unsigned int) hash version */
361  mutt_md5_finish_ctx(&md5ctx, digest.charval);
362  hcachever = digest.intval;
363  }
364 
365 #ifdef USE_HCACHE_COMPRESSION
367  {
368  const struct ComprOps *cops = compr_get_ops();
369 
370  hc->cctx = cops->open(C_HeaderCacheCompressLevel);
371  if (!hc->cctx)
372  {
373  FREE(&hc);
374  return NULL;
375  }
376 
377  /* remember the buffer of database backend */
378  mutt_debug(LL_DEBUG3, "Header cache will use %s compression\n", cops->name);
379  }
380 #endif
381 
382  hc->folder = get_foldername(folder);
383  hc->crc = hcachever;
384 
385  if (!path || (path[0] == '\0'))
386  {
387  FREE(&hc->folder);
388  FREE(&hc);
389  return NULL;
390  }
391 
392  struct Buffer *hcpath = mutt_buffer_pool_get();
393  hcache_per_folder(hcpath, path, hc->folder, namer);
394 
395  hc->ctx = ops->open(mutt_b2s(hcpath));
396  if (!hc->ctx)
397  {
398  /* remove a possibly incompatible version */
399  if (unlink(mutt_b2s(hcpath)) == 0)
400  {
401  hc->ctx = ops->open(mutt_b2s(hcpath));
402  if (!hc->ctx)
403  {
404  FREE(&hc->folder);
405  FREE(&hc);
406  }
407  }
408  }
409 
410  mutt_buffer_pool_release(&hcpath);
411  return hc;
412 }
char * C_HeaderCacheCompressMethod
Config: (hcache) Enable generic hcache database compression.
Definition: config.c:44
char * templ
Template to match.
Definition: regex3.h:112
void * cctx
Definition: lib.h:90
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
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:85
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:306
Key Value Store API.
Definition: lib.h:61
const char * name
Compression name.
Definition: lib.h:57
List of regular expressions.
Definition: regex3.h:108
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:110
unsigned int crc
Definition: lib.h:88
void * mutt_md5_finish_ctx(struct Md5Ctx *md5ctx, void *resbuf)
Process the remaining bytes in the buffer.
Definition: md5.c:286
short C_HeaderCacheCompressLevel
Config: (hcache) Level of compression for method.
Definition: config.c:43
void *(* open)(const char *path)
Open a connection to a Store.
Definition: lib.h:75
#define mutt_b2s(buf)
Definition: buffer.h:41
struct RegexList NoSpamList
List of regexes to whitelist non-spam emails.
Definition: globals.c:43
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:255
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:100
static unsigned int hcachever
Definition: hcache.c:61
void *(* open)(short level)
Open a compression context.
Definition: lib.h:67
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
List of regular expressions.
Definition: regex3.h:98
struct ReplaceList SpamList
List of regexes and patterns to match spam emails.
Definition: globals.c:44
void mutt_md5_process_bytes(const void *buf, size_t buflen, struct Md5Ctx *md5ctx)
Process a block of data.
Definition: md5.c:373
Header Cache Compression API.
Definition: lib.h:55
#define FREE(x)
Definition: memory.h:40
char * folder
Definition: lib.h:87
#define compr_get_ops()
Definition: hcache.c:66
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
char * pattern
printable version
Definition: regex3.h:90
#define hcache_get_ops()
Definition: hcache.c:63
Log at debug level 3.
Definition: logging.h:42
void * ctx
Definition: lib.h:89
+ 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 417 of file hcache.c.

418 {
419  const struct StoreOps *ops = hcache_get_ops();
420  if (!hc || !ops)
421  return;
422 
423 #ifdef USE_HCACHE_COMPRESSION
425  compr_get_ops()->close(&hc->cctx);
426 #endif
427 
428  ops->close(&hc->ctx);
429  FREE(&hc->folder);
430  FREE(&hc);
431 }
char * C_HeaderCacheCompressMethod
Config: (hcache) Enable generic hcache database compression.
Definition: config.c:44
void * cctx
Definition: lib.h:90
Key Value Store API.
Definition: lib.h:61
void(* close)(void **ptr)
Close a Store connection.
Definition: lib.h:121
#define FREE(x)
Definition: memory.h:40
char * folder
Definition: lib.h:87
#define compr_get_ops()
Definition: hcache.c:66
#define hcache_get_ops()
Definition: hcache.c:63
void * ctx
Definition: lib.h:89
+ 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 525 of file hcache.c.

527 {
528  if (!hc)
529  return -1;
530 
531  int dlen = 0;
532  char *data = dump(hc, e, &dlen, uidvalidity);
533 
534 #ifdef USE_HCACHE_COMPRESSION
536  {
537  /* We don't compress uidvalidity and the crc, so we can check them before
538  * decompressing on fetch(). */
539  size_t hlen = header_size();
540 
541  const struct ComprOps *cops = compr_get_ops();
542 
543  /* data / dlen gets ptr to compressed data here */
544  size_t clen = dlen;
545  void *cdata = cops->compress(hc->cctx, data + hlen, dlen - hlen, &clen);
546  if (!cdata)
547  {
548  FREE(&data);
549  return -1;
550  }
551 
552  char *whole = mutt_mem_malloc(hlen + clen);
553  memcpy(whole, data, hlen);
554  memcpy(whole + hlen, cdata, clen);
555 
556  FREE(&data);
557 
558  data = whole;
559  dlen = hlen + clen;
560  }
561 #endif
562 
563  /* store uncompressed data */
564  struct RealKey *rk = realkey(key, keylen);
565  int rc = mutt_hcache_store_raw(hc, rk->key, rk->len, data, dlen);
566 
567  FREE(&data);
568 
569  return rc;
570 }
char * C_HeaderCacheCompressMethod
Config: (hcache) Enable generic hcache database compression.
Definition: config.c:44
void * cctx
Definition: lib.h:90
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:188
size_t len
Definition: hcache.c:179
static size_t header_size(void)
Compute the size of the header with uuid validity and crc.
Definition: hcache.c:73
void *(* compress)(void *cctx, const char *data, size_t dlen, size_t *clen)
Compress header cache data.
Definition: lib.h:81
static void * dump(struct HeaderCache *hc, const struct Email *e, int *off, uint32_t uidvalidity)
Serialise an Email object.
Definition: hcache.c:89
char key[1024]
Definition: hcache.c:178
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
Header Cache Compression API.
Definition: lib.h:55
#define FREE(x)
Definition: memory.h:40
#define compr_get_ops()
Definition: hcache.c:66
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:582
+ 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 436 of file hcache.c.

438 {
439  struct RealKey *rk = realkey(key, keylen);
440  struct HCacheEntry entry = { 0 };
441 
442  size_t dlen;
443  void *data = mutt_hcache_fetch_raw(hc, rk->key, rk->len, &dlen);
444  void *to_free = data;
445  if (!data)
446  {
447  goto end;
448  }
449 
450  /* restore uidvalidity and crc */
451  size_t hlen = header_size();
452  int off = 0;
453  serial_restore_uint32_t(&entry.uidvalidity, data, &off);
454  serial_restore_int(&entry.crc, data, &off);
455  assert((size_t) off == hlen);
456  if (entry.crc != hc->crc || ((uidvalidity != 0) && uidvalidity != entry.uidvalidity))
457  {
458  goto end;
459  }
460 
461 #ifdef USE_HCACHE_COMPRESSION
463  {
464  const struct ComprOps *cops = compr_get_ops();
465 
466  void *dblob = cops->decompress(hc->cctx, (char *) data + hlen, dlen - hlen);
467  if (!dblob)
468  {
469  goto end;
470  }
471  data = (char *) dblob - hlen; /* restore skips uidvalidity and crc */
472  }
473 #endif
474 
475  entry.email = restore(data);
476 
477 end:
478  mutt_hcache_free_raw(hc, &to_free);
479  return entry;
480 }
char * C_HeaderCacheCompressMethod
Config: (hcache) Enable generic hcache database compression.
Definition: config.c:44
void * cctx
Definition: lib.h:90
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:188
Wrapper for Email retrieved from the header cache.
Definition: lib.h:96
size_t len
Definition: hcache.c:179
static size_t header_size(void)
Compute the size of the header with uuid validity and crc.
Definition: hcache.c:73
uint32_t uidvalidity
IMAP-specific UIDVALIDITY.
Definition: lib.h:98
void serial_restore_int(unsigned int *i, const unsigned char *d, int *off)
Unpack an integer from a binary blob.
Definition: serialize.c:96
void mutt_hcache_free_raw(struct HeaderCache *hc, void **data)
Multiplexor for StoreOps::free.
Definition: hcache.c:512
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:108
unsigned int crc
Definition: lib.h:88
char key[1024]
Definition: hcache.c:178
Header Cache Compression API.
Definition: lib.h:55
unsigned int crc
CRC of Email/Body/etc structs.
Definition: lib.h:99
#define compr_get_ops()
Definition: hcache.c:66
void *(* decompress)(void *cctx, const char *cbuf, size_t clen)
Decompress header cache data.
Definition: lib.h:94
struct Email * email
Retrieved email.
Definition: lib.h:100
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:494
static struct Email * restore(const unsigned char *d)
Restore an Email from data retrieved from the cache.
Definition: hcache.c:145
+ 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 582 of file hcache.c.

584 {
585  const struct StoreOps *ops = hcache_get_ops();
586 
587  if (!hc || !ops)
588  return -1;
589 
590  struct Buffer path = mutt_buffer_make(1024);
591 
592  keylen = mutt_buffer_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
593  int rc = ops->store(hc->ctx, mutt_b2s(&path), keylen, data, dlen);
594  mutt_buffer_dealloc(&path);
595 
596  return rc;
597 }
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
Key Value Store API.
Definition: lib.h:61
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
int(* store)(void *store, const char *key, size_t klen, void *value, size_t vlen)
Write a Value to the Store.
Definition: lib.h:105
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
#define mutt_b2s(buf)
Definition: buffer.h:41
char * data
Pointer to data.
Definition: buffer.h:35
char * folder
Definition: lib.h:87
#define hcache_get_ops()
Definition: hcache.c:63
void * ctx
Definition: lib.h:89
+ 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 494 of file hcache.c.

496 {
497  const struct StoreOps *ops = hcache_get_ops();
498 
499  if (!hc || !ops)
500  return NULL;
501 
502  struct Buffer path = mutt_buffer_make(1024);
503  keylen = mutt_buffer_printf(&path, "%s%.*s", hc->folder, (int) keylen, key);
504  void *blob = ops->fetch(hc->ctx, mutt_b2s(&path), keylen, dlen);
505  mutt_buffer_dealloc(&path);
506  return blob;
507 }
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
Key Value Store API.
Definition: lib.h:61
void *(* fetch)(void *store, const char *key, size_t klen, size_t *vlen)
Fetch a Value from the Store.
Definition: lib.h:86
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
#define mutt_b2s(buf)
Definition: buffer.h:41
char * folder
Definition: lib.h:87
#define hcache_get_ops()
Definition: hcache.c:63
void * ctx
Definition: lib.h:89
+ 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 512 of file hcache.c.

513 {
514  const struct StoreOps *ops = hcache_get_ops();
515 
516  if (!hc || !ops || !data || !*data)
517  return;
518 
519  ops->free(hc->ctx, data);
520 }
Key Value Store API.
Definition: lib.h:61
void(* free)(void *store, void **ptr)
Free a Value returned by fetch()
Definition: lib.h:93
#define hcache_get_ops()
Definition: hcache.c:63
void * ctx
Definition: lib.h:89
+ 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 602 of file hcache.c.

603 {
604  const struct StoreOps *ops = hcache_get_ops();
605  if (!hc)
606  return -1;
607 
608  struct Buffer path = mutt_buffer_make(1024);
609 
610  keylen = mutt_buffer_printf(&path, "%s%s", hc->folder, key);
611 
612  int rc = ops->delete_record(hc->ctx, mutt_b2s(&path), keylen);
613  mutt_buffer_dealloc(&path);
614  return rc;
615 }
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
Key Value Store API.
Definition: lib.h:61
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
#define mutt_b2s(buf)
Definition: buffer.h:41
int(* delete_record)(void *store, const char *key, size_t klen)
Delete a record from the Store.
Definition: lib.h:115
char * folder
Definition: lib.h:87
#define hcache_get_ops()
Definition: hcache.c:63
void * ctx
Definition: lib.h:89
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ config_init_hcache()

bool config_init_hcache ( struct ConfigSet cs)

Register hcache config variables - Implements module_init_config_t.

Definition at line 153 of file config.c.

154 {
155  return cs_register_variables(cs, HcacheVars, 0);
156 }
bool cs_register_variables(const struct ConfigSet *cs, struct ConfigDef vars[], int flags)
Register a set of config items.
Definition: set.c:286
struct ConfigDef HcacheVars[]
Definition: config.c:124
+ Here is the call graph for this function:

Variable Documentation

◆ C_HeaderCache

char* C_HeaderCache

Config: (hcache) Directory/file for the header cache database.

Definition at line 40 of file config.c.

◆ C_HeaderCacheBackend

char* C_HeaderCacheBackend

Config: (hcache) Header cache backend to use.

Definition at line 41 of file config.c.

◆ C_HeaderCacheCompressLevel

short C_HeaderCacheCompressLevel

Config: (hcache) Level of compression for method.

Definition at line 43 of file config.c.

◆ C_HeaderCacheCompressMethod

char* C_HeaderCacheCompressMethod

Config: (hcache) Enable generic hcache database compression.

Definition at line 44 of file config.c.