NeoMutt  2021-02-05-89-gabe350
Teaching an old dog new tricks
DOXYGEN
lib.h File Reference
#include <stdio.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.

Typedefs

typedef int(* bcache_list_t) (const char *id, struct BodyCache *bcache, void *data)
 Prototype for mutt_bcache_list() callback. More...
 

Functions

void mutt_bcache_close (struct BodyCache **bcache)
 Close an Email-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...
 
FILE * mutt_bcache_get (struct BodyCache *bcache, const char *id)
 Open a file 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...
 
struct BodyCachemutt_bcache_open (struct ConnAccount *account, const char *mailbox)
 Open an Email-Body Cache. More...
 
FILE * mutt_bcache_put (struct BodyCache *bcache, const char *id)
 Create a file 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 lib.h.

Typedef Documentation

◆ bcache_list_t

typedef int(* bcache_list_t) (const char *id, struct BodyCache *bcache, void *data)

Prototype for mutt_bcache_list() callback.

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

mutt_bcache_list() will call this function once for each item in the cache.

Definition at line 56 of file lib.h.

Function Documentation

◆ 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 165 of file bcache.c.

166 {
167  if (!bcache || !*bcache)
168  return;
169  FREE(&(*bcache)->path);
170  FREE(bcache);
171 }
+ 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 248 of file bcache.c.

249 {
250  struct Buffer *tmpid = mutt_buffer_pool_get();
251  mutt_buffer_printf(tmpid, "%s.tmp", id);
252 
253  int rc = mutt_bcache_move(bcache, mutt_buffer_string(tmpid), id);
254  mutt_buffer_pool_release(&tmpid);
255  return rc;
256 }
+ 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 265 of file bcache.c.

266 {
267  if (!id || (*id == '\0') || !bcache)
268  return -1;
269 
270  struct Buffer *path = mutt_buffer_pool_get();
271  mutt_buffer_addstr(path, bcache->path);
272  mutt_buffer_addstr(path, id);
273 
274  mutt_debug(LL_DEBUG3, "bcache: del: '%s'\n", mutt_buffer_string(path));
275 
276  int rc = unlink(mutt_buffer_string(path));
278  return rc;
279 }
+ 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 288 of file bcache.c.

289 {
290  if (!id || (*id == '\0') || !bcache)
291  return -1;
292 
293  struct Buffer *path = mutt_buffer_pool_get();
294  mutt_buffer_addstr(path, bcache->path);
295  mutt_buffer_addstr(path, id);
296 
297  int rc = 0;
298  struct stat st;
299  if (stat(mutt_buffer_string(path), &st) < 0)
300  rc = -1;
301  else
302  rc = (S_ISREG(st.st_mode) && (st.st_size != 0)) ? 0 : -1;
303 
304  mutt_debug(LL_DEBUG3, "bcache: exists: '%s': %s\n", mutt_buffer_string(path),
305  (rc == 0) ? "yes" : "no");
306 
308  return rc;
309 }
+ Here is the call graph for this function:
+ 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 180 of file bcache.c.

181 {
182  if (!id || (*id == '\0') || !bcache)
183  return NULL;
184 
185  struct Buffer *path = mutt_buffer_pool_get();
186  mutt_buffer_addstr(path, bcache->path);
187  mutt_buffer_addstr(path, id);
188 
189  FILE *fp = mutt_file_fopen(mutt_buffer_string(path), "r");
190 
191  mutt_debug(LL_DEBUG3, "bcache: get: '%s': %s\n", mutt_buffer_string(path),
192  fp ? "yes" : "no");
193 
195  return fp;
196 }
+ 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 330 of file bcache.c.

331 {
332  DIR *d = NULL;
333  struct dirent *de = NULL;
334  int rc = -1;
335 
336  if (!bcache || !(d = opendir(bcache->path)))
337  goto out;
338 
339  rc = 0;
340 
341  mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s'\n", bcache->path);
342 
343  while ((de = readdir(d)))
344  {
345  if (mutt_str_startswith(de->d_name, ".") || mutt_str_startswith(de->d_name, ".."))
346  {
347  continue;
348  }
349 
350  mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name);
351 
352  if (want_id && (want_id(de->d_name, bcache, data) != 0))
353  goto out;
354 
355  rc++;
356  }
357 
358 out:
359  if (d)
360  {
361  if (closedir(d) < 0)
362  rc = -1;
363  }
364  mutt_debug(LL_DEBUG3, "bcache: list: did %d entries\n", rc);
365  return rc;
366 }
+ 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 144 of file bcache.c.

145 {
146  if (!account)
147  return NULL;
148 
149  struct BodyCache *bcache = mutt_mem_calloc(1, sizeof(struct BodyCache));
150  if (bcache_path(account, mailbox, bcache) < 0)
151  {
152  mutt_bcache_close(&bcache);
153  return NULL;
154  }
155 
156  return bcache;
157 }
+ 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 208 of file bcache.c.

209 {
210  if (!id || (*id == '\0') || !bcache)
211  return NULL;
212 
213  struct Buffer *path = mutt_buffer_pool_get();
214  mutt_buffer_printf(path, "%s%s%s", bcache->path, id, ".tmp");
215 
216  struct stat sb;
217  if (stat(bcache->path, &sb) == 0)
218  {
219  if (!S_ISDIR(sb.st_mode))
220  {
221  mutt_error(_("Message cache isn't a directory: %s"), bcache->path);
222  return NULL;
223  }
224  }
225  else
226  {
227  if (mutt_file_mkdir(bcache->path, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
228  {
229  mutt_error(_("Can't create %s: %s"), bcache->path, strerror(errno));
230  return NULL;
231  }
232  }
233 
234  mutt_debug(LL_DEBUG3, "bcache: put: '%s'\n", path);
235 
236  FILE *fp = mutt_file_fopen(mutt_buffer_string(path), "w+");
238  return fp;
239 }
+ 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.

mutt_mem_calloc
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
_
#define _(a)
Definition: message.h:28
Buffer
String manipulation buffer.
Definition: buffer.h:33
LL_DEBUG3
@ LL_DEBUG3
Log at debug level 3.
Definition: logging.h:42
BodyCache
Local cache of email bodies.
Definition: bcache.c:53
mutt_file_fopen
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:589
FREE
#define FREE(x)
Definition: memory.h:40
mutt_buffer_pool_release
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
mutt_buffer_pool_get
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
bcache_path
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
BodyCache::path
char * path
Definition: bcache.c:55
mutt_debug
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
mutt_bcache_close
void mutt_bcache_close(struct BodyCache **bcache)
Close an Email-Body Cache.
Definition: bcache.c:165
mutt_buffer_string
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
mutt_bcache_move
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:114
mutt_file_mkdir
int mutt_file_mkdir(const char *path, mode_t mode)
Recursively create directories.
Definition: file.c:875
mutt_buffer_addstr
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
mutt_str_startswith
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:160
mutt_buffer_printf
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
mutt_error
#define mutt_error(...)
Definition: logging.h:84