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

Macros
#define	MIME_DEPTH_MAX   50
	Maximum MIME nesting depth for counting body parts.

Functions
void	attachmatch_free (void **ptr)
	Free an AttachMatch - Implements list_free_t -.
struct AttachMatch *	attachmatch_new (void)
	Create a new AttachMatch.
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, int depth)
	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, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'attachments' command - Implements Command::parse() -.
enum CommandResult	parse_unattachments (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unattachments' command - Implements Command::parse() -.
void	mutt_parse_mime_message (struct Email *e, FILE *fp)
	Parse a MIME email.
enum CommandResult	parse_mime_lookup (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mime-lookup' command - Implements Command::parse() -.
enum CommandResult	parse_unmime_lookup (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmime-lookup' command - Implements Command::parse() -.

Variables
const struct Command	AttachCommands []
	Attach Commands.

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.

Macro Definition Documentation

MIME_DEPTH_MAX

#define MIME_DEPTH_MAX   50

Maximum MIME nesting depth for counting body parts.

Definition at line 122 of file commands.c.

Function Documentation

attachmatch_new()

struct AttachMatch * attachmatch_new

(

void

)

Create a new AttachMatch.

Return values

ptr	New AttachMatch

Definition at line 79 of file commands.c.

{
  return MUTT_MEM_CALLOC(1, struct AttachMatch);
}

Here is the caller graph for this function:

count_body_parts_check()

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 91 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()

int count_body_parts ( struct Body * b, int depth )

static

Count the MIME Body parts.

Parameters

b	Body of email
depth	Current recursion depth

Return values

num	Number of MIME Body parts

Definition at line 130 of file commands.c.

{
  if (!b || (depth >= MIME_DEPTH_MAX))
    return 0;
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  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(&mod_data->attach_allow, bp, true))
          shallcount = false; /* attach not allowed */
        if (count_body_parts_check(&mod_data->attach_exclude, bp, false))
          shallcount = false; /* attach excluded */
      }
      else
      {
        if (!count_body_parts_check(&mod_data->inline_allow, bp, true))
          shallcount = false; /* inline not allowed */
        if (count_body_parts_check(&mod_data->inline_exclude, 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, depth + 1);
      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 227 of file commands.c.

{
  if (!e)
    return 0;
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  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(&mod_data->attach_allow) || !STAILQ_EMPTY(&mod_data->attach_exclude) ||
      !STAILQ_EMPTY(&mod_data->inline_allow) || !STAILQ_EMPTY(&mod_data->inline_exclude))
  {
    e->attach_total = count_body_parts(e->body, 0);
  }
  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 267 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()

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 292 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;
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NONE);
 
    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);
    memcpy(&tmpminor[1], a->minor, len);
    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);
      buf_fix_dptr(err);
      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(mod_data->attachments_notify, 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()

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 381 of file commands.c.

{
  struct Buffer *token = buf_pool_get();
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct AttachMatch *a = NULL;
  char *tmp = NULL;
  char *minor = NULL;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NONE);
    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;
    struct ListNode *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(mod_data->attachments_notify, 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()

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 454 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

AttachCommands

const struct Command AttachCommands[]

Initial value:

                    = {
  
  { "attachments", CMD_ATTACHMENTS, parse_attachments,
        N_("Set attachment counting rules"),
        N_("attachments { + | - }<disposition> <mime-type> [ <mime-type> ... ] | ?"),
        "mimesupport.html#attachments" },
  { "mime-lookup", CMD_MIME_LOOKUP, parse_mime_lookup,
        N_("Map specified MIME types/subtypes to display handlers"),
        N_("mime-lookup <mime-type>[/<mime-subtype> ] [ ... ]"),
        "mimesupport.html#mime-lookup" },
  { "unattachments", CMD_UNATTACHMENTS, parse_unattachments,
        N_("Remove attachment counting rules"),
        N_("unattachments { * | { + | - }<disposition> <mime-type> [ ... ] }"),
        "mimesupport.html#attachments" },
  { "unmime-lookup", CMD_UNMIME_LOOKUP, parse_unmime_lookup,
        N_("Remove custom MIME-type handlers"),
        N_("unmime-lookup { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#mime-lookup" },
 
  
  { "mime_lookup",         CMD_NONE, NULL, "mime-lookup",         NULL, NULL, CF_SYNONYM },
  { "unmime_lookup",       CMD_NONE, NULL, "unmime-lookup",       NULL, NULL, CF_SYNONYM },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NONE },
  
}

Attach Commands.

Definition at line 682 of file commands.c.

                                      {
  // clang-format off
  { "attachments", CMD_ATTACHMENTS, parse_attachments,
        N_("Set attachment counting rules"),
        N_("attachments { + | - }<disposition> <mime-type> [ <mime-type> ... ] | ?"),
        "mimesupport.html#attachments" },
  { "mime-lookup", CMD_MIME_LOOKUP, parse_mime_lookup,
        N_("Map specified MIME types/subtypes to display handlers"),
        N_("mime-lookup <mime-type>[/<mime-subtype> ] [ ... ]"),
        "mimesupport.html#mime-lookup" },
  { "unattachments", CMD_UNATTACHMENTS, parse_unattachments,
        N_("Remove attachment counting rules"),
        N_("unattachments { * | { + | - }<disposition> <mime-type> [ ... ] }"),
        "mimesupport.html#attachments" },
  { "unmime-lookup", CMD_UNMIME_LOOKUP, parse_unmime_lookup,
        N_("Remove custom MIME-type handlers"),
        N_("unmime-lookup { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#mime-lookup" },
 
  // Deprecated
  { "mime_lookup",         CMD_NONE, NULL, "mime-lookup",         NULL, NULL, CF_SYNONYM },
  { "unmime_lookup",       CMD_NONE, NULL, "unmime-lookup",       NULL, NULL, CF_SYNONYM },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NONE },
  // clang-format on
};