commands.h File Reference

Manage where the email is piped to external commands. More...

#include <stdbool.h>
#include <stdio.h>

Include dependency graph for commands.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	MessageTransformOpt { TRANSFORM_NONE = 0, TRANSFORM_DECRYPT, TRANSFORM_DECODE }
	Message transformation option. More...
enum	MessageSaveOpt { SAVE_COPY = 0, SAVE_MOVE }
	Message save option. More...

Functions
void	ci_bounce_message (struct Mailbox *m, struct EmailList *el)
	Bounce an email. More...
void	mutt_check_stats (struct Mailbox *m)
	Forcibly update mailbox stats. More...
bool	mutt_check_traditional_pgp (struct Mailbox *m, struct EmailList *el)
	Check if a message has inline PGP content. More...
void	mutt_commands_cleanup (void)
	Clean up commands globals. More...
void	mutt_display_address (struct Envelope *env)
	Display the address of a message. More...
int	mutt_display_message (struct MuttWindow *win_index, struct MuttWindow *win_ibar, struct MuttWindow *win_pager, struct MuttWindow *win_pbar, struct Mailbox *m, struct Email *e)
	Display a message in the pager. More...
bool	mutt_edit_content_type (struct Email *e, struct Body *b, FILE *fp)
	Edit the content type of an attachment. More...
void	mutt_enter_command (void)
	enter a neomutt command More...
void	mutt_pipe_message (struct Mailbox *m, struct EmailList *el)
	Pipe a message. More...
void	mutt_print_message (struct Mailbox *m, struct EmailList *el)
	Print a message. More...
int	mutt_save_message (struct Mailbox *m, struct EmailList *el, enum MessageSaveOpt, enum MessageTransformOpt transform_opt)
	Save an email. More...
int	mutt_save_message_ctx (struct Mailbox *m_src, struct Email *e, enum MessageSaveOpt save_opt, enum MessageTransformOpt transform_opt, struct Mailbox *m_dst)
	Save a message to a given mailbox. More...
bool	mutt_select_sort (bool reverse)
	Ask the user for a sort method. More...
bool	mutt_shell_escape (void)
	invoke a command in a subshell More...

Detailed Description

Manage where the email is piped to external 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 commands.h.

Enumeration Type Documentation

MessageTransformOpt

enum MessageTransformOpt

Message transformation option.

Enumerator
TRANSFORM_NONE	No transformation.
TRANSFORM_DECRYPT	Decrypt message.
TRANSFORM_DECODE	Decode message.

Definition at line 39 of file commands.h.

{
  TRANSFORM_NONE = 0,   
  TRANSFORM_DECRYPT,    
  TRANSFORM_DECODE,     
};

MessageSaveOpt

enum MessageSaveOpt

Message save option.

Enumerator
SAVE_COPY	Copy message, making a duplicate in another mailbox.
SAVE_MOVE	Move message to another mailbox, removing the original.

Definition at line 49 of file commands.h.

{
  SAVE_COPY = 0,   
  SAVE_MOVE,       
};

Function Documentation

ci_bounce_message()

void ci_bounce_message	(	struct Mailbox *	m,
		struct EmailList *	el
	)

Bounce an email.

Parameters

m	Mailbox
el	List of Emails to bounce

Definition at line 434 of file commands.c.

{
  if (!m || !el || STAILQ_EMPTY(el))
    return;

  char prompt[8193];
  char scratch[8192];
  char buf[8192] = { 0 };
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  char *err = NULL;
  int rc;
  int msg_count = 0;

  struct EmailNode *en = NULL;
  STAILQ_FOREACH(en, el, entries)
  {
    /* RFC5322 mandates a From: header,
     * so warn before bouncing messages without one */
    if (TAILQ_EMPTY(&en->email->env->from))
      mutt_error(_("Warning: message contains no From: header"));

    msg_count++;
  }

  if (msg_count == 1)
    mutt_str_copy(prompt, _("Bounce message to: "), sizeof(prompt));
  else
    mutt_str_copy(prompt, _("Bounce tagged messages to: "), sizeof(prompt));

  rc = mutt_get_field(prompt, buf, sizeof(buf), MUTT_ALIAS, false, NULL, NULL);
  if (rc || (buf[0] == '\0'))
    return;

  mutt_addrlist_parse2(&al, buf);
  if (TAILQ_EMPTY(&al))
  {
    mutt_error(_("Error parsing address"));
    return;
  }

  mutt_expand_aliases(&al);

  if (mutt_addrlist_to_intl(&al, &err) < 0)
  {
    mutt_error(_("Bad IDN: '%s'"), err);
    FREE(&err);
    mutt_addrlist_clear(&al);
    return;
  }

  buf[0] = '\0';
  mutt_addrlist_write(&al, buf, sizeof(buf), true);

#define EXTRA_SPACE (15 + 7 + 2)
  snprintf(scratch, sizeof(scratch),
           ngettext("Bounce message to %s?", "Bounce messages to %s?", msg_count), buf);

  const size_t width = msgwin_get_width();
  if (mutt_strwidth(scratch) > (width - EXTRA_SPACE))
  {
    mutt_simple_format(prompt, sizeof(prompt), 0, width - EXTRA_SPACE,
                       JUSTIFY_LEFT, 0, scratch, sizeof(scratch), false);
    mutt_str_cat(prompt, sizeof(prompt), "...?");
  }
  else
    mutt_str_copy(prompt, scratch, sizeof(prompt));

  const enum QuadOption c_bounce = cs_subset_quad(NeoMutt->sub, "bounce");
  if (query_quadoption(c_bounce, prompt) != MUTT_YES)
  {
    mutt_addrlist_clear(&al);
    msgwin_clear_text();
    mutt_message(ngettext("Message not bounced", "Messages not bounced", msg_count));
    return;
  }

  msgwin_clear_text();

  struct Message *msg = NULL;
  STAILQ_FOREACH(en, el, entries)
  {
    msg = mx_msg_open(m, en->email->msgno);
    if (!msg)
    {
      rc = -1;
      break;
    }

    rc = mutt_bounce_message(msg->fp, m, en->email, &al, NeoMutt->sub);
    mx_msg_close(m, &msg);

    if (rc < 0)
      break;
  }

  mutt_addrlist_clear(&al);
  /* If no error, or background, display message. */
  if ((rc == 0) || (rc == S_BKG))
    mutt_message(ngettext("Message bounced", "Messages bounced", msg_count));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_check_stats()

void mutt_check_stats

(

struct Mailbox *

m

)

Forcibly update mailbox stats.

Definition at line 1590 of file commands.c.

{
  mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_FORCE | MUTT_MAILBOX_CHECK_FORCE_STATS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_check_traditional_pgp()

bool mutt_check_traditional_pgp	(	struct Mailbox *	m,
		struct EmailList *	el
	)

Check if a message has inline PGP content.

Parameters

m	Mailbox
el	List of Emails to check

Return values

true	Message contains inline PGP content

Definition at line 1574 of file commands.c.

{
  bool rc = false;
  struct EmailNode *en = NULL;
  STAILQ_FOREACH(en, el, entries)
  {
    if (!(en->email->security & PGP_TRADITIONAL_CHECKED))
      rc = check_traditional_pgp(m, en->email) || rc;
  }

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_commands_cleanup()

void mutt_commands_cleanup

(

void

)

Clean up commands globals.

Definition at line 95 of file commands.c.

{
  mutt_buffer_dealloc(&LastSaveFolder);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_display_address()

void mutt_display_address

(

struct Envelope *

env

)

Display the address of a message.

Parameters

env	Envelope containing address

Definition at line 1026 of file commands.c.

{
  const char *pfx = NULL;
  char buf[128];

  struct AddressList *al = mutt_get_address(env, &pfx);
  if (!al)
    return;

  /* Note: We don't convert IDNA to local representation this time.
   * That is intentional, so the user has an opportunity to copy &
   * paste the on-the-wire form of the address to other, IDN-unable
   * software.  */
  buf[0] = '\0';
  mutt_addrlist_write(al, buf, sizeof(buf), false);
  mutt_message("%s: %s", pfx, buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_display_message()

int mutt_display_message	(	struct MuttWindow *	win_index,
		struct MuttWindow *	win_ibar,
		struct MuttWindow *	win_pager,
		struct MuttWindow *	win_pbar,
		struct Mailbox *	m,
		struct Email *	e
	)

Display a message in the pager.

Parameters

win_index	Index Window
win_ibar	Index Bar Window
win_pager	Pager Window
win_pbar	Pager Bar Window
m	Mailbox
e	Email to display

Return values

0	Success
-1	Error

Definition at line 207 of file commands.c.

{
  int rc = 0;
  bool builtin = false;
  CopyMessageFlags cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
  CopyHeaderFlags chflags;
  pid_t filterpid = -1;
  struct Buffer *tempfile = NULL;
  int res;

  struct Message *msg = mx_msg_open(m, e->msgno);
  if (!msg)
  {
    return -1;
  }

  mutt_parse_mime_message(m, e, msg->fp);
  mutt_message_hook(m, e, MUTT_MESSAGE_HOOK);

  char columns[16];
  // win_pager might not be visible and have a size yet, so use win_index
  snprintf(columns, sizeof(columns), "%d", win_index->state.cols);
  mutt_envlist_set("COLUMNS", columns, true);

  /* see if crypto is needed for this message.  if so, we should exit curses */
  if ((WithCrypto != 0) && e->security)
  {
    if (e->security & SEC_ENCRYPT)
    {
      if (e->security & APPLICATION_SMIME)
        crypt_smime_getkeys(e->env);
      if (!crypt_valid_passphrase(e->security))
        goto cleanup;

      cmflags |= MUTT_CM_VERIFY;
    }
    else if (e->security & SEC_SIGN)
    {
      /* find out whether or not the verify signature */
      /* L10N: Used for the $crypt_verify_sig prompt */
      const enum QuadOption c_crypt_verify_sig =
          cs_subset_quad(NeoMutt->sub, "crypt_verify_sig");
      if (query_quadoption(c_crypt_verify_sig, _("Verify signature?")) == MUTT_YES)
      {
        cmflags |= MUTT_CM_VERIFY;
      }
    }
  }

  if (cmflags & MUTT_CM_VERIFY || e->security & SEC_ENCRYPT)
  {
    if (e->security & APPLICATION_PGP)
    {
      if (!TAILQ_EMPTY(&e->env->from))
        crypt_pgp_invoke_getkeys(TAILQ_FIRST(&e->env->from));

      crypt_invoke_message(APPLICATION_PGP);
    }

    if (e->security & APPLICATION_SMIME)
      crypt_invoke_message(APPLICATION_SMIME);
  }

  FILE *fp_filter_out = NULL;
  tempfile = mutt_buffer_pool_get();
  mutt_buffer_mktemp(tempfile);
  FILE *fp_out = mutt_file_fopen(mutt_buffer_string(tempfile), "w");
  if (!fp_out)
  {
    mutt_error(_("Could not create temporary file"));
    goto cleanup;
  }

  const char *const c_display_filter =
      cs_subset_string(NeoMutt->sub, "display_filter");
  if (c_display_filter)
  {
    fp_filter_out = fp_out;
    fp_out = NULL;
    filterpid = filter_create_fd(c_display_filter, &fp_out, NULL, NULL, -1,
                                 fileno(fp_filter_out), -1);
    if (filterpid < 0)
    {
      mutt_error(_("Can't create display filter"));
      mutt_file_fclose(&fp_filter_out);
      unlink(mutt_buffer_string(tempfile));
      goto cleanup;
    }
  }

  const char *const c_pager = cs_subset_string(NeoMutt->sub, "pager");
  if (!c_pager || mutt_str_equal(c_pager, "builtin"))
    builtin = true;
  else
  {
    char buf[1024] = { 0 };
    const char *const c_pager_format =
        cs_subset_string(NeoMutt->sub, "pager_format");
    mutt_make_string(buf, sizeof(buf), win_index->state.cols, NONULL(c_pager_format),
                     m, Context ? Context->msg_in_pager : -1, e,
                     MUTT_FORMAT_NO_FLAGS, ExtPagerProgress);
    fputs(buf, fp_out);
    fputs("\n\n", fp_out);
  }

  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  chflags = (c_weed ? (CH_WEED | CH_REORDER) : CH_NO_FLAGS) | CH_DECODE | CH_FROM | CH_DISPLAY;
#ifdef USE_NOTMUCH
  if (m->type == MUTT_NOTMUCH)
    chflags |= CH_VIRTUAL;
#endif
  res = mutt_copy_message(fp_out, m, e, msg, cmflags, chflags, win_index->state.cols);

  if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (res < 0))
  {
    mutt_error(_("Could not copy message"));
    if (fp_filter_out)
    {
      filter_wait(filterpid);
      mutt_file_fclose(&fp_filter_out);
    }
    mutt_file_unlink(mutt_buffer_string(tempfile));
    goto cleanup;
  }

  if (fp_filter_out && (filter_wait(filterpid) != 0))
    mutt_any_key_to_continue(NULL);

  mutt_file_fclose(&fp_filter_out); /* XXX - check result? */

  if (WithCrypto)
  {
    /* update crypto information for this message */
    e->security &= ~(SEC_GOODSIGN | SEC_BADSIGN);
    e->security |= crypt_query(e->body);

    /* Remove color cache for this message, in case there
     * are color patterns for both ~g and ~V */
    e->pair = 0;

    /* Process protected headers and autocrypt gossip headers */
    process_protected_headers(m, e);
  }

  if (builtin)
  {
    if ((WithCrypto != 0) && (e->security & APPLICATION_SMIME) && (cmflags & MUTT_CM_VERIFY))
    {
      if (e->security & SEC_GOODSIGN)
      {
        if (crypt_smime_verify_sender(m, e, msg) == 0)
          mutt_message(_("S/MIME signature successfully verified"));
        else
          mutt_error(_("S/MIME certificate owner does not match sender"));
      }
      else if (e->security & SEC_PARTSIGN)
        mutt_message(_("Warning: Part of this message has not been signed"));
      else if (e->security & SEC_SIGN || e->security & SEC_BADSIGN)
        mutt_error(_("S/MIME signature could NOT be verified"));
    }

    if ((WithCrypto != 0) && (e->security & APPLICATION_PGP) && (cmflags & MUTT_CM_VERIFY))
    {
      if (e->security & SEC_GOODSIGN)
        mutt_message(_("PGP signature successfully verified"));
      else if (e->security & SEC_PARTSIGN)
        mutt_message(_("Warning: Part of this message has not been signed"));
      else if (e->security & SEC_SIGN)
        mutt_message(_("PGP signature could NOT be verified"));
    }

    /* Invoke the builtin pager */
    struct PagerData pdata = { 0 };
    struct PagerView pview = { &pdata };

    pdata.fp = msg->fp;
    pdata.fname = mutt_buffer_string(tempfile);

    pview.mode = PAGER_MODE_EMAIL;
    pview.banner = NULL;
    pview.flags = MUTT_PAGER_MESSAGE | (e->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
    pview.win_ibar = win_ibar;
    pview.win_index = win_index;
    pview.win_pbar = win_pbar;
    pview.win_pager = win_pager;
    rc = mutt_pager(&pview);
  }
  else
  {
    mutt_endwin();

    struct Buffer *cmd = mutt_buffer_pool_get();
    mutt_buffer_printf(cmd, "%s %s", NONULL(c_pager), mutt_buffer_string(tempfile));
    int r = mutt_system(mutt_buffer_string(cmd));
    if (r == -1)
      mutt_error(_("Error running \"%s\""), mutt_buffer_string(cmd));
    unlink(mutt_buffer_string(tempfile));
    mutt_buffer_pool_release(&cmd);

    if (!OptNoCurses)
      keypad(stdscr, true);
    if (r != -1)
      mutt_set_flag(m, e, MUTT_READ, true);
    const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
    if ((r != -1) && c_prompt_after)
    {
      mutt_unget_event(mutt_any_key_to_continue(_("Command: ")), 0);
      rc = km_dokey(MENU_PAGER);
    }
    else
      rc = 0;
  }

cleanup:
  mx_msg_close(m, &msg);
  mutt_envlist_unset("COLUMNS");
  mutt_buffer_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_edit_content_type()

bool mutt_edit_content_type	(	struct Email *	e,
		struct Body *	b,
		FILE *	fp
	)

Edit the content type of an attachment.

Parameters

e	Email
b	Attachment
fp	File handle to the attachment

Return values

true	A Any change is made

recvattach requires the return code to know when to regenerate the actx.

Definition at line 1433 of file commands.c.

{
  char buf[1024];
  char obuf[1024];
  char tmp[256];
  char charset[256];

  bool charset_changed = false;
  bool type_changed = false;
  bool structure_changed = false;

  char *cp = mutt_param_get(&b->parameter, "charset");
  mutt_str_copy(charset, cp, sizeof(charset));

  snprintf(buf, sizeof(buf), "%s/%s", TYPE(b), b->subtype);
  mutt_str_copy(obuf, buf, sizeof(obuf));
  if (!TAILQ_EMPTY(&b->parameter))
  {
    size_t l = strlen(buf);
    struct Parameter *np = NULL;
    TAILQ_FOREACH(np, &b->parameter, entries)
    {
      mutt_addr_cat(tmp, sizeof(tmp), np->value, MimeSpecials);
      l += snprintf(buf + l, sizeof(buf) - l, "; %s=%s", np->attribute, tmp);
      if (l >= sizeof(buf))
      {
        // L10N: e.g. "text/plain; charset=UTF-8; ..."
        mutt_error(_("Content type is too long"));
        return false;
      }
    }
  }

  if ((mutt_get_field("Content-Type: ", buf, sizeof(buf), MUTT_COMP_NO_FLAGS,
                      false, NULL, NULL) != 0) ||
      (buf[0] == '\0'))
  {
    return false;
  }

  /* clean up previous junk */
  mutt_param_free(&b->parameter);
  FREE(&b->subtype);

  mutt_parse_content_type(buf, b);

  snprintf(tmp, sizeof(tmp), "%s/%s", TYPE(b), NONULL(b->subtype));
  type_changed = !mutt_istr_equal(tmp, obuf);
  charset_changed =
      !mutt_istr_equal(charset, mutt_param_get(&b->parameter, "charset"));

  /* if in send mode, check for conversion - current setting is default. */

  if (!e && (b->type == TYPE_TEXT) && charset_changed)
  {
    snprintf(tmp, sizeof(tmp), _("Convert to %s upon sending?"),
             mutt_param_get(&b->parameter, "charset"));
    enum QuadOption ans = mutt_yesorno(tmp, b->noconv ? MUTT_NO : MUTT_YES);
    if (ans != MUTT_ABORT)
      b->noconv = (ans == MUTT_NO);
  }

  /* inform the user */

  snprintf(tmp, sizeof(tmp), "%s/%s", TYPE(b), NONULL(b->subtype));
  if (type_changed)
    mutt_message(_("Content-Type changed to %s"), tmp);
  if ((b->type == TYPE_TEXT) && charset_changed)
  {
    if (type_changed)
      mutt_sleep(1);
    mutt_message(b->noconv ? _("Character set changed to %s; not converting") :
                             _("Character set changed to %s; converting"),
                 mutt_param_get(&b->parameter, "charset"));
  }

  b->force_charset |= charset_changed;

  if (!is_multipart(b) && b->parts)
  {
    structure_changed = true;
    mutt_body_free(&b->parts);
  }
  if (!mutt_is_message_type(b->type, b->subtype) && b->email)
  {
    structure_changed = true;
    b->email->body = NULL;
    email_free(&b->email);
  }

  if (fp && !b->parts && (is_multipart(b) || mutt_is_message_type(b->type, b->subtype)))
  {
    structure_changed = true;
    mutt_parse_part(fp, b);
  }

  if ((WithCrypto != 0) && e)
  {
    if (e->body == b)
      e->security = SEC_NO_FLAGS;

    e->security |= crypt_query(b);
  }

  return structure_changed | type_changed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_enter_command()

void mutt_enter_command

(

void

)

enter a neomutt command

Definition at line 978 of file commands.c.

{
  char buf[1024] = { 0 };

  window_redraw(NULL);
  /* if enter is pressed after : with no command, just return */
  if ((mutt_get_field(":", buf, sizeof(buf), MUTT_COMMAND, false, NULL, NULL) != 0) ||
      (buf[0] == '\0'))
  {
    return;
  }

  struct Buffer err = mutt_buffer_make(256);

  /* check if buf is a valid icommand, else fall back quietly to parse_rc_lines */
  enum CommandResult rc = mutt_parse_icommand(buf, &err);
  if (!mutt_buffer_is_empty(&err))
  {
    /* since errbuf could potentially contain printf() sequences in it,
     * we must call mutt_error() in this fashion so that vsprintf()
     * doesn't expect more arguments that we passed */
    if (rc == MUTT_CMD_ERROR)
      mutt_error("%s", err.data);
    else
      mutt_warning("%s", err.data);
  }
  else if (rc != MUTT_CMD_SUCCESS)
  {
    rc = mutt_parse_rc_line(buf, &err);
    if (!mutt_buffer_is_empty(&err))
    {
      if (rc == MUTT_CMD_SUCCESS) /* command succeeded with message */
        mutt_message("%s", err.data);
      else if (rc == MUTT_CMD_ERROR)
        mutt_error("%s", err.data);
      else if (rc == MUTT_CMD_WARNING)
        mutt_warning("%s", err.data);
    }
  }
  /* else successful command */

  mutt_buffer_dealloc(&err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pipe_message()

void mutt_pipe_message	(	struct Mailbox *	m,
		struct EmailList *	el
	)

Pipe a message.

Parameters

m	Mailbox
el	List of Emails to pipe

Definition at line 760 of file commands.c.

{
  if (!m || !el)
    return;

  struct Buffer *buf = mutt_buffer_pool_get();

  if (mutt_buffer_get_field(_("Pipe to command: "), buf, MUTT_CMD, false, NULL,
                            NULL, NULL) != 0)
  {
    goto cleanup;
  }

  if (mutt_buffer_len(buf) == 0)
    goto cleanup;

  mutt_buffer_expand_path(buf);
  const bool c_pipe_decode = cs_subset_bool(NeoMutt->sub, "pipe_decode");
  const bool c_pipe_split = cs_subset_bool(NeoMutt->sub, "pipe_split");
  const char *const c_pipe_sep = cs_subset_string(NeoMutt->sub, "pipe_sep");
  pipe_message(m, el, mutt_buffer_string(buf), c_pipe_decode, false, c_pipe_split, c_pipe_sep);

cleanup:
  mutt_buffer_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_print_message()

void mutt_print_message	(	struct Mailbox *	m,
		struct EmailList *	el
	)

Print a message.

Parameters

m	Mailbox
el	List of Emails to print

Definition at line 791 of file commands.c.

{
  if (!m || !el)
    return;

  const enum QuadOption c_print = cs_subset_quad(NeoMutt->sub, "print");
  const char *const c_print_command =
      cs_subset_string(NeoMutt->sub, "print_command");
  if (c_print && !c_print_command)
  {
    mutt_message(_("No printing command has been defined"));
    return;
  }

  int msg_count = 0;
  struct EmailNode *en = NULL;
  STAILQ_FOREACH(en, el, entries)
  {
    msg_count++;
  }

  if (query_quadoption(c_print, (msg_count == 1) ?
                                    _("Print message?") :
                                    _("Print tagged messages?")) != MUTT_YES)
  {
    return;
  }

  const bool c_print_decode = cs_subset_bool(NeoMutt->sub, "print_decode");
  const bool c_print_split = cs_subset_bool(NeoMutt->sub, "print_split");
  if (pipe_message(m, el, c_print_command, c_print_decode, true, c_print_split, "\f") == 0)
    mutt_message(ngettext("Message printed", "Messages printed", msg_count));
  else
  {
    mutt_message(ngettext("Message could not be printed",
                          "Messages could not be printed", msg_count));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_save_message()

int mutt_save_message	(	struct Mailbox *	m,
		struct EmailList *	el,
		enum MessageSaveOpt	save_opt,
		enum MessageTransformOpt	transform_opt
	)

Save an email.

Parameters

m	Mailbox
el	List of Emails to save
save_opt	Copy or move, e.g. SAVE_MOVE
transform_opt	Transformation, e.g. TRANSFORM_DECRYPT

Return values

0	Copy/save was successful
-1	Error/abort

Definition at line 1144 of file commands.c.

{
  if (!el || STAILQ_EMPTY(el))
    return -1;

  int rc = -1;
  int tagged_progress_count = 0;
  unsigned int msg_count = 0;

  struct Buffer *buf = mutt_buffer_pool_get();
  struct stat st;
  struct EmailNode *en = NULL;

  STAILQ_FOREACH(en, el, entries)
  {
    msg_count++;
  }
  en = STAILQ_FIRST(el);

  const SecurityFlags security_flags = WithCrypto ? en->email->security : SEC_NO_FLAGS;
  const bool is_passphrase_needed = security_flags & SEC_ENCRYPT;

  const char *prompt = NULL;
  const char *progress_msg = NULL;

  // Set prompt and progress_msg
  switch (save_opt)
  {
    case SAVE_COPY:
      // L10N: Progress meter message when copying tagged messages
      progress_msg = (msg_count > 1) ? _("Copying tagged messages...") : NULL;
      switch (transform_opt)
      {
        case TRANSFORM_NONE:
          prompt = (msg_count > 1) ? _("Copy tagged to mailbox") : _("Copy to mailbox");
          break;
        case TRANSFORM_DECRYPT:
          prompt = (msg_count > 1) ? _("Decrypt-copy tagged to mailbox") :
                                     _("Decrypt-copy to mailbox");
          break;
        case TRANSFORM_DECODE:
          prompt = (msg_count > 1) ? _("Decode-copy tagged to mailbox") :
                                     _("Decode-copy to mailbox");
          break;
      }
      break;

    case SAVE_MOVE:
      // L10N: Progress meter message when saving tagged messages
      progress_msg = (msg_count > 1) ? _("Saving tagged messages...") : NULL;
      switch (transform_opt)
      {
        case TRANSFORM_NONE:
          prompt = (msg_count > 1) ? _("Save tagged to mailbox") : _("Save to mailbox");
          break;
        case TRANSFORM_DECRYPT:
          prompt = (msg_count > 1) ? _("Decrypt-save tagged to mailbox") :
                                     _("Decrypt-save to mailbox");
          break;
        case TRANSFORM_DECODE:
          prompt = (msg_count > 1) ? _("Decode-save tagged to mailbox") :
                                     _("Decode-save to mailbox");
          break;
      }
      break;
  }

  mutt_message_hook(m, en->email, MUTT_MESSAGE_HOOK);
  mutt_default_save(buf->data, buf->dsize, en->email);
  mutt_buffer_fix_dptr(buf);
  mutt_buffer_pretty_mailbox(buf);

  if (mutt_buffer_enter_fname(prompt, buf, false, NULL, false, NULL, NULL,
                              MUTT_SEL_NO_FLAGS) == -1)
  {
    goto cleanup;
  }

  size_t pathlen = mutt_buffer_len(buf);
  if (pathlen == 0)
    goto cleanup;

  /* Trim any trailing '/' */
  if (buf->data[pathlen - 1] == '/')
    buf->data[pathlen - 1] = '\0';

  /* This is an undocumented feature of ELM pointed out to me by Felix von
   * Leitner <leitner@prz.fu-berlin.de> */
  if (mutt_buffer_len(&LastSaveFolder) == 0)
    mutt_buffer_alloc(&LastSaveFolder, PATH_MAX);
  if (mutt_str_equal(mutt_buffer_string(buf), "."))
    mutt_buffer_copy(buf, &LastSaveFolder);
  else
    mutt_buffer_strcpy(&LastSaveFolder, mutt_buffer_string(buf));

  mutt_buffer_expand_path(buf);

  /* check to make sure that this file is really the one the user wants */
  if (mutt_save_confirm(mutt_buffer_string(buf), &st) != 0)
    goto cleanup;

  if (is_passphrase_needed && (transform_opt != TRANSFORM_NONE) &&
      !crypt_valid_passphrase(security_flags))
  {
    rc = -1;
    goto errcleanup;
  }

  mutt_message(_("Copying to %s..."), mutt_buffer_string(buf));

#ifdef USE_IMAP
  enum MailboxType mailbox_type = imap_path_probe(mutt_buffer_string(buf), NULL);
  if ((m->type == MUTT_IMAP) && (transform_opt == TRANSFORM_NONE) && (mailbox_type == MUTT_IMAP))
  {
    rc = imap_copy_messages(m, el, mutt_buffer_string(buf), save_opt);
    switch (rc)
    {
      /* success */
      case 0:
        mutt_clear_error();
        rc = 0;
        goto cleanup;
      /* non-fatal error: continue to fetch/append */
      case 1:
        break;
      /* fatal error, abort */
      case -1:
        goto errcleanup;
    }
  }
#endif

  mutt_file_resolve_symlink(buf);
  struct Mailbox *m_save = mx_path_resolve(mutt_buffer_string(buf));
  bool old_append = m_save->append;
  OpenMailboxFlags mbox_flags = MUTT_NEWFOLDER;
  /* Display a tagged message progress counter, rather than (for
   * IMAP) a per-message progress counter */
  if (msg_count > 1)
    mbox_flags |= MUTT_QUIET;
  if (!mx_mbox_open(m_save, mbox_flags))
  {
    rc = -1;
    mailbox_free(&m_save);
    goto errcleanup;
  }
  m_save->append = true;

#ifdef USE_COMP_MBOX
  /* If we're saving to a compressed mailbox, the stats won't be updated
   * until the next open.  Until then, improvise. */
  struct Mailbox *m_comp = NULL;
  if (m_save->compress_info)
  {
    m_comp = mailbox_find(m_save->realpath);
  }
  /* We probably haven't been opened yet */
  if (m_comp && (m_comp->msg_count == 0))
    m_comp = NULL;
#endif
  if (msg_count == 1)
  {
    rc = mutt_save_message_ctx(m, en->email, save_opt, transform_opt, m_save);
    if (rc != 0)
    {
      mx_mbox_close(m_save);
      m_save->append = old_append;
      goto errcleanup;
    }
#ifdef USE_COMP_MBOX
    if (m_comp)
    {
      m_comp->msg_count++;
      if (!en->email->read)
      {
        m_comp->msg_unread++;
        if (!en->email->old)
          m_comp->msg_new++;
      }
      if (en->email->flagged)
        m_comp->msg_flagged++;
    }
#endif
  }
  else
  {
    rc = 0;

#ifdef USE_NOTMUCH
    if (m->type == MUTT_NOTMUCH)
      nm_db_longrun_init(m, true);
#endif
    struct Progress *progress = progress_new(progress_msg, MUTT_PROGRESS_WRITE, msg_count);
    STAILQ_FOREACH(en, el, entries)
    {
      progress_update(progress, ++tagged_progress_count, -1);
      mutt_message_hook(m, en->email, MUTT_MESSAGE_HOOK);
      rc = mutt_save_message_ctx(m, en->email, save_opt, transform_opt, m_save);
      if (rc != 0)
        break;
#ifdef USE_COMP_MBOX
      if (m_comp)
      {
        struct Email *e2 = en->email;
        m_comp->msg_count++;
        if (!e2->read)
        {
          m_comp->msg_unread++;
          if (!e2->old)
            m_comp->msg_new++;
        }
        if (e2->flagged)
          m_comp->msg_flagged++;
      }
#endif
    }
    progress_free(&progress);

#ifdef USE_NOTMUCH
    if (m->type == MUTT_NOTMUCH)
      nm_db_longrun_done(m);
#endif
    if (rc != 0)
    {
      mx_mbox_close(m_save);
      m_save->append = old_append;
      goto errcleanup;
    }
  }

  const bool need_mailbox_cleanup =
      ((m_save->type == MUTT_MBOX) || (m_save->type == MUTT_MMDF));

  mx_mbox_close(m_save);
  m_save->append = old_append;

  if (need_mailbox_cleanup)
    mutt_mailbox_cleanup(mutt_buffer_string(buf), &st);

  mutt_clear_error();
  rc = 0;

errcleanup:
  if (rc != 0)
  {
    switch (save_opt)
    {
      case SAVE_MOVE:
        if (msg_count > 1)
        {
          // L10N: Message when an index tagged save operation fails for some reason
          mutt_error(_("Error saving tagged messages"));
        }
        else
        {
          // L10N: Message when an index/pager save operation fails for some reason
          mutt_error(_("Error saving message"));
        }
        break;
      case SAVE_COPY:
        if (msg_count > 1)
        {
          // L10N: Message when an index tagged copy operation fails for some reason
          mutt_error(_("Error copying tagged messages"));
        }
        else
        {
          // L10N: Message when an index/pager copy operation fails for some reason
          mutt_error(_("Error copying message"));
        }
        break;
    }
  }

cleanup:
  mutt_buffer_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_save_message_ctx()

int mutt_save_message_ctx	(	struct Mailbox *	m_src,
		struct Email *	e,
		enum MessageSaveOpt	save_opt,
		enum MessageTransformOpt	transform_opt,
		struct Mailbox *	m_dst
	)

Save a message to a given mailbox.

Parameters

m_src	Mailbox to copy from
e	Email
save_opt	Copy or move, e.g. SAVE_MOVE
transform_opt	Transformation, e.g. TRANSFORM_DECRYPT
m_dst	Mailbox to save to

Return values

0	Success
-1	Error

Definition at line 1103 of file commands.c.

{
  CopyMessageFlags cmflags = MUTT_CM_NO_FLAGS;
  CopyHeaderFlags chflags = CH_NO_FLAGS;
  int rc;

  set_copy_flags(e, transform_opt, &cmflags, &chflags);

  struct Message *msg = mx_msg_open(m_src, e->msgno);
  if (msg && transform_opt != TRANSFORM_NONE)
  {
    mutt_parse_mime_message(m_src, e, msg->fp);
  }

  rc = mutt_append_message(m_dst, m_src, e, msg, cmflags, chflags);
  mx_msg_close(m_src, &msg);
  if (rc != 0)
    return rc;

  if (save_opt == SAVE_MOVE)
  {
    mutt_set_flag(m_src, e, MUTT_DELETE, true);
    mutt_set_flag(m_src, e, MUTT_PURGE, true);
    const bool c_delete_untag = cs_subset_bool(NeoMutt->sub, "delete_untag");
    if (c_delete_untag)
      mutt_set_flag(m_src, e, MUTT_TAG, false);
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_select_sort()

bool mutt_select_sort

(

bool

reverse

)

Ask the user for a sort method.

Parameters

reverse

If true make it a reverse sort

Return values

true	The sort type changed

Definition at line 835 of file commands.c.

{
  enum SortType sort = SORT_DATE;

  switch (mutt_multi_choice(reverse ?
                                /* L10N: The highlighted letters must match the "Sort" options */
                                _("Rev-Sort "
                                  "(d)ate,(f)rm,(r)ecv,(s)ubj,t(o),(t)hread,(u)"
                                  "nsort,si(z)e,s(c)ore,s(p)am,(l)abel?") :
                                /* L10N: The highlighted letters must match the "Rev-Sort" options */
                                _("Sort "
                                  "(d)ate,(f)rm,(r)ecv,(s)ubj,t(o),(t)hread,(u)"
                                  "nsort,si(z)e,s(c)ore,s(p)am,(l)abel?"),
                            /* L10N: These must match the highlighted letters from "Sort" and "Rev-Sort" */
                            _("dfrsotuzcpl")))
  {
    case -1: /* abort - don't resort */
      return -1;

    case 1: /* (d)ate */
      sort = SORT_DATE;
      break;

    case 2: /* (f)rm */
      sort = SORT_FROM;
      break;

    case 3: /* (r)ecv */
      sort = SORT_RECEIVED;
      break;

    case 4: /* (s)ubj */
      sort = SORT_SUBJECT;
      break;

    case 5: /* t(o) */
      sort = SORT_TO;
      break;

    case 6: /* (t)hread */
      sort = SORT_THREADS;
      break;

    case 7: /* (u)nsort */
      sort = SORT_ORDER;
      break;

    case 8: /* si(z)e */
      sort = SORT_SIZE;
      break;

    case 9: /* s(c)ore */
      sort = SORT_SCORE;
      break;

    case 10: /* s(p)am */
      sort = SORT_SPAM;
      break;

    case 11: /* (l)abel */
      sort = SORT_LABEL;
      break;
  }

  const unsigned char c_use_threads =
      cs_subset_enum(NeoMutt->sub, "use_threads");
  const short c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  int rc = CSR_ERR_CODE;
  if ((sort != SORT_THREADS) || (c_use_threads == UT_UNSET))
  {
    if ((sort != SORT_THREADS) && (c_sort & SORT_LAST))
      sort |= SORT_LAST;
    if (reverse)
      sort |= SORT_REVERSE;

    rc = cs_subset_str_native_set(NeoMutt->sub, "sort", sort, NULL);
  }
  else
  {
    assert((c_sort & SORT_MASK) != SORT_THREADS); /* See index_config_observer() */
    /* Preserve the value of $sort, and toggle whether we are threaded. */
    switch (c_use_threads)
    {
      case UT_FLAT:
        rc = cs_subset_str_native_set(NeoMutt->sub, "use_threads",
                                      reverse ? UT_REVERSE : UT_THREADS, NULL);
        break;
      case UT_THREADS:
        rc = cs_subset_str_native_set(NeoMutt->sub, "use_threads",
                                      reverse ? UT_REVERSE : UT_FLAT, NULL);
        break;
      case UT_REVERSE:
        rc = cs_subset_str_native_set(NeoMutt->sub, "use_threads",
                                      reverse ? UT_FLAT : UT_THREADS, NULL);
        break;
      default:
        assert(false);
    }
  }

  return ((CSR_RESULT(rc) == CSR_SUCCESS) && !(rc & CSR_SUC_NO_CHANGE));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_shell_escape()

bool mutt_shell_escape

(

void

)

invoke a command in a subshell

Return values

true	A command was invoked (no matter what its result)
false	No command was invoked

Definition at line 943 of file commands.c.

{
  char buf[1024];

  buf[0] = '\0';
  if (mutt_get_field(_("Shell command: "), buf, sizeof(buf), MUTT_CMD, false, NULL, NULL) != 0)
  {
    return false;
  }

  const char *const c_shell = cs_subset_string(NeoMutt->sub, "shell");
  if ((buf[0] == '\0') && c_shell)
    mutt_str_copy(buf, c_shell, sizeof(buf));
  if (buf[0] == '\0')
  {
    return false;
  }

  msgwin_clear_text();
  mutt_endwin();
  fflush(stdout);
  int rc = mutt_system(buf);
  if (rc == -1)
    mutt_debug(LL_DEBUG1, "Error running \"%s\"", buf);

  const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
  if ((rc != 0) || c_wait_key)
    mutt_any_key_to_continue(NULL);

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: