module.c File Reference

Definition of the Email Module. More...

#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "module_data.h"
#include "tags.h"

Include dependency graph for module.c:

Go to the source code of this file.

Functions
static bool	email_init (struct NeoMutt *n)
	Initialise a Module - Implements Module::init()
static bool	email_config_define_variables (struct NeoMutt *n, struct ConfigSet *cs)
	Define the Config Variables - Implements Module::config_define_variables()
static bool	email_commands_register (struct NeoMutt *n, struct CommandArray *ca)
	Register NeoMutt Commands - Implements Module::commands_register()
static bool	email_cleanup (struct NeoMutt *n)
	Clean up a Module - Implements Module::cleanup()

Variables
struct ConfigDef	EmailVars []
	Config definitions for the Email library.
const struct Command	EmailCommands []
	Email Commands.
const struct Module	ModuleEmail
	Module for the Email library.

Detailed Description

Definition of the Email Module.

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 module.c.

Function Documentation

email_init()

static bool email_init ( struct NeoMutt * n )

static

Initialise a Module - Implements Module::init()

Definition at line 45 of file module.c.

{
  struct EmailModuleData *md = MUTT_MEM_CALLOC(1, struct EmailModuleData);
  neomutt_set_module_data(n, MODULE_ID_EMAIL, md);
 
  md->auto_subscribe_cache = NULL;
 
  STAILQ_INIT(&md->alternative_order);
  STAILQ_INIT(&md->auto_view);
  STAILQ_INIT(&md->header_order);
  STAILQ_INIT(&md->ignore);
  STAILQ_INIT(&md->mail);
  STAILQ_INIT(&md->mail_to_allow);
  STAILQ_INIT(&md->no_spam);
  STAILQ_INIT(&md->spam);
  STAILQ_INIT(&md->subscribed);
  STAILQ_INIT(&md->unignore);
  STAILQ_INIT(&md->unmail);
  STAILQ_INIT(&md->unsubscribed);
 
  /* RFC2368, "4. Unsafe headers"
   * The creator of a mailto URL can't expect the resolver of a URL to
   * understand more than the "subject" and "body" headers. Clients that
   * resolve mailto URLs into mail messages should be able to correctly create
   * RFC822-compliant mail messages using the "subject" and "body" headers. */
  add_to_stailq(&md->mail_to_allow, "body");
  add_to_stailq(&md->mail_to_allow, "subject");
  // Cc, In-Reply-To, and References help with not breaking threading on mailing lists
  add_to_stailq(&md->mail_to_allow, "cc");
  add_to_stailq(&md->mail_to_allow, "in-reply-to");
  add_to_stailq(&md->mail_to_allow, "references");
 
  driver_tags_init(md);
 
  return true;
}

Here is the call graph for this function:

email_config_define_variables()

static bool email_config_define_variables ( struct NeoMutt * n, struct ConfigSet * cs )

static

Define the Config Variables - Implements Module::config_define_variables()

Definition at line 85 of file module.c.

{
  return cs_register_variables(cs, EmailVars);
}

Here is the call graph for this function:

email_commands_register()

static bool email_commands_register ( struct NeoMutt * n, struct CommandArray * ca )

static

Register NeoMutt Commands - Implements Module::commands_register()

Definition at line 93 of file module.c.

{
  return commands_register(ca, EmailCommands);
}

Here is the call graph for this function:

email_cleanup()

static bool email_cleanup ( struct NeoMutt * n )

static

Clean up a Module - Implements Module::cleanup()

Definition at line 101 of file module.c.

{
  struct EmailModuleData *md = neomutt_get_module_data(n, MODULE_ID_EMAIL);
  ASSERT(md);
 
  mutt_hash_free(&md->auto_subscribe_cache);
 
  mutt_list_free(&md->alternative_order);
  mutt_list_free(&md->auto_view);
  mutt_list_free(&md->header_order);
  mutt_list_free(&md->ignore);
  mutt_list_free(&md->mail_to_allow);
  mutt_list_free(&md->unignore);
 
  mutt_regexlist_free(&md->mail);
  mutt_regexlist_free(&md->no_spam);
  mutt_regexlist_free(&md->subscribed);
  mutt_regexlist_free(&md->unmail);
  mutt_regexlist_free(&md->unsubscribed);
 
  mutt_replacelist_free(&md->spam);
 
  driver_tags_cleanup(md);
 
  FREE(&md);
  return true;
}

Here is the call graph for this function:

Variable Documentation

EmailVars

struct ConfigDef EmailVars[]

extern

Config definitions for the Email library.

Definition at line 56 of file config.c.

                               {
  // clang-format off
  { "auto_subscribe", DT_BOOL, false, 0, NULL,
    "Automatically check if the user is subscribed to a mailing list"
  },
  { "honor_disposition", DT_BOOL, false, 0, NULL,
    "Don't display MIME parts inline if they have a disposition of 'attachment'"
  },
  { "hidden_tags", DT_SLIST|D_SLIST_SEP_COMMA, IP "unread,draft,flagged,passed,replied,attachment,signed,encrypted", 0, NULL,
    "List of tags that shouldn't be displayed on screen (comma-separated)"
  },
  { "implicit_auto_view", DT_BOOL, false, 0, NULL,
    "Display MIME attachments inline if a 'copiousoutput' mailcap entry exists"
  },
  { "include_encrypted", DT_BOOL, false, 0, NULL,
    "Whether to include encrypted content when replying"
  },
  { "include_only_first", DT_BOOL, false, 0, NULL,
    "Only include the first attachment when replying"
  },
  { "mailcap_path", DT_SLIST|D_SLIST_SEP_COLON, IP "~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap", 0, NULL,
    "List of mailcap files (colon-separated)"
  },
  { "mailcap_sanitize", DT_BOOL, true, 0, NULL,
    "Restrict the possible characters in mailcap expandos"
  },
  { "preferred_languages", DT_SLIST|D_SLIST_SEP_COMMA, 0, 0, NULL,
    "List of Preferred Languages for multilingual MIME (comma-separated)"
  },
  { "reflow_space_quotes", DT_BOOL, true, 0, NULL,
    "Insert spaces into reply quotes for 'format=flowed' messages"
  },
  { "reflow_text", DT_BOOL, true, 0, NULL,
    "Reformat paragraphs of 'format=flowed' text"
  },
  { "reflow_wrap", DT_NUMBER, 78, 0, NULL,
    "Maximum paragraph width for reformatting 'format=flowed' text"
  },
  // L10N: $reply_regex default format
  //
  // This is a regular expression that matches reply subject lines.
  // By default, it only matches an initial "Re: ", which is the
  // standardized Latin prefix.
  //
  // However, many locales have other prefixes that are commonly used
  // too, such as Aw in Germany.  To add other prefixes, modify the first
  // parenthesized expression, such as:
  //    "^(re|aw)
  // you can add multiple values, for example:
  //    "^(re|aw|sv)
  //
  // Important:
  // - Use all lower case letters.
  // - Don't remove the 're' prefix from the list of choices.
  // - Please test the value you use inside Mutt.  A mistake here will break
  //   NeoMutt's threading behavior.  Note: the header cache can interfere with
  //   testing, so be sure to test with $header_cache unset.
  { "reply_regex", DT_REGEX|D_L10N_STRING, IP N_("^((re)(\\[[0-9]+\\])*:[ \t]*)*"), 0, NULL,
    "Regex to match message reply subjects like 're: '"
  },
  { "score", DT_BOOL, true, 0, NULL,
    "Use message scoring"
  },
  { "score_threshold_delete", DT_NUMBER, -1, 0, NULL,
    "Messages with a lower score will be automatically deleted"
  },
  { "score_threshold_flag", DT_NUMBER, 9999, 0, NULL,
    "Messages with a greater score will be automatically flagged"
  },
  { "score_threshold_read", DT_NUMBER, -1, 0, NULL,
    "Messages with a lower score will be automatically marked read"
  },
  { "show_multipart_alternative", DT_STRING, 0, 0, multipart_validator,
    "How to display 'multipart/alternative' MIME parts"
  },
  { "reverse_alias", DT_BOOL, false, 0, NULL,
    "Display the alias in the index, rather than the message's sender"
  },
  { "rfc2047_parameters", DT_BOOL, true, 0, NULL,
    "Decode RFC2047-encoded MIME parameters"
  },
  { "spam_separator", DT_STRING, IP ",", 0, NULL,
    "Separator for multiple spam headers"
  },
 
  { "implicit_autoview", DT_SYNONYM, IP "implicit_auto_view", IP "2023-01-25" },
  { "include_onlyfirst", DT_SYNONYM, IP "include_only_first", IP "2021-03-21" },
  { "reply_regexp", DT_SYNONYM, IP "reply_regex", IP "2021-03-21" },
  { NULL },
  // clang-format on
};

EmailCommands

const struct Command EmailCommands[]

extern

Email Commands.

Definition at line 222 of file commands.c.

                                       {
  // clang-format off
  { "alternative-order", CMD_ALTERNATIVE_ORDER, parse_list,
        N_("Set preference order for multipart alternatives"),
        N_("alternative-order <mime-type>[/<mime-subtype> ] [ ... ]"),
        "mimesupport.html#alternative-order" },
  { "auto-view", CMD_AUTO_VIEW, parse_list,
        N_("Automatically display specified MIME types inline"),
        N_("auto-view <mime-type>[/<mime-subtype> ] [ ... ]"),
        "mimesupport.html#auto-view" },
  { "group", CMD_GROUP, parse_group,
        N_("Add addresses to an address group"),
        N_("group [ -group <name> ... ] { -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "header-order", CMD_HEADER_ORDER, parse_list,
        N_("Define custom order of headers displayed"),
        N_("header-order <header> [ <header> ... ]"),
        "configuration.html#header-order" },
  { "ignore", CMD_IGNORE, parse_ignore,
        N_("Hide specified headers when displaying messages"),
        N_("ignore <string> [ <string> ...]"),
        "configuration.html#ignore" },
  { "lists", CMD_LISTS, parse_lists,
        N_("Add address to the list of mailing lists"),
        N_("lists [ -group <name> ... ] <regex> [ ... ]"),
        "configuration.html#lists" },
  { "mailto-allow", CMD_MAILTO_ALLOW, parse_list,
        N_("Permit specific header-fields in mailto URL processing"),
        N_("mailto-allow { * | <header-field> ... }"),
        "configuration.html#mailto-allow" },
  { "nospam", CMD_NOSPAM, parse_nospam,
        N_("Remove a spam detection rule"),
        N_("nospam { * | <regex> }"),
        "configuration.html#spam" },
  { "score", CMD_SCORE, parse_score,
        N_("Set a score value on emails matching a pattern"),
        N_("score <pattern> <value>"),
        "configuration.html#score-command" },
  { "spam", CMD_SPAM, parse_spam,
        N_("Define rules to parse spam detection headers"),
        N_("spam <regex> [ <format> ]"),
        "configuration.html#spam" },
  { "tag-formats", CMD_TAG_FORMATS, parse_tag_formats,
        N_("Define expandos tags"),
        N_("tag-formats <tag> <format-string> [ ... ] }"),
        "optionalfeatures.html#custom-tags" },
  { "tag-transforms", CMD_TAG_TRANSFORMS, parse_tag_transforms,
        N_("Rules to transform tags into icons"),
        N_("tag-transforms <tag> <transformed-string> [ ... ]"),
        "optionalfeatures.html#custom-tags" },
  { "unalternative-order", CMD_UNALTERNATIVE_ORDER, parse_unlist,
        N_("Remove MIME types from preference order"),
        N_("unalternative-order { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#alternative-order" },
  { "unauto-view", CMD_UNAUTO_VIEW, parse_unlist,
        N_("Remove MIME types from `auto-view` list"),
        N_("unauto-view { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#auto-view" },
  { "ungroup", CMD_UNGROUP, parse_group,
        N_("Remove addresses from an address `group`"),
        N_("ungroup [ -group <name> ... ] { * | -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "unheader-order", CMD_UNHEADER_ORDER, parse_unlist,
        N_("Remove header from `header-order` list"),
        N_("unheader-order { * | <header> ... }"),
        "configuration.html#header-order" },
  { "unignore", CMD_UNIGNORE, parse_unignore,
        N_("Remove a header from the `header-order` list"),
        N_("unignore { * | <string> ... }"),
        "configuration.html#ignore" },
  { "unlists", CMD_UNLISTS, parse_unlists,
        N_("Remove address from the list of mailing lists"),
        N_("unlists { * | <regex> ... }"),
        "configuration.html#lists" },
  { "unmailto-allow", CMD_UNMAILTO_ALLOW, parse_unlist,
        N_("Disallow header-fields in mailto processing"),
        N_("unmailto-allow { * | <header-field> ... }"),
        "configuration.html#mailto-allow" },
  { "unscore", CMD_UNSCORE, parse_unscore,
        N_("Remove scoring rules for matching patterns"),
        N_("unscore { * | <pattern> ... }"),
        "configuration.html#score-command" },
 
  // Deprecated
  { "alternative_order",   CMD_NONE, NULL, "alternative-order",   NULL, NULL, CF_SYNONYM },
  { "auto_view",           CMD_NONE, NULL, "auto-view",           NULL, NULL, CF_SYNONYM },
  { "hdr_order",           CMD_NONE, NULL, "header-order",        NULL, NULL, CF_SYNONYM },
  { "mailto_allow",        CMD_NONE, NULL, "mailto-allow",        NULL, NULL, CF_SYNONYM },
  { "unalternative_order", CMD_NONE, NULL, "unalternative-order", NULL, NULL, CF_SYNONYM },
  { "unauto_view",         CMD_NONE, NULL, "unauto-view",         NULL, NULL, CF_SYNONYM },
  { "unhdr_order",         CMD_NONE, NULL, "unheader-order",      NULL, NULL, CF_SYNONYM },
  { "unmailto_allow",      CMD_NONE, NULL, "unmailto-allow",      NULL, NULL, CF_SYNONYM },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NO_FLAGS },
  // clang-format on
};

ModuleEmail

const struct Module ModuleEmail

Initial value:

= {
  MODULE_ID_EMAIL,
  "email",
  email_init,
  NULL, 
  email_config_define_variables,
  email_commands_register,
  NULL, 
  NULL, 
  email_cleanup,
}

Module for the Email library.

Definition at line 132 of file module.c.

                                  {
  MODULE_ID_EMAIL,
  "email",
  email_init,
  NULL, // config_define_types
  email_config_define_variables,
  email_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  email_cleanup,
};