Compose Function API

Prototype for a Compose Function. More...

Collaboration diagram for Compose Function API:

Functions
static int	op_attachment_attach_file (struct ComposeSharedData *shared, int op)
	Attach files to this message - Implements compose_function_t -.
static int	op_attachment_attach_key (struct ComposeSharedData *shared, int op)
	Attach a PGP public key - Implements compose_function_t -.
static int	op_attachment_attach_message (struct ComposeSharedData *shared, int op)
	Attach messages to this message - Implements compose_function_t -.
static int	op_attachment_detach (struct ComposeSharedData *shared, int op)
	Delete the current entry - Implements compose_function_t -.
static int	op_attachment_edit_content_id (struct ComposeSharedData *shared, int op)
	Edit the 'Content-ID' of the attachment - Implements compose_function_t -.
static int	op_attachment_edit_description (struct ComposeSharedData *shared, int op)
	Edit attachment description - Implements compose_function_t -.
static int	op_attachment_edit_encoding (struct ComposeSharedData *shared, int op)
	Edit attachment transfer-encoding - Implements compose_function_t -.
static int	op_attachment_edit_language (struct ComposeSharedData *shared, int op)
	Edit the 'Content-Language' of the attachment - Implements compose_function_t -.
static int	op_attachment_edit_mime (struct ComposeSharedData *shared, int op)
	Edit attachment using mailcap entry - Implements compose_function_t -.
static int	op_attachment_edit_type (struct ComposeSharedData *shared, int op)
	Edit attachment content type - Implements compose_function_t -.
static int	op_attachment_filter (struct ComposeSharedData *shared, int op)
	Filter attachment through a shell command - Implements compose_function_t -.
static int	op_attachment_get_attachment (struct ComposeSharedData *shared, int op)
	Get a temporary copy of an attachment - Implements compose_function_t -.
static int	op_attachment_group_alts (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -.
static int	op_attachment_group_lingual (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -.
static int	op_attachment_group_related (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/related' - Implements compose_function_t -.
static int	op_attachment_move_down (struct ComposeSharedData *shared, int op)
	Move an attachment down in the attachment list - Implements compose_function_t -.
static int	op_attachment_move_up (struct ComposeSharedData *shared, int op)
	Move an attachment up in the attachment list - Implements compose_function_t -.
static int	op_attachment_new_mime (struct ComposeSharedData *shared, int op)
	Compose new attachment using mailcap entry - Implements compose_function_t -.
static int	op_attachment_print (struct ComposeSharedData *shared, int op)
	Print the current entry - Implements compose_function_t -.
static int	op_attachment_rename_attachment (struct ComposeSharedData *shared, int op)
	Send attachment with a different name - Implements compose_function_t -.
static int	op_attachment_save (struct ComposeSharedData *shared, int op)
	Save message/attachment to a mailbox/file - Implements compose_function_t -.
static int	op_attachment_toggle_disposition (struct ComposeSharedData *shared, int op)
	Toggle disposition between inline/attachment - Implements compose_function_t -.
static int	op_attachment_toggle_recode (struct ComposeSharedData *shared, int op)
	Toggle recoding of this attachment - Implements compose_function_t -.
static int	op_attachment_toggle_unlink (struct ComposeSharedData *shared, int op)
	Toggle whether to delete file after sending it - Implements compose_function_t -.
static int	op_attachment_ungroup (struct ComposeSharedData *shared, int op)
	Ungroup a 'multipart' attachment - Implements compose_function_t -.
static int	op_attachment_update_encoding (struct ComposeSharedData *shared, int op)
	Update an attachment's encoding info - Implements compose_function_t -.
static int	op_envelope_edit_headers (struct ComposeSharedData *shared, int op)
	Edit the message with headers - Implements compose_function_t -.
static int	op_compose_edit_file (struct ComposeSharedData *shared, int op)
	Edit the file to be attached - Implements compose_function_t -.
static int	op_compose_edit_message (struct ComposeSharedData *shared, int op)
	Edit the message - Implements compose_function_t -.
static int	op_compose_ispell (struct ComposeSharedData *shared, int op)
	Run ispell on the message - Implements compose_function_t -.
static int	op_compose_postpone_message (struct ComposeSharedData *shared, int op)
	Save this message to send later - Implements compose_function_t -.
static int	op_compose_rename_file (struct ComposeSharedData *shared, int op)
	Rename/move an attached file - Implements compose_function_t -.
static int	op_compose_send_message (struct ComposeSharedData *shared, int op)
	Send the message - Implements compose_function_t -.
static int	op_compose_write_message (struct ComposeSharedData *shared, int op)
	Write the message to a folder - Implements compose_function_t -.
static int	op_display_headers (struct ComposeSharedData *shared, int op)
	Display message and toggle header weeding - Implements compose_function_t -.
static int	op_exit (struct ComposeSharedData *shared, int op)
	Exit this menu - Implements compose_function_t -.
static int	op_forget_passphrase (struct ComposeSharedData *shared, int op)
	Wipe passphrases from memory - Implements compose_function_t -.

Detailed Description

Prototype for a Compose Function.

Parameters

shared	Shared Compose data
op	Operation to perform, e.g. OP_COMPOSE_WRITE_MESSAGE

Return values

enum	FunctionRetval

Function Documentation

op_attachment_attach_file()

static int op_attachment_attach_file ( struct ComposeSharedData *  shared, int  op  )

static

Attach files to this message - Implements compose_function_t -.

Definition at line 731 of file functions.c.

{
  char *prompt = _("Attach file");
  int numfiles = 0;
  char **files = NULL;
 
  struct Buffer *fname = buf_pool_get();
  if ((mw_enter_fname(prompt, fname, false, NULL, true, &files, &numfiles,
                      MUTT_SEL_MULTI) == -1) ||
      buf_is_empty(fname))
  {
    for (int i = 0; i < numfiles; i++)
      FREE(&files[i]);
 
    FREE(&files);
    buf_pool_release(&fname);
    return FR_NO_ACTION;
  }
 
  bool error = false;
  bool added_attachment = false;
  if (numfiles > 1)
  {
    mutt_message(ngettext("Attaching selected file...",
                          "Attaching selected files...", numfiles));
  }
  for (int i = 0; i < numfiles; i++)
  {
    char *att = files[i];
    if (!att)
      continue;
 
    struct AttachPtr *ap = mutt_aptr_new();
    ap->unowned = true;
    ap->body = mutt_make_file_attach(att, shared->sub);
    if (ap->body)
    {
      added_attachment = true;
      update_idx(shared->adata->menu, shared->adata->actx, ap);
    }
    else
    {
      error = true;
      mutt_error(_("Unable to attach %s"), att);
      mutt_aptr_free(&ap);
    }
    FREE(&files[i]);
  }
 
  FREE(&files);
  buf_pool_release(&fname);
 
  if (!error)
    mutt_clear_error();
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  if (added_attachment)
    mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_attach_key()

static int op_attachment_attach_key ( struct ComposeSharedData *  shared, int  op  )

static

Attach a PGP public key - Implements compose_function_t -.

Definition at line 796 of file functions.c.

{
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NOT_IMPL;
  struct AttachPtr *ap = mutt_aptr_new();
  ap->body = crypt_pgp_make_key_attachment();
  if (ap->body)
  {
    update_idx(shared->adata->menu, shared->adata->actx, ap);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
    mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  }
  else
  {
    mutt_aptr_free(&ap);
  }
 
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_attach_message()

static int op_attachment_attach_message ( struct ComposeSharedData *  shared, int  op  )

static

Attach messages to this message - Implements compose_function_t -.

This function handles:

• OP_ATTACHMENT_ATTACH_MESSAGE
• OP_ATTACHMENT_ATTACH_NEWS_MESSAGE

Definition at line 824 of file functions.c.

{
  char *prompt = _("Open mailbox to attach message from");
 
  OptNews = false;
  if (shared->mailbox && (op == OP_ATTACHMENT_ATTACH_NEWS_MESSAGE))
  {
    const char *const c_news_server = cs_subset_string(shared->sub, "news_server");
    CurrentNewsSrv = nntp_select_server(shared->mailbox, c_news_server, false);
    if (!CurrentNewsSrv)
      return FR_NO_ACTION;
 
    prompt = _("Open newsgroup to attach message from");
    OptNews = true;
  }
 
  struct Buffer *fname = buf_pool_get();
  if (shared->mailbox)
  {
    if ((op == OP_ATTACHMENT_ATTACH_MESSAGE) ^ (shared->mailbox->type == MUTT_NNTP))
    {
      buf_strcpy(fname, mailbox_path(shared->mailbox));
      buf_pretty_mailbox(fname);
    }
  }
 
  if ((mw_enter_fname(prompt, fname, true, shared->mailbox, false, NULL, NULL,
                      MUTT_SEL_NO_FLAGS) == -1) ||
      buf_is_empty(fname))
  {
    buf_pool_release(&fname);
    return FR_NO_ACTION;
  }
 
  if (OptNews)
    nntp_expand_path(fname->data, fname->dsize, &CurrentNewsSrv->conn->account);
  else
    buf_expand_path(fname);
 
  if (imap_path_probe(buf_string(fname), NULL) != MUTT_IMAP)
  {
    if (pop_path_probe(buf_string(fname), NULL) != MUTT_POP)
    {
      if (!OptNews && (nntp_path_probe(buf_string(fname), NULL) != MUTT_NNTP))
      {
        if (mx_path_probe(buf_string(fname)) != MUTT_NOTMUCH)
        {
          /* check to make sure the file exists and is readable */
          if (access(buf_string(fname), R_OK) == -1)
          {
            mutt_perror("%s", buf_string(fname));
            buf_pool_release(&fname);
            return FR_ERROR;
          }
        }
      }
    }
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
 
  struct Mailbox *m_attach = mx_path_resolve(buf_string(fname));
  const bool old_readonly = m_attach->readonly;
  if (!mx_mbox_open(m_attach, MUTT_READONLY))
  {
    mutt_error(_("Unable to open mailbox %s"), buf_string(fname));
    mx_fastclose_mailbox(m_attach, false);
    m_attach = NULL;
    buf_pool_release(&fname);
    return FR_ERROR;
  }
  buf_pool_release(&fname);
 
  if (m_attach->msg_count == 0)
  {
    mx_mbox_close(m_attach);
    mutt_error(_("No messages in that folder"));
    return FR_NO_ACTION;
  }
 
  /* `$sort`, `$sort_aux`, `$use_threads` could be changed in dlg_index() */
  const enum SortType old_sort = cs_subset_sort(shared->sub, "sort");
  const enum SortType old_sort_aux = cs_subset_sort(shared->sub, "sort_aux");
  const unsigned char old_use_threads = cs_subset_enum(shared->sub, "use_threads");
 
  mutt_message(_("Tag the messages you want to attach"));
  struct MuttWindow *dlg = index_pager_init();
  struct IndexSharedData *index_shared = dlg->wdata;
  index_shared->attach_msg = true;
  dialog_push(dlg);
  struct Mailbox *m_attach_new = dlg_index(dlg, m_attach);
  dialog_pop();
  mutt_window_free(&dlg);
 
  if (!shared->mailbox)
  {
    /* Restore old $sort variables */
    cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
    cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
    cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
    notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
    return FR_SUCCESS;
  }
 
  bool added_attachment = false;
  for (int i = 0; i < m_attach_new->msg_count; i++)
  {
    if (!m_attach_new->emails[i])
      break;
    if (!message_is_tagged(m_attach_new->emails[i]))
      continue;
 
    struct AttachPtr *ap = mutt_aptr_new();
    ap->body = mutt_make_message_attach(m_attach_new, m_attach_new->emails[i],
                                        true, shared->sub);
    if (ap->body)
    {
      added_attachment = true;
      update_idx(shared->adata->menu, shared->adata->actx, ap);
    }
    else
    {
      mutt_error(_("Unable to attach"));
      mutt_aptr_free(&ap);
    }
  }
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
 
  if (m_attach_new == m_attach)
  {
    m_attach->readonly = old_readonly;
  }
  mx_fastclose_mailbox(m_attach_new, false);
 
  /* Restore old $sort variables */
  cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
  cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
  cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  if (added_attachment)
    mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_detach()

static int op_attachment_detach ( struct ComposeSharedData *  shared, int  op  )

static

Delete the current entry - Implements compose_function_t -.

Definition at line 972 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  struct Menu *menu = shared->adata->menu;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (cur_att->unowned)
    cur_att->body->unlink = false;
 
  int index = menu_get_index(menu);
  if (delete_attachment(actx, index) == -1)
    return FR_ERROR;
 
  menu->num_tagged = 0;
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body->tagged)
      menu->num_tagged++;
  }
 
  update_menu(actx, menu, false);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
 
  index = menu_get_index(menu);
  if (index == 0)
    shared->email->body = actx->idx[0]->body;
 
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_edit_content_id()

static int op_attachment_edit_content_id ( struct ComposeSharedData *  shared, int  op  )

static

Edit the 'Content-ID' of the attachment - Implements compose_function_t -.

Definition at line 1008 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  int rc = FR_NO_ACTION;
  struct Buffer *buf = buf_pool_get();
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
 
  char *id = cur_att->body->content_id;
  if (id)
  {
    buf_strcpy(buf, id);
  }
  else
  {
    id = gen_cid();
    buf_strcpy(buf, id);
    FREE(&id);
  }
 
  if (mw_get_field("Content-ID: ", buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) == 0)
  {
    if (!mutt_str_equal(id, buf_string(buf)))
    {
      if (check_cid(buf_string(buf)))
      {
        mutt_str_replace(&cur_att->body->content_id, buf_string(buf));
        menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
        notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
        mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
        rc = FR_SUCCESS;
      }
      else
      {
        mutt_error(_("Content-ID can only contain the characters: -.0-9@A-Z_a-z"));
        rc = FR_ERROR;
      }
    }
  }
 
  buf_pool_release(&buf);
 
  if (rc != FR_ERROR)
    mutt_clear_error();
 
  return rc;
}

Here is the call graph for this function:

op_attachment_edit_description()

static int op_attachment_edit_description ( struct ComposeSharedData *  shared, int  op  )

static

Edit attachment description - Implements compose_function_t -.

Definition at line 1061 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  int rc = FR_NO_ACTION;
  struct Buffer *buf = buf_pool_get();
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  buf_strcpy(buf, cur_att->body->description);
 
  /* header names should not be translated */
  if (mw_get_field("Description: ", buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) == 0)
  {
    if (!mutt_str_equal(cur_att->body->description, buf_string(buf)))
    {
      mutt_str_replace(&cur_att->body->description, buf_string(buf));
      menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
      mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
      rc = FR_SUCCESS;
    }
  }
 
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attachment_edit_encoding()

static int op_attachment_edit_encoding ( struct ComposeSharedData *  shared, int  op  )

static

Edit attachment transfer-encoding - Implements compose_function_t -.

Definition at line 1092 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  int rc = FR_NO_ACTION;
  struct Buffer *buf = buf_pool_get();
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  buf_strcpy(buf, ENCODING(cur_att->body->encoding));
 
  if ((mw_get_field("Content-Transfer-Encoding: ", buf, MUTT_COMP_NO_FLAGS,
                    HC_OTHER, NULL, NULL) == 0) &&
      !buf_is_empty(buf))
  {
    int enc = mutt_check_encoding(buf_string(buf));
    if ((enc != ENC_OTHER) && (enc != ENC_UUENCODED))
    {
      if (enc != cur_att->body->encoding)
      {
        cur_att->body->encoding = enc;
        menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
        notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
        mutt_clear_error();
        mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
        rc = FR_SUCCESS;
      }
    }
    else
    {
      mutt_error(_("Invalid encoding"));
      rc = FR_ERROR;
    }
  }
 
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attachment_edit_language()

static int op_attachment_edit_language ( struct ComposeSharedData *  shared, int  op  )

static

Edit the 'Content-Language' of the attachment - Implements compose_function_t -.

Definition at line 1135 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  int rc = FR_NO_ACTION;
  struct Buffer *buf = buf_pool_get();
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
 
  buf_strcpy(buf, cur_att->body->language);
  if (mw_get_field("Content-Language: ", buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) == 0)
  {
    if (!mutt_str_equal(cur_att->body->language, buf_string(buf)))
    {
      mutt_str_replace(&cur_att->body->language, buf_string(buf));
      menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
      notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
      mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
      rc = FR_SUCCESS;
    }
    mutt_clear_error();
  }
  else
  {
    mutt_warning(_("Empty 'Content-Language'"));
    rc = FR_ERROR;
  }
 
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attachment_edit_mime()

static int op_attachment_edit_mime ( struct ComposeSharedData *  shared, int  op  )

static

Edit attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1171 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (!mutt_edit_attachment(cur_att->body))
    return FR_NO_ACTION;
 
  mutt_update_encoding(cur_att->body, shared->sub);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_edit_type()

static int op_attachment_edit_type ( struct ComposeSharedData *  shared, int  op  )

static

Edit attachment content type - Implements compose_function_t -.

Definition at line 1189 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (!mutt_edit_content_type(NULL, cur_att->body, NULL))
    return FR_NO_ACTION;
 
  /* this may have been a change to text/something */
  mutt_update_encoding(cur_att->body, shared->sub);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_filter()

static int op_attachment_filter ( struct ComposeSharedData *  shared, int  op  )

static

Filter attachment through a shell command - Implements compose_function_t -.

This function handles:

• OP_ATTACHMENT_FILTER
• OP_PIPE

Definition at line 1213 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  struct Menu *menu = shared->adata->menu;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't filter multipart attachments"));
    return FR_ERROR;
  }
  mutt_pipe_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body,
                            (op == OP_ATTACHMENT_FILTER));
  if (op == OP_ATTACHMENT_FILTER) /* cte might have changed */
  {
    menu_queue_redraw(menu, menu->tag_prefix ? MENU_REDRAW_FULL : MENU_REDRAW_CURRENT);
  }
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_get_attachment()

static int op_attachment_get_attachment ( struct ComposeSharedData *  shared, int  op  )

static

Get a temporary copy of an attachment - Implements compose_function_t -.

Definition at line 1240 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  int rc = FR_ERROR;
  struct Menu *menu = shared->adata->menu;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_tagged(&ba, actx, menu);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    if ((*bp)->type == TYPE_MULTIPART)
    {
      mutt_warning(_("Can't get multipart attachments"));
      continue;
    }
    mutt_get_tmp_attachment(*bp);
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  rc = FR_SUCCESS;
 
done:
  ARRAY_FREE(&ba);
  /* No send2hook since this doesn't change the message. */
  return rc;
}

Here is the call graph for this function:

op_attachment_group_alts()

static int op_attachment_group_alts ( struct ComposeSharedData *  shared, int  op  )

static

Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -.

Definition at line 1276 of file functions.c.

{
  if (shared->adata->menu->num_tagged < 2)
  {
    mutt_error(_("Grouping 'alternatives' requires at least 2 tagged messages"));
    return FR_ERROR;
  }
 
  return group_attachments(shared, "alternative");
}

Here is the call graph for this function:

op_attachment_group_lingual()

static int op_attachment_group_lingual ( struct ComposeSharedData *  shared, int  op  )

static

Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -.

Definition at line 1290 of file functions.c.

{
  if (shared->adata->menu->num_tagged < 2)
  {
    mutt_error(_("Grouping 'multilingual' requires at least 2 tagged messages"));
    return FR_ERROR;
  }
 
  /* traverse to see whether all the parts have Content-Language: set */
  int tagged_with_lang_num = 0;
  for (struct Body *b = shared->email->body; b; b = b->next)
    if (b->tagged && b->language && *b->language)
      tagged_with_lang_num++;
 
  if (shared->adata->menu->num_tagged != tagged_with_lang_num)
  {
    if (query_yesorno(_("Not all parts have 'Content-Language' set, continue?"),
                      MUTT_YES) != MUTT_YES)
    {
      mutt_message(_("Not sending this message"));
      return FR_ERROR;
    }
  }
 
  return group_attachments(shared, "multilingual");
}

Here is the call graph for this function:

op_attachment_group_related()

static int op_attachment_group_related ( struct ComposeSharedData *  shared, int  op  )

static

Group tagged attachments as 'multipart/related' - Implements compose_function_t -.

Definition at line 1320 of file functions.c.

{
  if (shared->adata->menu->num_tagged < 2)
  {
    mutt_error(_("Grouping 'related' requires at least 2 tagged messages"));
    return FR_ERROR;
  }
 
  // ensure Content-ID is set for tagged attachments
  for (struct Body *b = shared->email->body; b; b = b->next)
  {
    if (!b->tagged || (b->type == TYPE_MULTIPART))
      continue;
 
    char *id = b->content_id;
    if (id)
      continue;
 
    id = gen_cid();
    if (id)
    {
      mutt_str_replace(&b->content_id, id);
    }
  }
 
  return group_attachments(shared, "related");
}

Here is the call graph for this function:

op_attachment_move_down()

static int op_attachment_move_down ( struct ComposeSharedData *  shared, int  op  )

static

Move an attachment down in the attachment list - Implements compose_function_t -.

Definition at line 1351 of file functions.c.

{
  int index = menu_get_index(shared->adata->menu);
 
  struct AttachCtx *actx = shared->adata->actx;
 
  if (index < 0)
    return FR_ERROR;
 
  if (index == (actx->idxlen - 1))
  {
    mutt_error(_("Attachment is already at bottom"));
    return FR_NO_ACTION;
  }
  if ((actx->idx[index]->parent_type == TYPE_MULTIPART) &&
      !actx->idx[index]->body->next)
  {
    mutt_error(_("Attachment can't be moved out of group"));
    return FR_ERROR;
  }
 
  // find next attachment at current level
  int nextidx = index + 1;
  while ((nextidx < actx->idxlen) &&
         (actx->idx[nextidx]->level > actx->idx[index]->level))
  {
    nextidx++;
  }
  if (nextidx == actx->idxlen)
  {
    mutt_error(_("Attachment is already at bottom"));
    return FR_NO_ACTION;
  }
 
  // find final position
  int finalidx = index + 1;
  if (nextidx < actx->idxlen - 1)
  {
    if ((actx->idx[nextidx]->body->type == TYPE_MULTIPART) &&
        (actx->idx[nextidx + 1]->level > actx->idx[nextidx]->level))
    {
      finalidx += attach_body_count(actx->idx[nextidx]->body->parts, true);
    }
  }
 
  compose_attach_swap(shared->email, shared->adata->actx, index, nextidx);
  mutt_update_tree(shared->adata->actx);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  menu_set_index(shared->adata->menu, finalidx);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_move_up()

static int op_attachment_move_up ( struct ComposeSharedData *  shared, int  op  )

static

Move an attachment up in the attachment list - Implements compose_function_t -.

Definition at line 1406 of file functions.c.

{
  int index = menu_get_index(shared->adata->menu);
  if (index < 0)
    return FR_ERROR;
 
  struct AttachCtx *actx = shared->adata->actx;
 
  if (index == 0)
  {
    mutt_error(_("Attachment is already at top"));
    return FR_NO_ACTION;
  }
  if (actx->idx[index - 1]->level < actx->idx[index]->level)
  {
    mutt_error(_("Attachment can't be moved out of group"));
    return FR_ERROR;
  }
 
  // find previous attachment at current level
  int previdx = index - 1;
  while ((previdx > 0) && (actx->idx[previdx]->level > actx->idx[index]->level))
    previdx--;
 
  compose_attach_swap(shared->email, actx, previdx, index);
  mutt_update_tree(actx);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  menu_set_index(shared->adata->menu, previdx);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_new_mime()

static int op_attachment_new_mime ( struct ComposeSharedData *  shared, int  op  )

static

Compose new attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1440 of file functions.c.

{
  int rc = FR_NO_ACTION;
  struct Buffer *fname = buf_pool_get();
  struct Buffer *type = NULL;
  struct AttachPtr *ap = NULL;
 
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL };
  if ((mw_get_field(_("New file: "), fname, MUTT_COMP_NO_FLAGS, HC_FILE,
                    &CompleteFileOps, &cdata) != 0) ||
      buf_is_empty(fname))
  {
    goto done;
  }
  buf_expand_path(fname);
 
  /* Call to lookup_mime_type () ?  maybe later */
  type = buf_pool_get();
  if ((mw_get_field("Content-Type: ", type, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(type))
  {
    goto done;
  }
 
  rc = FR_ERROR;
  char *p = strchr(buf_string(type), '/');
  if (!p)
  {
    mutt_error(_("Content-Type is of the form base/sub"));
    goto done;
  }
  *p++ = 0;
  enum ContentType itype = mutt_check_mime_type(buf_string(type));
  if (itype == TYPE_OTHER)
  {
    mutt_error(_("Unknown Content-Type %s"), buf_string(type));
    goto done;
  }
 
  ap = mutt_aptr_new();
  /* Touch the file */
  FILE *fp = mutt_file_fopen(buf_string(fname), "w");
  if (!fp)
  {
    mutt_error(_("Can't create file %s"), buf_string(fname));
    goto done;
  }
  mutt_file_fclose(&fp);
 
  ap->body = mutt_make_file_attach(buf_string(fname), shared->sub);
  if (!ap->body)
  {
    mutt_error(_("Error attaching file"));
    goto done;
  }
  update_idx(shared->adata->menu, shared->adata->actx, ap);
  ap = NULL; // shared->adata->actx has taken ownership
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  cur_att->body->type = itype;
  mutt_str_replace(&cur_att->body->subtype, p);
  cur_att->body->unlink = true;
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
 
  if (mutt_compose_attachment(cur_att->body))
  {
    mutt_update_encoding(cur_att->body, shared->sub);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  }
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  rc = FR_SUCCESS;
 
done:
  mutt_aptr_free(&ap);
  buf_pool_release(&type);
  buf_pool_release(&fname);
  return rc;
}

Here is the call graph for this function:

op_attachment_print()

static int op_attachment_print ( struct ComposeSharedData *  shared, int  op  )

static

Print the current entry - Implements compose_function_t -.

Definition at line 1524 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  struct Menu *menu = shared->adata->menu;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't print multipart attachments"));
    return FR_ERROR;
  }
 
  mutt_print_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_rename_attachment()

static int op_attachment_rename_attachment ( struct ComposeSharedData *  shared, int  op  )

static

Send attachment with a different name - Implements compose_function_t -.

Definition at line 1546 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  char *src = NULL;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->d_filename)
    src = cur_att->body->d_filename;
  else
    src = cur_att->body->filename;
  struct Buffer *fname = buf_pool_get();
  buf_strcpy(fname, mutt_path_basename(NONULL(src)));
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL };
  int rc = mw_get_field(_("Send attachment with name: "), fname,
                        MUTT_COMP_NO_FLAGS, HC_FILE, &CompleteFileOps, &cdata);
  if (rc == 0)
  {
    // It's valid to set an empty string here, to erase what was set
    mutt_str_replace(&cur_att->body->d_filename, buf_string(fname));
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  }
  buf_pool_release(&fname);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_save()

static int op_attachment_save ( struct ComposeSharedData *  shared, int  op  )

static

Save message/attachment to a mailbox/file - Implements compose_function_t -.

Definition at line 1575 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  struct Menu *menu = shared->adata->menu;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't save multipart attachments"));
    return FR_ERROR;
  }
 
  mutt_save_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body, NULL, menu);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_toggle_disposition()

static int op_attachment_toggle_disposition ( struct ComposeSharedData *  shared, int  op  )

static

Toggle disposition between inline/attachment - Implements compose_function_t -.

Definition at line 1597 of file functions.c.

{
  /* toggle the content-disposition between inline/attachment */
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  cur_att->body->disposition = (cur_att->body->disposition == DISP_INLINE) ?
                                   DISP_ATTACH :
                                   DISP_INLINE;
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_toggle_recode()

static int op_attachment_toggle_recode ( struct ComposeSharedData *  shared, int  op  )

static

Toggle recoding of this attachment - Implements compose_function_t -.

Definition at line 1612 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (!mutt_is_text_part(cur_att->body))
  {
    mutt_error(_("Recoding only affects text attachments"));
    return FR_ERROR;
  }
  cur_att->body->noconv = !cur_att->body->noconv;
  if (cur_att->body->noconv)
    mutt_message(_("The current attachment won't be converted"));
  else
    mutt_message(_("The current attachment will be converted"));
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_toggle_unlink()

static int op_attachment_toggle_unlink ( struct ComposeSharedData *  shared, int  op  )

static

Toggle whether to delete file after sending it - Implements compose_function_t -.

Definition at line 1636 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  cur_att->body->unlink = !cur_att->body->unlink;
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  /* No send2hook since this doesn't change the message. */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_ungroup()

static int op_attachment_ungroup ( struct ComposeSharedData *  shared, int  op  )

static

Ungroup a 'multipart' attachment - Implements compose_function_t -.

Definition at line 1652 of file functions.c.

{
  if (shared->adata->actx->idx[shared->adata->menu->current]->body->type != TYPE_MULTIPART)
  {
    mutt_error(_("Attachment is not 'multipart'"));
    return FR_ERROR;
  }
 
  int aidx = shared->adata->menu->current;
  struct AttachCtx *actx = shared->adata->actx;
  struct Body *b = actx->idx[aidx]->body;
  struct Body *b_next = b->next;
  struct Body *b_previous = NULL;
  struct Body *b_parent = NULL;
  int parent_type = actx->idx[aidx]->parent_type;
  int level = actx->idx[aidx]->level;
 
  // reorder body pointers
  if (attach_body_previous(shared->email->body, b, &b_previous))
    b_previous->next = b->parts;
  else if (attach_body_parent(shared->email->body, NULL, b, &b_parent))
    b_parent->parts = b->parts;
  else
    shared->email->body = b->parts;
 
  // update attachment list
  int i = aidx + 1;
  while (actx->idx[i]->level > level)
  {
    actx->idx[i]->level--;
    if (actx->idx[i]->level == level)
    {
      actx->idx[i]->parent_type = parent_type;
      // set body->next for final attachment in group
      if (!actx->idx[i]->body->next)
        actx->idx[i]->body->next = b_next;
    }
    i++;
    if (i == actx->idxlen)
      break;
  }
 
  // free memory
  actx->idx[aidx]->body->parts = NULL;
  actx->idx[aidx]->body->next = NULL;
  actx->idx[aidx]->body->email = NULL;
  mutt_body_free(&actx->idx[aidx]->body);
  FREE(&actx->idx[aidx]->tree);
  FREE(&actx->idx[aidx]);
 
  // reorder attachment list
  for (int j = aidx; j < (actx->idxlen - 1); j++)
    actx->idx[j] = actx->idx[j + 1];
  actx->idx[actx->idxlen - 1] = NULL;
  actx->idxlen--;
  update_menu(actx, shared->adata->menu, false);
 
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_update_encoding()

static int op_attachment_update_encoding ( struct ComposeSharedData *  shared, int  op  )

static

Update an attachment's encoding info - Implements compose_function_t -.

Definition at line 1716 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_NO_ACTION;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_tagged(&ba, actx, menu);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    mutt_update_encoding(*bp, shared->sub);
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  rc = FR_SUCCESS;
 
done:
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_envelope_edit_headers()

static int op_envelope_edit_headers ( struct ComposeSharedData *  shared, int  op  )

static

Edit the message with headers - Implements compose_function_t -.

Definition at line 1750 of file functions.c.

{
  mutt_rfc3676_space_unstuff(shared->email);
  const char *tag = NULL;
  char *err = NULL;
  mutt_env_to_local(shared->email->env);
  const char *const c_editor = cs_subset_string(shared->sub, "editor");
  if (shared->email->body->type == TYPE_MULTIPART)
  {
    struct Body *b = shared->email->body->parts;
    while (b->parts)
      b = b->parts;
    mutt_edit_headers(NONULL(c_editor), b->filename, shared->email, shared->fcc);
  }
  else
  {
    mutt_edit_headers(NONULL(c_editor), shared->email->body->filename,
                      shared->email, shared->fcc);
  }
 
  if (mutt_env_to_intl(shared->email->env, &tag, &err))
  {
    mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
    FREE(&err);
  }
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ENVELOPE, NULL);
 
  mutt_rfc3676_space_stuff(shared->email);
  mutt_update_encoding(shared->email->body, shared->sub);
 
  /* attachments may have been added */
  if (shared->adata->actx->idxlen &&
      shared->adata->actx->idx[shared->adata->actx->idxlen - 1]->body->next)
  {
    mutt_actx_entries_free(shared->adata->actx);
    update_menu(shared->adata->actx, shared->adata->menu, true);
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  /* Unconditional hook since editor was invoked */
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_compose_edit_file()

static int op_compose_edit_file ( struct ComposeSharedData *  shared, int  op  )

static

Edit the file to be attached - Implements compose_function_t -.

Definition at line 1797 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't edit multipart attachments"));
    return FR_ERROR;
  }
  const char *const c_editor = cs_subset_string(shared->sub, "editor");
  mutt_edit_file(NONULL(c_editor), cur_att->body->filename);
  mutt_update_encoding(cur_att->body, shared->sub);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  /* Unconditional hook since editor was invoked */
  mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_edit_message()

static int op_compose_edit_message ( struct ComposeSharedData *  shared, int  op  )

static

Edit the message - Implements compose_function_t -.

Definition at line 1821 of file functions.c.

{
  const bool c_edit_headers = cs_subset_bool(shared->sub, "edit_headers");
  if (!c_edit_headers)
  {
    mutt_rfc3676_space_unstuff(shared->email);
    const char *const c_editor = cs_subset_string(shared->sub, "editor");
    mutt_edit_file(c_editor, shared->email->body->filename);
    mutt_rfc3676_space_stuff(shared->email);
    mutt_update_encoding(shared->email->body, shared->sub);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    /* Unconditional hook since editor was invoked */
    mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
    return FR_SUCCESS;
  }
 
  return op_envelope_edit_headers(shared, op);
}

Here is the call graph for this function:

op_compose_ispell()

static int op_compose_ispell ( struct ComposeSharedData *  shared, int  op  )

static

Run ispell on the message - Implements compose_function_t -.

Definition at line 1843 of file functions.c.

{
  endwin();
  const char *const c_ispell = cs_subset_string(shared->sub, "ispell");
  char buf[PATH_MAX] = { 0 };
  snprintf(buf, sizeof(buf), "%s -x %s", NONULL(c_ispell), shared->email->body->filename);
  if (mutt_system(buf) == -1)
  {
    mutt_error(_("Error running \"%s\""), buf);
    return FR_ERROR;
  }
 
  mutt_update_encoding(shared->email->body, shared->sub);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_postpone_message()

static int op_compose_postpone_message ( struct ComposeSharedData *  shared, int  op  )

static

Save this message to send later - Implements compose_function_t -.

Definition at line 1863 of file functions.c.

{
  if (check_attachments(shared->adata->actx, shared->sub) != 0)
  {
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    return FR_ERROR;
  }
 
  shared->rc = 1;
  return FR_DONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_compose_rename_file()

static int op_compose_rename_file ( struct ComposeSharedData *  shared, int  op  )

static

Rename/move an attached file - Implements compose_function_t -.

Definition at line 1878 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't rename multipart attachments"));
    return FR_ERROR;
  }
  struct Buffer *fname = buf_pool_get();
  buf_strcpy(fname, cur_att->body->filename);
  buf_pretty_mailbox(fname);
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL };
  if ((mw_get_field(_("Rename to: "), fname, MUTT_COMP_NO_FLAGS, HC_FILE,
                    &CompleteFileOps, &cdata) == 0) &&
      !buf_is_empty(fname))
  {
    struct stat st = { 0 };
    if (stat(cur_att->body->filename, &st) == -1)
    {
      /* L10N: "stat" is a system call. Do "man 2 stat" for more information. */
      mutt_error(_("Can't stat %s: %s"), buf_string(fname), strerror(errno));
      buf_pool_release(&fname);
      return FR_ERROR;
    }
 
    buf_expand_path(fname);
    if (mutt_file_rename(cur_att->body->filename, buf_string(fname)))
    {
      buf_pool_release(&fname);
      return FR_ERROR;
    }
 
    mutt_str_replace(&cur_att->body->filename, buf_string(fname));
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
 
    if (cur_att->body->stamp >= st.st_mtime)
      mutt_stamp_attachment(cur_att->body);
    mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
  }
  buf_pool_release(&fname);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_send_message()

static int op_compose_send_message ( struct ComposeSharedData *  shared, int  op  )

static

Send the message - Implements compose_function_t -.

Definition at line 1927 of file functions.c.

{
  /* Note: We don't invoke send2-hook here, since we want to leave
   * users an opportunity to change settings from the ":" prompt.  */
  if (check_attachments(shared->adata->actx, shared->sub) != 0)
  {
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    return FR_NO_ACTION;
  }
 
  if (!shared->fcc_set && !buf_is_empty(shared->fcc))
  {
    enum QuadOption ans = query_quadoption(_("Save a copy of this message?"),
                                           shared->sub, "copy");
    if (ans == MUTT_ABORT)
      return FR_NO_ACTION;
    else if (ans == MUTT_NO)
      buf_reset(shared->fcc);
  }
 
  shared->rc = 0;
  return FR_DONE;
}

Here is the call graph for this function:

op_compose_write_message()

static int op_compose_write_message ( struct ComposeSharedData *  shared, int  op  )

static

Write the message to a folder - Implements compose_function_t -.

Definition at line 1954 of file functions.c.

{
  int rc = FR_NO_ACTION;
  struct Buffer *fname = buf_pool_get();
  if (shared->mailbox)
  {
    buf_strcpy(fname, mailbox_path(shared->mailbox));
    buf_pretty_mailbox(fname);
  }
  if (shared->adata->actx->idxlen)
    shared->email->body = shared->adata->actx->idx[0]->body;
  if ((mw_enter_fname(_("Write message to mailbox"), fname, true, shared->mailbox,
                      false, NULL, NULL, MUTT_SEL_NO_FLAGS) != -1) &&
      !buf_is_empty(fname))
  {
    mutt_message(_("Writing message to %s ..."), buf_string(fname));
    buf_expand_path(fname);
 
    if (shared->email->body->next)
      shared->email->body = mutt_make_multipart(shared->email->body);
 
    if (mutt_write_fcc(buf_string(fname), shared->email, NULL, false, NULL,
                       NULL, shared->sub) == 0)
      mutt_message(_("Message written"));
 
    shared->email->body = mutt_remove_multipart(shared->email->body);
    rc = FR_SUCCESS;
  }
  buf_pool_release(&fname);
  return rc;
}

Here is the call graph for this function:

op_display_headers()

static int op_display_headers ( struct ComposeSharedData *  shared, int  op  )

static

Display message and toggle header weeding - Implements compose_function_t -.

This function handles:

• OP_ATTACHMENT_VIEW
• OP_ATTACHMENT_VIEW_MAILCAP
• OP_ATTACHMENT_VIEW_PAGER
• OP_ATTACHMENT_VIEW_TEXT
• OP_DISPLAY_HEADERS

Definition at line 1996 of file functions.c.

{
  if (!check_count(shared->adata->actx))
    return FR_NO_ACTION;
 
  enum ViewAttachMode mode = MUTT_VA_REGULAR;
 
  switch (op)
  {
    case OP_ATTACHMENT_VIEW:
    case OP_DISPLAY_HEADERS:
      break;
 
    case OP_ATTACHMENT_VIEW_MAILCAP:
      mode = MUTT_VA_MAILCAP;
      break;
 
    case OP_ATTACHMENT_VIEW_PAGER:
      mode = MUTT_VA_PAGER;
      break;
 
    case OP_ATTACHMENT_VIEW_TEXT:
      mode = MUTT_VA_AS_TEXT;
      break;
  }
 
  if (mode == MUTT_VA_REGULAR)
  {
    mutt_attach_display_loop(shared->sub, shared->adata->menu, op,
                             shared->email, shared->adata->actx, false);
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                   shared->adata->menu);
    mutt_view_attachment(NULL, cur_att->body, mode, shared->email,
                         shared->adata->actx, shared->adata->menu->win);
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_exit()

static int op_exit ( struct ComposeSharedData *  shared, int  op  )

static

Exit this menu - Implements compose_function_t -.

Definition at line 2043 of file functions.c.

{
  enum QuadOption ans = query_quadoption(_("Save (postpone) draft message?"),
                                         shared->sub, "postpone");
  if (ans == MUTT_NO)
  {
    for (int i = 0; i < shared->adata->actx->idxlen; i++)
      if (shared->adata->actx->idx[i]->unowned)
        shared->adata->actx->idx[i]->body->unlink = false;
 
    if (!(shared->flags & MUTT_COMPOSE_NOFREEHEADER))
    {
      for (int i = 0; i < shared->adata->actx->idxlen; i++)
      {
        /* avoid freeing other attachments */
        shared->adata->actx->idx[i]->body->next = NULL;
        if (!shared->adata->actx->idx[i]->body->email)
          shared->adata->actx->idx[i]->body->parts = NULL;
        mutt_body_free(&shared->adata->actx->idx[i]->body);
      }
    }
    shared->rc = -1;
    return FR_DONE;
  }
  else if (ans == MUTT_ABORT)
  {
    return FR_NO_ACTION;
  }
 
  return op_compose_postpone_message(shared, op);
}

Here is the call graph for this function:

op_forget_passphrase()

static int op_forget_passphrase ( struct ComposeSharedData *  shared, int  op  )

static

Wipe passphrases from memory - Implements compose_function_t -.

Definition at line 2078 of file functions.c.

{
  crypt_forget_passphrase();
  return FR_SUCCESS;
}

Here is the call graph for this function: