attachments.c File Reference

Handle the attachments command. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "attachments.h"
#include "ncrypt/lib.h"
#include "parse/lib.h"
#include "mview.h"

Include dependency graph for attachments.c:

Go to the source code of this file.

Data Structures
struct	AttachMatch
	An attachment matching a regex for attachment counter. More...

Functions
static void	attachmatch_free (struct AttachMatch **ptr)
	Free an AttachMatch - Implements list_free_t -.
static struct AttachMatch *	attachmatch_new (void)
	Create a new AttachMatch.
void	attach_cleanup (void)
	Free the attachments lists.
void	attach_init (void)
	Set up the attachments lists.
static bool	count_body_parts_check (struct ListHead *checklist, struct Body *b, bool dflt)
	Compares mime types to the ok and except lists.
static int	count_body_parts (struct Body *b)
	Count the MIME Body parts.
int	mutt_count_body_parts (struct Email *e, FILE *fp)
	Count the MIME Body parts.
void	mutt_attachments_reset (struct MailboxView *mv)
	Reset the attachment count for all Emails.
static enum CommandResult	parse_attach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
	Parse the "attachments" command.
static enum CommandResult	parse_unattach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
	Parse the "unattachments" command.
static int	print_attach_list (struct ListHead *h, const char op, const char *name)
	Print a list of attachments.
enum CommandResult	parse_attachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'attachments' command - Implements Command::parse() -.
enum CommandResult	parse_unattachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unattachments' command - Implements Command::parse() -.
void	mutt_parse_mime_message (struct Email *e, FILE *fp)
	Parse a MIME email.

Variables
static struct ListHead	AttachAllow = STAILQ_HEAD_INITIALIZER(AttachAllow)
	List of attachment types to be counted.
static struct ListHead	AttachExclude = STAILQ_HEAD_INITIALIZER(AttachExclude)
	List of attachment types to be ignored.
static struct ListHead	InlineAllow = STAILQ_HEAD_INITIALIZER(InlineAllow)
	List of inline types to counted.
static struct ListHead	InlineExclude = STAILQ_HEAD_INITIALIZER(InlineExclude)
	List of inline types to ignore.
static struct Notify *	AttachmentsNotify = NULL
	Notifications: NotifyAttach.

Detailed Description

Handle the attachments command.

Authors

• Pietro Cerutti
• 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 attachments.c.

Function Documentation

attachmatch_new()

static struct AttachMatch * attachmatch_new ( void  )

static

Create a new AttachMatch.

Return values

ptr	New AttachMatch

Definition at line 84 of file attachments.c.

{
  return MUTT_MEM_CALLOC(1, struct AttachMatch);
}

Here is the caller graph for this function:

attach_cleanup()

void attach_cleanup

(

void

)

Free the attachments lists.

Definition at line 92 of file attachments.c.

{
  notify_free(&AttachmentsNotify);
 
  /* Lists of AttachMatch */
  mutt_list_free_type(&AttachAllow, (list_free_t) attachmatch_free);
  mutt_list_free_type(&AttachExclude, (list_free_t) attachmatch_free);
  mutt_list_free_type(&InlineAllow, (list_free_t) attachmatch_free);
  mutt_list_free_type(&InlineExclude, (list_free_t) attachmatch_free);
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_init()

void attach_init

(

void

)

Set up the attachments lists.

Definition at line 106 of file attachments.c.

{
  if (AttachmentsNotify)
    return;
 
  AttachmentsNotify = notify_new();
  notify_set_parent(AttachmentsNotify, NeoMutt->notify);
}

Here is the call graph for this function:

Here is the caller graph for this function:

count_body_parts_check()

static bool count_body_parts_check ( struct ListHead *  checklist, struct Body *  b, bool  dflt  )

static

Compares mime types to the ok and except lists.

Parameters

checklist	List of AttachMatch
b	Email Body
dflt	Log whether the matches are OK, or Excluded

Return values

true	Attachment should be counted

Definition at line 122 of file attachments.c.

{
  /* If list is null, use default behavior. */
  if (!checklist || STAILQ_EMPTY(checklist))
  {
    return false;
  }
 
  struct AttachMatch *a = NULL;
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, checklist, entries)
  {
    a = (struct AttachMatch *) np->data;
    mutt_debug(LL_DEBUG3, "%s %d/%s ?? %s/%s [%d]... ", dflt ? "[OK]   " : "[EXCL] ",
               b->type, b->subtype ? b->subtype : "*", a->major, a->minor, a->major_int);
    if (((a->major_int == TYPE_ANY) || (a->major_int == b->type)) &&
        (!b->subtype || (regexec(&a->minor_regex, b->subtype, 0, NULL, 0) == 0)))
    {
      mutt_debug(LL_DEBUG3, "yes\n");
      return true;
    }
    else
    {
      mutt_debug(LL_DEBUG3, "no\n");
    }
  }
 
  return false;
}

Here is the caller graph for this function:

count_body_parts()

static int count_body_parts ( struct Body *  b )

static

Count the MIME Body parts.

Parameters

b	Body of email

Return values

num	Number of MIME Body parts

Definition at line 157 of file attachments.c.

{
  if (!b)
    return 0;
 
  int count = 0;
 
  for (struct Body *bp = b; bp; bp = bp->next)
  {
    /* Initial disposition is to count and not to recurse this part. */
    bool shallcount = true; /* default */
    bool shallrecurse = false;
 
    mutt_debug(LL_DEBUG5, "desc=\"%s\"; fn=\"%s\", type=\"%d/%s\"\n",
               bp->description ? bp->description : ("none"),
               bp->filename   ? bp->filename :
               bp->d_filename ? bp->d_filename :
                                "(none)",
               bp->type, bp->subtype ? bp->subtype : "*");
 
    if (bp->type == TYPE_MESSAGE)
    {
      shallrecurse = true;
 
      /* If it's an external body pointer, don't recurse it. */
      if (mutt_istr_equal(bp->subtype, "external-body"))
        shallrecurse = false;
    }
    else if (bp->type == TYPE_MULTIPART)
    {
      /* Always recurse multiparts, except multipart/alternative. */
      shallrecurse = true;
      if (mutt_istr_equal(bp->subtype, "alternative"))
      {
        const bool c_count_alternatives = cs_subset_bool(NeoMutt->sub, "count_alternatives");
        shallrecurse = c_count_alternatives;
      }
    }
 
    if ((bp->disposition == DISP_INLINE) && (bp->type != TYPE_MULTIPART) &&
        (bp->type != TYPE_MESSAGE) && (bp == b))
    {
      shallcount = false; /* ignore fundamental inlines */
    }
 
    /* If this body isn't scheduled for enumeration already, don't bother
     * profiling it further.  */
    if (shallcount)
    {
      /* Turn off shallcount if message type is not in ok list,
       * or if it is in except list. Check is done separately for
       * inlines vs. attachments.  */
 
      if (bp->disposition == DISP_ATTACH)
      {
        if (!count_body_parts_check(&AttachAllow, bp, true))
          shallcount = false; /* attach not allowed */
        if (count_body_parts_check(&AttachExclude, bp, false))
          shallcount = false; /* attach excluded */
      }
      else
      {
        if (!count_body_parts_check(&InlineAllow, bp, true))
          shallcount = false; /* inline not allowed */
        if (count_body_parts_check(&InlineExclude, bp, false))
          shallcount = false; /* excluded */
      }
    }
 
    if (shallcount)
      count++;
    bp->attach_qualifies = shallcount;
 
    mutt_debug(LL_DEBUG3, "%p shallcount = %d\n", (void *) bp, shallcount);
 
    if (shallrecurse)
    {
      mutt_debug(LL_DEBUG3, "%p pre count = %d\n", (void *) bp, count);
      bp->attach_count = count_body_parts(bp->parts);
      count += bp->attach_count;
      mutt_debug(LL_DEBUG3, "%p post count = %d\n", (void *) bp, count);
    }
  }
 
  mutt_debug(LL_DEBUG3, "return %d\n", (count < 0) ? 0 : count);
  return (count < 0) ? 0 : count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_count_body_parts()

int mutt_count_body_parts	(	struct Email *	e,
		FILE *	fp
	)

Count the MIME Body parts.

Parameters

e	Email
fp	File to parse

Return values

num	Number of MIME Body parts

Definition at line 251 of file attachments.c.

{
  if (!e)
    return 0;
 
  bool keep_parts = false;
 
  if (e->attach_valid)
    return e->attach_total;
 
  if (e->body->parts)
    keep_parts = true;
  else
    mutt_parse_mime_message(e, fp);
 
  if (!STAILQ_EMPTY(&AttachAllow) || !STAILQ_EMPTY(&AttachExclude) ||
      !STAILQ_EMPTY(&InlineAllow) || !STAILQ_EMPTY(&InlineExclude))
  {
    e->attach_total = count_body_parts(e->body);
  }
  else
  {
    e->attach_total = 0;
  }
 
  e->attach_valid = true;
 
  if (!keep_parts)
    mutt_body_free(&e->body->parts);
 
  return e->attach_total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attachments_reset()

void mutt_attachments_reset

(

struct MailboxView *

mv

)

Reset the attachment count for all Emails.

Parameters

mv	Mailbox view

Definition at line 288 of file attachments.c.

{
  if (!mv || !mv->mailbox)
    return;
 
  struct Mailbox *m = mv->mailbox;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    e->attach_valid = false;
    e->attach_total = 0;
  }
}

Here is the caller graph for this function:

parse_attach_list()

static enum CommandResult parse_attach_list ( struct Buffer *  buf, struct Buffer *  s, struct ListHead *  head, struct Buffer *  err  )

static

Parse the "attachments" command.

Parameters

buf	Buffer for temporary storage
s	Buffer containing the attachments command
head	List of AttachMatch to add to
err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 313 of file attachments.c.

{
  struct AttachMatch *a = NULL;
  char *p = NULL;
  char *tmpminor = NULL;
  size_t len;
  int rc;
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (!buf->data || (*buf->data == '\0'))
      continue;
 
    a = attachmatch_new();
 
    /* some cheap hacks that I expect to remove */
    if (mutt_istr_equal(buf->data, "any"))
      a->major = mutt_str_dup("*/.*");
    else if (mutt_istr_equal(buf->data, "none"))
      a->major = mutt_str_dup("cheap_hack/this_should_never_match");
    else
      a->major = mutt_str_dup(buf->data);
 
    p = strchr(a->major, '/');
    if (p)
    {
      *p = '\0';
      p++;
      a->minor = p;
    }
    else
    {
      a->minor = "unknown";
    }
 
    len = strlen(a->minor);
    tmpminor = MUTT_MEM_MALLOC(len + 3, char);
    strcpy(&tmpminor[1], a->minor);
    tmpminor[0] = '^';
    tmpminor[len + 1] = '$';
    tmpminor[len + 2] = '\0';
 
    a->major_int = mutt_check_mime_type(a->major);
    rc = REG_COMP(&a->minor_regex, tmpminor, REG_ICASE);
 
    FREE(&tmpminor);
 
    if (rc != 0)
    {
      regerror(rc, &a->minor_regex, err->data, err->dsize);
      FREE(&a->major);
      FREE(&a);
      return MUTT_CMD_ERROR;
    }
 
    mutt_debug(LL_DEBUG3, "added %s/%s [%d]\n", a->major, a->minor, a->major_int);
 
    mutt_list_insert_tail(head, (char *) a);
  } while (MoreArgs(s));
 
  if (!a)
    return MUTT_CMD_ERROR;
 
  mutt_debug(LL_NOTIFY, "NT_ATTACH_ADD: %s/%s\n", a->major, a->minor);
  notify_send(AttachmentsNotify, NT_ATTACH, NT_ATTACH_ADD, NULL);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unattach_list()

static enum CommandResult parse_unattach_list ( struct Buffer *  buf, struct Buffer *  s, struct ListHead *  head, struct Buffer *  err  )

static

Parse the "unattachments" command.

Parameters

buf	Buffer for temporary storage
s	Buffer containing the unattachments command
head	List of AttachMatch to remove from
err	Buffer for error messages

Return values

MUTT_CMD_SUCCESS

Always

Definition at line 393 of file attachments.c.

{
  struct AttachMatch *a = NULL;
  char *tmp = NULL;
  char *minor = NULL;
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    FREE(&tmp);
 
    if (mutt_istr_equal(buf->data, "any"))
      tmp = mutt_str_dup("*/.*");
    else if (mutt_istr_equal(buf->data, "none"))
      tmp = mutt_str_dup("cheap_hack/this_should_never_match");
    else
      tmp = mutt_str_dup(buf->data);
 
    minor = strchr(tmp, '/');
    if (minor)
    {
      *minor = '\0';
      minor++;
    }
    else
    {
      minor = "unknown";
    }
    const enum ContentType major = mutt_check_mime_type(tmp);
 
    struct ListNode *np = NULL, *tmp2 = NULL;
    STAILQ_FOREACH_SAFE(np, head, entries, tmp2)
    {
      a = (struct AttachMatch *) np->data;
      mutt_debug(LL_DEBUG3, "check %s/%s [%d] : %s/%s [%d]\n", a->major,
                 a->minor, a->major_int, tmp, minor, major);
      if ((a->major_int == major) && mutt_istr_equal(minor, a->minor))
      {
        mutt_debug(LL_DEBUG3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
        mutt_debug(LL_NOTIFY, "NT_ATTACH_DELETE: %s/%s\n", a->major, a->minor);
 
        regfree(&a->minor_regex);
        FREE(&a->major);
        STAILQ_REMOVE(head, np, ListNode, entries);
        FREE(&np->data);
        FREE(&np);
      }
    }
 
  } while (MoreArgs(s));
 
  FREE(&tmp);
 
  notify_send(AttachmentsNotify, NT_ATTACH, NT_ATTACH_DELETE, NULL);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_attach_list()

static int print_attach_list ( struct ListHead *  h, const char  op, const char *  name  )

static

Print a list of attachments.

Parameters

h	List of attachments
op	Operation, e.g. '+', '-'
name	Attached/Inline, 'A', 'I'

Return values

0

Always

Definition at line 459 of file attachments.c.

{
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, h, entries)
  {
    printf("attachments %c%s %s/%s\n", op, name,
           ((struct AttachMatch *) np->data)->major,
           ((struct AttachMatch *) np->data)->minor);
  }
 
  return 0;
}

Here is the caller graph for this function:

mutt_parse_mime_message()

void mutt_parse_mime_message	(	struct Email *	e,
		FILE *	fp
	)

Parse a MIME email.

Parameters

e	Email
fp	File to parse

Definition at line 596 of file attachments.c.

{
  const bool right_type = (e->body->type == TYPE_MESSAGE) ||
                          (e->body->type == TYPE_MULTIPART);
  const bool not_parsed = (e->body->parts == NULL);
 
  if (right_type && fp && not_parsed)
  {
    mutt_parse_part(fp, e->body);
    if (WithCrypto)
    {
      e->security = crypt_query(e->body);
    }
  }
 
  e->attach_valid = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

AttachAllow

struct ListHead AttachAllow = STAILQ_HEAD_INITIALIZER(AttachAllow)

static

List of attachment types to be counted.

Definition at line 56 of file attachments.c.

AttachExclude

struct ListHead AttachExclude = STAILQ_HEAD_INITIALIZER(AttachExclude)

static

List of attachment types to be ignored.

Definition at line 57 of file attachments.c.

InlineAllow

struct ListHead InlineAllow = STAILQ_HEAD_INITIALIZER(InlineAllow)

static

List of inline types to counted.

Definition at line 58 of file attachments.c.

InlineExclude

struct ListHead InlineExclude = STAILQ_HEAD_INITIALIZER(InlineExclude)

static

List of inline types to ignore.

Definition at line 59 of file attachments.c.

AttachmentsNotify

struct Notify* AttachmentsNotify = NULL

static

Notifications: NotifyAttach.

Definition at line 60 of file attachments.c.