lib.h File Reference

Body Caching (local copies of email bodies) More...

#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)

Functions
void	mutt_bcache_close (struct BodyCache **ptr)
	Close an Email-Body Cache.
int	mutt_bcache_commit (struct BodyCache *bcache, const char *id)
	Move a temporary file into the Body Cache.
int	mutt_bcache_del (struct BodyCache *bcache, const char *id)
	Delete a file from the Body Cache.
int	mutt_bcache_exists (struct BodyCache *bcache, const char *id)
	Check if a file exists in the Body Cache.
FILE *	mutt_bcache_get (struct BodyCache *bcache, const char *id)
	Open a file in the Body Cache.
int	mutt_bcache_list (struct BodyCache *bcache, bcache_list_t want_id, void *data)
	Find matching entries in the Body Cache.
struct BodyCache *	mutt_bcache_open (struct ConnAccount *account, const char *mailbox)
	Open an Email-Body Cache.
FILE *	mutt_bcache_put (struct BodyCache *bcache, const char *id)
	Create a file in the Body Cache.

Detailed Description

Body Caching (local copies of email bodies)

Authors

• Richard Russon

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.

Typedef Documentation

bcache_list_t

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

Definition at line 54 of file lib.h.

Function Documentation

mutt_bcache_close()

void mutt_bcache_close

(

struct BodyCache **

ptr

)

Close an Email-Body Cache.

Parameters

[out]

ptr

Body cache

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

Definition at line 167 of file bcache.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct BodyCache *bcache = *ptr;
  FREE(&bcache->path);
 
  FREE(ptr);
}

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

bcache	Body Cache from mutt_bcache_open()
id	Per-mailbox unique identifier for the message

Return values

0	Success
-1	Failure

Definition at line 252 of file bcache.c.

{
  struct Buffer *tmpid = buf_pool_get();
  buf_printf(tmpid, "%s.tmp", id);
 
  int rc = mutt_bcache_move(bcache, buf_string(tmpid), id);
  buf_pool_release(&tmpid);
  return rc;
}

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

bcache	Body Cache from mutt_bcache_open()
id	Per-mailbox unique identifier for the message

Return values

0	Success
-1	Failure

Definition at line 269 of file bcache.c.

{
  if (!id || (*id == '\0') || !bcache)
    return -1;
 
  struct Buffer *path = buf_pool_get();
  buf_addstr(path, bcache->path);
  buf_addstr(path, id);
 
  mutt_debug(LL_DEBUG3, "bcache: del: '%s'\n", buf_string(path));
 
  int rc = unlink(buf_string(path));
  buf_pool_release(&path);
  return rc;
}

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

bcache	Body Cache from mutt_bcache_open()
id	Per-mailbox unique identifier for the message

Return values

0	Success
-1	Failure

Definition at line 292 of file bcache.c.

{
  if (!id || (*id == '\0') || !bcache)
    return -1;
 
  struct Buffer *path = buf_pool_get();
  buf_addstr(path, bcache->path);
  buf_addstr(path, id);
 
  int rc = 0;
  struct stat st = { 0 };
  if (stat(buf_string(path), &st) < 0)
    rc = -1;
  else
    rc = (S_ISREG(st.st_mode) && (st.st_size != 0)) ? 0 : -1;
 
  mutt_debug(LL_DEBUG3, "bcache: exists: '%s': %s\n", buf_string(path),
             (rc == 0) ? "yes" : "no");
 
  buf_pool_release(&path);
  return rc;
}

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

bcache	Body Cache from mutt_bcache_open()
id	Per-mailbox unique identifier for the message

Return values

ptr	Success
NULL	Failure

Definition at line 185 of file bcache.c.

{
  if (!id || (*id == '\0') || !bcache)
    return NULL;
 
  struct Buffer *path = buf_pool_get();
  buf_addstr(path, bcache->path);
  buf_addstr(path, id);
 
  FILE *fp = mutt_file_fopen(buf_string(path), "r");
 
  mutt_debug(LL_DEBUG3, "bcache: get: '%s': %s\n", buf_string(path), fp ? "yes" : "no");
 
  buf_pool_release(&path);
  return fp;
}

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

bcache	Body Cache from mutt_bcache_open()
want_id	Callback function called for each match
data	Data to pass to the callback function

Return values

-1	Failure
>=0	count 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 334 of file bcache.c.

{
  DIR *dir = NULL;
  struct dirent *de = NULL;
  int rc = -1;
 
  if (!bcache || !(dir = mutt_file_opendir(bcache->path, MUTT_OPENDIR_NONE)))
    goto out;
 
  rc = 0;
 
  mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s'\n", bcache->path);
 
  while ((de = readdir(dir)))
  {
    if (mutt_str_startswith(de->d_name, ".") || mutt_str_startswith(de->d_name, ".."))
    {
      continue;
    }
 
    mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name);
 
    if (want_id && (want_id(de->d_name, bcache, data) != 0))
      goto out;
 
    rc++;
  }
 
out:
  if (dir)
  {
    if (closedir(dir) < 0)
      rc = -1;
  }
  mutt_debug(LL_DEBUG3, "bcache: list: did %d entries\n", rc);
  return rc;
}

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

account	current mailbox' account (required)
mailbox	path to the mailbox of the account (optional)

Return values

NULL

Failure

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

{
  if (!account)
    return NULL;
 
  struct BodyCache *bcache = MUTT_MEM_CALLOC(1, struct BodyCache);
  if (bcache_path(account, mailbox, bcache) < 0)
  {
    mutt_bcache_close(&bcache);
    return NULL;
  }
 
  return bcache;
}

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

bcache	Body Cache from mutt_bcache_open()
id	Per-mailbox unique identifier for the message

Return values

ptr	Success
NULL	Failure

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

Definition at line 212 of file bcache.c.

{
  if (!id || (*id == '\0') || !bcache)
    return NULL;
 
  struct Buffer *path = buf_pool_get();
  buf_printf(path, "%s%s%s", bcache->path, id, ".tmp");
 
  struct stat st = { 0 };
  if (stat(bcache->path, &st) == 0)
  {
    if (!S_ISDIR(st.st_mode))
    {
      mutt_error(_("Message cache isn't a directory: %s"), bcache->path);
      return NULL;
    }
  }
  else
  {
    if (mutt_file_mkdir(bcache->path, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
    {
      mutt_error(_("Can't create %s: %s"), bcache->path, strerror(errno));
      return NULL;
    }
  }
 
  mutt_debug(LL_DEBUG3, "bcache: put: '%s'\n", buf_string(path));
 
  FILE *fp = mutt_file_fopen(buf_string(path), "w+");
  buf_pool_release(&path);
  return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function: