NeoMutt  2023-11-03-107-g582dc1
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 struct RealKeyrealkey (struct HeaderCache *hc, const char *key, size_t keylen, bool compress)
 Compute the real key used in the backend, taking into account the compression method.
 
static void hcache_free (struct HeaderCache **ptr)
 Free a header cache.
 
static struct HeaderCachehcache_new (void)
 Create a new header cache.
 
static size_t header_size (void)
 Compute the size of the header with uuid validity and crc.
 
static uint32_t email_pack_flags (const struct Email *e)
 Pack the Email flags into a uint32_t.
 
static void email_unpack_flags (struct Email *e, uint32_t packed)
 Unpack the Email flags from a uint32_t.
 
static uint32_t email_pack_timezone (const struct Email *e)
 Pack the Email timezone into a uint32_t.
 
static void email_unpack_timezone (struct Email *e, uint32_t packed)
 Unpack the Email timezone from a uint32_t.
 
static void * dump_email (struct HeaderCache *hc, const struct Email *e, int *off, uint32_t uidvalidity)
 Serialise an Email object.
 
static struct Emailrestore_email (const unsigned char *d)
 Restore an Email from data retrieved from the cache.
 
static bool create_hcache_dir (const char *path)
 Create parent dirs for the hcache database.
 
static void hcache_per_folder (struct HeaderCache *hc, struct Buffer *hcpath, const char *path, hcache_namer_t namer)
 Generate the hcache pathname.
 
static char * get_foldername (const char *folder)
 Where should the cache be stored?
 
static void free_raw (struct HeaderCache *hc, void **data)
 Multiplexor for StoreOps::free.
 
static unsigned int generate_hcachever (void)
 Calculate hcache version from dynamic configuration.
 
struct HeaderCachehcache_open (const char *path, const char *folder, hcache_namer_t namer)
 Multiplexor for StoreOps::open.
 
void hcache_close (struct HeaderCache **ptr)
 Multiplexor for StoreOps::close.
 
struct HCacheEntry hcache_fetch_email (struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
 Multiplexor for StoreOps::fetch.
 
bool hcache_fetch_raw_obj_full (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.
 
char * hcache_fetch_raw_str (struct HeaderCache *hc, const char *key, size_t keylen)
 Fetch a string from the cache.
 
int hcache_store_email (struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
 Multiplexor for StoreOps::store.
 
int hcache_store_raw (struct HeaderCache *hc, const char *key, size_t keylen, void *data, size_t dlen)
 Store a key / data pair.
 
int hcache_delete_email (struct HeaderCache *hc, const char *key, size_t keylen)
 Multiplexor for StoreOps::delete_record.
 
int hcache_delete_raw (struct HeaderCache *hc, const char *key, size_t keylen)
 Multiplexor for StoreOps::delete_record.
 

Variables

static unsigned int HcacheVer = 0x0
 Header Cache version.
 

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

Function Documentation

◆ realkey()

static struct RealKey * realkey ( struct HeaderCache hc,
const char *  key,
size_t  keylen,
bool  compress 
)
static

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

Parameters
hcHeader cache handle
keyOriginal key
keylenLength of original key
compressWill the data be compressed?
Return values
ptrStatic location holding data and length of the real key

Definition at line 83 of file hcache.c.

85{
86 static struct RealKey rk;
87
88 rk.keylen = snprintf(rk.key, sizeof(rk.key), "%s/%.*s", hc->folder, (int) keylen, key);
89
90#ifdef USE_HCACHE_COMPRESSION
91 if (compress && hc->compr_ops)
92 {
93 // Append the compression type, e.g. "-zstd"
94 rk.keylen += snprintf(rk.key + rk.keylen, sizeof(rk.key) - rk.keylen, "-%s",
95 hc->compr_ops->name);
96 }
97#endif
98
99 return &rk;
100}
const char * name
Compression name.
Definition: lib.h:64
char * folder
Folder name.
Definition: lib.h:89
const struct ComprOps * compr_ops
Compression backend.
Definition: lib.h:93
Hcache key name (including compression method)
Definition: hcache.c:70
char key[1024]
Key name.
Definition: hcache.c:71
size_t keylen
Length of key.
Definition: hcache.c:72
+ Here is the caller graph for this function:

◆ hcache_free()

static void hcache_free ( struct HeaderCache **  ptr)
static

Free a header cache.

Parameters
ptrheader cache to free

Definition at line 106 of file hcache.c.

107{
108 if (!ptr || !*ptr)
109 return;
110
111 struct HeaderCache *hc = *ptr;
112 FREE(&hc->folder);
113
114 FREE(ptr);
115}
#define FREE(x)
Definition: memory.h:45
Header Cache.
Definition: lib.h:88
+ Here is the caller graph for this function:

◆ hcache_new()

static struct HeaderCache * hcache_new ( void  )
static

Create a new header cache.

Return values
ptrNewly created header cache

Definition at line 121 of file hcache.c.

122{
123 return mutt_mem_calloc(1, sizeof(struct HeaderCache));
124}
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ header_size()

static size_t header_size ( void  )
static

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

Return values
numSize of the header

Definition at line 130 of file hcache.c.

131{
132 return sizeof(int) + sizeof(uint32_t);
133}
+ Here is the caller graph for this function:

◆ email_pack_flags()

static uint32_t email_pack_flags ( const struct Email e)
inlinestatic

Pack the Email flags into a uint32_t.

Parameters
eEmail to pack
Return values
numuint32_t of packed flags
Note
Order of packing must match email_unpack_flags()

Definition at line 142 of file hcache.c.

143{
144 if (!e)
145 return 0;
146
147 // clang-format off
148 return e->security +
149 (e->expired << 16) +
150 (e->flagged << 17) +
151 (e->mime << 18) +
152 (e->old << 19) +
153 (e->read << 20) +
154 (e->replied << 21) +
155 (e->superseded << 22) +
156 (e->trash << 23);
157 // clang-format on
158}
bool read
Email is read.
Definition: email.h:48
bool mime
Has a MIME-Version header?
Definition: email.h:46
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
bool old
Email is seen, but unread.
Definition: email.h:47
bool flagged
Marked important?
Definition: email.h:45
bool replied
Email has been replied to.
Definition: email.h:49
bool expired
Already expired?
Definition: email.h:44
bool trash
Message is marked as trashed on disk (used by the maildir_trash option)
Definition: email.h:51
bool superseded
Got superseded?
Definition: email.h:50
+ Here is the caller graph for this function:

◆ email_unpack_flags()

static void email_unpack_flags ( struct Email e,
uint32_t  packed 
)
inlinestatic

Unpack the Email flags from a uint32_t.

Parameters
eEmail to unpack into
packedPacked flags
Note
Order of packing must match email_pack_flags()

Definition at line 167 of file hcache.c.

168{
169 if (!e)
170 return;
171
172 // clang-format off
173 e->security = (packed & ((1 << 16) - 1)); // bits 0-15
174 e->expired = (packed & (1 << 16));
175 e->flagged = (packed & (1 << 17));
176 e->mime = (packed & (1 << 18));
177 e->old = (packed & (1 << 19));
178 e->read = (packed & (1 << 20));
179 e->replied = (packed & (1 << 21));
180 e->superseded = (packed & (1 << 22));
181 e->trash = (packed & (1 << 23));
182 // clang-format on
183}
+ Here is the caller graph for this function:

◆ email_pack_timezone()

static uint32_t email_pack_timezone ( const struct Email e)
inlinestatic

Pack the Email timezone into a uint32_t.

Parameters
eEmail to pack
Return values
numuint32_t of packed timezone
Note
Order of packing must match email_unpack_timezone()

Definition at line 192 of file hcache.c.

193{
194 if (!e)
195 return 0;
196
197 return e->zhours + (e->zminutes << 5) + (e->zoccident << 11);
198}
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:55
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:56
unsigned int zhours
Hours away from UTC.
Definition: email.h:54
+ Here is the caller graph for this function:

◆ email_unpack_timezone()

static void email_unpack_timezone ( struct Email e,
uint32_t  packed 
)
inlinestatic

Unpack the Email timezone from a uint32_t.

Parameters
eEmail to unpack into
packedPacked timezone
Note
Order of packing must match email_pack_timezone()

Definition at line 207 of file hcache.c.

208{
209 if (!e)
210 return;
211
212 // clang-format off
213 e->zhours = (packed & ((1 << 5) - 1)); // bits 0-4 (5)
214 e->zminutes = ((packed >> 5) & ((1 << 6) - 1)); // bits 5-10 (6)
215 e->zoccident = (packed & (1 << 11)); // bit 11 (1)
216 // clang-format on
217}
+ Here is the caller graph for this function:

◆ dump_email()

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

Serialise an Email object.

Parameters
hcHeader cache handle
eEmail to serialise
offSize of the binary blob
uidvalidityIMAP server identifier
Return values
ptrBinary 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 230 of file hcache.c.

231{
232 bool convert = !CharsetIsUtf8;
233
234 *off = 0;
235 unsigned char *d = mutt_mem_malloc(4096);
236
237 d = serial_dump_uint32_t((uidvalidity != 0) ? uidvalidity : mutt_date_now(), d, off);
238 d = serial_dump_int(hc->crc, d, off);
239
240 assert((size_t) *off == header_size());
241
242 uint32_t packed = email_pack_flags(e);
243 d = serial_dump_uint32_t(packed, d, off);
244
245 packed = email_pack_timezone(e);
246 d = serial_dump_uint32_t(packed, d, off);
247
248 uint64_t big = e->date_sent;
249 d = serial_dump_uint64_t(big, d, off);
250 big = e->received;
251 d = serial_dump_uint64_t(big, d, off);
252
253 d = serial_dump_int(e->lines, d, off);
254
255 d = serial_dump_envelope(e->env, d, off, convert);
256 d = serial_dump_body(e->body, d, off, convert);
257 d = serial_dump_tags(&e->tags, d, off);
258
259 return d;
260}
static uint32_t email_pack_flags(const struct Email *e)
Pack the Email flags into a uint32_t.
Definition: hcache.c:142
static uint32_t email_pack_timezone(const struct Email *e)
Pack the Email timezone into a uint32_t.
Definition: hcache.c:192
static size_t header_size(void)
Compute the size of the header with uuid validity and crc.
Definition: hcache.c:130
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
bool CharsetIsUtf8
Is the user's current character set utf-8?
Definition: charset.c:63
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:446
unsigned char * serial_dump_body(const struct Body *b, unsigned char *d, int *off, bool convert)
Pack an Body into a binary blob.
Definition: serialize.c:520
unsigned char * serial_dump_uint64_t(const uint64_t s, unsigned char *d, int *off)
Pack a uint64_t into a binary blob.
Definition: serialize.c:100
unsigned char * serial_dump_int(const unsigned int i, unsigned char *d, int *off)
Pack an integer into a binary blob.
Definition: serialize.c:68
unsigned char * serial_dump_envelope(const struct Envelope *env, unsigned char *d, int *off, bool convert)
Pack an Envelope into a binary blob.
Definition: serialize.c:585
unsigned char * serial_dump_uint32_t(const uint32_t s, unsigned char *d, int *off)
Pack a uint32_t into a binary blob.
Definition: serialize.c:84
unsigned char * serial_dump_tags(const struct TagList *tags, unsigned char *d, int *off)
Pack a TagList into a binary blob.
Definition: serialize.c:687
struct Envelope * env
Envelope information.
Definition: email.h:66
int lines
How many lines in the body of this message?
Definition: email.h:60
struct Body * body
List of MIME parts.
Definition: email.h:67
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:58
struct TagList tags
For drivers that support server tagging.
Definition: email.h:70
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:59
unsigned int crc
CRC of the cache entry.
Definition: lib.h:90
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ restore_email()

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

Restore an Email from data retrieved from the cache.

Parameters
dData retrieved using hcache_fetch_email()
Return values
ptrSuccess, the restored header (can't be NULL)
Note
The returned Email must be free'd by caller code with email_free()

Definition at line 270 of file hcache.c.

271{
272 int off = 0;
273 struct Email *e = email_new();
274 bool convert = !CharsetIsUtf8;
275
276 off += sizeof(uint32_t); // skip validate
277 off += sizeof(unsigned int); // skip crc
278
279 uint32_t packed = 0;
280 serial_restore_uint32_t(&packed, d, &off);
281 email_unpack_flags(e, packed);
282
283 packed = 0;
284 serial_restore_uint32_t(&packed, d, &off);
285 email_unpack_timezone(e, packed);
286
287 uint64_t big = 0;
288 serial_restore_uint64_t(&big, d, &off);
289 e->date_sent = big;
290
291 big = 0;
292 serial_restore_uint64_t(&big, d, &off);
293 e->received = big;
294
295 unsigned int num = 0;
296 serial_restore_int(&num, d, &off);
297 e->lines = num;
298
299 e->env = mutt_env_new();
300 serial_restore_envelope(e->env, d, &off, convert);
301
302 e->body = mutt_body_new();
303 serial_restore_body(e->body, d, &off, convert);
304 serial_restore_tags(&e->tags, d, &off);
305
306 return e;
307}
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:43
struct Email * email_new(void)
Create a new Email.
Definition: email.c:78
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:43
static void email_unpack_flags(struct Email *e, uint32_t packed)
Unpack the Email flags from a uint32_t.
Definition: hcache.c:167
static void email_unpack_timezone(struct Email *e, uint32_t packed)
Unpack the Email timezone from a uint32_t.
Definition: hcache.c:207
void serial_restore_tags(struct TagList *tags, const unsigned char *d, int *off)
Unpack a TagList from a binary blob.
Definition: serialize.c:712
void serial_restore_envelope(struct Envelope *env, const unsigned char *d, int *off, bool convert)
Unpack an Envelope from a binary blob.
Definition: serialize.c:633
void serial_restore_uint64_t(uint64_t *s, const unsigned char *d, int *off)
Unpack an uint64_t from a binary blob.
Definition: serialize.c:139
void serial_restore_body(struct Body *b, const unsigned char *d, int *off, bool convert)
Unpack a Body from a binary blob.
Definition: serialize.c:551
void serial_restore_int(unsigned int *i, const unsigned char *d, int *off)
Unpack an integer from a binary blob.
Definition: serialize.c:115
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:127
The envelope/body of an email.
Definition: email.h:37
+ 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
pathDatabase filename
Return values
trueSuccess
falseFailure (errno set)

Definition at line 315 of file hcache.c.

316{
317 char *dir = mutt_str_dup(path);
318 if (!dir)
319 return false;
320
321 char *p = strrchr(dir, '/');
322 if (!p)
323 {
324 FREE(&dir);
325 return true;
326 }
327
328 *p = '\0';
329
330 int rc = mutt_file_mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO);
331 if (rc != 0)
332 mutt_error(_("Can't create %s: %s"), dir, strerror(errno));
333
334 FREE(&dir);
335 return (rc == 0);
336}
int mutt_file_mkdir(const char *path, mode_t mode)
Recursively create directories.
Definition: file.c:977
#define mutt_error(...)
Definition: logging2.h:92
#define _(a)
Definition: message.h:28
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
+ 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 HeaderCache hc,
struct Buffer hcpath,
const char *  path,
hcache_namer_t  namer 
)
static

Generate the hcache pathname.

Parameters
hcHeader cache handle
hcpathBuffer for the result
pathBase directory, from $header_cache
namerCallback 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 (hc->folder)
  • NAME: Create by namer, or md5sum of hc->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 359 of file hcache.c.

361{
362 struct stat st = { 0 };
363
364 int plen = mutt_str_len(path);
365 int rc = stat(path, &st);
366 bool slash = (path[plen - 1] == '/');
367
368 if (((rc == 0) && !S_ISDIR(st.st_mode)) || ((rc == -1) && !slash))
369 {
370 /* An existing file or a non-existing path not ending with a slash */
371 mutt_encode_path(hcpath, path);
373 return;
374 }
375
376 /* We have a directory - no matter whether it exists, or not */
377 struct Buffer *hcfile = buf_pool_get();
378 if (namer)
379 {
380 namer(hc->folder, hcfile);
381 buf_concat_path(hcpath, path, buf_string(hcfile));
382 }
383 else
384 {
385 unsigned char m[16]; /* binary md5sum */
386 struct Buffer *name = buf_pool_get();
387
388#ifdef USE_HCACHE_COMPRESSION
389 const char *cm = hc->compr_ops ? hc->compr_ops->name : "";
390 buf_printf(name, "%s|%s%s", hc->store_ops->name, hc->folder, cm);
391#else
392 buf_printf(name, "%s|%s", hc->store_ops->name, hc->folder);
393#endif
394 mutt_md5(buf_string(name), m);
395 buf_reset(name);
396 mutt_md5_toascii(m, name->data);
397 buf_printf(hcpath, "%s%s%s", path, slash ? "" : "/", buf_string(name));
398 buf_pool_release(&name);
399 }
400
401 mutt_encode_path(hcpath, buf_string(hcpath));
403 buf_pool_release(&hcfile);
404}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:173
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:88
size_t buf_concat_path(struct Buffer *buf, const char *dir, const char *fname)
Join a directory name and a filename.
Definition: buffer.c:484
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
static bool create_hcache_dir(const char *path)
Create parent dirs for the hcache database.
Definition: hcache.c:315
void * mutt_md5(const char *str, void *buf)
Calculate the MD5 hash of a NULL-terminated string.
Definition: md5.c:317
void mutt_md5_toascii(const void *digest, char *resbuf)
Convert a binary MD5 digest into ASCII Hexadecimal.
Definition: md5.c:456
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
void mutt_encode_path(struct Buffer *buf, const char *src)
Convert a path to 'us-ascii'.
Definition: muttlib.c:1447
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
String manipulation buffer.
Definition: buffer.h:34
char * data
Pointer to data.
Definition: buffer.h:35
const struct StoreOps * store_ops
Store backend.
Definition: lib.h:91
const char * name
Store name.
Definition: lib.h:70
+ 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
folderPath to be canonicalised
Return values
ptrNew string with canonical path

Definition at line 411 of file hcache.c.

412{
413 /* if the folder is local, canonify the path to ensure equivalent paths share
414 * the hcache */
415 char *p = mutt_mem_malloc(PATH_MAX + 1);
416 if (!realpath(folder, p))
417 mutt_str_replace(&p, folder);
418
419 return p;
420}
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:327
#define PATH_MAX
Definition: mutt.h:41
+ 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 425 of file hcache.c.

426{
427 hc->store_ops->free(hc->store_handle, data);
428}
StoreHandle * store_handle
Store handle.
Definition: lib.h:92
void(* free)(StoreHandle *store, void **ptr)
Definition: lib.h:109
+ Here is the caller graph for this function:

◆ generate_hcachever()

static unsigned int generate_hcachever ( void  )
static

Calculate hcache version from dynamic configuration.

Return values
numHeader cache version

< MD5 digest as a string

< MD5 digest as an integer

Definition at line 434 of file hcache.c.

435{
436 union
437 {
438 unsigned char charval[16];
439 unsigned int intval;
440 } digest;
441 struct Md5Ctx md5ctx = { 0 };
442
443 mutt_md5_init_ctx(&md5ctx);
444
445 /* Seed with the compiled-in header structure hash */
446 unsigned int ver = HCACHEVER;
447 mutt_md5_process_bytes(&ver, sizeof(ver), &md5ctx);
448
449 /* Mix in user's spam list */
450 struct Replace *sp = NULL;
451 STAILQ_FOREACH(sp, &SpamList, entries)
452 {
453 mutt_md5_process(sp->regex->pattern, &md5ctx);
454 mutt_md5_process(sp->templ, &md5ctx);
455 }
456
457 /* Mix in user's nospam list */
458 struct RegexNode *np = NULL;
459 STAILQ_FOREACH(np, &NoSpamList, entries)
460 {
461 mutt_md5_process(np->regex->pattern, &md5ctx);
462 }
463
464 /* Get a hash and take its bytes as an (unsigned int) hash version */
465 mutt_md5_finish_ctx(&md5ctx, digest.charval);
466
467 return digest.intval;
468}
struct ReplaceList SpamList
List of regexes to match subscribed mailing lists.
Definition: globals.c:45
struct RegexList NoSpamList
List of regexes and patterns to match spam emails.
Definition: globals.c:43
void mutt_md5_process_bytes(const void *buf, size_t buflen, struct Md5Ctx *md5ctx)
Process a block of data.
Definition: md5.c:373
void mutt_md5_process(const char *str, struct Md5Ctx *md5ctx)
Process a NULL-terminated string.
Definition: md5.c:355
void mutt_md5_init_ctx(struct Md5Ctx *md5ctx)
Initialise the MD5 computation.
Definition: md5.c:261
void * mutt_md5_finish_ctx(struct Md5Ctx *md5ctx, void *resbuf)
Process the remaining bytes in the buffer.
Definition: md5.c:285
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
Cursor for the MD5 hashing.
Definition: md5.h:37
List of regular expressions.
Definition: regex3.h:99
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:100
char * pattern
printable version
Definition: regex3.h:90
List of regular expressions.
Definition: regex3.h:109
char * templ
Template to match.
Definition: regex3.h:112
struct Regex * regex
Regex containing a regular expression.
Definition: regex3.h:110
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_open()

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

Multiplexor for StoreOps::open.

Open the connection to the header cache.

Definition at line 473 of file hcache.c.

474{
475 if (!path || (path[0] == '\0'))
476 return NULL;
477
478 if (HcacheVer == 0x0)
480
481 struct HeaderCache *hc = hcache_new();
482
484 hc->crc = HcacheVer;
485
486 const char *const c_header_cache_backend = cs_subset_string(NeoMutt->sub, "header_cache_backend");
487 hc->store_ops = store_get_backend_ops(c_header_cache_backend);
488 if (!hc->store_ops)
489 {
490 hcache_free(&hc);
491 return NULL;
492 }
493
494#ifdef USE_HCACHE_COMPRESSION
495 const char *const c_header_cache_compress_method = cs_subset_string(NeoMutt->sub, "header_cache_compress_method");
496 if (c_header_cache_compress_method)
497 {
498 hc->compr_ops = compress_get_ops(c_header_cache_compress_method);
499
500 const short c_header_cache_compress_level = cs_subset_number(NeoMutt->sub, "header_cache_compress_level");
501 hc->compr_handle = hc->compr_ops->open(c_header_cache_compress_level);
502 if (!hc->compr_handle)
503 {
504 hcache_free(&hc);
505 return NULL;
506 }
507
508 /* remember the buffer of database backend */
509 mutt_debug(LL_DEBUG3, "Header cache will use %s compression\n",
510 hc->compr_ops->name);
511 }
512#endif
513
514 struct Buffer *hcpath = buf_pool_get();
515 hcache_per_folder(hc, hcpath, path, namer);
516
517 hc->store_handle = hc->store_ops->open(buf_string(hcpath));
518 if (!hc->store_handle)
519 {
520 /* remove a possibly incompatible version */
521 if (unlink(buf_string(hcpath)) == 0)
522 {
523 hc->store_handle = hc->store_ops->open(buf_string(hcpath));
524 if (!hc->store_handle)
525 {
526 if (hc->compr_ops)
527 {
528 hc->compr_ops->close(&hc->compr_handle);
529 }
530 hcache_free(&hc);
531 }
532 }
533 }
534
535 buf_pool_release(&hcpath);
536 return hc;
537}
const struct ComprOps * compress_get_ops(const char *compr)
Get the API functions for a compress backend.
Definition: compress.c:79
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:144
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
static unsigned int HcacheVer
Header Cache version.
Definition: hcache.c:64
static void hcache_free(struct HeaderCache **ptr)
Free a header cache.
Definition: hcache.c:106
static struct HeaderCache * hcache_new(void)
Create a new header cache.
Definition: hcache.c:121
static unsigned int generate_hcachever(void)
Calculate hcache version from dynamic configuration.
Definition: hcache.c:434
static void hcache_per_folder(struct HeaderCache *hc, struct Buffer *hcpath, const char *path, hcache_namer_t namer)
Generate the hcache pathname.
Definition: hcache.c:359
static char * get_foldername(const char *folder)
Where should the cache be stored?
Definition: hcache.c:411
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
const struct StoreOps * store_get_backend_ops(const char *str)
Get the API functions for an store backend.
Definition: store.c:106
ComprHandle *(* open)(short level)
Definition: lib.h:77
void(* close)(ComprHandle **ptr)
Definition: lib.h:122
ComprHandle * compr_handle
Compression handle.
Definition: lib.h:94
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
StoreHandle *(* open)(const char *path)
Definition: lib.h:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_close()

void hcache_close ( struct HeaderCache **  ptr)

Multiplexor for StoreOps::close.

Close the connection to the header cache.

Definition at line 542 of file hcache.c.

543{
544 if (!ptr || !*ptr)
545 return;
546
547 struct HeaderCache *hc = *ptr;
548
549#ifdef USE_HCACHE_COMPRESSION
550 if (hc->compr_ops)
551 hc->compr_ops->close(&hc->compr_handle);
552#endif
553
554 hc->store_ops->close(&hc->store_handle);
555
556 hcache_free(ptr);
557}
void(* close)(StoreHandle **ptr)
Definition: lib.h:146
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_fetch_email()

struct HCacheEntry hcache_fetch_email ( 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 562 of file hcache.c.

564{
565 struct HCacheEntry hce = { 0 };
566 if (!hc)
567 return hce;
568
569 size_t dlen = 0;
570 struct RealKey *rk = realkey(hc, key, keylen, true);
571 void *data = hc->store_ops->fetch(hc->store_handle, rk->key, rk->keylen, &dlen);
572 void *to_free = data;
573 if (!data)
574 {
575 goto end;
576 }
577
578 /* restore uidvalidity and crc */
579 size_t hlen = header_size();
580 if (hlen > dlen)
581 {
582 goto end;
583 }
584 int off = 0;
585 serial_restore_uint32_t(&hce.uidvalidity, data, &off);
586 serial_restore_int(&hce.crc, data, &off);
587 assert((size_t) off == hlen);
588 if ((hce.crc != hc->crc) || ((uidvalidity != 0) && (uidvalidity != hce.uidvalidity)))
589 {
590 goto end;
591 }
592
593#ifdef USE_HCACHE_COMPRESSION
594 if (hc->compr_ops)
595 {
596 void *dblob = hc->compr_ops->decompress(hc->compr_handle,
597 (char *) data + hlen, dlen - hlen);
598 if (!dblob)
599 {
600 goto end;
601 }
602 data = (char *) dblob - hlen; /* restore skips uidvalidity and crc */
603 }
604#endif
605
606 hce.email = restore_email(data);
607
608end:
609 free_raw(hc, &to_free);
610 return hce;
611}
static struct Email * restore_email(const unsigned char *d)
Restore an Email from data retrieved from the cache.
Definition: hcache.c:270
static void free_raw(struct HeaderCache *hc, void **data)
Multiplexor for StoreOps::free.
Definition: hcache.c:425
static struct RealKey * realkey(struct HeaderCache *hc, const char *key, size_t keylen, bool compress)
Compute the real key used in the backend, taking into account the compression method.
Definition: hcache.c:83
void *(* decompress)(ComprHandle *handle, const char *cbuf, size_t clen)
Definition: lib.h:110
Wrapper for Email retrieved from the header cache.
Definition: lib.h:101
uint32_t uidvalidity
IMAP-specific UIDVALIDITY.
Definition: lib.h:102
struct Email * email
Retrieved email.
Definition: lib.h:104
unsigned int crc
CRC of Email/Body/etc structs.
Definition: lib.h:103
void *(* fetch)(StoreHandle *store, const char *key, size_t klen, size_t *vlen)
Definition: lib.h:99
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_fetch_raw_obj_full()

bool hcache_fetch_raw_obj_full ( 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]hcPointer to the struct HeaderCache structure got by hcache_open()
[in]keyMessage identification string
[in]keylenLength of the string pointed to by key
[out]dstPointer to the destination object
[in]dstlenSize of the destination object
Return values
trueSuccess, the data was found and the length matches
falseOtherwise

Definition at line 623 of file hcache.c.

625{
626 bool rc = true;
627 size_t srclen = 0;
628
629 struct RealKey *rk = realkey(hc, key, keylen, false);
630 void *src = hc->store_ops->fetch(hc->store_handle, rk->key, rk->keylen, &srclen);
631
632 if (src && (srclen == dstlen))
633 {
634 memcpy(dst, src, dstlen);
635 }
636 else
637 {
638 rc = false;
639 }
640 free_raw(hc, &src);
641 return rc;
642}
+ Here is the call graph for this function:

◆ hcache_fetch_raw_str()

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

Fetch a string from the cache.

Parameters
[in]hcPointer to the struct HeaderCache structure got by hcache_open()
[in]keyMessage identification string
[in]keylenLength of the string pointed to by key
Return values
ptrSuccess, the data if found
NULLOtherwise

Definition at line 652 of file hcache.c.

653{
654 char *res = NULL;
655 size_t dlen = 0;
656
657 struct RealKey *rk = realkey(hc, key, keylen, false);
658 void *data = hc->store_ops->fetch(hc->store_handle, rk->key, rk->keylen, &dlen);
659 if (data)
660 {
661 res = mutt_strn_dup(data, dlen);
662 free_raw(hc, &data);
663 }
664 return res;
665}
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition: string.c:452
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_store_email()

int hcache_store_email ( 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 670 of file hcache.c.

672{
673 if (!hc)
674 return -1;
675
676 int dlen = 0;
677 char *data = dump_email(hc, e, &dlen, uidvalidity);
678
679#ifdef USE_HCACHE_COMPRESSION
680 if (hc->compr_ops)
681 {
682 /* We don't compress uidvalidity and the crc, so we can check them before
683 * decompressing on fetch(). */
684 size_t hlen = header_size();
685
686 /* data / dlen gets ptr to compressed data here */
687 size_t clen = dlen;
688 void *cdata = hc->compr_ops->compress(hc->compr_handle, data + hlen, dlen - hlen, &clen);
689 if (!cdata)
690 {
691 FREE(&data);
692 return -1;
693 }
694
695 char *whole = mutt_mem_malloc(hlen + clen);
696 memcpy(whole, data, hlen);
697 memcpy(whole + hlen, cdata, clen);
698
699 FREE(&data);
700
701 data = whole;
702 dlen = hlen + clen;
703 }
704#endif
705
706 struct RealKey *rk = realkey(hc, key, keylen, true);
707 int rc = hc->store_ops->store(hc->store_handle, rk->key, rk->keylen, data, dlen);
708
709 FREE(&data);
710
711 return rc;
712}
static void * dump_email(struct HeaderCache *hc, const struct Email *e, int *off, uint32_t uidvalidity)
Serialise an Email object.
Definition: hcache.c:230
void *(* compress)(ComprHandle *handle, const char *data, size_t dlen, size_t *clen)
Definition: lib.h:94
int(* store)(StoreHandle *store, const char *key, size_t klen, void *value, size_t vlen)
Definition: lib.h:124
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_store_raw()

int 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 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 724 of file hcache.c.

726{
727 if (!hc)
728 return -1;
729
730 struct RealKey *rk = realkey(hc, key, keylen, false);
731 int rc = hc->store_ops->store(hc->store_handle, rk->key, rk->keylen, data, dlen);
732
733 return rc;
734}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_delete_email()

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

Multiplexor for StoreOps::delete_record.

Delete a key / data pair.

Definition at line 739 of file hcache.c.

740{
741 if (!hc)
742 return -1;
743
744 struct RealKey *rk = realkey(hc, key, keylen, true);
745
746 return hc->store_ops->delete_record(hc->store_handle, rk->key, rk->keylen);
747}
int(* delete_record)(StoreHandle *store, const char *key, size_t klen)
Definition: lib.h:137
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ hcache_delete_raw()

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

Multiplexor for StoreOps::delete_record.

Delete a key / data pair.

Definition at line 752 of file hcache.c.

753{
754 if (!hc)
755 return -1;
756
757 struct RealKey *rk = realkey(hc, key, keylen, false);
758
759 return hc->store_ops->delete_record(hc->store_handle, rk->key, rk->keylen);
760}
+ 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.