neomutt.c

Go to the documentation of this file.

 
#include "config.h"
#include <errno.h>
#include <locale.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "neomutt.h"
#include "account.h"
#include "command.h"
#include "mailbox.h"
#include "module_api.h"
#include "muttlib.h"
#ifdef ENABLE_NLS
#include <libintl.h>
#endif
 
struct NeoMutt *NeoMutt = NULL; 

#define CONFIG_INIT_TYPE(CS, NAME)                                             \
  extern const struct ConfigSetType Cst##NAME;                                 \
  cs_register_type(CS, &Cst##NAME)

#define CONFIG_INIT_VARS(CS, NAME)                                             \
  bool config_init_##NAME(struct ConfigSet *cs);                               \
  config_init_##NAME(CS)

static bool init_env(struct NeoMutt *n, char **envp)
{
  if (!n)
    return false;
 
  mutt_str_replace(&n->username, mutt_str_getenv("USER"));
  mutt_str_replace(&n->home_dir, mutt_str_getenv("HOME"));
 
  envlist_free(&n->env);
  n->env = envlist_init(envp);
 
  return true;
}

static bool init_locale(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  setlocale(LC_ALL, "");
 
#ifdef ENABLE_NLS
  const char *domdir = mutt_str_getenv("TEXTDOMAINDIR");
  if (domdir)
    bindtextdomain(PACKAGE, domdir);
  else
    bindtextdomain(PACKAGE, MUTTLOCALEDIR);
  textdomain(PACKAGE);
#endif
 
  n->time_c_locale = duplocale(LC_GLOBAL_LOCALE);
  if (n->time_c_locale)
    n->time_c_locale = newlocale(LC_TIME_MASK, "C", n->time_c_locale);
 
  if (!n->time_c_locale)
  {
    mutt_error("%s", strerror(errno)); // LCOV_EXCL_LINE
    return false;                      // LCOV_EXCL_LINE
  }
 
#ifndef LOCALES_HACK
  /* Do we have a locale definition? */
  if (mutt_str_getenv("LC_ALL") || mutt_str_getenv("LANG") || mutt_str_getenv("LC_CTYPE"))
  {
    OptLocales = true;
  }
#endif
 
  return true;
}
 
#ifdef ENABLE_NLS
static void localise_config(struct ConfigSet *cs)
{
  struct Buffer *value = buf_pool_get();
  struct HashElemArray hea = get_elem_list(cs, GEL_ALL_CONFIG);
  struct HashElem **hep = NULL;
 
  ARRAY_FOREACH(hep, &hea)
  {
    struct HashElem *he = *hep;
    if (!(he->type & D_L10N_STRING))
      continue;
 
    buf_reset(value);
    cs_he_initial_get(cs, he, value);
 
    // Lookup the translation
    const char *l10n = gettext(buf_string(value));
    config_he_set_initial(cs, he, l10n);
  }
 
  ARRAY_FREE(&hea);
  buf_pool_release(&value);
}
#endif

static void reset_tilde(struct ConfigSet *cs)
{
  static const char *names[] = { "folder", "mbox", "postponed", "record" };
 
  struct Buffer *value = buf_pool_get();
  for (size_t i = 0; i < countof(names); i++)
  {
    struct HashElem *he = cs_get_elem(cs, names[i]);
    if (!he)
      continue;
    buf_reset(value);
    cs_he_initial_get(cs, he, value);
    expand_path(value, false);
    config_he_set_initial(cs, he, value->data);
  }
  buf_pool_release(&value);
}

static bool init_config(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  n->cs = cs_new(500);
 
  n->sub = cs_subset_new(NULL, NULL, n->notify);
  n->sub->scope = SET_SCOPE_NEOMUTT;
  n->sub->cs = n->cs;
 
  bool rc = true;
 
  // Set up the Config Types
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->config_define_types)
    {
      mutt_debug(LL_DEBUG3, "%s:config_define_types()\n", mod->name);
      rc &= mod->config_define_types(n, n->sub->cs);
    }
  }
 
  if (!rc)
    return false;
 
  // Define the Config Variables
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->config_define_variables)
    {
      mutt_debug(LL_DEBUG3, "%s:config_define_variables()\n", mod->name);
      rc &= mod->config_define_variables(n, n->sub->cs);
    }
  }
 
  if (!rc)
    return false;
 
  // Post-processing
#ifdef ENABLE_NLS
  localise_config(n->sub->cs);
#endif
  reset_tilde(n->sub->cs);
 
  /* Unset suspend by default if we're the session leader */
  if (getsid(0) == getpid())
    config_str_set_initial(n->sub->cs, "suspend", "no");
 
  return rc;
}

static bool init_commands(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  struct CommandArray *ca = &n->commands;
 
  bool rc = true;
 
  // Set up the Config Types
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->commands_register)
    {
      mutt_debug(LL_DEBUG3, "%s:commands_register()\n", mod->name);
      rc &= mod->commands_register(n, ca);
    }
  }
 
  return rc;
}

static bool init_modules(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  bool rc = true;
 
  // Initialise the Modules
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->init)
    {
      mutt_debug(LL_DEBUG3, "%s:init()\n", mod->name);
      rc &= mod->init(n);
    }
  }
 
  return rc;
}

static bool init_gui_modules(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  bool rc = true;
 
  // Initialise the Gui Modules
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->gui_init)
    {
      mutt_debug(LL_DEBUG3, "%s:gui_init()\n", mod->name);
      rc &= mod->gui_init(n);
    }
  }
 
  return rc;
}

struct NeoMutt *neomutt_new(void)
{
  return MUTT_MEM_CALLOC(1, struct NeoMutt);
}

bool neomutt_init(struct NeoMutt *n, char **envp, const struct Module **modules)
{
  if (!n || !modules)
    return false;
 
  for (int i = 0; modules[i]; i++)
  {
    const struct Module *mod = modules[i];
 
    n->modules[mod->mid] = mod;
  }
 
  if (!init_env(n, envp))
    return false;
 
  if (!init_locale(n))
    return false;
 
  if (!init_config(n))
    return false;
 
  if (!init_commands(n))
    return false;
 
  if (!init_modules(n))
    return false;
 
  ARRAY_INIT(&n->accounts);
  n->notify = notify_new();
  notify_set_parent(n->sub->notify, n->notify);
 
  n->notify_timeout = notify_new();
  notify_set_parent(n->notify_timeout, n->notify);
 
  n->notify_resize = notify_new();
  notify_set_parent(n->notify_resize, n->notify);
 
  // Change the current umask, and save the original one
  n->user_default_umask = umask(077);
  mutt_debug(LL_DEBUG1, "user's umask %03o\n", n->user_default_umask);
  mutt_debug(LL_DEBUG3, "umask set to 077\n");
 
  return true;
}

bool neomutt_gui_init(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  return init_gui_modules(n);
}

static bool cleanup_modules(struct NeoMutt *n)
{
  if (!n)
    return false;
 
  bool rc = true;
 
  // Cleanup the Modules
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    void *mod_data = n->module_data[mod->mid];
 
    if (mod->cleanup && mod_data)
    {
      n->module_data[mod->mid] = NULL;
      mutt_debug(LL_DEBUG3, "%s:cleanup()\n", mod->name);
      rc &= mod->cleanup(n, mod_data);
    }
 
    if (n->module_data[mod->mid])
    {
      mutt_debug(LL_DEBUG1, "Module %s didn't clean up its data\n", mod->name);
      rc = false;
    }
  }
 
  return rc;
}

static void cleanup_gui_modules(struct NeoMutt *n)
{
  if (!n)
    return;
 
  // Cleanup the Gui Modules
  for (enum ModuleId id = MODULE_ID_MAIN; id < MODULE_ID_MAX; id++)
  {
    const struct Module *mod = n->modules[id];
    if (!mod)
      continue;
 
    if (mod->gui_cleanup)
    {
      mutt_debug(LL_DEBUG3, "%s:gui_cleanup()\n", mod->name);
      mod->gui_cleanup(n);
    }
  }
}

void neomutt_cleanup(struct NeoMutt *n)
{
  if (!n)
    return;
 
  cleanup_gui_modules(n);
 
  commands_clear(&n->commands);
  cleanup_modules(n);
}

void neomutt_gui_cleanup(struct NeoMutt *n)
{
  if (!n)
    return;
 
  cleanup_gui_modules(n);
}

void neomutt_free(struct NeoMutt **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct NeoMutt *n = *ptr;
 
  neomutt_accounts_free(n);
 
  if (n->sub)
  {
    struct ConfigSet *cs = n->sub->cs;
    cs_subset_free(&n->sub);
    cs_free(&cs);
  }
 
  notify_free(&n->notify_resize);
  notify_free(&n->notify_timeout);
  notify_free(&n->notify);
  if (n->time_c_locale)
    freelocale(n->time_c_locale);
 
  FREE(&n->home_dir);
  FREE(&n->username);
 
  envlist_free(&n->env);
 
  FREE(ptr);
}

bool neomutt_account_add(struct NeoMutt *n, struct Account *a)
{
  if (!n || !a)
    return false;
 
  ARRAY_ADD(&n->accounts, a);
  notify_set_parent(a->notify, n->notify);
 
  mutt_debug(LL_NOTIFY, "NT_ACCOUNT_ADD: %s %p\n",
             mailbox_get_type_name(a->type), (void *) a);
  struct EventAccount ev_a = { a };
  notify_send(n->notify, NT_ACCOUNT, NT_ACCOUNT_ADD, &ev_a);
  return true;
}

void neomutt_account_remove(struct NeoMutt *n, struct Account *a)
{
  if (!n || !a || ARRAY_EMPTY(&n->accounts))
    return;
 
  struct Account **ap = NULL;
  ARRAY_FOREACH(ap, &n->accounts)
  {
    if ((*ap) != a)
      continue;
 
    ARRAY_REMOVE(&n->accounts, ap);
    account_free(&a);
    break;
  }
}

void neomutt_accounts_free(struct NeoMutt *n)
{
  if (!n)
    return;
 
  if (!ARRAY_EMPTY(&n->accounts))
  {
    mutt_debug(LL_NOTIFY, "NT_ACCOUNT_DELETE_ALL\n");
    struct EventAccount ev_a = { NULL };
    notify_send(n->notify, NT_ACCOUNT, NT_ACCOUNT_DELETE_ALL, &ev_a);
 
    struct Account **ap = NULL;
    ARRAY_FOREACH(ap, &n->accounts)
    {
      account_free(ap);
    }
  }
 
  ARRAY_FREE(&n->accounts);
}

struct MailboxArray neomutt_mailboxes_get(struct NeoMutt *n, enum MailboxType type)
{
  struct MailboxArray ma = ARRAY_HEAD_INITIALIZER;
 
  if (!n)
    return ma;
 
  struct Account **ap = NULL;
  struct Mailbox **mp = NULL;
 
  ARRAY_FOREACH(ap, &n->accounts)
  {
    struct Account *a = *ap;
    if ((type > MUTT_UNKNOWN) && (a->type != type))
      continue;
 
    ARRAY_FOREACH(mp, &a->mailboxes)
    {
      ARRAY_ADD(&ma, *mp);
    }
  }
 
  return ma;
}

FILE *mutt_file_fopen_masked_full(const char *path, const char *mode,
                                  const char *file, int line, const char *func)
{
  // Set the user's umask (saved on startup)
  mode_t old_umask = umask(NeoMutt->user_default_umask);
  mutt_debug(LL_DEBUG3, "umask set to %03o\n", NeoMutt->user_default_umask);
 
  // The permissions will be limited by the umask
  FILE *fp = mutt_file_fopen_full(path, mode, 0666, file, line, func);
 
  umask(old_umask); // Immediately restore the umask
  mutt_debug(LL_DEBUG3, "umask set to %03o\n", old_umask);
 
  return fp;
}

void *neomutt_get_module_data(struct NeoMutt *n, enum ModuleId id)
{
  if (!n)
    return NULL;
 
  return n->module_data[id];
}

void neomutt_set_module_data(struct NeoMutt *n, enum ModuleId id, void *data)
{
  if (!n)
    return;
 
  n->module_data[id] = data;
}