bcache.c

Go to the documentation of this file.

 
#include "config.h"
#include <dirent.h>
#include <errno.h>
#include <stdio.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 "conn/lib.h"
#include "lib.h"
#include "muttlib.h"
 
struct BodyCache
{
  char *path; 
};
 
static int bcache_path(struct ConnAccount *account, const char *mailbox, struct BodyCache *bcache)
{
  const char *const c_message_cache_dir = cs_subset_path(NeoMutt->sub, "message_cache_dir");
  if (!account || !c_message_cache_dir || !bcache)
    return -1;
 
  struct stat st = { 0 };
  if (!((stat(c_message_cache_dir, &st) == 0) && S_ISDIR(st.st_mode)))
  {
    mutt_error(_("Cache disabled, $message_cache_dir isn't a directory: %s"), c_message_cache_dir);
    return -1;
  }
 
  struct Url url = { 0 };
  struct Buffer *host = buf_pool_get();
 
  /* make up a Url we can turn into a string */
  account_to_url(account, &url);
  /* account_to_url() just sets up some pointers;
   * if this ever changes, we have a memleak here */
  url.path = NULL;
  if (url_tostring(&url, host->data, host->dsize, U_PATH) < 0)
  {
    mutt_debug(LL_DEBUG1, "URL to string failed\n");
    buf_pool_release(&host);
    return -1;
  }
  buf_fix_dptr(host);
 
  buf_addstr(host, mailbox);
 
  struct Buffer *path = buf_pool_get();
  struct Buffer *dst = buf_pool_get();
  mutt_encode_path(path, buf_string(host));
 
  buf_printf(dst, "%s/%s", c_message_cache_dir, buf_string(path));
  if (*(dst->dptr - 1) != '/')
    buf_addch(dst, '/');
 
  mutt_debug(LL_DEBUG3, "path: '%s'\n", buf_string(dst));
  bcache->path = buf_strdup(dst);
 
  buf_pool_release(&host);
  buf_pool_release(&path);
  buf_pool_release(&dst);
  return 0;
}
 
static int mutt_bcache_move(struct BodyCache *bcache, const char *id, const char *newid)
{
  if (!bcache || !id || (*id == '\0') || !newid || (*newid == '\0'))
    return -1;
 
  struct Buffer *path = buf_pool_get();
  struct Buffer *newpath = buf_pool_get();
 
  buf_printf(path, "%s%s", bcache->path, id);
  buf_printf(newpath, "%s%s", bcache->path, newid);
 
  mutt_debug(LL_DEBUG3, "bcache: mv: '%s' '%s'\n", buf_string(path), buf_string(newpath));
 
  int rc = rename(buf_string(path), buf_string(newpath));
  buf_pool_release(&path);
  buf_pool_release(&newpath);
  return rc;
}
 
struct BodyCache *mutt_bcache_open(struct ConnAccount *account, const char *mailbox)
{
  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;
}
 
void mutt_bcache_close(struct BodyCache **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct BodyCache *bcache = *ptr;
  FREE(&bcache->path);
 
  FREE(ptr);
}
 
FILE *mutt_bcache_get(struct BodyCache *bcache, const char *id)
{
  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;
}
 
FILE *mutt_bcache_put(struct BodyCache *bcache, const char *id)
{
  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;
}
 
int mutt_bcache_commit(struct BodyCache *bcache, const char *id)
{
  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;
}
 
int mutt_bcache_del(struct BodyCache *bcache, const char *id)
{
  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;
}
 
int mutt_bcache_exists(struct BodyCache *bcache, const char *id)
{
  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;
}
 
int mutt_bcache_list(struct BodyCache *bcache, bcache_list_t want_id, void *data)
{
  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;
}