commands.c File Reference

Handle the attachments command. More...

#include "config.h"
#include <stdbool.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 "commands.h"
#include "ncrypt/lib.h"
#include "parse/lib.h"
#include "mview.h"

Include dependency graph for commands.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 (const struct Command *cmd, struct Buffer *line, struct ListHead *head, struct Buffer *err)
	Parse the "attachments" command.
static enum CommandResult	parse_unattach_list (const struct Command *cmd, struct Buffer *line, 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 (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'attachments' command - Implements Command::parse() -.
enum CommandResult	parse_unattachments (const struct Command *cmd, struct Buffer *line, 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 commands.c.

Function Documentation

attachmatch_new()

static struct AttachMatch * attachmatch_new ( void )

static

Create a new AttachMatch.

Return values

ptr	New AttachMatch

Definition at line 83 of file commands.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 91 of file commands.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 105 of file commands.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 121 of file commands.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 156 of file commands.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 250 of file commands.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 287 of file commands.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 ( const struct Command * cmd, struct Buffer * line, struct ListHead * head, struct Buffer * err )

static

Parse the "attachments" command.

Parameters

cmd	Command being parsed
line	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 312 of file commands.c.

{
  struct AttachMatch *a = NULL;
  char *p = NULL;
  char *tmpminor = NULL;
  size_t len;
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (buf_is_empty(token))
      continue;
 
    a = attachmatch_new();
 
    /* some cheap hacks that I expect to remove */
    if (mutt_istr_equal(token->data, "any"))
      a->major = mutt_str_dup("*/.*");
    else if (mutt_istr_equal(token->data, "none"))
      a->major = mutt_str_dup("cheap_hack/this_should_never_match");
    else
      a->major = buf_strdup(token);
 
    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);
    int rc_regex = REG_COMP(&a->minor_regex, tmpminor, REG_ICASE);
 
    FREE(&tmpminor);
 
    if (rc_regex != 0)
    {
      regerror(rc_regex, &a->minor_regex, err->data, err->dsize);
      FREE(&a->major);
      FREE(&a);
      goto done;
    }
 
    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(line));
 
  if (!a)
    goto done;
 
  mutt_debug(LL_NOTIFY, "NT_ATTACH_ADD: %s/%s\n", a->major, a->minor);
  notify_send(AttachmentsNotify, NT_ATTACH, NT_ATTACH_ADD, NULL);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

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 ( const struct Command * cmd, struct Buffer * line, struct ListHead * head, struct Buffer * err )

static

Parse the "unattachments" command.

Parameters

cmd	Command being parsed
line	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 397 of file commands.c.

{
  struct Buffer *token = buf_pool_get();
 
  struct AttachMatch *a = NULL;
  char *tmp = NULL;
  char *minor = NULL;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    FREE(&tmp);
 
    if (mutt_istr_equal(token->data, "any"))
      tmp = mutt_str_dup("*/.*");
    else if (mutt_istr_equal(token->data, "none"))
      tmp = mutt_str_dup("cheap_hack/this_should_never_match");
    else
      tmp = buf_strdup(token);
 
    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(line));
 
  FREE(&tmp);
 
  notify_send(AttachmentsNotify, NT_ATTACH, NT_ATTACH_DELETE, NULL);
 
  buf_pool_release(&token);
  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 466 of file commands.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 629 of file commands.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 55 of file commands.c.

AttachExclude

struct ListHead AttachExclude = STAILQ_HEAD_INITIALIZER(AttachExclude)

static

List of attachment types to be ignored.

Definition at line 56 of file commands.c.

InlineAllow

struct ListHead InlineAllow = STAILQ_HEAD_INITIALIZER(InlineAllow)

static

List of inline types to counted.

Definition at line 57 of file commands.c.

InlineExclude

struct ListHead InlineExclude = STAILQ_HEAD_INITIALIZER(InlineExclude)

static

List of inline types to ignore.

Definition at line 58 of file commands.c.

AttachmentsNotify

struct Notify* AttachmentsNotify = NULL

static

Notifications: NotifyAttach.

Definition at line 59 of file commands.c.