
                            The Mutt E-Mail Client
                                       
by Michael Elkins [1]<me@cs.hmc.edu>

   v0.92.13, 30 June 1998
     _________________________________________________________________
   
   ``All mail clients suck. This one just sucks less.'' -me, circa 1995
     _________________________________________________________________
   
1. Introduction

   Mutt is a small but very powerful text-based MIME mail client. Mutt is
   highly configurable, and is well suited to the mail power user with
   advanced features like key bindings, keyboard macros, mail threading,
   regular expression searches and a powerful pattern matching language
   for selecting groups of messages.
   
1.1 Mutt Home Page

   [2]http://www.cs.hmc.edu/~me/mutt/index.html
   
1.2 Mailing Lists

   To subscribe to one of the following mailing lists, send a message
   with the word subscribe in the subject to
   list-name-request@cs.hmc.edu.
   
     * [3]mutt-announce@cs.hmc.edu -- low traffic list for announcements
     * [4]mutt-users@cs.hmc.edu -- help, bug reports and feature requests
     * [5]mutt-dev@cs.hmc.edu -- development mailing list
       
   Note: all messages posted to mutt-announce are automatically forwarded
   to mutt-users, so you do not need to be subscribed to both lists.
   
1.3 Software Distribution Sites

     * [6]ftp://ftp.cs.hmc.edu/pub/me/mutt/
       
1.4 IRC

   Visit channel #mutt on [7]DALnet (www.dal.net) to chat with other
   people interested in Mutt.
   
1.5 USENET

   See the newsgroup [8]comp.mail.mutt.
   
1.6 Copyright

   Mutt is Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
   
   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, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   
2. Getting Started

   This section is intended as a brief overview of how to use Mutt. There
   are many other features which are described elsewhere in the manual.
   There is even more information available in the Mutt FAQ and various
   web pages. See the [9]Mutt Page for more details.
   
   The keybindings described in this section are the defaults as
   distributed. Your local system administrator may have altered the
   defaults for your site. You can always type ``?'' in any menu to
   display the current bindings.
   
   The first thing you need to do is invoke mutt, simply by typing mutt
   at the command line. There are various command-line options, see
   either the mutt man page or the [10]reference.
   
2.1 Moving Around in Menus

   Information is presented in menus, very similar to ELM. Here is a
   table showing the common keys used to navigate menus in Mutt.
   
j or Down       next-entry      move to the next entry
k or Up         previous-entry  move to the previous entry
z or PageDn     page-down       go to the next page
Z or PageUp     page-up         go to the previous page
= or Home       first-entry     jump to the first entry
* or End        last-entry      jump to the last entry
q               quit            exit the current menu
?               help            list all keybindings for the current menu

2.2 Editing Input Fields

   Mutt has a builtin line editor which is used as the primary way to
   input textual data such as email addresses or filenames. The keys used
   to move around while editing are very similar to those of Emacs.
   
^A or <Home> bol             move to the start of the line
^B or <Left> backward-char   move back one char
^D or <Delete>       delete-char     delete the char under the cursor
^E or <End>  eol             move to the end of the line
^F or <Right>        forward-char    move forward one char
^K              kill-eol        delete to the end of the line
^U              kill-line       delete entire line
^W              kill-word       kill the word in front of the cursor
<Up>         history-up      recall previous string from history
<Down>               history-down    recall next string from history
<BackSpace>  backspace       kill the char in front of the cursor
^G              n/a             abort
<Tab>                n/a             complete filename (only when prompting for
 a file)
<Return>     n/a             finish editing

   You can remap the editor functions using the [11]bind command. For
   example, to make the Delete key delete the character in front of the
   cursor rather than under, you could use
   
   bind editor delete backspace
   
2.3 Reading Mail - The Index and Pager

   Similar to many other mail clients, there are two modes in which mail
   is read in Mutt. The first is the index of messages in the mailbox,
   which is called the ``index'' in Mutt. The second mode is the display
   of the message contents. This is called the ``pager.''
   
   The next few sections describe the functions provided in each of these
   modes.
   
  The Message Index
  
c               change to a different mailbox
ESC c           change to a folder in read-only mode
C               copy the current message to another mailbox
ESC C           decode a message and copy it to a folder
ESC s           decode a message and save it to a folder
D               delete messages matching a pattern
d               delete the current message
F               mark as important
l               show messages matching a pattern
N               mark message as new
o               change the current sort method
O               reverse sort the mailbox
q               save changes and exit
s               save-message
t               toggle the tag on a message
ESC t           toggle tag on entire message thread
u               undelete-message
v               view-attachments
x               abort changes and exit
<Return>     display-message
<Tab>                jump to the next new message
@               show the author's full e-mail address
$               save changes to mailbox
/               search
ESC /           search-reverse
^L              clear and redraw the screen
^T              tag messages matching a pattern
^U              undelete messages matching a pattern

  Status Flags
  
   In addition to who sent the message and the subject, a short summary
   of the disposition of each message is printed beside the message
   number. Zero or more of the following ``flags'' may appear, which
   mean:
   
D       message is deleted
K       contains a PGP public key
M       requires mailcap to view
N       message is new
O       message is old
P       message is PGP encrypted
r       message has been replied to
S       message is PGP signed
!       message is flagged
*       message is tagged

   Some of the status flags can be turned on or off using
     * set-flag (default: w)
     * clear-flag (default: W)
       
   Furthermore, the following flags reflect who the message is addressed
   to. They can be customized with the [12]$to_chars variable.
   
+       message is to you and you only
T       message is to you, but also to or cc'ed to others
C       message is cc'ed to you
F       message is from you

  The Pager
  
   By default, Mutt uses its builtin pager to display the body of
   messages. The pager is very similar to the Unix program less though
   not nearly as featureful.
   
<Return>     go down one line
<Space>              display the next page (or next message if at the end of a
message)
-               go back to the previous page
n               display the next message
?               show keybindings
/               search for a regular expression (pattern)
\               toggle search pattern coloring

   In addition, many of the functions from the index are available in the
   pager, such as delete-message or copy-message (this is one advantage
   over using an external pager to view messages).
   
   Also, the internal pager supports a couple other advanced features.
   For one, it will accept and translate the ``standard'' nroff sequences
   for bold and underline. These sequences are a series of either the
   letter, backspace (^H), the letter again for bold or the letter,
   backspace, ``_'' for denoting underline. Mutt will attempt to display
   these in bold and underline respectively if your terminal supports
   them. If not, you can use the bold and underline [13]color objects to
   specify a color or mono attribute for them.
   
   Additionally, the internal pager supports the ANSI escape sequences
   for character attributes. Mutt translates them into the correct color
   and character settings. The sequences Mutt supports are:
   
ESC [ Ps;Ps;Ps;...;Ps m
where Ps =
0    All Attributes Off
1    Bold on
4    Underline on
5    Blink on
7    Reverse video on
3x   Foreground color is x
4x   Background color is x

Colors are
0    black
1    red
2    green
3    yellow
4    blue
5    magenta
6    cyan
7    white

   Mutt uses these attributes for handling text/enriched messages, and
   they can also be used by an external [14]autoview script for
   highlighting purposes. Note: If you change the colors for your
   display, for example by changing the color associated with color2 for
   your xterm, then that color will be used instead of green.
   
  Threaded Mode
  
   When the mailbox is [15]sorted by threads, there are a few additional
   functions available in the index and pager modes.
   
^D      delete-thread           delete all messages in the current thread
^U      undelete-thread         undelete all messages in the current thread
^N      next-thread             jump to the start of the next thread
^P      previous-thread         jump to the start of the previous thread
^R      read-thread             mark the current thread as read
ESC d   delete-subthread        delete all messages in the current subthread
ESC u   undelete-subthread      undelete all messages in the current subthread
ESC n   next-subthread          jump to the start of the next subthread
ESC p   previous-subthread      jump to the start of the previous subthread
ESC r   read-subthread          mark the current subthread as read
ESC t   tag-thread              toggle the tag on the current thread

   See also: [16]$strict_threads.
   
  Miscellaneous Functions
  
   create-alias (default: a)
   
   Creates a new alias based upon the current message (or prompts for a
   new one). Once editing is complete, an [17]alias command is added to
   the file specified by the [18]$alias_file variable for future use.
   Note: Specifying an [19]$alias_file does not add the aliases
   specified there-in, you must also [20]source the file.
   
   display-headers (default: h)
   
   Toggles the weeding of message header fields specified by [21]ignore
   commands.
   
   enter-command (default: ``:'')
   
   This command is used to execute any command you would normally put in
   a configuration file. A common use is to check the settings of
   variables, or in conjunction with [22]macros to change settings on the
   fly.
   
   extract-keys (default: ESC k)
   
   This command extracts PGP public keys from the current or tagged
   message(s) and adds them to your [23]$pgp_v2_pubring or
   [24]$pgp_v5_pubring depending on [25]$pgp_key_version.
   
   forget-passphrase (default: ^F)
   
   This command wipes the PGP passphrase from memory. It is useful, if
   you misspelled the passphrase.
   
   list-reply (default: L)
   
   Reply to the current or tagged message(s) by extracting any addresses
   which match the addresses given by the [26]lists command. Using this
   when replying to messages posted to mailing lists help avoid duplicate
   copies being sent to the author of the message you are replying to.
   
   pipe-message (default: |)
   
   Asks for an external Unix command and pipes the current or tagged
   message(s) to it. The variables [27]$pipe_decode, [28]$pipe_split,
   [29]$pipe_sep and [30]$wait_key control the exact behaviour of this
   function.
   
   shell-escape (default: !)
   
   Asks for an external Unix command and executes it. The [31]$wait_key
   can be used to control whether Mutt will wait for a key to be pressed
   when the command returns (presumably to let the user read the output
   of the command), based on the return status of the named command.
   
   toggle-quoted (default: T)
   
   The pager uses the [32]$quote_regexp variable to detect quoted text
   when displaying the body of the message. This function toggles the
   display of the quoted material in the message. It is particularly
   useful when are interested in just the response and there is a large
   amount of quoted text in the way.
   
   skip-quoted (default: S)
   
   This function will go to the next line of non-quoted text which come
   after a line of quoted text in the internal pager.
   
2.4 Sending Mail

   The following bindings are available in the index for sending
   messages.
   
m       compose         compose a new message
r       reply           reply to sender
g       group-reply     reply to all recipients
L       list-reply      reply to mailing list address
f       forward         forward message
b       bounce          bounce (remail) message
ESC k   mail-key        mail a PGP public key to someone

   Bouncing a message sends the message as is to the recipient you
   specify. Forwarding a message allows you to add comments or modify the
   message you are forwarding. Bouncing a message uses the [33]sendmail
   command to send a copy of a message to recipients as if they were
   original recipients of the message. See also [34]$mime_forward.
   
   Mutt will then enter the compose menu and prompt you for the
   recipients to place on the ``To:'' header field. Next, it will ask you
   for the ``Subject:'' field for the message, providing a default if you
   are replying to or forwarding a message. See also [35]$askcc,
   [36]$askbcc, [37]$autoedit, and [38]$fast_reply for changing how Mutt
   asks these questions.
   
   Mutt will then automatically start your [39]$editor on the message
   body. If the [40]$edit_headers variable is set, the headers will be at
   the top of the message in your editor. Any messages you are replying
   to will be added in sort order to the message, with appropriate
   [41]$attribution, [42]$indent_string and [43]$post_indent_string. When
   forwarding a message, if the [44]$mime_forward variable is unset, a
   copy of the forwarded message will be included. If you have specified
   a [45]$signature, it will be appended to the message.
   
   Once you have finished editing the body of your mail message, you are
   returned to the compose menu. The following options are available:
   
a       attach-file             attach a file
ESC k   attach-key              attach a PGP public key
d       edit-description        edit description on attachment
D       detach-file             detach a file
T       edit-to                 edit the To field
c       edit-cc                 edit the Cc field
b       edit-bcc                edit the Bcc field
y       send-message            send the message
s       edit-subject            edit the Subject
f       edit-fcc                specify an ``Fcc'' mailbox
p       pgp-menu                select PGP options (``i'' version only)
P       postpone-message        postpone this message until later
q       quit                    quit (abort) sending the message
i       ispell                  check spelling (if available on your system)
^F      forget-passphrase       whipe PGP passphrase from memory

  Editing the message header
  
   When editing the header of your outgoing message, there are a couple
   of special features available.
   
   If you specify
   Fcc: filename
   Mutt will pick up filename just as if you had used the edit-fcc
   function in the compose menu.
   
   You can also attach files to your message by specifying
   Attach: filename [ description ]
   where filename is the file to attach and description is an optional
   string to use as the description of the attached file.
   
   When replying to messages, if you remove the In-Reply-To: field from
   the header field, Mutt will not generate a References: field, which
   allows you to create a new message thread.
   
   If you want to use PGP, you can specify
   
   Pgp: [ E | S | S<id> ]
   
   ``E'' encrypts, ``S'' signs and ``S<id>'' signs with the given key,
   setting [46]$pgp_sign_as permanently.
   
   Also see [47]edit_headers.
   
2.5 Postponing Mail

   At times it is desirable to delay sending a message that you have
   already begun to compose. When the postpone-message function is used
   in the compose menu, the body of your message and attachments are
   stored in the mailbox specified by the [48]$postponed variable. This
   means that you can recall the message even if you exit Mutt and then
   restart it at a later time.
   
   Once a message is postponed, there are several ways to resume it. From
   the command line you can use the ``-p'' option, or if you compose a
   new message from the index or pager you will be prompted if postponed
   messages exist. If multiple messages are currently postponed, the
   postponed menu will pop up and you can select which message you would
   like to resume.
   
   Note: If you postpone a reply to a message, the reply setting of the
   message is only updated when you actually finish the message and send
   it. Also, you must be in the same folder with the message you replied
   to for the status of the message to be updated.
   
   See also the [49]$postpone quad-option.
   
3. Configuration

   While the default configuration (or ``preferences'') make Mutt usable
   right out of the box, it is often desirable to tailor Mutt to suit
   your own tastes. When Mutt is first invoked, it will attempt to read
   the ``system'' configuration file (defaults set by your local system
   administrator), unless the ``-n'' [50]command line option is
   specified. This file is typically /etc/Muttrc or
   /usr/local/lib/Muttrc. Next, it looks for a file in your home
   directory named .muttrc. In this file is where you place [51]commands
   to configure Mutt.
   
   In addition, mutt supports version specific configuration files that
   are parsed instead of the default files as explained above. For
   instance, if your system has a Muttrc-0.88 file in the system
   configuration directory, and you are running version 0.88 of mutt,
   this file will be sourced instead of the Muttrc file. The same is true
   of the user configuration file, if you have a file .muttrc-0.88.6 in
   your home directory, when you run mutt version 0.88.6, it will source
   this file instead of the default .muttrc file. The version number is
   the same which is visible using the ``-v'' [52]command line switch or
   using the show-version key (default: V) from the index menu.
   
3.1 Syntax of Initialization Files

   An initialization file consists of a series of [53]commands. Each line
   of the file may contain one or more commands. When multiple commands
   are used, they must be separated by a semicolon (;).
   
        set realname='Mutt user' ; ignore x-

   The hash mark, or pound sign (``#''), is used as a ``comment''
   character. You can use it to annotate your initialization file. All
   text after the comment character to the end of the line is ignored.
   For example,
   
my_hdr X-Disclaimer: Why are you listening to me? # This is a comment

   Single quotes (') and double quotes (") can be used to quote strings
   which contain spaces or other special characters. The difference
   between the two types of quotes is similar to that of many popular
   shell programs, namely that a single quote is used to specify a
   literal string (one that is not interpreted for shell variables or
   quoting with a backslash [see next paragraph]), while double quotes
   indicate a string for which should be evaluated. For example, backtics
   are evaluated inside of double quotes, but not for single quotes.
   
   \ quotes the next character, just as in shells such as bash and zsh.
   For example, if want to put quotes ``"'' inside of a string, you can
   use ``\'' to force the next character to be a literal instead of
   interpreted character.
   
set realname="Michael \"MuttDude\" Elkins"

   ``\\'' means to insert a literal ``\'' into the line. ``\n'' and
   ``\r'' have their usual C meanings of linefeed and carriage-return,
   respectively.
   
   A \ at the end of a line can be used to split commands over multiple
   lines, provided that the split points don't appear in the middle of
   command names.
   
   It is also possible to substitute the output of a Unix command in an
   initialization file. This is accomplished by enclosing the command in
   backquotes (``). For example,
   
my_hdr X-Operating-System: `uname -a`

   The output of the Unix command ``uname -a'' will be substituted before
   the line is parsed. Note that since initialization files are line
   oriented, only the first line of output from the Unix command will be
   substituted.
   
   For a complete list of the commands understood by mutt, see the
   [54]command reference.
   
3.2 Defining/Using aliases

   Usage: alias key address [ , address, ... ]
   
   It's usually very cumbersome to remember or type out the address of
   someone you are communicating with. Mutt allows you to create
   ``aliases'' which map a short string to a full address.
   
   Note: if you want to create an alias for a group (by specifying more
   than one address), you must separate the addresses with a comma
   (``,'').
   
   To remove an alias or aliases:
   
   unalias addr [ addr ... ]
   
alias muttdude me@cs.hmc.edu (Michael Elkins)
alias theguys manny, moe, jack

   Unlike other mailers, Mutt doesn't require aliases to be defined in a
   special file. The alias command can appear anywhere in a configuration
   file, as long as this file is [55]sourced. Consequently, you can have
   multiple alias files, or you can have all aliases defined in your
   muttrc.
   
   On the other hand, the [56]create-alias function can use only one
   file, the one pointed to by the [57]$alias_file variable (which is
   ~/.muttrc by default). This file is not special either, in the sense
   that Mutt will happily append aliases to any file, but in order for
   the new aliases to take effect you need to explicitly [58]source this
   file too.
   
   For example:
   
source /usr/local/share/Mutt.aliases
source ~/.mail_aliases
set alias_file=~/.mail_aliases

   To use aliases, you merely use the alias at any place in mutt where
   mutt prompts for addresses, such as the To: or Cc: prompt. You can
   also enter aliases in your editor at the appropriate headers if you
   have the [59]$edit_headers variable set.
   
   In addition, at the various address prompts, you can use the tab
   character to expand a partial alias to the full alias. If there are
   multiple matches, mutt will bring up a menu with the matching aliases.
   In order to be presented with the full list of aliases, you must hit
   tab with out a partial alias, such as at the beginning of the prompt
   or after a comma denoting multiple addresses.
   
   In the alias menu, you can select as many aliases as you want with the
   select-entry key (default: RET), and use the exit key (default: q) to
   return to the address prompt.
   
3.3 Changing the default key bindings

   Usage: bind map key function
   
   This command allows you to change the default key bindings (operation
   invoked when pressing a key).
   
   map specifies in which menu the binding belongs. The currently defined
   maps are:
   
     * generic
     * alias
     * attach
     * browser
     * editor
     * index
     * compose
     * pager
     * pgp
     * url
       
   key is the key (or key sequence) you wish to bind. To specify a
   control character, use the sequence \Cx, where x is the letter of the
   control character (for example, to specify control-A use ``\Ca'').
   Note that the case of x as well as \C is ignored, so that \CA, \Ca,
   \cA and \ca are all equivalent. An alternative form is to specify the
   key as a three digit octal number prefixed with a ``\'' (for example
   \177 is equivalent to \c?).
   
   In addition, key may consist of:
   
\t              tab
\r              carriage return
\n              newline
\e              escape
up              up arrow
down            down arrow
left            left arrow
right           right arrow
pageup          Page Up
pagedown        Page Down
backspace       Backspace
delete          Delete
insert          Insert
enter           Enter
home            Home
end             End
f1              function key 1
f10             function key 10

   key does not need to be enclosed in quotes unless it contains a space
   (`` '').
   
   function specifies which action to take when key is pressed. For a
   complete list of functions, see the [60]reference. The special
   function noop unbinds the specify key sequence.
   
3.4 Setting variables based upon mailbox

   Usage: folder-hook [!]pattern command
   
   It is often desirable to change settings based on which mailbox you
   are reading. The folder-hook command provides a method by which you
   can execute any configuration command. pattern is a regular expression
   specifying in which mailboxes to execute command before loading. If a
   mailbox matches multiple folder-hook's, they are executed in the order
   given in the muttrc.
   
   Note: if you use the ``!'' shortcut for [61]$spoolfile at the
   beginning of the pattern, you must place it inside of double or single
   quotes in order to distinguish it from the logical not operator for
   the expression.
   
   Note that the settings are not restored when you leave the mailbox.
   For example, a command action to perform is to change the sorting
   method based upon the mailbox being read:
   
folder-hook mutt set sort=threads

   However, the sorting method is not restored to its previous value when
   reading a different mailbox. To specify a default command, use the
   pattern ``.'':
   
folder-hook . set sort=date-sent

3.5 Keyboard macros

   Usage: macro menu key sequence
   
   Macros are useful when you would like a single key to perform a series
   of actions. When you press key in menu menu, Mutt will behave as if
   you had typed sequence. So if you have a common sequence of commands
   you type, you can create a macro to execute those commands with a
   single key.
   
   key and sequence are expanded by the same rules as the [62]key
   bindings, with the addition that control characters in sequence can
   also be specified as ^x. In order to get a caret (``^'') you need to
   use ^^.
   
   Note: Macro definitions (if any) listed in the help screen(s), are
   silently truncated at the screen width, and are not wrapped.
   
3.6 Using color and mono video attributes

   Usage: color object foreground background [ regexp ]
   Usage: color index foreground background [ pattern ]
   Usage: uncolor index pattern [ pattern ... ]
   
   If your terminal supports color, you can spice up Mutt by creating
   your own color scheme. To define the color of an object (type of
   information), you must specify both a foreground color and a
   background color (it is not possible to only specify one or the
   other).
   
   object can be one of:
   
     * attachment
     * body (match regexp in the body of messages)
     * bold (hiliting bold patterns in the body of messages)
     * error (error messages printed by Mutt)
     * header (match regexp in the message header)
     * hdrdefault (default color of the message header in the pager)
     * index (match pattern in the message index)
     * indicator (arrow or bar used to indicate the current item in a
       menu)
     * markers (the ``+'' markers at the beginning of wrapped lines in
       the pager)
     * message (informational messages)
     * normal
     * quoted (text matching [63]$quote_regexp in the body of a message)
     * quoted1, quoted2, ..., quotedN (higher levels of quoting)
     * search (hiliting of words in the pager)
     * signature
     * status (mode lines used to display info about the mailbox or
       message)
     * tilde (the ``~'' used to pad blank lines in the pager)
     * tree (thread tree drawn in the message index and attachment menu)
     * underline (hiliting underlined patterns in the body of messages)
       
   foreground and background can be one of the following:
   
     * white
     * black
     * green
     * magenta
     * blue
     * cyan
     * yellow
     * red
     * default
     * colorx
       
   foreground can optionally be prefixed with the keyword bright to make
   the foreground color boldfaced (e.g., brightred).
   
   If your terminal supports it, the special keyword default can be used
   as a transparent color. The value brightdefault is also valid. If Mutt
   is linked against the S-Lang library, you also need to set the
   COLORFGBG environment variable to the default colors of your terminal
   for this to work; for example (for Bourne-like shells):
   
set COLORFGBG="green;black"
export COLORFGBG

   Note: The S-Lang library requires you to use the lightgray and brown
   keywords instead of white and yellow when setting this variable.
   
   Note: The uncolor command can be applied to the index object only. It
   removes entries from the list. You must specify the same pattern
   specified in the color command for it to be removed. The pattern ``*''
   is a special token which means to clear the color index list of all
   entries.
   
   Mutt also recognizes the keywords color0, color1, ..., colorN-1 (N
   being the number of colors supported by your terminal). This is useful
   when you remap the colors for your display (for example by changing
   the color associated with color2 for your xterm), since color names
   may then lose their normal meaning.
   
   If your terminal does not support color, it is still possible change
   the video attributes through the use of the ``mono'' command:
   
   Usage: mono <object> <attribute> [ regexp ]
   
   where attribute is one of the following:
   
     * none
     * bold
     * underline
     * reverse
     * standout
       
3.7 Ignoring (weeding) unwanted message headers

   Usage: [un]ignore pattern [ pattern ... ]
   
   Messages often have many header fields added by automatic processing
   systems, or which may not seem useful to display on the screen. This
   command allows you to specify header fields which you don't normally
   want to see.
   
   You do not need to specify the full header field name. For example,
   ``ignore content-'' will ignore all header fields that begin with the
   pattern ``content-''.
   
   To remove a previously added token from the list, use the ``unignore''
   command. Note that if you do ``ignore x-'' it is not possible to
   ``unignore x-mailer,'' for example. The ``unignore'' command does not
   make Mutt display headers with the given pattern.
   
   ``unignore *'' will remove all tokens from the ignore list.
   
   For example:
   
# Sven's draconian header weeding
ignore *
unignore from date subject to cc
unignore organization organisation x-mailer: x-newsreader: x-mailing-list:
unignore posted-to:

3.8 Mailing lists

   Usage: [un]lists address [ address ... ]
   
   Mutt has a few nice features for [64]handling mailing lists. In order
   to take advantage of them, you must specify which addresses belong to
   mailing lists.
   
   It is important to note that you should never specify the domain name
   ( the part after the ``@'') with the lists command. You should only
   specify the ``mailbox'' portion of the address (the part before the
   ``@''). For example, if you've subscribed to the Mutt mailing list,
   you will receive mail addressed to mutt-users@cs.hmc.edu. So, to tell
   Mutt that this is a mailing list, you would add ``lists mutt-users''
   to your initialization file.
   
   The ``unlists'' command is to remove a token from the list of
   mailing-lists. Use ``unlists *'' to remove all tokens.
   
3.9 Using Multiple spool mailboxes

   Usage: mbox-hook [!]pattern mailbox
   
   This command is used to move read messages from a specified mailbox to
   a different mailbox automatically when you quit or change folders.
   pattern is a regular expression specifying the mailbox to treat as a
   ``spool'' mailbox and mailbox specifies where mail should be saved
   when read.
   
   Unlike some of the other hook commands, only the first matching
   pattern is used (it is not possible to save read mail in more than a
   single mailbox).
   
3.10 Defining mailboxes which receive mail

   Usage: mailboxes [!]filename [ filename ... ]
   
   This command specifies folders which can receive mail and which will
   be checked for new messages. By default, the main menu status bar
   displays how many of these folders have new messages.
   
   When changing folders, pressing space will cycle through folders with
   new mail.
   
   Pressing TAB in the directory browser will bring up a menu showing the
   files specified by the mailboxes command, and indicate which contain
   new messages. Mutt will automatically enter this mode when invoked
   from the command line with the -y option.
   
   Note: new mail is detected by comparing the last modification time to
   the last access time. Utilities like biff or frm or any other program
   which accesses the mailbox might cause Mutt to never detect new mail
   for that mailbox if they do not properly reset the access time.
   
   Note: the filenames in the mailboxes command are resolved when the
   command is executed, so if these names contain [65]shortcut characters
   (such as ``='' and ``!''), any variable definition that affect these
   characters (like [66]$folder and [67]$spool) should be executed before
   the mailboxes command.
   
3.11 User defined headers

   Usage:
   my_hdr string
   unmy_hdr field [ field ... ]
   
   The ``my_hdr'' command allows you to create your own header fields
   which will be added to every message you send.
   
   For example, if you would like to add an ``Organization:'' header
   field to all of your outgoing messages, you can put the command
   
     my_hdr Organization: A Really Big Company, Anytown, USA
     
   in your .muttrc.
   
   Note: space characters are not allowed between the keyword and the
   colon (``:''). The standard for electronic mail (RFC822) says that
   space is illegal there, so Mutt enforces the rule.
   
   If you would like to add a header field to a single message, you
   should either set the [68]edit_headers variable, or use the
   edit-headers function (default: ``E'') in the send-menu so that you
   can edit the header of your message along with the body.
   
   To remove user defined header fields, use the ``unmy_hdr'' command.
   You may specify an asterisk (``*'') to remove all header fields, or
   the fields to remove. For example, to remove all ``To'' and ``Cc''
   header fields, you could use:
   
     unmy_hdr to cc
     
3.12 Defining the order of headers when viewing messages

   Usage: hdr_order header1 header2 header3
   
   With this command, you can specify an order in which mutt will attempt
   to present headers to you when viewing messages.
   
hdr_order From Date: From: To: Cc: Subject:

3.13 Specify default save filename

   Usage: save-hook [!]regexp filename
   
   This command is used to override the default filename used when saving
   messages. filename will be used as the default filename if the message
   is From: an address matching regexp or if you are the author and the
   message is addressed to: something matching regexp.
   
   See [69]matching messages for information on the exact format of
   regexp.
   
   Examples:
   
save-hook me@(turing\\.)?cs\\.hmc\\.edu$ +elkins
save-hook aol\\.com$ +spam

   Also see the [70]fcc-save-hook command.
   
3.14 Specify default Fcc: mailbox when composing

   Usage: fcc-hook [!]regexp mailbox
   
   This command is used to save outgoing mail in a mailbox other than
   [71]$record. Mutt searches the initial list of message recipients for
   the first matching regexp and uses mailbox as the default Fcc:
   mailbox. If no match is found the message will be saved to [72]$record
   mailbox.
   
   See [73]matching messages for information on the exact format of
   regexp.
   
   Example: fcc-hook aol.com$ +spammers
   
   The above will save a copy of all messages going to the aol.com domain
   to the `+spammers' mailbox by default. Also see the [74]fcc-save-hook
   command.
   
3.15 Specify default save filename and default Fcc: mailbox at once

   Usage: fcc-save-hook [!]regexp mailbox
   
   This command is a shortcut, equivalent to doing both a [75]fcc-hook
   and a [76]save-hook with its arguments.
   
3.16 Change settings based upon message recipients

   Usage: send-hook [!]regexp command
   
   This command can be used to execute arbitrary configuration commands
   based upon recipients of the message. regexp is a regular expression
   matching the desired address. command is executed when regexp matches
   recipients of the message. When multiple matches occur, commands are
   executed in the order they are specified in the muttrc.
   
   See [77]matching messages for information on the exact format of
   regexp.
   
   Example: send-hook mutt "set mime_forward signature=''"
   
   Another typical use for this command is to change the values of the
   [78]$attribution, [79]$signature and [80]$locale variables in order to
   change the language of the attributions and signatures based upon the
   recipients.
   
   Note: the send-hook's are only executed ONCE after getting the initial
   list of recipients. Adding a recipient after replying or editing the
   message will NOT cause any send-hook to be executed.
   
3.17 Adding key sequences to the keyboard buffer

   Usage: push string
   
   This command adds the named string to the keyboard buffer. You may use
   it to automatically run a sequence of commands at startup, or when
   entering certain folders.
   
3.18 Message Scoring

   Usage: score pattern value
   Usage: unscore pattern [ pattern ... ]
   
   The score commands adds value to a message's score if pattern matches
   it. pattern is a string in the format described in the [81]searching
   section. value is a positive or negative integer. A message's final
   score is the sum total of all matching score entries. However, you may
   optionally prefix value with an equal sign (=) to cause evaluation to
   stop at a particular entry if there is a match. Negative final scores
   are rounded up to 0.
   
   The unscore command removes score entries from the list. You must
   specify the same pattern specified in the score command for it to be
   removed. The pattern ``*'' is a special token which means to clear the
   list of all score entries.
   
3.19 Setting variables

   Usage: set [no|inv]variable[=value] [ variable ... ]
   Usage: toggle variable [variable ... ]
   Usage: unset variable [variable ... ]
   Usage: reset variable [variable ... ]
   
   This command is used to set (and unset) [82]configuration variables.
   There are four basic types of variables: boolean, number, string and
   quadoption. boolean variables can be set (true) or unset (false).
   number variables can be assigned a positive integer value.
   
   string variables consist of any number of printable characters.
   strings must be enclosed in quotes if they contain spaces or tabs.
   You may also use the ``C'' escape sequences \n and \t for newline and
   tab, respectively.
   
   quadoption variables are used to control whether or not to be prompted
   for certain actions, or to specify a default action. A value of yes
   will cause the action to be carried out automatically as if you had
   answered yes to the question. Similarly, a value of no will cause the
   the action to be carried out as if you had answered ``no.'' A value of
   ask-yes will cause a prompt with a default answer of ``yes'' and
   ask-no will provide a default answer of ``no.''
   
   Prefixing a variable with ``no'' will unset it. Example: set noaskbcc.
   
   For boolean variables, you may optionally prefix the variable name
   with inv to toggle the value (on or off). This is useful when writing
   macros. Example: set invsmart_wrap.
   
   The toggle command automatically prepends the inv prefix to all
   specified variables.
   
   The unset command automatically prepends the no prefix to all
   specified variables.
   
   Using the enter-command function in the index menu, you can query the
   value of a variable by prefixing the name of the variable with a
   question mark:
   
set ?allow_8bit

   The question mark is actually only required for boolean variables.
   
   The reset command resets all given variables to the compile time
   defaults (hopefully mentioned in this manual). If you use the command
   set and prefix the variable with ``&'' this has the same behavior as
   the reset command.
   
   With the reset command there exists the special variable ``all'',
   which allows you to reset all variables to their system defaults.
   
3.20 Reading initialization commands from another file

   Usage: source filename
   
   This command allows the inclusion of initialization commands from
   other files. For example, I place all of my aliases in ~/.mail_aliases
   so that I can make my ~/.muttrc readable and keep my aliases private.
   
   If the filename begins with a tilde (``~''), it will be expanded to
   the path of your home directory.
   
   If the filename ends with a vertical bar (|), then filename is
   considered to be an executable program from which to read input (eg.
   source ~bin/myscript|/.
   
4. Advanced Usage

4.1 Searching and Regular Expressions

   All text patterns for searching and matching in Mutt must be specified
   as regular expressions (regexp) in the ``POSIX extended'' syntax
   (which is more or less the syntax used by egrep and GNU awk). For your
   convenience, we have included below a brief description of this
   syntax.
   
   The search is case sensitive if the pattern contains at least one
   upper case letter, and case insensitive otherwise. Note that ``\''
   must be quoted if used for a regular expression in an initialization
   command: ``\\''. For more information, see the section on
   [83]searching below.
   
  Regular Expressions
  
   A regular expression is a pattern that describes a set of strings.
   Regular expressions are constructed analogously to arithmetic
   expressions, by using various operators to combine smaller
   expressions.
   
   The fundamental building blocks are the regular expressions that match
   a single character. Most characters, including all letters and digits,
   are regular expressions that match themselves. Any metacharacter with
   special meaning may be quoted by preceding it with a backslash.
   
   The period ``.'' matches any single character. The caret ``^'' and the
   dollar sign ``$'' are metacharacters that respectively match the empty
   string at the beginning and end of a line.
   
   A list of characters enclosed by ``['' and ``]'' matches any single
   character in that list; if the first character of the list is a caret
   ``^'' then it matches any character not in the list. For example, the
   regular expression [0123456789] matches any single digit. A range of
   ASCII characters may be specified by giving the first and last
   characters, separated by a hyphen ``-''. Most metacharacters lose
   their special meaning inside lists. To include a literal ``]'' place
   it first in the list. Similarly, to include a literal ``^'' place it
   anywhere but first. Finally, to include a literal hyphen ``-'' place
   it last.
   
   Certain named classes of characters are predefined. Character classes
   consist of ``[:'', a keyword denoting the class, and ``:]''. The
   following classes are defined by the POSIX standard:
   
   [:alnum:]
          Alphanumeric characters.
          
   [:alpha:]
          Alphabetic characters.
          
   [:blank:]
          Space or tab characters.
          
   [:cntrl:]
          Control characters.
          
   [:digit:]
          Numeric characters.
          
   [:graph:]
          Characters that are both printable and visible. (A space is
          printable, but not visible, while an ``a'' is both.)
          
   [:lower:]
          Lower-case alphabetic characters.
          
   [:print:]
          Printable characters (characters that are not control
          characters.)
          
   [:punct:]
          Punctuation characters (characters that are not letter, digits,
          control characters, or space characters).
          
   [:space:]
          Space characters (such as space, tab and formfeed, to name a
          few).
          
   [:upper:]
          Upper-case alphabetic characters.
          
   [:xdigit:]
          Characters that are hexadecimal digits.
          
   A character class is only valid in a regular expression inside the
   brackets of a character list. Note that the brackets in these class
   names are part of the symbolic names, and must be included in addition
   to the brackets delimiting the bracket list. For example, [[:digit:]]
   is equivalent to [0-9].
   
   Two additional special sequences can appear in character lists. These
   apply to non-ASCII character sets, which can have single symbols
   (called collating elements) that are represented with more than one
   character, as well as several characters that are equivalent for
   collating or sorting purposes:
   
   Collating Symbols
          A collating symbols is a multi-character collating element
          enclosed in ``[.'' and ``.]''. For example, if ``ch'' is a
          collating element, then [[.ch.]] is a regexp that matches this
          collating element, while [ch] is a regexp that matches either
          ``c'' or ``h''.
          
   Equivalence Classes
          An equivalence class is a locale-specific name for a list of
          characters that are equivalent. The name is enclosed in ``[=''
          and ``=]''. For example, the name ``e'' might be used to
          represent all of ``è'' ``é'' and ``e''. In this case, [[=e=]]
          is a regexp that matches any of ``è'', ``é'' and ``e''.
          
   A regular expression matching a single character may be followed by
   one of several repetition operators:
   
   ?
          The preceding item is optional and matched at most once.
          
   *
          The preceding item will be matched zero or more times.
          
   +
          The preceding item will be matched one or more times.
          
   {n}
          The preceding item is matched exactly n times.
          
   {n,}
          The preceding item is matched n or more times.
          
   {,m}
          The preceding item is matched at most m times.
          
   {n,m}
          The preceding item is matched at least n times, but no more
          than m times.
          
   Two regular expressions may be concatenated; the resulting regular
   expression matches any string formed by concatenating two substrings
   that respectively match the concatenated subexpressions.
   
   Two regular expressions may be joined by the infix operator ``|''; the
   resulting regular expression matches any string matching either
   subexpression.
   
   Repetition takes precedence over concatenation, which in turn takes
   precedence over alternation. A whole subexpression may be enclosed in
   parentheses to override these precedence rules.
   
   Note: If you compile Mutt with the GNU rx package, the following
   operators may also be used in regular expressions:
   
   \\y
          Matches the empty string at either the beginning or the end of
          a word.
          
   \\B
          Matches the empty string within a word.
          
   \\<
          Matches the empty string at the beginning of a word.
          
   \\>
          Matches the empty string at the end of a word.
          
   \\w
          Matches any word-constituent character (letter, digit, or
          underscore).
          
   \\W
          Matches any character that is not word-constituent.
          
   \\`
          Matches the empty string at the beginning of a buffer (string).
          
   \\'
          Matches the empty string at the end of a buffer.
          
   pLease note however that these operators are not defined by POSIX, so
   they may or may not be available in stock libraries on various
   systems.
   
  Searching
  
   Many of Mutt's commands allow you to specify a pattern to match
   (limit, tag-pattern, delete-pattern, etc.). There are several ways to
   select messages:
   
~A              all messages
~b PATTERN      messages which contain PATTERN in the message body
~B PATTERN      messages which contain PATTERN in the whole message
~c USER         messages carbon-copied to USER
~C PATTERN      message is either to: or cc: PATTERN
~D              deleted messages
~d [MIN]-[MAX]  messages with ``date-sent'' in a Date range
~E              expired messages
~e PATTERN      message which contains PATTERN in the ``Sender'' field
~F              flagged messages
~f USER         messages originating from USER
~h PATTERN      messages which contain PATTERN in the message header
~i ID           message which match ID in the ``Message-ID'' field
~L PATTERN      message is either originated or received by PATTERN
~l              message is addressed to a known mailing list
~m [MIN]-[MAX]  message in the range MIN to MAX
~n [MIN]-[MAX]  messages with a score in the range MIN to MAX
~N              new messages
~O              old messages
~p              message is addressed to you (consults $alternates)
~P              message is from you (consults $alternates)
~Q              messages which have been replied to
~R              read messages
~r [MIN]-[MAX]  messages with ``date-received'' in a Date range
~S              superseded messages
~s SUBJECT      messages having SUBJECT in the ``Subject'' field.
~T              tagged messages
~t USER         messages addressed to USER
~U              unread messages
~x PATTERN      messages which contain PATTERN in the `References' field
~z [MIN]-[MAX]  messages with a size in the range MIN to MAX

   Where PATTERN, USER, ID, and SUBJECT are [84]regular expressions.
   
  Complex Searches
  
   Logical AND is performed by specifying more than one criterion. For
   example:
   
~t mutt ~f elkins

   would select messages which contain the word ``mutt'' in the list of
   recipients and that have the word ``elkins'' in the ``From'' header
   field.
   
   Mutt also recognizes the following operators to create more complex
   search patterns:
   
     * ! -- logical NOT operator
     * | -- logical OR operator
     * () -- logical grouping operator
       
   Here is an example illustrating a complex search pattern. This pattern
   will select all messages which do not contain ``mutt'' in the ``To''
   or ``Cc'' field and which are from ``elkins''.
   
!(~t mutt|~c mutt) ~f elkins

  Searching by Date
  
   Mutt supports two types of dates, absolute and relative.
   
   Absolute. Dates must be in DD/MM/YY format (month and year are
   optional, defaulting to the current month and year). An example of a
   valid range of dates is:
   
Limit to messages matching: ~d 20/1/95-31/10

   If you omit the minimum (first) date, and just specify ``-DD/MM/YY'',
   all messages before the given date will be selected. If you omit the
   maximum (second) date, and specify ``DD/MM/YY-'', all messages after
   the given date will be selected. If you specify a single date with no
   dash (``-''), only messages sent on the given date will be selected.
   
   Relative. This type of date is relative to the current date, and may
   be specified as:
     * >offset (messages older than offset units)
     * <offset (messages newer than offset units)
     * =offset (messages exactly offset units old)
       
   offset is specified as a positive number with one of the following
   units:
y       years
m       months
w       weeks
d       days

   Example: to select messages less than 1 month old, you would use
   
Limit to messages matching: ~d <1m

   Note: all dates used when searching are relative to the local time
   zone, so unless you change the setting of your [85]$index_format to
   include a %[...] format, these are not the dates shown in the main
   index.
   
4.2 Using Tags

   Sometimes it is desirable to perform an operation on a group of
   messages all at once rather than one at a time. An example might be to
   save messages to a mailing list to a separate folder, or to delete all
   messages with a given subject. To tag all messages matching a pattern,
   use the tag-pattern function, which is bound to ``control-T'' by
   default. Or you can select individual messages by hand using the
   ``tag-message'' function, which is bound to ``t'' by default. See
   [86]searching for Mutt's searching syntax.
   
   Once you have tagged the desired messages, you can use the
   ``tag-prefix'' operator, which is the ``;'' (semicolon) key by
   default. When the ``tag-prefix'' operator is used, the next operation
   will be applied to all tagged messages if that operation can be used
   in that manner. If the [87]$auto_tag variable is set, the next
   operation applies to the tagged messages automatically, without
   requiring the ``tag-prefix''.
   
4.3 Using Hooks

   A hook is a concept borrowed from the EMACS editor which allows you to
   execute arbitrary commands before performing some operation. For
   example, you may wish to tailor your configuration based upon which
   mailbox you are reading, or to whom you are sending mail. In the Mutt
   world, a hook consists of a [88]regular expression along with a
   configuration option/command. See
     * [89]folder-hook
     * [90]send-hook
     * [91]save-hook
     * [92]mbox-hook
     * [93]fcc-hook
     * [94]fcc-save-hook
       
   for specific details on each type of hook available.
   
  Message Matching in Hooks
  
   Hooks that act upon messages (send-hook, save-hook, fcc-hook) are
   evaluated in a slightly different manner. For the other types of
   hooks, a [95]regular expression. But in dealing with messages a finer
   grain of control is needed for matching since for different purposes
   you want to match different criteria.
   
   Mutt allows the use of the [96]search pattern language for matching
   messages in hook commands. This works in exactly the same way as it
   would when limiting or searching the mailbox, except that you are
   restricted to those operators which match information from the
   envelope of the message (i.e. from, to, cc, date, subject, etc.).
   
   For example, if you wanted to set your return address based upon
   sending mail to a specific address, you could do something like:
   
send-hook '~t ^me@cs\.hmc\.edu$' 'my_hdr From: Mutt User <user@host>'

   which would execute the given command when sending mail to
   me@cs.hmc.edu.
   
   However, it is not required that you write the pattern to match using
   the full searching language. You can still specify a simple regular
   expression like the other hooks, in which case Mutt will translate
   your pattern into the full language, using the translation specified
   by the [97]$dfault_hook variable. The pattern is translated at the
   time the hook is declared, so the value of [98]$dfault_hook that is in
   effect at that time will be used.
   
4.4 External Address Queries

   Mutt supports connecting to external directory databases such as LDAP,
   ph/qi, bbdb, or NIS through a wrapper script which connects to mutt
   using a simple interface. Using the [99]$query_command variable, you
   specify the wrapper command to use. For example:
   
set query_command = "mutt_ldap_query.pl '%s'"

   The wrapper script should accept the query on the command-line. It
   should return a one line message, than each matching response on a
   single line, each line containing a tab separated address then name
   then some other optional information. On error, or if there are no
   matching addresses, return a non-zero exit code and a one line error
   message.
   
   An example multiple response output:
   
Searching database ... 20 entries ... 3 matching:
me@cs.hmc.edu   Michael Elkins  mutt dude
blong@fiction.net       Brandon Long    mutt and more
roessler@guug.de        Thomas Roessler mutt pgp

   There are two mechanisms for accessing the query function of mutt. One
   is to do a query from the index menu using the query function
   (default: Q). This will prompt for a query, then bring up the query
   menu which will list the matching responses. From the query menu, you
   can select addresses to create aliases, or to mail. You can tag
   multiple messages to mail, start a new query, or have a new query
   appended to the current responses.
   
   The other mechanism for accessing the query function is for address
   completion, similar to the alias completion. In any prompt for address
   entry, you can use the complete-query function (default: ^T) to run a
   query based on the current address you have typed. Like aliases, mutt
   will look for what you have typed back to the last space or comma. If
   there is a single response for that query, mutt will expand the
   address in place. If there are multiple responses, mutt will activate
   the query menu. At the query menu, you can select one or more
   addresses to be added to the prompt.
   
4.5 Mailbox Formats

   Mutt supports reading and writing of four different mailbox formats:
   mbox, MMDF, MH and Maildir. The mailbox type is autodetected, so there
   is no need to use a flag for different mailbox types. When creating
   new mailboxes, Mutt uses the default specified with the
   [100]$mbox_type variable.
   
   mbox. This is the most widely used mailbox format for UNIX. All
   messages are stored in a single file. Each message has a line of the
   form:
   
From me@cs.hmc.edu Fri, 11 Apr 1997 11:44:56 PST

   to denote the start of a new message (this is often referred to as the
   ``From_'' line).
   
   MMDF. This is a variant of the mbox format. Each message is surrounded
   by lines containing ``^A^A^A^A'' (four control-A's).
   
   MH. A radical departure from mbox and MMDF, a mailbox consists of a
   directory and each message is stored in a separate file. The filename
   indicates the message number (however, this is may not correspond to
   the message number Mutt displays). Deleted messages are renamed with a
   comma (,) prepended to the filename. Note: Mutt detects this type of
   mailbox by looking for either .mh_sequences or .xmhcache (needed to
   distinguish normal directories from MH mailboxes). Mutt does not
   update these files, yet.
   
   Maildir. The newest of the mailbox formats, used by the Qmail MTA (a
   replacement for sendmail). Similar to MH, except that it adds three
   subdirectories of the mailbox: tmp, new and cur. Filenames for the
   messages are chosen in such a way they are unique, even when two
   programs are writing the mailbox over NFS, which means that no file
   locking is needed.
   
4.6 Mailbox Shortcuts

   There are a number of built in shortcuts which refer to specific
   mailboxes. These shortcuts can be used anywhere you are prompted for a
   file or mailbox path.
   
     * ! -- refers to your [101]$spool (incoming) mailbox
     * > -- refers to your [102]$mbox file
     * < -- refers to your [103]$record file
     * - -- refers to the file you've last visited
     * ~ -- refers to your home directory
     * = or + -- refers to your [104]$folder directory
     * @alias -- refers to the [105]default save folder as determined by
       the address of the alias
       
4.7 Handling Mailing Lists

   Mutt has a few configuration options that make dealing with large
   amounts of mail easier. The first thing you must do is to let Mutt
   know what addresses you consider to be mailing lists (technically this
   does not have to be a mailing list, but that is what it is most often
   used for). This is accomplished through the use of the [106]lists
   command in your muttrc.
   
   Now that Mutt knows what your mailing lists are, it can do several
   things, the first of which is the ability to show the list name in the
   index menu display. This is useful to distinguish between personal and
   list mail in the same mailbox. In the [107]$index_format variable, the
   escape ``%L'' will return the string ``To <list>'' when ``list''
   appears in the ``To'' field, and ``Cc <list>'' when it appears in the
   ``Cc'' field (otherwise it returns the name of the author).
   
   Often times the ``To'' and ``Cc'' fields in mailing list messages tend
   to get quite large. Most people do not bother to remove the author of
   the message they are reply to from the list, resulting in two or more
   copies being sent to that person. The ``list-reply'' function, which
   by default is bound to ``L'' in the index menu and pager, helps reduce
   the clutter by only replying to the mailing list addresses instead of
   all recipients.
   
   The other method some mailing list admins use is to generate a
   ``Reply-To'' field which points back to the mailing list address
   rather than the author of the message. This can create problems when
   trying to reply directly to the author in private, since most mail
   clients will automatically reply to the address given in the
   ``Reply-To'' field. Mutt uses the [108]$reply_to variable to help
   decide which address to use. If set, you will be prompted as to
   whether or not you would like to use the address given in the
   ``Reply-To'' field, or reply directly to the address given in the
   ``From'' field. When unset, the ``Reply-To'' field will be used when
   present.
   
   Lastly, Mutt has the ability to [109]sort the mailbox into
   [110]threads. A thread is a group of messages which all relate to the
   same subject. This is usually organized into a tree-like structure
   where a message and all of its replies are represented graphically. If
   you've ever used a threaded news client, this is the same concept. It
   makes dealing with large volume mailing lists easier because you can
   easily delete uninteresting threads and quickly find topics of value.
   
4.8 Delivery Status Notification (DSN) Support

   RFC1894 defines a set of MIME content types for relaying information
   about the status of electronic mail messages. These can be thought of
   as ``return receipts.'' Berkeley sendmail 8.8.x currently has some
   command line options in which the mail client can make requests as to
   what type of status messages should be returned.
   
   To support this, there are two variables. [111]$dsn_notify is used to
   request receipts for different results (such as failed message,
   message delivered, etc.). [112]$dsn_return requests how much of your
   message should be returned with the receipt (headers or full message).
   Refer to the man page on sendmail for more details on DSN.
   
4.9 POP3 Support (OPTIONAL)

   If Mutt was compiled with POP3 support (by running the configure
   script with the --enable-pop flag), it has the ability to fetch your
   mail from a remote server for local browsing. When you invoke the
   fetch-mail function (default: G), Mutt attempts to connect to
   [113]pop_host and authenticate by logging in as [114]pop_user. After
   the connection is established, you will be prompted for your password
   on the remote system.
   
   Once you have been authenticated, Mutt will fetch all your new mail
   and place it in the local [115]spoolfile. After this point, Mutt runs
   exactly as if the mail had always been local.
   
   Note: The POP3 support is there only for convenience, and it's rather
   limited. If you need more functionality you should consider using a
   specialized program, such as [116]fetchmail
   
4.10 IMAP Support (OPTIONAL)

   If Mutt was compiled with IMAP support (by running the configure
   script with the --enable-imap flag), it has the ability to work with
   folders located on a remote imap server.
   
   You can access the remote inbox by selecting the folder
   {imapserver}inbox, where imapserver is the name of the IMAP server and
   inbox is the special name for your spool mailbox on the IMAP server.
   If you want to access another mail folder at the IMAP server, you
   should use {imapserver}path/to/folder where path/to/folder is the path
   of the folder you want to access relative to your home directory.
   
   Note: The IMAP support is in a very early state and quite unstable at
   the moment. If you need a more stable way to access your IMAP folder,
   consider using a specialized program, such as [117]fetchmail.
   
5. Mutt's MIME Support

   Quite a bit of effort has been made to make Mutt the premier text-mode
   MIME MUA. Every effort has been made to provide the functionality that
   the discerning MIME user requires, and the conformance to the
   standards wherever possible. When configuring Mutt for MIME, there are
   two extra types of configuration files which Mutt uses. One is the
   mime.types file, which contains the mapping of file extensions to IANA
   MIME types. The other is the mailcap file, which specifies the
   external commands to use for handling specific MIME types.
   
5.1 Using MIME in Mutt

   There are three areas/menus in Mutt which deal with MIME, they are the
   pager (while viewing a message), the attachment menu and the compose
   menu.
   
  Viewing MIME messages in the pager
  
   When you select a message from the index and view it in the pager,
   Mutt decodes the message to a text representation. Mutt internally
   supports a number of MIME types, including text/plain, text/enriched,
   message/rfc822, and message/news. In addition, the export controlled
   version of Mutt recognizes a variety of PGP MIME types, including
   PGP/MIME and application/pgp.
   
   Mutt will denote attachments with a couple lines describing them.
   These lines are of the form:
   
[-- Attachment #1: Description --]
[-- Type: text/plain, Encoding: 7bit, Size: 10000 --]

   Where the Description is the description or filename given for the
   attachment, and the Encoding is one of
   7bit/8bit/quoted-printable/base64/binary.
   
   If Mutt cannot deal with a MIME type, it will display a message like:
   
[-- image/gif is unsupported (use 'v' to view this part) --]

  The Attachment Menu
  
   The default binding for view-attachments is `v', which displays the
   attachment menu for a message. The attachment menu displays a list of
   the attachments in a message. From the attachment menu, you can save,
   print, pipe, delete, and view attachments. You can apply these
   operations to a group of attachments at once, by tagging the
   attachments and by using the ``tag-prefix'' operator. You can also
   reply to the current message from this menu, and only the current
   attachment (or the attachments tagged) will be quoted in your reply.
   You can view attachments as text, or view them using the mailcap
   viewer definition. See the help on the attachment menu for more
   information.
   
  The Compose Menu
  
   The compose menu is the menu you see before you send a message. It
   allows you to edit the recipient list, the subject, and other aspects
   of your message. It also contains a list of the attachments of your
   message, including the main body. From this menu, you can print, copy,
   filter, pipe, edit, compose, review, and rename an attachment or a
   list of tagged attachments. You can also modifying the attachment
   information, notably the type, encoding and description.
   
   Attachments appear as follows:
-   1 [text/plain, 7bit, 1K]             /tmp/mutt-euler-8082-0 <no description
>
    2 [applica/x-gunzip, base64, 422K]   ~/src/mutt-0.85.tar.gz <no description
>

   The '-' denotes that Mutt will delete the file after sending the
   message. It can be toggled with the toggle-unlink command (default:
   U). The next field is the MIME content-type, and can be changed with
   the edit-type command (default: ^T). The next field is the encoding
   for the attachment, which allows a binary message to be encoded for
   transmission on 7bit links. It can be changed with the edit-encoding
   command (default: ^E). The next field is the size of the attachment,
   rounded to kilobytes or megabytes. The next field is the filename,
   which can be changed with the rename-file command (default: R). The
   final field is the description of the attachment, and can be changed
   with the edit-description command (default: d).
   
5.2 MIME Type configuration with mime.types

   When you add an attachment to your mail message, Mutt searches your
   personal mime.types file at ${HOME}/.mime.types, and then the system
   mime.types file at SHAREDIR/mime.types. SHAREDIR is defined at
   compilation time, and can be determined by typing mutt -v from the
   command line.
   
   The mime.types file consist of lines containing a MIME type and a
   space separated list of extensions. For example:
   
application/postscript          ps eps
application/pgp                 pgp
audio/x-aiff                    aif aifc aiff

   A sample mime.types file comes with the Mutt distribution, and should
   contain most of the MIME types you are likely to use.
   
   If Mutt can not determine the mime type by the extension of the file
   you attach, it will look at the file. If the file is free of binary
   information, Mutt will assume that the file is plain text, and mark it
   as text/plain. If the file contains binary information, then Mutt will
   mark it as application/octect-stream. You can change the MIME type
   that Mutt assigns to an attachment by using the edit-type command from
   the compose menu (default: ^T). When typing in the MIME type, Mutt
   requires that major type be one of the 5 types: application, text,
   image, video, or audio. If you attempt to use a different major type,
   Mutt will abort the change.
   
5.3 MIME Viewer configuration with mailcap

   Mutt supports RFC 1524 MIME Configuration, in particular the Unix
   specific format specified in Appendix A of RFC 1524. This file format
   is commonly referred to as the mailcap format. Many MIME compliant
   programs utilize the mailcap format, allowing you to specify handling
   for all MIME types in one place for all programs. Programs known to
   use this format include Netscape, XMosaic, lynx and metamail.
   
   In order to handle various MIME types that Mutt can not handle
   internally, Mutt parses a series of external configuration files to
   find an external handler. The default search string for these files is
   a colon delimited list set to
   
${HOME}/.mailcap:SHAREDIR/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/
mailcap

   where $HOME is your home directory and SHAREDIR is the shared
   directory defined at compile time (visible from mutt -v).
   
   In particular, the metamail distribution will install a mailcap file,
   usually as /etc/mailcap, which contains some baseline entries.
   
  The Basics of the mailcap file
  
   A mailcap file consists of a series of lines which are comments,
   blank, or definitions.
   
   A comment line consists of a # character followed by anything you
   want.
   
   A blank line is blank.
   
   A definition line consists of a content type, a view command, and any
   number of optional fields. Each field of a definition line is divided
   by a semicolon ';' character.
   
   The content type is specified in the MIME standard type/subtype
   method. For example, text/plain, text/html, image/gif, etc. In
   addition, the mailcap format includes two formats for wildcards, one
   using the special '*' subtype, the other is the implicit wild, where
   you only include the major type. For example, image/*, or video, will
   match all image types and video types, respectively.
   
   The view command is a Unix command for viewing the type specified.
   There are two different types of commands supported. The default is to
   send the body of the MIME message to the command on stdin. You can
   change this behaviour by using %s as a parameter to your view command.
   This will cause Mutt to save the body of the MIME message to a
   temporary file, and then call the view command with the %s replaced by
   the name of the temporary file. In both cases, Mutt will turn over the
   terminal to the view program until the program quits, at which time
   Mutt will remove the temporary file if it exists.
   
   So, in the simplest form, you can send a text/plain message to the
   external pager more on stdin:
   
text/plain; more

   Or, you could send the message as a file:
   
text/plain; more %s

   Perhaps you would like to use lynx to interactively view a text/html
   message:
   
text/html; lynx "%s"

   In this case, lynx does not support viewing a file from stdin, so you
   must use the %s syntax. Note: Some older versions of lynx contain a
   bug where they will check the mailcap file for a viewer for text/html.
   They will find the line which calls lynx, and run it. This causes lynx
   to continuously spawn itself to view the object.
   
   On the other hand, maybe you don't want to use lynx interactively, you
   just want to have it convert the text/html to text/plain, then you can
   use:
   
text/html; lynx -dump "%s" | more

   Perhaps you wish to use lynx to view text/html files, and a pager on
   all other text formats, then you would use the following:
   
text/html; lynx "%s"
text/*; more

   This is the simplest form of a mailcap file.
   
  Advanced mailcap Usage
  
  Optional Fields
  
   In addition to the required content-type and view command fields, you
   can add semi-colon ';' separated fields to set flags and other
   options. Mutt recognizes the following optional fields:
   
   copiousoutput
          This flag tells Mutt that the command passes possibly large
          amounts of text on stdout. This causes Mutt to invoke a pager
          (either the internal pager or the external pager defined by the
          pager variable) on the output of the view command. Without this
          flag, Mutt assumes that the command is interactive. One could
          use this to replace the pipe to more in the lynx -dump example
          in the Basic section:
          
text/html; lynx -dump %s ; copiousoutput

          This will cause lynx to format the text/html output as
          text/plain and Mutt will use your standard pager to display the
          results.
          
   needsterminal
          Mutt uses this flag when viewing attachments with
          [118]autoview, in order to decide whether it should honor the
          setting of the [119]$wait_key variable or not. When an
          attachment is viewed using an interactive program, and the
          corresponding mailcap entry has a needsterminal flag, Mutt will
          use [120]$wait_key and the exit status of the program to decide
          if it will ask you to press a key after the external program
          has exited. In all other situations it will not prompt you for
          a key.
          
   compose=<command>
          This flag specifies the command to use to create a new
          attachment of a specific MIME type. Mutt supports this from the
          compose menu.
          
   composetyped=<command>
          This flag specifies the command to use to create a new
          attachment of a specific MIME type. This command differs from
          the compose command in that mutt will expect standard MIME
          headers on the data. This can be used to specify parameters,
          filename, description, etc. for a new attachment. Mutt supports
          this from the compose menu.
          
   print=<command>
          This flag specifies the command to use to print a specific MIME
          type. Mutt supports this from the attachment and compose menus.
          
   edit=<command>
          This flag specifies the command to use to edit a specific MIME
          type. Mutt supports this from the compose menu, and also uses
          it to compose new attachments. Mutt will default to the defined
          editor for text attachments.
          
   nametemplate=<template>
          This field specifies the format for the file denoted by %s in
          the command fields. Certain programs will require a certain
          file extension, for instance, to correctly view a file. For
          instance, lynx will only interpret a file as text/html if the
          file ends in .html. So, you would specify lynx as a text/html
          viewer with a line in the mailcap file like:
          
text/html; lynx %s; nametemplate=%s.html

   test=<command>
          This field specifies a command to run to test whether this
          mailcap entry should be used. The command is defined with the
          command expansion rules defined in the next section. If the
          command returns 0, then the test passed, and Mutt uses this
          entry. If the command returns non-zero, then the test failed,
          and Mutt continues searching for the right entry. Note: the
          content-type must match before Mutt performs the test. For
          example:
          
text/html; netscape -remote 'openURL(%s)' ; test=RunningX
text/html; lynx %s

          In this example, Mutt will run the program RunningX which will
          return 0 if the X Window manager is running, and non-zero if it
          isn't. If RunningX returns 0, then Mutt will call netscape to
          display the text/html object. If RunningX doesn't return 0,
          then Mutt will go on to the next entry and use lynx to display
          the text/html object.
          
  Search Order
  
   When searching for an entry in the mailcap file, Mutt will search for
   the most useful entry for its purpose. For instance, if you are
   attempting to print an image/gif, and you have the following entries
   in your mailcap file, Mutt will search for an entry with the print
   command:
   
image/*;        xv %s
image/gif;      ; print= anytopnm %s | pnmtops | lpr; \
                nametemplate=%s.gif

   Mutt will skip the image/* entry and use the image/gif entry with the
   print command.
   
   In addition, you can use this with [121]Autoview to denote two
   commands for viewing an attachment, one to be viewed automatically,
   the other to be viewed interactively from the attachment menu. In
   addition, you can then use the test feature to determine which viewer
   to use interactively depending on your environment.
   
text/html;      netscape -remote 'openURL(%s)' ; test=RunningX
text/html;      lynx %s; nametemplate=%s.html
text/html;      lynx -dump %s; nametemplate=%s.html; copiousoutput

   For [122]Autoview, Mutt will choose the third entry because of the
   copiousoutput tag. For interactive viewing, Mutt will run the program
   RunningX to determine if it should use the first entry. If the program
   returns non-zero, Mutt will use the second entry for interactive
   viewing.
   
  Command Expansion
  
   The various commands defined in the mailcap files are passed to the
   /bin/sh shell using the system() function. Before the command is
   passed to /bin/sh -c, it is parsed to expand various special
   parameters with information from Mutt. The keywords Mutt expands are:
   
   %s
          As seen in the basic mailcap section, this variable is expanded
          to a filename specified by the calling program. This file
          contains the body of the message to view/print/edit or where
          the composing program should place the results of composition.
          In addition, the use of this keyword causes Mutt to not pass
          the body of the message to the view/print/edit program on
          stdin.
          
   %t
          Mutt will expand %t to the text representation of the content
          type of the message in the same form as the first parameter of
          the mailcap definition line, ie text/html or image/gif.
          
   %{<parameter>}
          Mutt will expand this to the value of the specified parameter
          from the Content-Type: line of the mail message. For instance,
          if Your mail message contains:
          
Content-Type: text/plain; charset=iso-8859-1

          then Mutt will expand %{charset} to iso-8859-1. The default
          metamail mailcap file uses this feature to test the charset to
          spawn an xterm using the right charset to view the message.
          
   \%
          This will be replaced by a %
          
   Mutt does not currently support the %F and %n keywords specified in
   RFC 1524. The main purpose of these parameters is for multipart
   messages, which is handled internally by Mutt.
   
  Example mailcap files
  
   This mailcap file is fairly simple and standard:
     _________________________________________________________________
   
# I'm always running X :)
video/*;        xanim %s > /dev/null
image/*;        xv %s > /dev/null

# I'm always running netscape (if my computer had more memory, maybe)
text/html;      netscape -remote 'openURL(%s)'
     _________________________________________________________________
   
   This mailcap file shows quite a number of examples:
     _________________________________________________________________
   
# Use xanim to view all videos   Xanim produces a header on startup,
# send that to /dev/null so I don't see it
video/*;        xanim %s > /dev/null

# Send html to a running netscape by remote
text/html;      netscape -remote 'openURL(%s)'; test=RunningNetscape

# If I'm not running netscape but I am running X, start netscape on the
# object
text/html;      netscape %s; test=RunningX

# Else use lynx to view it as text
text/html;      lynx %s

# This version would convert the text/html to text/plain
text/html;      lynx -dump %s; copiousoutput

# enriched.sh converts text/enriched to text/html and then uses
# lynx -dump to convert it to text/plain
text/enriched;  enriched.sh ; copiousoutput

# I use enscript to print text in two columns to a page
text/*;         more %s; print=enscript -2Gr %s

# Netscape adds a flag to tell itself to view jpegs internally
image/jpeg;xv %s; x-mozilla-flags=internal

# Use xv to view images if I'm running X
# In addition, this uses the \ to extend the line and set my editor
# for images
image/*;xv %s; test=RunningX; \
        edit=xpaint %s

# Convert images to text using the netpbm tools
image/*;  (anytopnm %s | pnmscale -xysize 80 46 | ppmtopgm | pgmtopbm |
pbmtoascii -1x2 ) 2>&1 ; copiousoutput

# Send excel spreadsheets to my NT box
application/ms-excel; open.pl %s
     _________________________________________________________________
   
5.4 MIME Autoview

   In addition to explicitly telling Mutt to view an attachment with the
   MIME viewer defined in the mailcap file, Mutt has support for
   automatically viewing MIME attachments while in the pager.
   
   To work, you must define a viewer in the mailcap file which uses the
   copiousoutput option to denote that it is non-interactive. Usually,
   you also use the entry to convert the attachment to a text
   representation which you can view in the pager.
   
   You then use the auto_view muttrc command to list the content-types
   that you wish to view automatically.
   
   For instance, if you set auto_view to:
   
auto_view text/html text/enriched application/x-gunzip application/postscript i
mage/gif application/x-tar-gz

   Mutt could use the following mailcap entries to automatically view
   attachments of these types.
   
text/html;      lynx -dump %s; copiousoutput; nametemplate=%s.html
text/enriched;  enriched.sh  ; copiousoutput
image/*;        anytopnm %s | pnmscale -xsize 80 -ysize 50 | ppmtopgm | pgmtopb
m | pbmtoascii ; copiousoutput
application/x-gunzip;   gzcat; copiousoutput
application/x-tar-gz; gunzip -c %s | tar -tf - ; copiousoutput
application/postscript; ps2ascii %s; copiousoutput

5.5 MIME Multipart/Alternative

   Mutt has some heuristics for determining which attachment of a
   multipart/alternative type to display. First, mutt will check the
   alternative_order list to determine if one of the available types is
   preferred. The alternative_order list consists of a number of
   mimetypes in order, including support for implicit and explicit
   wildcards, for example:
   
alternative_order text/enriched text/plain text application/postscript image/*

   Next, mutt will check if any of the types have a defined
   [123]auto_view, and use that. Failing that, Mutt will look for any
   text type. As a last attempt, mutt will look for any type it knows how
   to handle.
   
6. Reference

6.1 Command line options

   Running mutt with no arguments will make Mutt attempt to read your
   spool mailbox. However, it is possible to read other mailboxes and to
   send messages from the command line as well.
   
-a      attach a file to a message
-c      specify a carbon-copy (Cc) address
-e      specify a config command to be run after initilization files are read
-F      specify an alternate file to read initialization commands
-f      specify a mailbox to load
-h      print help on command line options
-H      specify a draft file from which to read a header and body
-i      specify a file to include in a message composition
-n      do not read the system Muttrc
-m      specify a default mailbox type
-p      recall a postponed message
-R      open mailbox in read-only mode
-s      specify a subject (enclose in quotes if it contains spaces)
-v      show version number and compile-time definitions
-x      simulate the mailx(1) compose mode
-y      show a menu containing the files specified by the mailboxes command
-z      exit immediately if there are no messages in the mailbox
-Z      open the first folder with new message,exit immediately if none

   To read messages in a mailbox
   
   mutt [ -nz ] [ -F muttrc ] [ -m type ] [ -f mailbox ]
   
   To compose a new message
   
   mutt [ -n ] [ -F muttrc ] [ -a file ] [ -c address ] [ -i filename ] [
   -s subject ] address [ address ... ]
   
   Mutt also supports a ``batch'' mode to send prepared messages. Simply
   redirect input from the file you wish to send. For example,
   
   mutt -s "data set for run #2" professor@bigschool.edu < ~/run2.dat
   
   This command will send a message to ``professor@bigschool.edu'' with a
   subject of ``data set for run #2''. In the body of the message will be
   the contents of the file ``~/run2.dat''.


	[ many sections removed, sorry ]   
