mutt_attach.h File Reference

Handling of email attachments. More...

#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"

Include dependency graph for mutt_attach.h:

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

Go to the source code of this file.

Enumerations
enum	ViewAttachMode { MUTT_VA_REGULAR = 1 , MUTT_VA_MAILCAP , MUTT_VA_AS_TEXT , MUTT_VA_PAGER }
	Options for mutt_view_attachment() More...
enum	SaveAttach { MUTT_SAVE_NO_FLAGS = 0 , MUTT_SAVE_APPEND , MUTT_SAVE_OVERWRITE }
	Options for saving attachments. More...

Functions
int	mutt_attach_display_loop (struct ConfigSubset *sub, struct Menu *menu, int op, struct Email *e, struct AttachCtx *actx, bool recv)
	Event loop for the Attachment menu.
void	mutt_save_attachment_list (struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b, struct Email *e, struct Menu *menu)
	Save a list of attachments.
void	mutt_pipe_attachment_list (struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b, bool filter)
	Pipe a list of attachments to a command.
void	mutt_print_attachment_list (struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b)
	Print a list of Attachments.
int	mutt_view_attachment (FILE *fp, struct Body *b, enum ViewAttachMode mode, struct Email *e, struct AttachCtx *actx, struct MuttWindow *win)
	View an attachment.
void	mutt_check_lookup_list (struct Body *b, char *type, size_t len)
	Update the mime type.
int	mutt_compose_attachment (struct Body *b)
	Create an attachment.
int	mutt_decode_save_attachment (FILE *fp, struct Body *b, const char *path, StateFlags flags, enum SaveAttach opt)
	Decode, then save an attachment.
bool	mutt_edit_attachment (struct Body *b)
	Edit an attachment.
int	mutt_get_tmp_attachment (struct Body *b)
	Get a temporary copy of an attachment.
int	mutt_pipe_attachment (FILE *fp, struct Body *b, const char *path, const char *outfile)
	Pipe an attachment to a command.
int	mutt_print_attachment (FILE *fp, struct Body *b)
	Print out an attachment.
int	mutt_save_attachment (FILE *fp, struct Body *b, const char *path, enum SaveAttach opt, struct Email *e)
	Save an attachment.
void	mutt_add_temp_attachment (const char *filename)
	Add file to list of temporary attachments.
void	mutt_temp_attachments_cleanup (void)
	Delete all temporary attachments.

Detailed Description

Handling of email attachments.

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 mutt_attach.h.

Enumeration Type Documentation

ViewAttachMode

enum ViewAttachMode

Options for mutt_view_attachment()

Enumerator
MUTT_VA_REGULAR	View using default method.
MUTT_VA_MAILCAP	Force viewing using mailcap entry.
MUTT_VA_AS_TEXT	Force viewing as text.
MUTT_VA_PAGER	View attachment in pager using copiousoutput mailcap.

Definition at line 42 of file mutt_attach.h.

{
  MUTT_VA_REGULAR = 1, 
  MUTT_VA_MAILCAP,     
  MUTT_VA_AS_TEXT,     
  MUTT_VA_PAGER,       
};

SaveAttach

enum SaveAttach

Options for saving attachments.

See also

mutt_save_attachment(), mutt_decode_save_attachment(), save_attachment_open(), mutt_check_overwrite()

Enumerator
MUTT_SAVE_NO_FLAGS	No flags set.
MUTT_SAVE_APPEND	Append to existing file.
MUTT_SAVE_OVERWRITE	Overwrite existing file.

Definition at line 56 of file mutt_attach.h.

{
  MUTT_SAVE_NO_FLAGS = 0, 
  MUTT_SAVE_APPEND,       
  MUTT_SAVE_OVERWRITE,    
};

Function Documentation

mutt_attach_display_loop()

int mutt_attach_display_loop	(	struct ConfigSubset *	sub,
		struct Menu *	menu,
		int	op,
		struct Email *	e,
		struct AttachCtx *	actx,
		bool	recv
	)

Event loop for the Attachment menu.

Parameters

sub	Config Subset
menu	Menu listing Attachments
op	Operation, e.g. OP_ATTACHMENT_VIEW
e	Email
actx	Attachment context
recv	true if these are received attachments (rather than in compose)

Return values

num	Operation performed

Definition at line 962 of file recvattach.c.

{
  do
  {
    switch (op)
    {
      case OP_DISPLAY_HEADERS:
        bool_str_toggle(NeoMutt->sub, "weed", NULL);
        FALLTHROUGH;
 
      case OP_ATTACHMENT_VIEW:
      {
        struct AttachPtr *cur_att = current_attachment(actx, menu);
        if (!cur_att->fp)
        {
          if (cur_att->body->type == TYPE_MULTIPART)
          {
            struct Body *b = cur_att->body->parts;
            while (b->parts)
              b = b->parts;
            cur_att = b->aptr;
          }
        }
        op = mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_REGULAR,
                                  e, actx, menu->win);
        break;
      }
 
      case OP_NEXT_ENTRY:
      case OP_MAIN_NEXT_UNDELETED: /* hack */
      {
        const int index = menu_get_index(menu) + 1;
        if (index < menu->max)
        {
          menu_set_index(menu, index);
          op = OP_ATTACHMENT_VIEW;
        }
        else
        {
          op = OP_NULL;
        }
        break;
      }
 
      case OP_PREV_ENTRY:
      case OP_MAIN_PREV_UNDELETED: /* hack */
      {
        const int index = menu_get_index(menu) - 1;
        if (index >= 0)
        {
          menu_set_index(menu, index);
          op = OP_ATTACHMENT_VIEW;
        }
        else
        {
          op = OP_NULL;
        }
        break;
      }
 
      case OP_ATTACHMENT_EDIT_TYPE:
      {
        struct AttachPtr *cur_att = current_attachment(actx, menu);
        /* when we edit the content-type, we should redisplay the attachment
         * immediately */
        mutt_edit_content_type(e, cur_att->body, cur_att->fp);
        if (recv)
          recvattach_edit_content_type(actx, menu, e);
        else
          mutt_edit_content_type(e, cur_att->body, cur_att->fp);
 
        menu_queue_redraw(menu, MENU_REDRAW_INDEX);
        op = OP_ATTACHMENT_VIEW;
        break;
      }
      /* functions which are passed through from the pager */
      case OP_PIPE:
      {
        struct AttachPtr *cur_att = current_attachment(actx, menu);
        mutt_pipe_attachment_list(actx, cur_att->fp, false, cur_att->body, false);
        op = OP_ATTACHMENT_VIEW;
        break;
      }
      case OP_ATTACHMENT_PRINT:
      {
        struct AttachPtr *cur_att = current_attachment(actx, menu);
        mutt_print_attachment_list(actx, cur_att->fp, false, cur_att->body);
        op = OP_ATTACHMENT_VIEW;
        break;
      }
      case OP_ATTACHMENT_SAVE:
      {
        struct AttachPtr *cur_att = current_attachment(actx, menu);
        mutt_save_attachment_list(actx, cur_att->fp, false, cur_att->body, e, NULL);
        op = OP_ATTACHMENT_VIEW;
        break;
      }
      case OP_CHECK_TRADITIONAL:
        if (!(WithCrypto & APPLICATION_PGP) || (e && e->security & PGP_TRADITIONAL_CHECKED))
        {
          op = OP_NULL;
          break;
        }
        FALLTHROUGH;
 
      case OP_ATTACHMENT_COLLAPSE:
        if (recv)
          return op;
        FALLTHROUGH;
 
      default:
        op = OP_NULL;
    }
  } while (op != OP_NULL);
 
  return op;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_save_attachment_list()

void mutt_save_attachment_list	(	struct AttachCtx *	actx,
		FILE *	fp,
		bool	tag,
		struct Body *	b,
		struct Email *	e,
		struct Menu *	menu
	)

Save a list of attachments.

Parameters

actx	Attachment context
fp	File handle for the attachment (OPTIONAL)
tag	If true, only save the tagged attachments
b	First Attachment
e	Email
menu	Menu listing attachments

Definition at line 433 of file recvattach.c.

{
  char *directory = NULL;
  int rc = 1;
  int last = menu_get_index(menu);
  FILE *fp_out = NULL;
  int saved_attachments = 0;
 
  struct Buffer *buf = buf_pool_get();
  struct Buffer *tfile = buf_pool_get();
 
  const bool c_attach_split = cs_subset_bool(NeoMutt->sub, "attach_split");
  const char *const c_attach_sep = cs_subset_string(NeoMutt->sub, "attach_sep");
  const bool c_attach_save_without_prompting = cs_subset_bool(NeoMutt->sub, "attach_save_without_prompting");
 
  for (int i = 0; !tag || (i < actx->idxlen); i++)
  {
    if (tag)
    {
      fp = actx->idx[i]->fp;
      b = actx->idx[i]->body;
    }
    if (!tag || b->tagged)
    {
      if (c_attach_split)
      {
        if (tag && menu && b->aptr)
        {
          menu_set_index(menu, b->aptr->num);
          menu_queue_redraw(menu, MENU_REDRAW_MOTION);
 
          menu_redraw(menu);
        }
        if (c_attach_save_without_prompting)
        {
          // Save each file, with no prompting, using the configured 'AttachSaveDir'
          rc = save_without_prompting(fp, b, e);
          if (rc == 0)
            saved_attachments++;
        }
        else
        {
          // Save each file, prompting the user for the location each time.
          if (query_save_attachment(fp, b, e, &directory) == -1)
            break;
        }
      }
      else
      {
        enum SaveAttach opt = MUTT_SAVE_NO_FLAGS;
 
        if (buf_is_empty(buf))
        {
          buf_strcpy(buf, mutt_path_basename(NONULL(b->filename)));
          prepend_savedir(buf);
 
          struct FileCompletionData cdata = { false, NULL, NULL, NULL };
          if ((mw_get_field(_("Save to file: "), buf, MUTT_COMP_CLEAR, HC_FILE,
                            &CompleteFileOps, &cdata) != 0) ||
              buf_is_empty(buf))
          {
            goto cleanup;
          }
          buf_expand_path(buf);
          if (mutt_check_overwrite(b->filename, buf_string(buf), tfile, &opt, NULL))
            goto cleanup;
        }
        else
        {
          opt = MUTT_SAVE_APPEND;
        }
 
        rc = save_attachment_flowed_helper(fp, b, buf_string(tfile), opt, e);
        if ((rc == 0) && c_attach_sep && (fp_out = mutt_file_fopen(buf_string(tfile), "a")))
        {
          fprintf(fp_out, "%s", c_attach_sep);
          mutt_file_fclose(&fp_out);
        }
      }
    }
    if (!tag)
      break;
  }
 
  FREE(&directory);
 
  if (tag && menu)
  {
    menu_set_index(menu, last);
    menu_queue_redraw(menu, MENU_REDRAW_MOTION);
  }
 
  if (rc == 0)
  {
    if (!c_attach_split)
      saved_attachments = 1;
 
    if (!c_attach_split || c_attach_save_without_prompting)
    {
      mutt_message(ngettext("Attachment saved", "%d attachments saved", saved_attachments),
                   saved_attachments);
    }
  }
 
cleanup:
  buf_pool_release(&buf);
  buf_pool_release(&tfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pipe_attachment_list()

void mutt_pipe_attachment_list	(	struct AttachCtx *	actx,
		FILE *	fp,
		bool	tag,
		struct Body *	b,
		bool	filter
	)

Pipe a list of attachments to a command.

Parameters

actx	Attachment context
fp	File handle to the attachment (OPTIONAL)
tag	If true, only save the tagged attachments
b	First Attachment
filter	Is this command a filter?

Definition at line 725 of file recvattach.c.

{
  struct State state = { 0 };
  struct Buffer *buf = NULL;
 
  if (fp)
    filter = false; /* sanity check: we can't filter in the recv case yet */
 
  buf = buf_pool_get();
  /* perform charset conversion on text attachments when piping */
  state.flags = STATE_CHARCONV;
 
  if (mw_get_field((filter ? _("Filter through: ") : _("Pipe to: ")), buf,
                   MUTT_COMP_NO_FLAGS, HC_EXT_COMMAND, &CompleteFileOps, NULL) != 0)
  {
    goto cleanup;
  }
 
  if (buf_is_empty(buf))
    goto cleanup;
 
  buf_expand_path(buf);
 
  const bool c_attach_split = cs_subset_bool(NeoMutt->sub, "attach_split");
  if (!filter && !c_attach_split)
  {
    mutt_endwin();
    pid_t pid = filter_create(buf_string(buf), &state.fp_out, NULL, NULL, EnvList);
    pipe_attachment_list(buf_string(buf), actx, fp, tag, b, filter, &state);
    mutt_file_fclose(&state.fp_out);
    const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
    if ((filter_wait(pid) != 0) || c_wait_key)
      mutt_any_key_to_continue(NULL);
  }
  else
  {
    pipe_attachment_list(buf_string(buf), actx, fp, tag, b, filter, &state);
  }
 
cleanup:
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_print_attachment_list()

void mutt_print_attachment_list	(	struct AttachCtx *	actx,
		FILE *	fp,
		bool	tag,
		struct Body *	b
	)

Print a list of Attachments.

Parameters

actx	Attachment context
fp	File handle to the attachment (OPTIONAL)
tag	Apply to all tagged Attachments
b	First Attachment

Definition at line 888 of file recvattach.c.

{
  char prompt[128] = { 0 };
  struct State state = { 0 };
  int tagmsgcount = 0;
 
  if (tag)
    for (int i = 0; i < actx->idxlen; i++)
      if (actx->idx[i]->body->tagged)
        tagmsgcount++;
 
  snprintf(prompt, sizeof(prompt),
           tag ? ngettext("Print tagged attachment?", "Print %d tagged attachments?", tagmsgcount) :
                 _("Print attachment?"),
           tagmsgcount);
  if (query_quadoption(prompt, NeoMutt->sub, "print") != MUTT_YES)
    return;
 
  const bool c_attach_split = cs_subset_bool(NeoMutt->sub, "attach_split");
  if (c_attach_split)
  {
    print_attachment_list(actx, fp, tag, b, &state);
  }
  else
  {
    if (!can_print(actx, b, tag))
      return;
    mutt_endwin();
    const char *const c_print_command = cs_subset_string(NeoMutt->sub, "print_command");
    pid_t pid = filter_create(NONULL(c_print_command), &state.fp_out, NULL, NULL, EnvList);
    print_attachment_list(actx, fp, tag, b, &state);
    mutt_file_fclose(&state.fp_out);
    const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
    if ((filter_wait(pid) != 0) || c_wait_key)
      mutt_any_key_to_continue(NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_view_attachment()

int mutt_view_attachment	(	FILE *	fp,
		struct Body *	b,
		enum ViewAttachMode	mode,
		struct Email *	e,
		struct AttachCtx *	actx,
		struct MuttWindow *	win
	)

View an attachment.

Parameters

fp	Source file stream. Can be NULL
b	The message body containing the attachment
mode	How the attachment should be viewed, see ViewAttachMode
e	Current Email. Can be NULL
actx	Attachment context
win	Window

Return values

0	The viewer is run and exited successfully
-1	Error
num	Return value of mutt_do_pager() when it is used

Display a message attachment using the viewer program configured in mailcap. If there is no mailcap entry for a file type, view the image as text. Viewer processes are opened and waited on synchronously so viewing an attachment this way will block the main neomutt process until the viewer process exits.

Definition at line 419 of file mutt_attach.c.

{
  bool use_mailcap = false;
  bool use_pipe = false;
  bool use_pager = true;
  char type[256] = { 0 };
  char desc[512] = { 0 };
  char *fname = NULL;
  struct MailcapEntry *entry = NULL;
  int rc = -1;
  bool has_tempfile = false;
  bool unlink_pagerfile = false;
 
  bool is_message = mutt_is_message_type(b->type, b->subtype);
  if ((WithCrypto != 0) && is_message && b->email &&
      (b->email->security & SEC_ENCRYPT) && !crypt_valid_passphrase(b->email->security))
  {
    return rc;
  }
 
  struct Buffer *tmpfile = buf_pool_get();
  struct Buffer *pagerfile = buf_pool_get();
  struct Buffer *cmd = buf_pool_get();
 
  use_mailcap = ((mode == MUTT_VA_MAILCAP) ||
                 ((mode == MUTT_VA_REGULAR) && mutt_needs_mailcap(b)) ||
                 (mode == MUTT_VA_PAGER));
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
 
  char columns[16] = { 0 };
  snprintf(columns, sizeof(columns), "%d", win->state.cols);
  envlist_set(&EnvList, "COLUMNS", columns, true);
 
  if (use_mailcap)
  {
    entry = mailcap_entry_new();
    enum MailcapLookup mailcap_opt = (mode == MUTT_VA_PAGER) ? MUTT_MC_AUTOVIEW : MUTT_MC_NO_FLAGS;
    if (!mailcap_lookup(b, type, sizeof(type), entry, mailcap_opt))
    {
      if ((mode == MUTT_VA_REGULAR) || (mode == MUTT_VA_PAGER))
      {
        /* fallback to view as text */
        mailcap_entry_free(&entry);
        mutt_error(_("No matching mailcap entry found.  Viewing as text."));
        mode = MUTT_VA_AS_TEXT;
        use_mailcap = false;
      }
      else
      {
        goto return_error;
      }
    }
  }
 
  if (use_mailcap)
  {
    if (!entry->command)
    {
      mutt_error(_("MIME type not defined.  Can't view attachment."));
      goto return_error;
    }
    buf_strcpy(cmd, entry->command);
 
    fname = mutt_str_dup(b->filename);
    /* In send mode(!fp), we allow slashes because those are part of
     * the tmpfile.  The path will be removed in expand_filename */
    mutt_file_sanitize_filename(fname, fp ? true : false);
    mailcap_expand_filename(entry->nametemplate, fname, tmpfile);
    FREE(&fname);
 
    if (mutt_save_attachment(fp, b, buf_string(tmpfile), 0, NULL) == -1)
      goto return_error;
    has_tempfile = true;
 
    mutt_rfc3676_space_unstuff_attachment(b, buf_string(tmpfile));
 
    /* check for multipart/related and save attachments with b Content-ID */
    if (mutt_str_equal(type, "text/html"))
    {
      struct Body *related_ancestor = NULL;
      if (actx->body_idx && (WithCrypto != 0) && (e->security & SEC_ENCRYPT))
        related_ancestor = attach_body_ancestor(actx->body_idx[0], b, "related");
      else
        related_ancestor = attach_body_ancestor(e->body, b, "related");
      if (related_ancestor)
      {
        struct CidMapList cid_map_list = STAILQ_HEAD_INITIALIZER(cid_map_list);
        mutt_debug(LL_DEBUG2, "viewing text/html attachment in multipart/related group\n");
        /* save attachments and build cid_map_list Content-ID to filename mapping list */
        cid_save_attachments(related_ancestor->parts, &cid_map_list);
        /* replace Content-IDs with filenames */
        cid_to_filename(tmpfile, &cid_map_list);
        /* empty Content-ID to filename mapping list */
        cid_map_list_clear(&cid_map_list);
      }
    }
 
    use_pipe = mailcap_expand_command(b, buf_string(tmpfile), type, cmd);
    use_pager = entry->copiousoutput;
  }
 
  if (use_pager)
  {
    if (fp && !use_mailcap && b->filename)
    {
      /* recv case */
      buf_strcpy(pagerfile, b->filename);
      mutt_adv_mktemp(pagerfile);
    }
    else
    {
      buf_mktemp(pagerfile);
    }
  }
 
  if (use_mailcap)
  {
    pid_t pid = 0;
    int fd_temp = -1, fd_pager = -1;
 
    if (!use_pager)
      mutt_endwin();
 
    const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
    if (use_pager || use_pipe)
    {
      if (use_pager &&
          ((fd_pager = mutt_file_open(buf_string(pagerfile),
                                      O_CREAT | O_EXCL | O_WRONLY, 0600)) == -1))
      {
        mutt_perror("open");
        goto return_error;
      }
      unlink_pagerfile = true;
 
      if (use_pipe && ((fd_temp = open(buf_string(tmpfile), 0)) == -1))
      {
        if (fd_pager != -1)
          close(fd_pager);
        mutt_perror("open");
        goto return_error;
      }
      unlink_pagerfile = true;
 
      pid = filter_create_fd(buf_string(cmd), NULL, NULL, NULL, use_pipe ? fd_temp : -1,
                             use_pager ? fd_pager : -1, -1, EnvList);
 
      if (pid == -1)
      {
        if (fd_pager != -1)
          close(fd_pager);
 
        if (fd_temp != -1)
          close(fd_temp);
 
        mutt_error(_("Can't create filter"));
        goto return_error;
      }
 
      if (use_pager)
      {
        if (b->description)
        {
          snprintf(desc, sizeof(desc), _("---Command: %-20.20s Description: %s"),
                   buf_string(cmd), b->description);
        }
        else
        {
          snprintf(desc, sizeof(desc), _("---Command: %-30.30s Attachment: %s"),
                   buf_string(cmd), type);
        }
        filter_wait(pid);
      }
      else
      {
        if (wait_interactive_filter(pid) || (entry->needsterminal && c_wait_key))
          mutt_any_key_to_continue(NULL);
      }
 
      if (fd_temp != -1)
        close(fd_temp);
      if (fd_pager != -1)
        close(fd_pager);
    }
    else
    {
      /* interactive cmd */
      int rv = mutt_system(buf_string(cmd));
      if (rv == -1)
        mutt_debug(LL_DEBUG1, "Error running \"%s\"\n", cmd->data);
 
      if ((rv != 0) || (entry->needsterminal && c_wait_key))
        mutt_any_key_to_continue(NULL);
    }
  }
  else
  {
    /* Don't use mailcap; the attachment is viewed in the pager */
 
    if (mode == MUTT_VA_AS_TEXT)
    {
      /* just let me see the raw data */
      if (fp)
      {
        /* Viewing from a received message.
         *
         * Don't use mutt_save_attachment() because we want to perform charset
         * conversion since this will be displayed by the internal pager.  */
        struct State state = { 0 };
 
        state.fp_out = mutt_file_fopen(buf_string(pagerfile), "w");
        if (!state.fp_out)
        {
          mutt_debug(LL_DEBUG1, "mutt_file_fopen(%s) errno=%d %s\n",
                     buf_string(pagerfile), errno, strerror(errno));
          mutt_perror("%s", buf_string(pagerfile));
          goto return_error;
        }
        state.fp_in = fp;
        state.flags = STATE_CHARCONV;
        mutt_decode_attachment(b, &state);
        mutt_file_fclose(&state.fp_out);
      }
      else
      {
        /* in compose mode, just copy the file.  we can't use
         * mutt_decode_attachment() since it assumes the content-encoding has
         * already been applied */
        if (mutt_save_attachment(fp, b, buf_string(pagerfile), MUTT_SAVE_NO_FLAGS, NULL))
          goto return_error;
        unlink_pagerfile = true;
      }
      mutt_rfc3676_space_unstuff_attachment(b, buf_string(pagerfile));
    }
    else
    {
      StateFlags flags = STATE_DISPLAY | STATE_DISPLAY_ATTACH;
      const char *const c_pager = pager_get_pager(NeoMutt->sub);
      if (!c_pager)
        flags |= STATE_PAGER;
 
      /* Use built-in handler */
      if (mutt_decode_save_attachment(fp, b, buf_string(pagerfile), flags, MUTT_SAVE_NO_FLAGS))
      {
        goto return_error;
      }
      unlink_pagerfile = true;
    }
 
    if (b->description)
      mutt_str_copy(desc, b->description, sizeof(desc));
    else if (b->filename)
      snprintf(desc, sizeof(desc), _("---Attachment: %s: %s"), b->filename, type);
    else
      snprintf(desc, sizeof(desc), _("---Attachment: %s"), type);
  }
 
  /* We only reach this point if there have been no errors */
 
  if (use_pager)
  {
    struct PagerData pdata = { 0 };
    struct PagerView pview = { &pdata };
 
    pdata.actx = actx;
    pdata.body = b;
    pdata.fname = buf_string(pagerfile);
    pdata.fp = fp;
 
    pview.banner = desc;
    pview.flags = MUTT_PAGER_ATTACHMENT |
                  (is_message ? MUTT_PAGER_MESSAGE : MUTT_PAGER_NO_FLAGS) |
                  ((use_mailcap && entry->xneomuttnowrap) ? MUTT_PAGER_NOWRAP :
                                                            MUTT_PAGER_NO_FLAGS);
    pview.mode = PAGER_MODE_ATTACH;
 
    rc = mutt_do_pager(&pview, e);
 
    buf_reset(pagerfile);
    unlink_pagerfile = false;
  }
  else
  {
    rc = 0;
  }
 
return_error:
 
  if (!entry || !entry->xneomuttkeep)
  {
    if ((fp && !buf_is_empty(tmpfile)) || has_tempfile)
    {
      /* add temporary file to TempAttachmentsList to be deleted on timeout hook */
      mutt_add_temp_attachment(buf_string(tmpfile));
    }
  }
 
  mailcap_entry_free(&entry);
 
  if (unlink_pagerfile)
    mutt_file_unlink(buf_string(pagerfile));
 
  buf_pool_release(&tmpfile);
  buf_pool_release(&pagerfile);
  buf_pool_release(&cmd);
  envlist_unset(&EnvList, "COLUMNS");
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_check_lookup_list()

void mutt_check_lookup_list	(	struct Body *	b,
		char *	type,
		size_t	len
	)

Update the mime type.

Parameters

b	Message attachment body
type	Buffer with mime type of attachment in "type/subtype" format
len	Buffer length

Definition at line 343 of file mutt_attach.c.

{
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &MimeLookupList, entries)
  {
    const int i = mutt_str_len(np->data) - 1;
    if (((i > 0) && (np->data[i - 1] == '/') && (np->data[i] == '*') &&
         mutt_istrn_equal(type, np->data, i)) ||
        mutt_istr_equal(type, np->data))
    {
      struct Body tmp = { 0 };
      enum ContentType n;
      if ((n = mutt_lookup_mime_type(&tmp, b->filename)) != TYPE_OTHER ||
          (n = mutt_lookup_mime_type(&tmp, b->description)) != TYPE_OTHER)
      {
        snprintf(type, len, "%s/%s",
                 (n == TYPE_AUDIO)       ? "audio" :
                 (n == TYPE_APPLICATION) ? "application" :
                 (n == TYPE_IMAGE)       ? "image" :
                 (n == TYPE_MESSAGE)     ? "message" :
                 (n == TYPE_MODEL)       ? "model" :
                 (n == TYPE_MULTIPART)   ? "multipart" :
                 (n == TYPE_TEXT)        ? "text" :
                 (n == TYPE_VIDEO)       ? "video" :
                                           "other",
                 tmp.subtype);
        mutt_debug(LL_DEBUG1, "\"%s\" -> %s\n", b->filename, type);
      }
      FREE(&tmp.subtype);
      FREE(&tmp.xtype);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_compose_attachment()

int mutt_compose_attachment

(

struct Body *

b

)

Create an attachment.

Parameters

b	Body of email

Return values

1	Require full screen redraw
0	Otherwise

Definition at line 120 of file mutt_attach.c.

{
  char type[256] = { 0 };
  struct MailcapEntry *entry = mailcap_entry_new();
  bool unlink_newfile = false;
  int rc = 0;
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *newfile = buf_pool_get();
  struct Buffer *tmpfile = buf_pool_get();
 
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
  if (mailcap_lookup(b, type, sizeof(type), entry, MUTT_MC_COMPOSE))
  {
    if (entry->composecommand || entry->composetypecommand)
    {
      if (entry->composetypecommand)
        buf_strcpy(cmd, entry->composetypecommand);
      else
        buf_strcpy(cmd, entry->composecommand);
 
      mailcap_expand_filename(entry->nametemplate, b->filename, newfile);
      mutt_debug(LL_DEBUG1, "oldfile: %s     newfile: %s\n", b->filename,
                 buf_string(newfile));
      if (mutt_file_symlink(b->filename, buf_string(newfile)) == -1)
      {
        if (query_yesorno(_("Can't match 'nametemplate', continue?"), MUTT_YES) != MUTT_YES)
          goto bailout;
        buf_strcpy(newfile, b->filename);
      }
      else
      {
        unlink_newfile = true;
      }
 
      if (mailcap_expand_command(b, buf_string(newfile), type, cmd))
      {
        /* For now, editing requires a file, no piping */
        mutt_error(_("Mailcap compose entry requires %%s"));
      }
      else
      {
        int r;
 
        mutt_endwin();
        r = mutt_system(buf_string(cmd));
        if (r == -1)
          mutt_error(_("Error running \"%s\""), buf_string(cmd));
 
        if ((r != -1) && entry->composetypecommand)
        {
          FILE *fp = mutt_file_fopen(b->filename, "r");
          if (!fp)
          {
            mutt_perror(_("Failure to open file to parse headers"));
            goto bailout;
          }
 
          struct Body *b_mime = mutt_read_mime_header(fp, 0);
          if (b_mime)
          {
            if (!TAILQ_EMPTY(&b_mime->parameter))
            {
              mutt_param_free(&b->parameter);
              b->parameter = b_mime->parameter;
              TAILQ_INIT(&b_mime->parameter);
            }
            if (b_mime->description)
            {
              FREE(&b->description);
              b->description = b_mime->description;
              b_mime->description = NULL;
            }
            if (b_mime->form_name)
            {
              FREE(&b->form_name);
              b->form_name = b_mime->form_name;
              b_mime->form_name = NULL;
            }
 
            /* Remove headers by copying out data to another file, then
             * copying the file back */
            const LOFF_T offset = b_mime->offset;
            mutt_body_free(&b_mime);
            if (!mutt_file_seek(fp, offset, SEEK_SET))
            {
              goto bailout;
            }
 
            buf_mktemp(tmpfile);
            FILE *fp_tmp = mutt_file_fopen(buf_string(tmpfile), "w");
            if (!fp_tmp)
            {
              mutt_perror(_("Failure to open file to strip headers"));
              mutt_file_fclose(&fp);
              goto bailout;
            }
            mutt_file_copy_stream(fp, fp_tmp);
            mutt_file_fclose(&fp);
            mutt_file_fclose(&fp_tmp);
            mutt_file_unlink(b->filename);
            if (mutt_file_rename(buf_string(tmpfile), b->filename) != 0)
            {
              mutt_perror(_("Failure to rename file"));
              goto bailout;
            }
          }
        }
      }
    }
  }
  else
  {
    mutt_message(_("No mailcap compose entry for %s, creating empty file"), type);
    rc = 1;
    goto bailout;
  }
 
  rc = 1;
 
bailout:
 
  if (unlink_newfile)
    unlink(buf_string(newfile));
 
  buf_pool_release(&cmd);
  buf_pool_release(&newfile);
  buf_pool_release(&tmpfile);
 
  mailcap_entry_free(&entry);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_decode_save_attachment()

int mutt_decode_save_attachment	(	FILE *	fp,
		struct Body *	b,
		const char *	path,
		StateFlags	flags,
		enum SaveAttach	opt
	)

Decode, then save an attachment.

Parameters

fp	File to read from (OPTIONAL)
b	Attachment
path	Path to save the Attachment to
flags	Flags, e.g. STATE_DISPLAY
opt	Save option, see SaveAttach

Return values

0	Success
-1	Error

Definition at line 1041 of file mutt_attach.c.

{
  struct State state = { 0 };
  unsigned int saved_encoding = 0;
  struct Body *saved_parts = NULL;
  struct Email *e_saved = NULL;
  int rc = 0;
 
  state.flags = flags;
 
  if (opt == MUTT_SAVE_APPEND)
    state.fp_out = mutt_file_fopen_masked(path, "a");
  else if (opt == MUTT_SAVE_OVERWRITE)
    state.fp_out = mutt_file_fopen_masked(path, "w");
  else
    state.fp_out = mutt_file_fopen_masked(path, "w");
 
  if (!state.fp_out)
  {
    mutt_perror("fopen");
    return -1;
  }
 
  if (fp)
  {
    state.fp_in = fp;
    state.flags |= STATE_CHARCONV;
  }
  else
  {
    /* When called from the compose menu, the attachment isn't parsed,
     * so we need to do it here. */
    state.fp_in = mutt_file_fopen(b->filename, "r");
    if (!state.fp_in)
    {
      mutt_perror("fopen");
      mutt_file_fclose(&state.fp_out);
      return -1;
    }
 
    struct stat st = { 0 };
    if (fstat(fileno(state.fp_in), &st) == -1)
    {
      mutt_perror("stat");
      mutt_file_fclose(&state.fp_in);
      mutt_file_fclose(&state.fp_out);
      return -1;
    }
 
    saved_encoding = b->encoding;
    if (!is_multipart(b))
      b->encoding = ENC_8BIT;
 
    b->length = st.st_size;
    b->offset = 0;
    saved_parts = b->parts;
    e_saved = b->email;
    mutt_parse_part(state.fp_in, b);
 
    if (b->noconv || is_multipart(b))
      state.flags |= STATE_CHARCONV;
  }
 
  mutt_body_handler(b, &state);
 
  if (mutt_file_fsync_close(&state.fp_out) != 0)
  {
    mutt_perror("fclose");
    rc = -1;
  }
  if (!fp)
  {
    b->length = 0;
    b->encoding = saved_encoding;
    if (saved_parts)
    {
      email_free(&b->email);
      b->parts = saved_parts;
      b->email = e_saved;
    }
    mutt_file_fclose(&state.fp_in);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_edit_attachment()

bool mutt_edit_attachment

(

struct Body *

b

)

Edit an attachment.

Parameters

b	Email containing attachment

Return values

true	Editor found
false	Editor not found

Currently, this only works for send mode, as it assumes that the Body->filename actually contains the information. I'm not sure we want to deal with editing attachments we've already received, so this should be ok.

Returning 0 is useful to tell the calling menu to redraw

Definition at line 265 of file mutt_attach.c.

{
  char type[256] = { 0 };
  struct MailcapEntry *entry = mailcap_entry_new();
  bool unlink_newfile = false;
  bool rc = false;
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *newfile = buf_pool_get();
 
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
  if (mailcap_lookup(b, type, sizeof(type), entry, MUTT_MC_EDIT))
  {
    if (entry->editcommand)
    {
      buf_strcpy(cmd, entry->editcommand);
      mailcap_expand_filename(entry->nametemplate, b->filename, newfile);
      mutt_debug(LL_DEBUG1, "oldfile: %s     newfile: %s\n", b->filename,
                 buf_string(newfile));
      if (mutt_file_symlink(b->filename, buf_string(newfile)) == -1)
      {
        if (query_yesorno(_("Can't match 'nametemplate', continue?"), MUTT_YES) != MUTT_YES)
          goto bailout;
        buf_strcpy(newfile, b->filename);
      }
      else
      {
        unlink_newfile = true;
      }
 
      if (mailcap_expand_command(b, buf_string(newfile), type, cmd))
      {
        /* For now, editing requires a file, no piping */
        mutt_error(_("Mailcap Edit entry requires %%s"));
        goto bailout;
      }
      else
      {
        mutt_endwin();
        if (mutt_system(buf_string(cmd)) == -1)
        {
          mutt_error(_("Error running \"%s\""), buf_string(cmd));
          goto bailout;
        }
      }
    }
  }
  else if (b->type == TYPE_TEXT)
  {
    /* On text, default to editor */
    const char *const c_editor = cs_subset_string(NeoMutt->sub, "editor");
    mutt_edit_file(NONULL(c_editor), b->filename);
  }
  else
  {
    mutt_error(_("No mailcap edit entry for %s"), type);
    goto bailout;
  }
 
  rc = true;
 
bailout:
 
  if (unlink_newfile)
    unlink(buf_string(newfile));
 
  buf_pool_release(&cmd);
  buf_pool_release(&newfile);
 
  mailcap_entry_free(&entry);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_tmp_attachment()

int mutt_get_tmp_attachment

(

struct Body *

b

)

Get a temporary copy of an attachment.

Parameters

b	Attachment to copy

Return values

0	Success
-1	Error

Definition at line 72 of file mutt_attach.c.

{
  char type[256] = { 0 };
 
  if (b->unlink)
    return 0;
 
  struct Buffer *tmpfile = buf_pool_get();
  struct MailcapEntry *entry = mailcap_entry_new();
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
  mailcap_lookup(b, type, sizeof(type), entry, MUTT_MC_NO_FLAGS);
  mailcap_expand_filename(entry->nametemplate, b->filename, tmpfile);
 
  mailcap_entry_free(&entry);
 
  FILE *fp_in = NULL, *fp_out = NULL;
  if ((fp_in = mutt_file_fopen(b->filename, "r")) &&
      (fp_out = mutt_file_fopen(buf_string(tmpfile), "w")))
  {
    mutt_file_copy_stream(fp_in, fp_out);
    mutt_str_replace(&b->filename, buf_string(tmpfile));
    b->unlink = true;
 
    struct stat st = { 0 };
    if ((fstat(fileno(fp_in), &st) == 0) && (b->stamp >= st.st_mtime))
    {
      mutt_stamp_attachment(b);
    }
  }
  else
  {
    mutt_perror("%s", fp_in ? buf_string(tmpfile) : b->filename);
  }
 
  mutt_file_fclose(&fp_in);
  mutt_file_fclose(&fp_out);
 
  buf_pool_release(&tmpfile);
 
  return b->unlink ? 0 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pipe_attachment()

int mutt_pipe_attachment	(	FILE *	fp,
		struct Body *	b,
		const char *	path,
		const char *	outfile
	)

Pipe an attachment to a command.

Parameters

fp	File to pipe into the command
b	Attachment
path	Path to command
outfile	File to save output to

Return values

1	Success
0	Error

Definition at line 739 of file mutt_attach.c.

{
  pid_t pid = 0;
  int out = -1, rc = 0;
  bool is_flowed = false;
  bool unlink_unstuff = false;
  FILE *fp_filter = NULL, *fp_unstuff = NULL, *fp_in = NULL;
  struct Buffer *unstuff_tempfile = NULL;
 
  if (outfile && *outfile)
  {
    out = mutt_file_open(outfile, O_CREAT | O_EXCL | O_WRONLY, 0600);
    if (out < 0)
    {
      mutt_perror("open");
      return 0;
    }
  }
 
  if (mutt_rfc3676_is_format_flowed(b))
  {
    is_flowed = true;
    unstuff_tempfile = buf_pool_get();
    buf_mktemp(unstuff_tempfile);
  }
 
  mutt_endwin();
 
  if (outfile && *outfile)
    pid = filter_create_fd(path, &fp_filter, NULL, NULL, -1, out, -1, EnvList);
  else
    pid = filter_create(path, &fp_filter, NULL, NULL, EnvList);
  if (pid < 0)
  {
    mutt_perror(_("Can't create filter"));
    goto bail;
  }
 
  /* recv case */
  if (fp)
  {
    struct State state = { 0 };
 
    /* perform charset conversion on text attachments when piping */
    state.flags = STATE_CHARCONV;
 
    if (is_flowed)
    {
      fp_unstuff = mutt_file_fopen(buf_string(unstuff_tempfile), "w");
      if (!fp_unstuff)
      {
        mutt_perror("mutt_file_fopen");
        goto bail;
      }
      unlink_unstuff = true;
 
      state.fp_in = fp;
      state.fp_out = fp_unstuff;
      mutt_decode_attachment(b, &state);
      mutt_file_fclose(&fp_unstuff);
 
      mutt_rfc3676_space_unstuff_attachment(b, buf_string(unstuff_tempfile));
 
      fp_unstuff = mutt_file_fopen(buf_string(unstuff_tempfile), "r");
      if (!fp_unstuff)
      {
        mutt_perror("mutt_file_fopen");
        goto bail;
      }
      mutt_file_copy_stream(fp_unstuff, fp_filter);
      mutt_file_fclose(&fp_unstuff);
    }
    else
    {
      state.fp_in = fp;
      state.fp_out = fp_filter;
      mutt_decode_attachment(b, &state);
    }
  }
  else
  {
    /* send case */
    const char *infile = NULL;
 
    if (is_flowed)
    {
      if (mutt_save_attachment(fp, b, buf_string(unstuff_tempfile),
                               MUTT_SAVE_NO_FLAGS, NULL) == -1)
      {
        goto bail;
      }
      unlink_unstuff = true;
      mutt_rfc3676_space_unstuff_attachment(b, buf_string(unstuff_tempfile));
      infile = buf_string(unstuff_tempfile);
    }
    else
    {
      infile = b->filename;
    }
 
    fp_in = mutt_file_fopen(infile, "r");
    if (!fp_in)
    {
      mutt_perror("fopen");
      goto bail;
    }
 
    mutt_file_copy_stream(fp_in, fp_filter);
    mutt_file_fclose(&fp_in);
  }
 
  mutt_file_fclose(&fp_filter);
  rc = 1;
 
bail:
  if (outfile && *outfile)
  {
    close(out);
    if (rc == 0)
      unlink(outfile);
    else if (is_flowed)
      mutt_rfc3676_space_stuff_attachment(NULL, outfile);
  }
 
  mutt_file_fclose(&fp_unstuff);
  mutt_file_fclose(&fp_filter);
  mutt_file_fclose(&fp_in);
 
  if (unlink_unstuff)
    mutt_file_unlink(buf_string(unstuff_tempfile));
  buf_pool_release(&unstuff_tempfile);
 
  /* check for error exit from child process */
  if ((pid > 0) && (filter_wait(pid) != 0))
    rc = 0;
 
  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 rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_print_attachment()

int mutt_print_attachment	(	FILE *	fp,
		struct Body *	b
	)

Print out an attachment.

Parameters

fp	File to write to
b	Attachment

Return values

1	Success
0	Error

Ok, the difference between send and receive: recv: Body->filename is a suggested name, and Mailbox|Email points to the attachment in mailbox which is encoded send: Body->filename points to the un-encoded file which contains the attachment

Definition at line 1141 of file mutt_attach.c.

{
  char type[256] = { 0 };
  pid_t pid;
  FILE *fp_in = NULL, *fp_out = NULL;
  bool unlink_newfile = false;
  struct Buffer *newfile = buf_pool_get();
  struct Buffer *cmd = buf_pool_get();
 
  int rc = 0;
 
  snprintf(type, sizeof(type), "%s/%s", TYPE(b), b->subtype);
 
  if (mailcap_lookup(b, type, sizeof(type), NULL, MUTT_MC_PRINT))
  {
    mutt_debug(LL_DEBUG2, "Using mailcap\n");
 
    struct MailcapEntry *entry = mailcap_entry_new();
    mailcap_lookup(b, type, sizeof(type), entry, MUTT_MC_PRINT);
 
    char *sanitized_fname = mutt_str_dup(b->filename);
    /* In send mode (!fp), we allow slashes because those are part of
     * the tempfile.  The path will be removed in expand_filename */
    mutt_file_sanitize_filename(sanitized_fname, fp ? true : false);
    mailcap_expand_filename(entry->nametemplate, sanitized_fname, newfile);
    FREE(&sanitized_fname);
 
    if (mutt_save_attachment(fp, b, buf_string(newfile), MUTT_SAVE_NO_FLAGS, NULL) == -1)
    {
      goto mailcap_cleanup;
    }
    unlink_newfile = 1;
 
    mutt_rfc3676_space_unstuff_attachment(b, buf_string(newfile));
 
    buf_strcpy(cmd, entry->printcommand);
 
    bool piped = mailcap_expand_command(b, buf_string(newfile), type, cmd);
 
    mutt_endwin();
 
    const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
    /* interactive program */
    if (piped)
    {
      fp_in = mutt_file_fopen(buf_string(newfile), "r");
      if (!fp_in)
      {
        mutt_perror("fopen");
        mailcap_entry_free(&entry);
        goto mailcap_cleanup;
      }
 
      pid = filter_create(buf_string(cmd), &fp_out, NULL, NULL, EnvList);
      if (pid < 0)
      {
        mutt_perror(_("Can't create filter"));
        mailcap_entry_free(&entry);
        mutt_file_fclose(&fp_in);
        goto mailcap_cleanup;
      }
      mutt_file_copy_stream(fp_in, fp_out);
      mutt_file_fclose(&fp_out);
      mutt_file_fclose(&fp_in);
      if (filter_wait(pid) || c_wait_key)
        mutt_any_key_to_continue(NULL);
    }
    else
    {
      int rc2 = mutt_system(buf_string(cmd));
      if (rc2 == -1)
        mutt_debug(LL_DEBUG1, "Error running \"%s\"\n", cmd->data);
 
      if ((rc2 != 0) || c_wait_key)
        mutt_any_key_to_continue(NULL);
    }
 
    rc = 1;
 
  mailcap_cleanup:
    if (unlink_newfile)
      mutt_file_unlink(buf_string(newfile));
 
    mailcap_entry_free(&entry);
    goto out;
  }
 
  const char *const c_print_command = cs_subset_string(NeoMutt->sub, "print_command");
  if (mutt_istr_equal("text/plain", type) || mutt_istr_equal("application/postscript", type))
  {
    rc = (mutt_pipe_attachment(fp, b, NONULL(c_print_command), NULL));
    goto out;
  }
  else if (mutt_can_decode(b))
  {
    /* decode and print */
 
    fp_in = NULL;
    fp_out = NULL;
 
    buf_mktemp(newfile);
    if (mutt_decode_save_attachment(fp, b, buf_string(newfile), STATE_PRINTING,
                                    MUTT_SAVE_NO_FLAGS) == 0)
    {
      unlink_newfile = true;
      mutt_debug(LL_DEBUG2, "successfully decoded %s type attachment to %s\n",
                 type, buf_string(newfile));
 
      fp_in = mutt_file_fopen(buf_string(newfile), "r");
      if (!fp_in)
      {
        mutt_perror("fopen");
        goto decode_cleanup;
      }
 
      mutt_debug(LL_DEBUG2, "successfully opened %s read-only\n", buf_string(newfile));
 
      mutt_endwin();
      pid = filter_create(NONULL(c_print_command), &fp_out, NULL, NULL, EnvList);
      if (pid < 0)
      {
        mutt_perror(_("Can't create filter"));
        goto decode_cleanup;
      }
 
      mutt_debug(LL_DEBUG2, "Filter created\n");
 
      mutt_file_copy_stream(fp_in, fp_out);
 
      mutt_file_fclose(&fp_out);
      mutt_file_fclose(&fp_in);
 
      const bool c_wait_key = cs_subset_bool(NeoMutt->sub, "wait_key");
      if ((filter_wait(pid) != 0) || c_wait_key)
        mutt_any_key_to_continue(NULL);
      rc = 1;
    }
  decode_cleanup:
    mutt_file_fclose(&fp_in);
    mutt_file_fclose(&fp_out);
    if (unlink_newfile)
      mutt_file_unlink(buf_string(newfile));
  }
  else
  {
    mutt_error(_("I don't know how to print that"));
    rc = 0;
  }
 
out:
  buf_pool_release(&newfile);
  buf_pool_release(&cmd);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_save_attachment()

int mutt_save_attachment	(	FILE *	fp,
		struct Body *	b,
		const char *	path,
		enum SaveAttach	opt,
		struct Email *	e
	)

Save an attachment.

Parameters

fp	Source file stream. Can be NULL
b	Email Body
path	Where to save the attachment
opt	Save option, see SaveAttach
e	Current Email. Can be NULL

Return values

0	Success
-1	Error

Definition at line 907 of file mutt_attach.c.

{
  if (!b)
    return -1;
 
  if (fp)
  {
    /* recv mode */
 
    if (e && b->email && (b->encoding != ENC_BASE64) &&
        (b->encoding != ENC_QUOTED_PRINTABLE) && mutt_is_message_type(b->type, b->subtype))
    {
      /* message type attachments are written to mail folders. */
 
      char buf[8192] = { 0 };
      struct Message *msg = NULL;
      CopyHeaderFlags chflags = CH_NO_FLAGS;
      int rc = -1;
 
      struct Email *e_new = b->email;
      e_new->msgno = e->msgno; /* required for MH/maildir */
      e_new->read = true;
 
      if (!mutt_file_seek(fp, b->offset, SEEK_SET))
        return -1;
      if (!fgets(buf, sizeof(buf), fp))
        return -1;
      struct Mailbox *m_att = mx_path_resolve(path);
      if (!mx_mbox_open(m_att, MUTT_APPEND | MUTT_QUIET))
      {
        mailbox_free(&m_att);
        return -1;
      }
      msg = mx_msg_open_new(m_att, e_new,
                            is_from(buf, NULL, 0, NULL) ? MUTT_MSG_NO_FLAGS : MUTT_ADD_FROM);
      if (!msg)
      {
        mx_mbox_close(m_att);
        return -1;
      }
      if ((m_att->type == MUTT_MBOX) || (m_att->type == MUTT_MMDF))
        chflags = CH_FROM | CH_UPDATE_LEN;
      chflags |= ((m_att->type == MUTT_MAILDIR) ? CH_NOSTATUS : CH_UPDATE);
      if ((mutt_copy_message_fp(msg->fp, fp, e_new, MUTT_CM_NO_FLAGS, chflags, 0) == 0) &&
          (mx_msg_commit(m_att, msg) == 0))
      {
        rc = 0;
      }
      else
      {
        rc = -1;
      }
 
      mx_msg_close(m_att, &msg);
      mx_mbox_close(m_att);
      return rc;
    }
    else
    {
      /* In recv mode, extract from folder and decode */
 
      struct State state = { 0 };
 
      state.fp_out = save_attachment_open(path, opt);
      if (!state.fp_out)
      {
        mutt_perror("fopen");
        return -1;
      }
      if (!mutt_file_seek((state.fp_in = fp), b->offset, SEEK_SET))
      {
        mutt_file_fclose(&state.fp_out);
        return -1;
      }
      mutt_decode_attachment(b, &state);
 
      if (mutt_file_fsync_close(&state.fp_out) != 0)
      {
        mutt_perror("fclose");
        return -1;
      }
    }
  }
  else
  {
    if (!b->filename)
      return -1;
 
    /* In send mode, just copy file */
 
    FILE *fp_old = mutt_file_fopen(b->filename, "r");
    if (!fp_old)
    {
      mutt_perror("fopen");
      return -1;
    }
 
    FILE *fp_new = save_attachment_open(path, opt);
    if (!fp_new)
    {
      mutt_perror("fopen");
      mutt_file_fclose(&fp_old);
      return -1;
    }
 
    if (mutt_file_copy_stream(fp_old, fp_new) == -1)
    {
      mutt_error(_("Write fault"));
      mutt_file_fclose(&fp_old);
      mutt_file_fclose(&fp_new);
      return -1;
    }
    mutt_file_fclose(&fp_old);
    if (mutt_file_fsync_close(&fp_new) != 0)
    {
      mutt_error(_("Write fault"));
      return -1;
    }
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_add_temp_attachment()

void mutt_add_temp_attachment

(

const char *

filename

)

Add file to list of temporary attachments.

Parameters

filename

filename with full path

Definition at line 1301 of file mutt_attach.c.

{
  mutt_list_insert_tail(&TempAttachmentsList, mutt_str_dup(filename));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_temp_attachments_cleanup()

void mutt_temp_attachments_cleanup

(

void

)

Delete all temporary attachments.

Definition at line 1309 of file mutt_attach.c.

{
  struct ListNode *np = NULL;
 
  STAILQ_FOREACH(np, &TempAttachmentsList, entries)
  {
    (void) mutt_file_chmod_add(np->data, S_IWUSR);
    mutt_file_unlink(np->data);
  }
 
  mutt_list_free(&TempAttachmentsList);
}

Here is the call graph for this function:

Here is the caller graph for this function: