recvattach.h File Reference

Routines for managing attachments. More...

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

Include dependency graph for recvattach.h:

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

Go to the source code of this file.

Functions
void	mutt_attach_init (struct AttachCtx *actx)
	Create a new Attachment context.
void	mutt_update_tree (struct AttachCtx *actx)
	Refresh the list of attachments.
void	dlg_attach (struct ConfigSubset *sub, struct MailboxView *mv, struct Email *e, FILE *fp, bool attach_msg)
	Show the attachments in a Menu -.
void	mutt_generate_recvattach_list (struct AttachCtx *actx, struct Email *e, struct Body *parts, FILE *fp, int parent_type, int level, bool decrypted)
	Create a list of attachments.
struct AttachPtr *	current_attachment (struct AttachCtx *actx, struct Menu *menu)
	Get the current attachment.
void	mutt_update_recvattach_menu (struct AttachCtx *actx, struct Menu *menu, bool init)
	Update the Attachment Menu.
void	recvattach_edit_content_type (struct AttachCtx *actx, struct Menu *menu, struct Email *e)
	Edit the content type of an attachment.
int	ba_add_tagged (struct BodyArray *ba, struct AttachCtx *actx, struct Menu *menu)
	Get an array of tagged Attachments.

Detailed Description

Routines for managing 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 recvattach.h.

Function Documentation

mutt_attach_init()

void mutt_attach_init

(

struct AttachCtx *

actx

)

Create a new Attachment context.

Parameters

actx	Attachment context

Definition at line 1190 of file recvattach.c.

{
  /* Collapse the attachments if '$digest_collapse' is set AND if...
   * the outer container is of type 'multipart/digest' */
  bool digest = mutt_istr_equal(actx->email->body->subtype, "digest");
 
  const bool c_digest_collapse = cs_subset_bool(NeoMutt->sub, "digest_collapse");
  for (int i = 0; i < actx->idxlen; i++)
  {
    actx->idx[i]->body->tagged = false;
 
    /* OR an inner container is of type 'multipart/digest' */
    actx->idx[i]->collapsed = (c_digest_collapse &&
                               (digest ||
                                ((actx->idx[i]->body->type == TYPE_MULTIPART) &&
                                 mutt_istr_equal(actx->idx[i]->body->subtype, "digest"))));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_update_tree()

void mutt_update_tree

(

struct AttachCtx *

actx

)

Refresh the list of attachments.

Parameters

actx	Attachment context

Definition at line 116 of file recvattach.c.

{
  char buf[256] = { 0 };
  char *s = NULL;
 
  mutt_update_v2r(actx);
 
  for (int vindex = 0; vindex < actx->vcount; vindex++)
  {
    const int rindex = actx->v2r[vindex];
    actx->idx[rindex]->num = vindex;
    if ((2 * (actx->idx[rindex]->level + 2)) < sizeof(buf))
    {
      if (actx->idx[rindex]->level)
      {
        s = buf + 2 * (actx->idx[rindex]->level - 1);
        *s++ = (actx->idx[rindex]->body->next) ? MUTT_TREE_LTEE : MUTT_TREE_LLCORNER;
        *s++ = MUTT_TREE_HLINE;
        *s++ = MUTT_TREE_RARROW;
      }
      else
      {
        s = buf;
      }
      *s = '\0';
    }
 
    if (actx->idx[rindex]->tree)
    {
      if (!mutt_str_equal(actx->idx[rindex]->tree, buf))
        mutt_str_replace(&actx->idx[rindex]->tree, buf);
    }
    else
    {
      actx->idx[rindex]->tree = mutt_str_dup(buf);
    }
 
    if (((2 * (actx->idx[rindex]->level + 2)) < sizeof(buf)) &&
        actx->idx[rindex]->level)
    {
      s = buf + 2 * (actx->idx[rindex]->level - 1);
      *s++ = (actx->idx[rindex]->body->next) ? MUTT_TREE_VLINE : MUTT_TREE_SPACE;
      *s++ = MUTT_TREE_SPACE;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_generate_recvattach_list()

void mutt_generate_recvattach_list	(	struct AttachCtx *	actx,
		struct Email *	e,
		struct Body *	b,
		FILE *	fp,
		int	parent_type,
		int	level,
		bool	decrypted )

Create a list of attachments.

Parameters

actx	Attachment context
e	Email
b	Body of email
fp	File to read from
parent_type	Type, e.g. TYPE_MULTIPART
level	Attachment depth
decrypted	True if attachment has been decrypted

Definition at line 1092 of file recvattach.c.

{
  struct Body *bp = NULL;
  struct Body *new_body = NULL;
  FILE *fp_new = NULL;
  SecurityFlags type;
 
  for (bp = b; bp; bp = bp->next)
  {
    bool need_secured = false;
    bool secured = false;
 
    if (((WithCrypto & APPLICATION_SMIME) != 0) && (type = mutt_is_application_smime(bp)))
    {
      need_secured = true;
 
      if (type & SEC_ENCRYPT)
      {
        if (!crypt_valid_passphrase(APPLICATION_SMIME))
          goto decrypt_failed;
 
        if (e->env)
          crypt_smime_getkeys(e->env);
      }
 
      secured = (crypt_smime_decrypt_mime(fp, &fp_new, bp, &new_body) == 0);
      /* If the decrypt/verify-opaque doesn't generate mime output, an empty
       * text/plain type will still be returned by mutt_read_mime_header().
       * We can't distinguish an actual part from a failure, so only use a
       * text/plain that results from a single top-level part. */
      if (secured && (new_body->type == TYPE_TEXT) &&
          mutt_istr_equal("plain", new_body->subtype) && ((b != bp) || bp->next))
      {
        mutt_body_free(&new_body);
        mutt_file_fclose(&fp_new);
        goto decrypt_failed;
      }
 
      if (secured && (type & SEC_ENCRYPT))
        e->security |= SMIME_ENCRYPT;
    }
 
    if (((WithCrypto & APPLICATION_PGP) != 0) &&
        (mutt_is_multipart_encrypted(bp) || mutt_is_malformed_multipart_pgp_encrypted(bp)))
    {
      need_secured = true;
 
      if (!crypt_valid_passphrase(APPLICATION_PGP))
        goto decrypt_failed;
 
      secured = (crypt_pgp_decrypt_mime(fp, &fp_new, bp, &new_body) == 0);
 
      if (secured)
        e->security |= PGP_ENCRYPT;
    }
 
    if (need_secured && secured)
    {
      mutt_actx_add_fp(actx, fp_new);
      mutt_actx_add_body(actx, new_body);
      mutt_generate_recvattach_list(actx, e, new_body, fp_new, parent_type, level, 1);
      continue;
    }
 
  decrypt_failed:
    /* Fall through and show the original parts if decryption fails */
    if (need_secured && !secured)
      mutt_error(_("Can't decrypt encrypted message"));
 
    struct AttachPtr *ap = mutt_aptr_new();
    mutt_actx_add_attach(actx, ap);
 
    ap->body = bp;
    ap->fp = fp;
    bp->aptr = ap;
    ap->parent_type = parent_type;
    ap->level = level;
    ap->decrypted = decrypted;
 
    if (mutt_is_message_type(bp->type, bp->subtype))
    {
      mutt_generate_recvattach_list(actx, bp->email, bp->parts, fp, bp->type,
                                    level + 1, decrypted);
      e->security |= bp->email->security;
    }
    else
    {
      mutt_generate_recvattach_list(actx, e, bp->parts, fp, bp->type, level + 1, decrypted);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

current_attachment()

struct AttachPtr * current_attachment	(	struct AttachCtx *	actx,
		struct Menu *	menu )

Get the current attachment.

Parameters

actx	Attachment context
menu	Menu

Return values

ptr	Current Attachment

Definition at line 71 of file recvattach.c.

{
  const int virt = menu_get_index(menu);
  const int index = actx->v2r[virt];
 
  return actx->idx[index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_update_recvattach_menu()

void mutt_update_recvattach_menu	(	struct AttachCtx *	actx,
		struct Menu *	menu,
		bool	init )

Update the Attachment Menu.

Parameters

actx	Attachment context
menu	Menu listing Attachments
init	If true, create a new Attachments context

Definition at line 1215 of file recvattach.c.

{
  if (init)
  {
    mutt_generate_recvattach_list(actx, actx->email, actx->email->body,
                                  actx->fp_root, -1, 0, 0);
    mutt_attach_init(actx);
  }
 
  mutt_update_tree(actx);
 
  menu->max = actx->vcount;
 
  const int index = menu_get_index(menu);
  if (index >= menu->max)
    menu_set_index(menu, menu->max - 1);
  menu_queue_redraw(menu, MENU_REDRAW_INDEX);
}

Here is the call graph for this function:

Here is the caller graph for this function:

recvattach_edit_content_type()

void recvattach_edit_content_type	(	struct AttachCtx *	actx,
		struct Menu *	menu,
		struct Email *	e )

Edit the content type of an attachment.

Parameters

actx	Attachment context
menu	Menu listing Attachments
e	Email

Definition at line 932 of file recvattach.c.

{
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (!mutt_edit_content_type(e, cur_att->body, cur_att->fp))
    return;
 
  /* The mutt_update_recvattach_menu() will overwrite any changes
   * made to a decrypted cur_att->body, so warn the user. */
  if (cur_att->decrypted)
  {
    mutt_message(_("Structural changes to decrypted attachments are not supported"));
    mutt_sleep(1);
  }
  /* Editing the content type can rewrite the body structure. */
  for (int i = 0; i < actx->idxlen; i++)
    actx->idx[i]->body = NULL;
  mutt_actx_entries_free(actx);
  mutt_update_recvattach_menu(actx, menu, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ba_add_tagged()

int ba_add_tagged	(	struct BodyArray *	ba,
		struct AttachCtx *	actx,
		struct Menu *	menu )

Get an array of tagged Attachments.

Parameters

ba	Empty BodyArray to populate
actx	List of Attachments
menu	Menu

Return values

num	Number of selected Attachments
-1	Error

Definition at line 1242 of file recvattach.c.

{
  if (!ba || !actx || !menu)
    return -1;
 
  if (menu->tag_prefix)
  {
    for (int i = 0; i < actx->idxlen; i++)
    {
      struct Body *b = actx->idx[i]->body;
      if (b->tagged)
      {
        ARRAY_ADD(ba, b);
      }
    }
  }
  else
  {
    struct AttachPtr *cur = current_attachment(actx, menu);
    if (!cur)
      return -1;
 
    ARRAY_ADD(ba, cur->body);
  }
 
  return ARRAY_SIZE(ba);
}

Here is the call graph for this function:

Here is the caller graph for this function: