mailbox.c

Go to the documentation of this file.

 
#include "config.h"
#include <assert.h>
#include <sys/stat.h>
#include "config/lib.h"
#include "email/lib.h"
#include "mailbox.h"
#include "neomutt.h"
 
int mailbox_gen(void)
{
  static int gen = 0;
  return gen++;
}
 
struct Mailbox *mailbox_new(void)
{
  struct Mailbox *m = mutt_mem_calloc(1, sizeof(struct Mailbox));
 
  mutt_buffer_init(&m->pathbuf);
  m->notify = notify_new();
 
  m->email_max = 25;
  m->emails = mutt_mem_calloc(m->email_max, sizeof(struct Email *));
  m->v2r = mutt_mem_calloc(m->email_max, sizeof(int));
  m->gen = mailbox_gen();
 
  return m;
}
 
void mailbox_free(struct Mailbox **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Mailbox *m = *ptr;
 
  mailbox_changed(m, NT_MAILBOX_CLOSED);
 
  if (m->mdata && m->mdata_free)
    m->mdata_free(&m->mdata);
 
  for (size_t i = 0; i < m->email_max; i++)
    email_free(&m->emails[i]);
 
  mutt_buffer_dealloc(&m->pathbuf);
  cs_subset_free(&m->sub);
  FREE(&m->name);
  FREE(&m->realpath);
  FREE(&m->emails);
  FREE(&m->v2r);
  notify_free(&m->notify);
  mailbox_gc_run();
 
  FREE(ptr);
}
 
struct Mailbox *mailbox_find(const char *path)
{
  if (!path)
    return NULL;
 
  struct stat sb;
  struct stat tmp_sb;
 
  if (stat(path, &sb) != 0)
    return NULL;
 
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  struct Mailbox *m = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    if ((stat(mailbox_path(np->mailbox), &tmp_sb) == 0) &&
        (sb.st_dev == tmp_sb.st_dev) && (sb.st_ino == tmp_sb.st_ino))
    {
      m = np->mailbox;
      break;
    }
  }
  neomutt_mailboxlist_clear(&ml);
 
  return m;
}
 
struct Mailbox *mailbox_find_name(const char *name)
{
  if (!name)
    return NULL;
 
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  struct Mailbox *m = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    if (mutt_str_equal(np->mailbox->name, name))
    {
      m = np->mailbox;
      break;
    }
  }
  neomutt_mailboxlist_clear(&ml);
 
  return m;
}
 
void mailbox_update(struct Mailbox *m)
{
  struct stat sb;
 
  if (!m)
    return;
 
  if (stat(mailbox_path(m), &sb) == 0)
    m->size = (off_t) sb.st_size;
  else
    m->size = 0;
}
 
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
{
  if (!m)
    return;
 
  struct EventMailbox ev_m = { m };
  notify_send(m->notify, NT_MAILBOX, action, &ev_m);
}
 
void mailbox_size_add(struct Mailbox *m, const struct Email *e)
{
  m->size += email_size(e);
}
 
void mailbox_size_sub(struct Mailbox *m, const struct Email *e)
{
  m->size -= email_size(e);
}
 
bool mailbox_set_subset(struct Mailbox *m, struct ConfigSubset *sub)
{
  if (!m || m->sub || !sub)
    return false;
 
  m->sub = cs_subset_new(m->name, sub, m->notify);
  m->sub->scope = SET_SCOPE_MAILBOX;
  return true;
}
 
static struct
{
  struct Email *arr[10];
  size_t idx;
} gc = { 0 };
 
void mailbox_gc_add(struct Email *e)
{
  assert(e);
  if (gc.idx == mutt_array_size(gc.arr))
  {
    mailbox_gc_run();
  }
  gc.arr[gc.idx++] = e;
}
 
/*
 * mailbox_gc_run - Run the garbage-collection
 */
void mailbox_gc_run(void)
{
  for (size_t i = 0; i < gc.idx; i++)
  {
    email_free(&gc.arr[i]);
  }
  gc.idx = 0;
}