NeoMutt  2020-06-26-89-g172cd3
Teaching an old dog new tricks
DOXYGEN
bcache.c File Reference

Body Caching - local copies of email bodies. More...

#include "config.h"
#include <dirent.h>
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "email/lib.h"
#include "mutt_account.h"
#include "muttlib.h"
#include "bcache/lib.h"
+ Include dependency graph for bcache.c:

Go to the source code of this file.

Data Structures

struct  BodyCache
 Local cache of email bodies. More...
 

Functions

static int bcache_path (struct ConnAccount *account, const char *mailbox, struct BodyCache *bcache)
 Create the cache path for a given account/mailbox. More...
 
static int mutt_bcache_move (struct BodyCache *bcache, const char *id, const char *newid)
 Change the id of a message in the cache. More...
 
struct BodyCachemutt_bcache_open (struct ConnAccount *account, const char *mailbox)
 Open an Email-Body Cache. More...
 
void mutt_bcache_close (struct BodyCache **bcache)
 Close an Email-Body Cache. More...
 
FILE * mutt_bcache_get (struct BodyCache *bcache, const char *id)
 Open a file in the Body Cache. More...
 
FILE * mutt_bcache_put (struct BodyCache *bcache, const char *id)
 Create a file in the Body Cache. More...
 
int mutt_bcache_commit (struct BodyCache *bcache, const char *id)
 Move a temporary file into the Body Cache. More...
 
int mutt_bcache_del (struct BodyCache *bcache, const char *id)
 Delete a file from the Body Cache. More...
 
int mutt_bcache_exists (struct BodyCache *bcache, const char *id)
 Check if a file exists in the Body Cache. More...
 
int mutt_bcache_list (struct BodyCache *bcache, bcache_list_t want_id, void *data)
 Find matching entries in the Body Cache. More...
 

Variables

bool C_MessageCacheClean
 Config: (imap/pop) Clean out obsolete entries from the message cache. More...
 
char * C_MessageCachedir
 Config: (imap/pop) Directory for the message cache. More...
 

Detailed Description

Body Caching - local copies of email bodies.

Authors
  • Brendan Cully
  • Rocco Rutte

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

Function Documentation

◆ bcache_path()

static int bcache_path ( struct ConnAccount account,
const char *  mailbox,
struct BodyCache bcache 
)
static

Create the cache path for a given account/mailbox.

Parameters
accountAccount info
mailboxMailbox name
bcacheBody cache
Return values
0Success
-1Failure

Definition at line 66 of file bcache.c.

67 {
68  char host[256];
69  struct Url url = { 0 };
70 
71  if (!account || !C_MessageCachedir || !bcache)
72  return -1;
73 
74  /* make up a Url we can turn into a string */
75  mutt_account_tourl(account, &url);
76  /* mutt_account_tourl() just sets up some pointers;
77  * if this ever changes, we have a memleak here */
78  url.path = NULL;
79  if (url_tostring(&url, host, sizeof(host), U_PATH) < 0)
80  {
81  mutt_debug(LL_DEBUG1, "URL to string failed\n");
82  return -1;
83  }
84 
85  struct Buffer *path = mutt_buffer_pool_get();
86  struct Buffer *dst = mutt_buffer_pool_get();
87  mutt_encode_path(path, NONULL(mailbox));
88 
89  mutt_buffer_printf(dst, "%s/%s%s", C_MessageCachedir, host, mutt_b2s(path));
90  if (*(dst->dptr - 1) != '/')
91  mutt_buffer_addch(dst, '/');
92 
93  mutt_debug(LL_DEBUG3, "path: '%s'\n", mutt_b2s(dst));
94  bcache->path = mutt_buffer_strdup(dst);
95 
98  return 0;
99 }
#define NONULL(x)
Definition: string2.h:37
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:66
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
char * mutt_buffer_strdup(struct Buffer *buf)
Copy a Buffer&#39;s string.
Definition: buffer.c:432
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
char * C_MessageCachedir
Config: (imap/pop) Directory for the message cache.
Definition: bcache.c:48
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
void mutt_account_tourl(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:79
#define mutt_b2s(buf)
Definition: buffer.h:41
char * dptr
Current read/write position.
Definition: buffer.h:36
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
char * path
Path.
Definition: url.h:73
Log at debug level 1.
Definition: logging.h:40
int url_tostring(struct Url *url, char *dest, size_t len, int flags)
Output the URL string for a given Url object.
Definition: url.c:418
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
Log at debug level 3.
Definition: logging.h:42
#define U_PATH
Definition: url.h:48
void mutt_encode_path(struct Buffer *buf, const char *src)
Convert a path to &#39;us-ascii&#39;.
Definition: muttlib.c:1474
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_move()

static int mutt_bcache_move ( struct BodyCache bcache,
const char *  id,
const char *  newid 
)
static

Change the id of a message in the cache.

Parameters
bcacheBody cache
idPer-mailbox unique identifier for the message
newidNew id for the message

Definition at line 107 of file bcache.c.

108 {
109  if (!bcache || !id || (*id == '\0') || !newid || (*newid == '\0'))
110  return -1;
111 
112  struct Buffer *path = mutt_buffer_pool_get();
113  struct Buffer *newpath = mutt_buffer_pool_get();
114 
115  mutt_buffer_printf(path, "%s%s", bcache->path, id);
116  mutt_buffer_printf(newpath, "%s%s", bcache->path, newid);
117 
118  mutt_debug(LL_DEBUG3, "bcache: mv: '%s' '%s'\n", mutt_b2s(path), mutt_b2s(newpath));
119 
120  int rc = rename(mutt_b2s(path), mutt_b2s(newpath));
122  mutt_buffer_pool_release(&newpath);
123  return rc;
124 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define mutt_b2s(buf)
Definition: buffer.h:41
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_open()

struct BodyCache* mutt_bcache_open ( struct ConnAccount account,
const char *  mailbox 
)

Open an Email-Body Cache.

Parameters
accountcurrent mailbox' account (required)
mailboxpath to the mailbox of the account (optional)
Return values
NULLFailure

The driver using it is responsible for ensuring that hierarchies are separated by '/' (if it knows of such a concepts like mailboxes or hierarchies)

Definition at line 136 of file bcache.c.

137 {
138  if (!account)
139  return NULL;
140 
141  struct BodyCache *bcache = mutt_mem_calloc(1, sizeof(struct BodyCache));
142  if (bcache_path(account, mailbox, bcache) < 0)
143  {
144  mutt_bcache_close(&bcache);
145  return NULL;
146  }
147 
148  return bcache;
149 }
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
Local cache of email bodies.
Definition: bcache.c:53
static int bcache_path(struct ConnAccount *account, const char *mailbox, struct BodyCache *bcache)
Create the cache path for a given account/mailbox.
Definition: bcache.c:66
void mutt_bcache_close(struct BodyCache **bcache)
Close an Email-Body Cache.
Definition: bcache.c:157
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_close()

void mutt_bcache_close ( struct BodyCache **  bcache)

Close an Email-Body Cache.

Parameters
[out]bcacheBody cache

Free all memory of bcache and finally FREE() it, too.

Definition at line 157 of file bcache.c.

158 {
159  if (!bcache || !*bcache)
160  return;
161  FREE(&(*bcache)->path);
162  FREE(bcache);
163 }
#define FREE(x)
Definition: memory.h:40
+ Here is the caller graph for this function:

◆ mutt_bcache_get()

FILE* mutt_bcache_get ( struct BodyCache bcache,
const char *  id 
)

Open a file in the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
idPer-mailbox unique identifier for the message
Return values
ptrSuccess
NULLFailure

Definition at line 172 of file bcache.c.

173 {
174  if (!id || (*id == '\0') || !bcache)
175  return NULL;
176 
177  struct Buffer *path = mutt_buffer_pool_get();
178  mutt_buffer_addstr(path, bcache->path);
179  mutt_buffer_addstr(path, id);
180 
181  FILE *fp = mutt_file_fopen(mutt_b2s(path), "r");
182 
183  mutt_debug(LL_DEBUG3, "bcache: get: '%s': %s\n", mutt_b2s(path), fp ? "yes" : "no");
184 
186  return fp;
187 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
#define mutt_b2s(buf)
Definition: buffer.h:41
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_put()

FILE* mutt_bcache_put ( struct BodyCache bcache,
const char *  id 
)

Create a file in the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
idPer-mailbox unique identifier for the message
Return values
ptrSuccess
NULLFailure

The returned FILE* is in a temporary location. Use mutt_bcache_commit to put it into place

Definition at line 199 of file bcache.c.

200 {
201  if (!id || (*id == '\0') || !bcache)
202  return NULL;
203 
204  struct Buffer *path = mutt_buffer_pool_get();
205  mutt_buffer_printf(path, "%s%s%s", bcache->path, id, ".tmp");
206 
207  struct stat sb;
208  if (stat(bcache->path, &sb) == 0)
209  {
210  if (!S_ISDIR(sb.st_mode))
211  {
212  mutt_error(_("Message cache isn't a directory: %s"), bcache->path);
213  return NULL;
214  }
215  }
216  else
217  {
218  if (mutt_file_mkdir(bcache->path, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
219  {
220  mutt_error(_("Can't create %s: %s"), bcache->path, strerror(errno));
221  return NULL;
222  }
223  }
224 
225  mutt_debug(LL_DEBUG3, "bcache: put: '%s'\n", path);
226 
227  FILE *fp = mutt_file_fopen(mutt_b2s(path), "w+");
229  return fp;
230 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
int mutt_file_mkdir(const char *path, mode_t mode)
Recursively create directories.
Definition: file.c:875
#define mutt_b2s(buf)
Definition: buffer.h:41
#define mutt_error(...)
Definition: logging.h:84
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_commit()

int mutt_bcache_commit ( struct BodyCache bcache,
const char *  id 
)

Move a temporary file into the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
idPer-mailbox unique identifier for the message
Return values
0Success
-1Failure

Definition at line 239 of file bcache.c.

240 {
241  struct Buffer *tmpid = mutt_buffer_pool_get();
242  mutt_buffer_printf(tmpid, "%s.tmp", id);
243 
244  int rc = mutt_bcache_move(bcache, mutt_b2s(tmpid), id);
245  mutt_buffer_pool_release(&tmpid);
246  return rc;
247 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define mutt_b2s(buf)
Definition: buffer.h:41
static int mutt_bcache_move(struct BodyCache *bcache, const char *id, const char *newid)
Change the id of a message in the cache.
Definition: bcache.c:107
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_del()

int mutt_bcache_del ( struct BodyCache bcache,
const char *  id 
)

Delete a file from the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
idPer-mailbox unique identifier for the message
Return values
0Success
-1Failure

Definition at line 256 of file bcache.c.

257 {
258  if (!id || (*id == '\0') || !bcache)
259  return -1;
260 
261  struct Buffer *path = mutt_buffer_pool_get();
262  mutt_buffer_addstr(path, bcache->path);
263  mutt_buffer_addstr(path, id);
264 
265  mutt_debug(LL_DEBUG3, "bcache: del: '%s'\n", mutt_b2s(path));
266 
267  int rc = unlink(mutt_b2s(path));
269  return rc;
270 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
#define mutt_b2s(buf)
Definition: buffer.h:41
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_exists()

int mutt_bcache_exists ( struct BodyCache bcache,
const char *  id 
)

Check if a file exists in the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
idPer-mailbox unique identifier for the message
Return values
0Success
-1Failure

Definition at line 279 of file bcache.c.

280 {
281  if (!id || (*id == '\0') || !bcache)
282  return -1;
283 
284  struct Buffer *path = mutt_buffer_pool_get();
285  mutt_buffer_addstr(path, bcache->path);
286  mutt_buffer_addstr(path, id);
287 
288  int rc = 0;
289  struct stat st;
290  if (stat(mutt_b2s(path), &st) < 0)
291  rc = -1;
292  else
293  rc = (S_ISREG(st.st_mode) && (st.st_size != 0)) ? 0 : -1;
294 
295  mutt_debug(LL_DEBUG3, "bcache: exists: '%s': %s\n", mutt_b2s(path),
296  (rc == 0) ? "yes" : "no");
297 
299  return rc;
300 }
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
char * path
Definition: bcache.c:55
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
#define mutt_b2s(buf)
Definition: buffer.h:41
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_bcache_list()

int mutt_bcache_list ( struct BodyCache bcache,
bcache_list_t  want_id,
void *  data 
)

Find matching entries in the Body Cache.

Parameters
bcacheBody Cache from mutt_bcache_open()
want_idCallback function called for each match
dataData to pass to the callback function
Return values
-1Failure
>=0count of matching items

This more or less "examines" the cache and calls a function with each id it finds if given.

The optional callback function gets the id of a message, the very same body cache handle mutt_bcache_list() is called with (to, perhaps, perform further operations on the bcache), and a data cookie which is just passed as-is. If the return value of the callback is non-zero, the listing is aborted and continued otherwise. The callback is optional so that this function can be used to count the items in the cache (see below for return value).

Definition at line 321 of file bcache.c.

322 {
323  DIR *d = NULL;
324  struct dirent *de = NULL;
325  int rc = -1;
326 
327  if (!bcache || !(d = opendir(bcache->path)))
328  goto out;
329 
330  rc = 0;
331 
332  mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s'\n", bcache->path);
333 
334  while ((de = readdir(d)))
335  {
336  if (mutt_str_startswith(de->d_name, ".") || mutt_str_startswith(de->d_name, ".."))
337  {
338  continue;
339  }
340 
341  mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name);
342 
343  if (want_id && (want_id(de->d_name, bcache, data) != 0))
344  goto out;
345 
346  rc++;
347  }
348 
349 out:
350  if (d)
351  {
352  if (closedir(d) < 0)
353  rc = -1;
354  }
355  mutt_debug(LL_DEBUG3, "bcache: list: did %d entries\n", rc);
356  return rc;
357 }
char * path
Definition: bcache.c:55
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:165
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ C_MessageCacheClean

bool C_MessageCacheClean

Config: (imap/pop) Clean out obsolete entries from the message cache.

Definition at line 44 of file bcache.c.

◆ C_MessageCachedir

char* C_MessageCachedir

Config: (imap/pop) Directory for the message cache.

Definition at line 48 of file bcache.c.