mailboxes.c File Reference

Parse Mailboxes Commands. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mailboxes.h"
#include "parse/lib.h"
#include "muttlib.h"
#include "mx.h"
#include "monitor.h"

Include dependency graph for mailboxes.c:

Go to the source code of this file.

Functions
static enum CommandResult	mailbox_add (const char *folder, const char *mailbox, const char *label, enum TriBool poll, enum TriBool notify, struct Buffer *err)
	Add a new Mailbox.
bool	mailbox_add_simple (const char *mailbox, struct Buffer *err)
	Add a new Mailbox.
void	parse_mailbox_free (struct ParseMailbox *pm)
	Free a ParseMailbox structure.
void	parse_mailbox_array_free (struct ParseMailboxArray *pma)
	Free a ParseMailboxArray.
bool	parse_mailboxes_args (const struct Command *cmd, struct Buffer *line, struct Buffer *err, struct ParseMailboxArray *args)
	Parse the 'mailboxes' and 'named-mailboxes' commands.
enum CommandResult	parse_mailboxes_exec (const struct Command *cmd, struct ParseMailboxArray *args, struct Buffer *err)
	Execute the 'mailboxes' or 'named-mailboxes' command.
enum CommandResult	parse_mailboxes (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mailboxes' command - Implements Command::parse() -.
static void	do_unmailboxes (struct Mailbox *m)
	Remove a Mailbox from the Sidebar/notifications.
bool	mailbox_remove_simple (const char *mailbox)
	Remove a Mailbox.
static void	do_unmailboxes_star (void)
	Remove all Mailboxes from the Sidebar/notifications.
enum CommandResult	parse_unmailboxes (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmailboxes' command - Implements Command::parse() -.

Detailed Description

Parse Mailboxes Commands.

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 mailboxes.c.

Function Documentation

mailbox_add()

static enum CommandResult mailbox_add ( const char * folder, const char * mailbox, const char * label, enum TriBool poll, enum TriBool notify, struct Buffer * err )

static

Add a new Mailbox.

Parameters

folder	Path to use for '+' abbreviations
mailbox	Mailbox to add
label	Descriptive label
poll	Enable mailbox polling?
notify	Enable mailbox notification?
err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 53 of file mailboxes.c.

{
  mutt_debug(LL_DEBUG1, "Adding mailbox: '%s' label '%s', poll %s, notify %s\n",
             mailbox, label ? label : "[NONE]",
             (poll == TB_UNSET) ? "[UNSPECIFIED]" :
             (poll == TB_TRUE)  ? "true" :
                                  "false",
             (notify == TB_UNSET) ? "[UNSPECIFIED]" :
             (notify == TB_TRUE)  ? "true" :
                                    "false");
  struct Mailbox *m = mailbox_new();
 
  buf_strcpy(&m->pathbuf, mailbox);
  /* int rc = */ mx_path_canon2(m, folder);
 
  if (m->type <= MUTT_UNKNOWN)
  {
    buf_printf(err, "Unknown Mailbox: %s", m->realpath);
    mailbox_free(&m);
    return MUTT_CMD_ERROR;
  }
 
  bool new_account = false;
  struct Account *a = mx_ac_find(m);
  if (!a)
  {
    a = account_new(NULL, NeoMutt->sub);
    a->type = m->type;
    new_account = true;
  }
 
  if (!new_account)
  {
    struct Mailbox *m_old = mx_mbox_find(a, m->realpath);
    if (m_old)
    {
      if (!m_old->visible)
      {
        m_old->visible = true;
        m_old->gen = mailbox_gen();
      }
 
      if (label)
        mutt_str_replace(&m_old->name, label);
 
      if (notify != TB_UNSET)
        m_old->notify_user = notify;
 
      if (poll != TB_UNSET)
        m_old->poll_new_mail = poll;
 
      struct EventMailbox ev_m = { m_old };
      notify_send(m_old->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
 
      mailbox_free(&m);
      return MUTT_CMD_SUCCESS;
    }
  }
 
  if (label)
    m->name = mutt_str_dup(label);
 
  if (notify != TB_UNSET)
    m->notify_user = notify;
 
  if (poll != TB_UNSET)
    m->poll_new_mail = poll;
 
  if (!mx_ac_add(a, m))
  {
    mailbox_free(&m);
    if (new_account)
    {
      cs_subset_free(&a->sub);
      FREE(&a->name);
      notify_free(&a->notify);
      FREE(&a);
    }
    return MUTT_CMD_SUCCESS;
  }
 
  if (new_account)
  {
    neomutt_account_add(NeoMutt, a);
  }
 
  // this is finally a visible mailbox in the sidebar and mailboxes list
  m->visible = true;
 
#ifdef USE_INOTIFY
  mutt_monitor_add(m);
#endif
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mailbox_add_simple()

bool mailbox_add_simple	(	const char *	mailbox,
		struct Buffer *	err )

Add a new Mailbox.

Parameters

mailbox	Mailbox to add
err	Buffer for error messages

Return values

true

Success

Definition at line 157 of file mailboxes.c.

{
  enum CommandResult rc = mailbox_add("", mailbox, NULL, TB_UNSET, TB_UNSET, err);
 
  return (rc == MUTT_CMD_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_mailbox_free()

void parse_mailbox_free

(

struct ParseMailbox *

pm

)

Free a ParseMailbox structure.

Parameters

pm	ParseMailbox to free

Definition at line 168 of file mailboxes.c.

{
  if (!pm)
    return;
 
  FREE(&pm->path);
  FREE(&pm->label);
}

Here is the caller graph for this function:

parse_mailbox_array_free()

void parse_mailbox_array_free

(

struct ParseMailboxArray *

pma

)

Free a ParseMailboxArray.

Parameters

pma	ParseMailboxArray to free

Definition at line 181 of file mailboxes.c.

{
  if (!pma)
    return;
 
  struct ParseMailbox *pm = NULL;
  ARRAY_FOREACH(pm, pma)
  {
    parse_mailbox_free(pm);
  }
  ARRAY_FREE(pma);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_mailboxes_args()

bool parse_mailboxes_args	(	const struct Command *	cmd,
		struct Buffer *	line,
		struct Buffer *	err,
		struct ParseMailboxArray *	args )

Parse the 'mailboxes' and 'named-mailboxes' commands.

Parameters

[in]	cmd	Command being parsed
[in]	line	Text to parse
[out]	err	Buffer for error messages
[out]	args	Parsed args

Return values

true

Success

Parse:

• mailboxes [[ -label <label> ] | -nolabel ] [ -notify | -nonotify ] [ -poll | -nopoll ] <mailbox> [ ... ]
• named-mailboxes [ -notify | -nonotify ] [ -poll | -nopoll ] <mailbox> [ ... ]

Definition at line 206 of file mailboxes.c.

{
  if (!cmd || !line || !err || !args)
    return false;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return false;
  }
 
  // Parsed (label, mailbox, flags) tuples will be appended to the @args array
  struct Buffer *label = buf_pool_get();
  struct Buffer *mailbox = buf_pool_get();
  struct Buffer *token = buf_pool_get();
  bool rc = false;
 
  while (MoreArgs(line))
  {
    bool label_set = false;
    enum TriBool notify = TB_UNSET;
    enum TriBool poll = TB_UNSET;
 
    do
    {
      // Start by handling the options
      parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
      if (mutt_str_equal(buf_string(token), "-label"))
      {
        if (!MoreArgs(line))
        {
          buf_printf(err, _("%s: too few arguments"), "mailboxes -label");
          goto done;
        }
 
        parse_extract_token(label, line, TOKEN_NO_FLAGS);
        label_set = true;
      }
      else if (mutt_str_equal(buf_string(token), "-nolabel"))
      {
        buf_reset(label);
        label_set = true;
      }
      else if (mutt_str_equal(buf_string(token), "-notify"))
      {
        notify = TB_TRUE;
      }
      else if (mutt_str_equal(buf_string(token), "-nonotify"))
      {
        notify = TB_FALSE;
      }
      else if (mutt_str_equal(buf_string(token), "-poll"))
      {
        poll = TB_TRUE;
      }
      else if (mutt_str_equal(buf_string(token), "-nopoll"))
      {
        poll = TB_FALSE;
      }
      else if ((cmd->id == CMD_NAMED_MAILBOXES) && !label_set)
      {
        if (!MoreArgs(line))
        {
          buf_printf(err, _("%s: too few arguments"), cmd->name);
          goto done;
        }
 
        buf_copy(label, token);
        label_set = true;
      }
      else
      {
        buf_copy(mailbox, token);
        break;
      }
    } while (MoreArgs(line));
 
    if (buf_is_empty(mailbox))
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      goto done;
    }
 
    struct ParseMailbox pm = {
      .path = buf_strdup(mailbox),
      .label = label_set ? buf_strdup(label) : NULL,
      .poll = poll,
      .notify = notify,
    };
    ARRAY_ADD(args, pm);
 
    buf_reset(label);
    buf_reset(mailbox);
  }
 
  rc = true;
 
done:
  buf_pool_release(&label);
  buf_pool_release(&mailbox);
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_mailboxes_exec()

enum CommandResult parse_mailboxes_exec	(	const struct Command *	cmd,
		struct ParseMailboxArray *	args,
		struct Buffer *	err )

Execute the 'mailboxes' or 'named-mailboxes' command.

Parameters

[in]	cmd	Command being executed
[in]	args	Parsed arguments
[out]	err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 319 of file mailboxes.c.

{
  if (!cmd || !args || !err)
    return MUTT_CMD_ERROR;
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  enum CommandResult rc = MUTT_CMD_SUCCESS;
 
  struct ParseMailbox *pm = NULL;
  ARRAY_FOREACH(pm, args)
  {
    rc = mailbox_add(c_folder, pm->path, pm->label, pm->poll, pm->notify, err);
    if (rc != MUTT_CMD_SUCCESS)
      return rc;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_unmailboxes()

static void do_unmailboxes ( struct Mailbox * m )

static

Remove a Mailbox from the Sidebar/notifications.

Parameters

m	Mailbox to unmailboxes

Definition at line 368 of file mailboxes.c.

{
#ifdef USE_INOTIFY
  if (m->poll_new_mail)
    mutt_monitor_remove(m);
#endif
  m->visible = false;
  m->gen = -1;
  if (m->opened)
  {
    struct EventMailbox ev_m = { NULL };
    mutt_debug(LL_NOTIFY, "NT_MAILBOX_CHANGE: NULL\n");
    notify_send(NeoMutt->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
  else
  {
    account_mailbox_remove(m->account, m);
    mailbox_free(&m);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mailbox_remove_simple()

bool mailbox_remove_simple

(

const char *

mailbox

)

Remove a Mailbox.

Parameters

mailbox

Path of Mailbox to remove

Return values

true

Success

Definition at line 394 of file mailboxes.c.

{
  struct Buffer *buf = buf_pool_get();
  buf_strcpy(buf, mailbox);
  expand_path(buf, false);
 
  struct Account **ap = NULL;
  ARRAY_FOREACH(ap, &NeoMutt->accounts)
  {
    struct Mailbox *m = mx_mbox_find(*ap, buf_string(buf));
    if (m)
    {
      do_unmailboxes(m);
      buf_pool_release(&buf);
      return true;
    }
  }
 
  buf_pool_release(&buf);
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_unmailboxes_star()

static void do_unmailboxes_star ( void )

static

Remove all Mailboxes from the Sidebar/notifications.

Definition at line 419 of file mailboxes.c.

{
  struct MailboxArray ma = neomutt_mailboxes_get(NeoMutt, MUTT_MAILBOX_ANY);
 
  struct Mailbox **mp = NULL;
  ARRAY_FOREACH(mp, &ma)
  {
    do_unmailboxes(*mp);
  }
  ARRAY_FREE(&ma); // Clean up the ARRAY, but not the Mailboxes
}

Here is the call graph for this function:

Here is the caller graph for this function: