commands.c

Go to the documentation of this file.

 
#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"

struct AttachMatch
{
  const char *major;          
  enum ContentType major_int; 
  const char *minor;          
  regex_t minor_regex;        
};

void attachmatch_free(void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AttachMatch **am_ptr = (struct AttachMatch **) ptr;
  struct AttachMatch *am = *am_ptr;
  regfree(&am->minor_regex);
  FREE(&am->major);
  FREE(am_ptr);
}

struct AttachMatch *attachmatch_new(void)
{
  return MUTT_MEM_CALLOC(1, struct AttachMatch);
}

static bool count_body_parts_check(struct ListHead *checklist, struct Body *b, bool dflt)
{
  /* 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;
}

#define MIME_DEPTH_MAX 50

static int count_body_parts(struct Body *b, int depth)
{
  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;
}

int mutt_count_body_parts(struct Email *e, FILE *fp)
{
  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;
}

void mutt_attachments_reset(struct MailboxView *mv)
{
  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;
  }
}

static enum CommandResult parse_attach_list(const struct Command *cmd, struct Buffer *line,
                                            struct ListHead *head, struct Buffer *err)
{
  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;
}

static enum CommandResult parse_unattach_list(const struct Command *cmd, struct Buffer *line,
                                              struct ListHead *head, struct Buffer *err)
{
  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;
}

static int print_attach_list(struct ListHead *h, const char op, const char *name)
{
  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;
}

enum CommandResult parse_attachments(const struct Command *cmd, struct Buffer *line,
                                     const struct ParseContext *pc, struct ParseError *pe)
{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  parse_extract_token(token, line, TOKEN_NONE);
 
  char *category = token->data;
  char op = *category++;
 
  if (op == '?')
  {
    mutt_endwin();
    fflush(stdout);
    printf("\n%s\n\n", _("Current attachments settings:"));
    print_attach_list(&mod_data->attach_allow, '+', "A");
    print_attach_list(&mod_data->attach_exclude, '-', "A");
    print_attach_list(&mod_data->inline_allow, '+', "I");
    print_attach_list(&mod_data->inline_exclude, '-', "I");
    mutt_any_key_to_continue(NULL);
 
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    category--;
  }
 
  struct ListHead *head = NULL;
  if (mutt_istr_startswith("attachment", category))
  {
    if (op == '+')
      head = &mod_data->attach_allow;
    else
      head = &mod_data->attach_exclude;
  }
  else if (mutt_istr_startswith("inline", category))
  {
    if (op == '+')
      head = &mod_data->inline_allow;
    else
      head = &mod_data->inline_exclude;
  }
  else
  {
    buf_strcpy(err, _("attachments: invalid disposition"));
    goto done;
  }
 
  rc = parse_attach_list(cmd, line, head, err);
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_unattachments(const struct Command *cmd, struct Buffer *line,
                                       const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char op;
  const char *p = NULL;
  struct ListHead *head = NULL;
 
  parse_extract_token(token, line, TOKEN_NONE);
 
  p = buf_string(token);
  op = *p++;
 
  if (op == '*')
  {
    mutt_list_free_type(&mod_data->attach_allow, attachmatch_free);
    mutt_list_free_type(&mod_data->attach_exclude, attachmatch_free);
    mutt_list_free_type(&mod_data->inline_allow, attachmatch_free);
    mutt_list_free_type(&mod_data->inline_exclude, attachmatch_free);
 
    mutt_debug(LL_NOTIFY, "NT_ATTACH_DELETE_ALL\n");
    notify_send(mod_data->attachments_notify, NT_ATTACH, NT_ATTACH_DELETE_ALL, NULL);
 
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    p--;
  }
  if (mutt_istr_startswith("attachment", p))
  {
    if (op == '+')
      head = &mod_data->attach_allow;
    else
      head = &mod_data->attach_exclude;
  }
  else if (mutt_istr_startswith("inline", p))
  {
    if (op == '+')
      head = &mod_data->inline_allow;
    else
      head = &mod_data->inline_exclude;
  }
  else
  {
    buf_strcpy(err, _("unattachments: invalid disposition"));
    goto done;
  }
 
  rc = parse_unattach_list(cmd, line, head, err);
 
done:
  buf_pool_release(&token);
  return rc;
}

void mutt_parse_mime_message(struct Email *e, FILE *fp)
{
  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;
}

enum CommandResult parse_mime_lookup(const struct Command *cmd, struct Buffer *line,
                                     const struct ParseContext *pc, struct ParseError *pe)
{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  return parse_stailq(cmd, line, &mod_data->mime_lookup, pc, pe);
}

enum CommandResult parse_unmime_lookup(const struct Command *cmd, struct Buffer *line,
                                       const struct ParseContext *pc, struct ParseError *pe)
{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  return parse_unstailq(cmd, line, &mod_data->mime_lookup, pc, pe);
}

const struct Command AttachCommands[] = {
  // 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
};