@c This is part of the GNU Mailutils manual.
@c Copyright (C) 1999-2012, 2014-2017 Free Software Foundation, Inc.
@c See file mailutils.texi for copying conditions.
@comment *******************************************************************

GNU Mailutils provides a broad set of utilities for handling
electronic mail.  These utilities address the needs of both system
administrators and users.

All utilities are built around a single core subsystem and share many
common aspects.  All of them are able to work with almost any existing
mailbox formats.  They use a common configuration file syntax, and
their configuration files are located in a single subdirectory.

In this chapter we will discuss each utility, and give some advices on
how to use them in various real life situations.

First of all we will describe command line and configuration file
syntax.

@menu
* command line::      Command Line Syntax.  
* configuration::     Common Configuration File.
* debugging::

* frm and from::      List Headers from a Mailbox.
* mail::              Send and Receive Mail.
* messages::          Count the Number of Messages in a Mailbox.
* movemail::          Moves Mail from the User Maildrop to the Local File.
* readmsg::           Extract Messages from a Folder.

* sieve::             Mail Filtering Utility.
* guimb::             Mailbox Scanning and Processing Language.

* maidag::            General-purpose Mail Delivery Agent.

* mimeview::          Universal File Viewer.

* pop3d::             POP3 Daemon.
* imap4d::            IMAP4 Daemon.
* comsatd::           Comsat Daemon.

* mh::                The MH Message Handling System.

* mailutils::         The Mailutils Multi-Purpose Tool.
@end menu

@node command line
@section Command Line

@menu
* Option Basics::       Basic Notions About Command Line Options.
* Common Options::      Options That are Common for All Utilities.
@end menu

@node Option Basics
@subsection Basic Notions About Command Line Options

  Many command line options have two forms, called short and long
forms.  Both forms are absolutely identical in function; they are
interchangeable. 

  The @dfn{short} form is a traditional form for UNIX utilities.
In this form, the option consists of a single dash, followed by a
single letter, e.g.  @option{-c}.

  Short options which require arguments take their arguments
immediately following the option letter, optionally separated by white
space.  For example, you might write @option{-f name}, or @option{-fname}.
Here, @option{-f} is the option, and @option{name} is its argument.

  Short options which allow optional arguments take their arguments
immediately following the option letter, @emph{without any intervening
white space characters}.  This is important, so that the command line
parser might discern that the text following option is its argument,
not the next command line parameter.  For example, if option @option{-d}
took an optional argument, then @option{-dname} would mean the option
with its argument (@option{name} in this case), and @option{-d name} would
mean the @option{-d} option without any argument, followed by command
line argument @option{name}.

  Short options' letters may be clumped together, but you are not
required to do this.  When short options are clumped as a set, use one
(single) dash for them all, e.g.  @option{-cvl} is equivalent to @option{-c
-v -l}.  However, only options that do not take arguments may be
clustered this way.  If an option takes an argument, it can only be
the last option in such a cluster, otherwise it would be impossible to
specify the argument for it.  Anyway, it is much more readable to
specify such options separated.

  The @dfn{long} option names are probably easier to memorize than
their short counterparts.  They consist of two dashes, followed by a
multi-letter option name, which is usually selected to be a mnemonics
for the operation it requests.  For example, @option{--verbose} is a
long option that increases the verbosity of a utility.  In addition,
long option names can abbreviated, provided that such an abbreviation
is unique among the options understood by a given utility.  For
example, if a utility takes options @option{--foreground} and
@option{--forward}, then the shortest possible abbreviations for these
options are @option{--fore} and @option{--forw}, correspondingly.  If
you try to use @option{--for}, the utility will abort and inform you
that the abbreviation you use is ambiguous, so it is not clear which
of the options you intended to use.

  Long options which require arguments take those arguments following
the option name.  There are two ways of specifying a mandatory
argument.  It can be separated from the option name either by an equal
sign, or by any amount of white space characters.  For example, if the
@option{--file} option requires an argument, and you wish to supply
@file{name} as its argument, then you can do so using any of the
following notations: @option{--file=name} or @option{--file name}.

  In contrast, optional arguments must always be introduced using an
equal sign.

@node Common Options
@subsection Options That are Common for All Utilities.

  All GNU Mailutils programs understand a common subset of options.

@table @option
@xopindex{help, described}
@item --help
@itemx -?
  Display a short summary of the command line options understood by
this utilities, along with a terse description of each.

  The output of this option consists of three major parts.  First, a
usage synopsis is displayed.  For example:

@example
@group
Usage: sieve [OPTION...] SCRIPT
GNU sieve -- a mail filtering tool
@end group
@end example

  The first line tells that the @command{sieve} utility takes any
number of options (brackets indicate optional part) and a single
mandatory argument (@samp{SCRIPT}).  The second lines summarizes the
purpose of the utility.

  Following this header is an option summary.  It consists of two
columns:

@verbatim
  -c, --compile-only         Compile script and exit
  -d, --debug[=FLAGS]        Debug flags
  -e, --email=ADDRESS        Override user email address
@end verbatim


The leftmost column contains a comma-separated list of option
names.  Short options are listed first.  The options are ordered
alphabetically.  Arguments, if any, are specified after the last
option name in the list, so that, e.g. the option @samp{-e} in the
example above requires an argument: @samp{-e ADDRESS}.  Optional
arguments are enclosed in square brackets, as in @option{--debug}
option in the example above.

The rightmost column contains a short description of the option
purpose. 

  The last part of @option{--help} output contains some additional
notices and lists the email address for reporting bugs.

@xopindex{usage, described}
@item --usage
Display a short summary of options.  In the contrast to the
@option{--help} option, only option names and arguments
are printed, without any textual description.  For example:

@example
@group
Usage: sieve [-cv?V] [--compile-only] [--debug[=FLAGS]]
             [--email=ADDRESS] SCRIPT
@end group
@end example
@end table

  The exact formatting of the output produced by these two options is
configurable.  @xref{Usage Vars}, for a detailed descriptions of it.

@table @option
@xopindex{version, described}
@item --version 
@itemx -V
Print program version and exit.

@xopindex{show-config-options, described}
@item --show-config-options
Show configuration options used when compiling the package.  You can
use this option to verify if support for a particular mailbox format
or other functionality is compiled in the binary.  The output of this
option is intended to be both machine-readable and understandable by
humans.
@end table

  The following command line options affect parsing of configuration
files.  Here we provide a short summary, the next section will
describe them in detail.

@table @option
@xopindex{config-file, introduced}
@item --config-file=@var{file}
Load this configuration file, instead of the default.

@xopindex{config-help, introduced}
@item --config-help
Show configuration file summary.

@xopindex{config-lint, introduced}
@item --config-lint
Check configuration file syntax and exit

@xopindex{config-verbose, introduced}
@item --config-verbose
Verbosely log parsing of the configuration files.

@xopindex{no-site-config, introduced}
@item --no-site-config
Do not load site-wide configuration file.

@xopindex{no-user-config, introduced}
@item --no-user-config
Do not load user configuration file.

@xopindex{no-config, introduced}
@item --no-config
Don't load site-wide and user configuration files.

@xopindex{set, introduced}
@item --set=@var{path}=@var{value}
Set configuration variable.  @xref{the --set option}.
@end table

@node configuration
@section Mailutils Configuration File
@cindex Mailutils configuration file
@cindex mailutils.conf

  Configuration files are the principal means of configuring any GNU
Mailutils component.  When started, each utility tries to load its
configuration from the following locations, in that order:

@enumerate 1
@item Main site-wide configuration file.

It is named @file{@var{sysconfdir}/mailutils.conf}, where
@var{sysconfdir} stands for the system configuration directory set
when compiling the package. You can obtain the value of @var{sysconfdir} by running

@example
$ mailutils info sysconfdir
@end example

@noindent
or

@example
$ @var{prog} --show-config-options | grep SYSCONFDIR
@end example

@noindent
where @var{prog} stands for any GNU Mailutils utility.

@xopindex{no-site-config, described}
The site-wide configuration file is not read if any of
@option{--no-site-config} or @option{--no-config} command line options
was given.

Older versions of GNU Mailutils read configuration from file
@file{mailutils.rc}.  To facilitate transition, mailutils will look
for that file as well.  If both the default site-wide configuration
file and legacy configuration file are present you will get the
following warning:

@example
legacy configuration file /etc/mailutils.rc ignored
@end example

Otherwise, if @file{mailutils.conf} does not exist and
@file{mailutils.rc} is present, it will be used instead and the
following warning will be issued:

@example
 using legacy configuration file /etc/mailutils.rc:
 please rename it to /etc/mailutils.conf
@end example

@item Per-user configuration file.

Client utilities, such as @command{frm} or @command{sieve}, look in
the user home directory for a file named @samp{.@var{prog}}, where
@var{prog} is the name of the utility.  If present, this file will be
loaded after loading the site-wide configuration file.  For example,
the per-user configuration file for @command{sieve} utility is named
@file{.sieve}.

@xopindex{no-user-config, described}
Loading of per-user configuration file is disabled by
@option{--no-user-config} and @option{--no-config} options.
@end enumerate

Server programs, such as @command{imap4d} don't use per-user
configuration files.

The @option{--no-config} option provides a shortcut for disabling
loading of the default configuration files.  For servers, its effect
is the same as of @option{--no-site-config}.  For client utilities, it
is equivalent to @option{--no-site-config --no-user-config} used
together.

@xopindex{config-file, described}
The @option{--config-file} command line option instructs the program
to read configuration from the file supplied as its argument.  In that
case, default configuration files are not used at all.

@xopindex{config-verbose, described}
Neither site-wide nor user configuration files are required to
exist.  If any or both of them are absent, GNU Mailutils won't
complain -- the utility will silently fall back to its default
settings.

To make configuration processing more verbose, use the
@option{--config-verbose} command line option.  Here is an example of
what you might get using this option:

@example
imap4d: parsing file `/etc/mailutils.conf'
imap4d: finished parsing file `/etc/mailutils.conf'
@end example

Specifying this option more than once adds more verbosity to this
output.  If this option is given two times, GNU Mailutils will print
each configuration file statement it parsed, along with the exact
location where it occurred (the exact meaning of each statement will
be described later in this chapter):

@example
imap4d: parsing file `/etc/mailutils.conf'
@hashchar{} 1 "/etc/mailutils.conf"
mailbox @{
@hashchar{} 2 "/etc/mailutils.conf"
  mailbox-pattern maildir:/var/spool/mail;type=index;param=2;user=$@{user@};
@hashchar{} 3 "/etc/mailutils.conf"
  mailbox-type maildir;
@};
@hashchar{} 6 "/etc/mailutils.conf"
include /etc/mailutils.d;
imap4d: parsing file `/etc/mailutils.d/imap4d'
...
@end example

@xopindex{config-lint, described}
  To test configuration file without actually running the utility,
use the @option{--config-lint} command line option.  With this option,
any Mailutils utility exits after finishing parsing of the
configuration files.  Any errors occurred during parsing are displayed
on the standard error output.  This option can be combined with
@option{--config-verbose} to obtain more detailed output.

@xopindex{config-help, described}
  The @option{--config-help} command line option produces on the
standard output the summary of all configuration statements understood
by the utility, with detailed comments and in the form suitable for
configuration file.  For example, the simplest way to write a
configuration file for, say, @command{imap4d} is to run

@example
$ imap4d --config-help > imap4d.conf
@end example

@noindent
and to edit the @file{imap4d.conf} file with your editor of choice.

The order in which configuration files are loaded defines the
precedence of their settings.  Thus, for client utilities, settings
from the per-user configuration file override those from the site-wide
configuration.

@xopindex{set, described}
  It is also possible to set or override arbitrary configuration
variables in the command line.  It can be done via the @option{--set}
option.  Its argument is a @dfn{pathname} of the variable to be set,
followed by an equals sign and a value.  For example, to define the
variable @samp{syslog} in section @samp{logging} to @samp{no}, do the
following: 

@example
$ imap4d --set .logging.syslog=no
@end example

Configuration pathnames are discussed in detail in @ref{Paths}.  For a
detailed description of this option, @ref{the --set option}.

The @option{--set} options are processed after loading all
configuration files.

@menu
* conf-syntax::         Configuration File Syntax
* Variables::           Variable Expansion
* include::             Include Statement
* program statement::
* logging statement::
* debug statement::
* mailbox statement::
* locking statement::
* mailer statement::
* acl statement::
* tcp-wrappers statement::
* Server Settings::
* auth statement::
* pam statement::
* virtdomain statement::
* radius statement::
* sql statement::
* ldap statement::
* tls statement::
* gsasl statement::
@end menu

@node conf-syntax
@subsection Configuration File Syntax
  The configuration file consists of statements and comments.

  There are three classes of lexical tokens: keywords, values, and
separators.  Blanks, tabs, newlines and comments, collectively called
@dfn{white space} are ignored except as they serve to separate
tokens.  Some white space is required to separate otherwise adjacent 
keywords and values.

@menu
* Comments::
* Statements::
* Paths::
@end menu

@node Comments
@subsubsection Comments
@cindex Comments in a configuration file
@cindex single-line comments
  @dfn{Comments} may appear anywhere where white space may appear in the
configuration file.  There are two kinds of comments:
single-line and multi-line comments.  @dfn{Single-line} comments start
with @samp{#} or @samp{//} and continue to the end of the line:

@example
# This is a comment
// This too is a comment
@end example

@cindex multi-line comments
  @dfn{Multi-line} or @dfn{C-style} comments start with the two
characters @samp{/*} (slash, star) and continue until the first
occurrence of @samp{*/} (star, slash).

  Multi-line comments cannot be nested.  However, single-line comments
may well appear within multi-line ones.

@node Statements
@subsubsection Statements
@cindex statements, configuration file
@cindex configuration file statements
@cindex statement, simple
@cindex simple statements
  A @dfn{simple statement} consists of a keyword and value
separated by any amount of whitespace.  Simple statement is terminated
with a semicolon (@samp{;}).

  The following is a simple statement:

@example
standalone yes;
pidfile /var/run/pop3d.pid;
@end example

  A @dfn{keyword} begins with a letter and may contain letters,
decimal digits, underscores (@samp{_}) and dashes (@samp{-}).
Examples of keywords are: @samp{expression}, @samp{output-file}.

  A @dfn{value} can be one of the following:

@table @asis
@item number
  A number is a sequence of decimal digits.

@anchor{boolean value}  
@item boolean
@cindex boolean value
  A boolean value is one of the following: @samp{yes}, @samp{true},
@samp{t} or @samp{1}, meaning @dfn{true}, and @samp{no},
@samp{false}, @samp{nil}, @samp{0} meaning @dfn{false}.
  
@item unquoted string
@cindex string, unquoted
  An unquoted string may contain letters, digits, and any of the
following characters: @samp{_}, @samp{-}, @samp{.}, @samp{/},
@samp{@@}, @samp{*}, @samp{:}.

@item quoted string
@cindex quoted string
@cindex string, quoted
@cindex escape sequence
  A quoted string is any sequence of characters enclosed in
double-quotes (@samp{"}).  A backslash appearing within a quoted
string introduces an @dfn{escape sequence}, which is replaced
with a single character according to the following rules:

@float Table, backslash-interpretation
@caption{Backslash escapes}
@multitable @columnfractions 0.30 .5
@item Sequence @tab Replaced with
@item \a @tab Audible bell character (@acronym{ASCII} 7)
@item \b @tab Backspace character (@acronym{ASCII} 8)
@item \f @tab Form-feed character (@acronym{ASCII} 12)
@item \n @tab Newline character (@acronym{ASCII} 10)
@item \r @tab Carriage return character (@acronym{ASCII} 13)
@item \t @tab Horizontal tabulation character (@acronym{ASCII} 9)
@item \v @tab Vertical tabulation character (@acronym{ASCII} 11)
@item \\ @tab A single backslash (@samp{\})
@item \" @tab A double-quote.
@end multitable
@end float

  In addition, the sequence @samp{\@var{newline}} is removed from
the string.  This allows to split long strings over several
physical lines, e.g.:

@example
@group
"a long string may be\
 split over several lines"
@end group
@end example

  If the character following a backslash is not one of those specified
above, the backslash is ignored and a warning is issued.

  Two or more adjacent quoted strings are concatenated, which gives
another way to split long strings over several lines to improve
readability.  The following fragment produces the same result as the
example above:

@example
@group
"a long string may be"
" split over several lines"
@end group
@end example

@anchor{here-document}
@item Here-document
@cindex here-document
  A @dfn{here-document} is a special construct that allows to introduce
strings of text containing embedded newlines.  

  The @code{<<@var{word}} construct instructs the parser to read all
the following lines up to the line containing only @var{word}, with
possible trailing blanks.  Any lines thus read are concatenated
together into a single string.  For example:

@example
@group
<<EOT
A multiline
string
EOT
@end group
@end example

  The body of a here-document is interpreted the same way as a
double-quoted string, unless @var{word} is preceded by a backslash
(e.g.  @samp{<<\EOT}) or enclosed in double-quotes, in which case
the text is read as is, without interpretation of escape sequences.

  If @var{word} is prefixed with @code{-} (a dash), then all leading
tab characters are stripped from input lines and the line containing
@var{word}.  Furthermore, if @code{-} is followed by a single space,
all leading whitespace is stripped from them.  This allows to indent
here-documents in a natural fashion.  For example:

@example
@group
<<- TEXT
    The leading whitespace will be
    ignored when reading these lines.
TEXT
@end group
@end example

  It is important that the terminating delimiter be the only token on
its line.  The only exception to this rule is allowed if a
here-document appears as the last element of a statement.  In this
case a semicolon can be placed on the same line with its terminating 
delimiter, as in: 

@example
help-text <<-EOT
        A sample help text.
EOT;
@end example

@anchor{list values}
@item list
@cindex list
  A @dfn{list} is a comma-separated list of values.  Lists are
enclosed in parentheses.  The following example shows a statement
whose value is a list of strings:

@example
alias (test,null);
@end example

  In any case where a list is appropriate, a single value is allowed
without being a member of a list: it is equivalent to a list with a
single member.  This means that, e.g.

@example
alias test;
@end example

@noindent
is equivalent to

@example
alias (test);
@end example
@end table

@cindex statement, block
@cindex block statement
  A @dfn{block statement} introduces a logical group of 
statements.  It consists of a keyword, followed by an optional value,
and a sequence of statements enclosed in curly braces, as shown in
the example below:

@example
@group
server srv1 @{
  host 10.0.0.1;
  community "foo";
@}
@end group
@end example

  The closing curly brace may be followed by a semicolon, although
this is not required.

@node Paths
@subsubsection Statement Path

@command{Mailutils} configuration files have a distinct hierarchical
structure.  Each statement in such files can therefore be identified
by its name and the names of block statements containing it.  Such
names form the @dfn{pathname}, similar to that used by UNIX file system.

For example, consider the following file:

@example
foo @{
  bar @{
    baz 45;   # @r{A.}
  @}
  baz 98;     # @r{B.}
@}
@end example

The full pathname of the statement marked with @samp{A} can be written
as:

@example
.foo.bar.baz
@end example

Similarly, the statement marked with @samp{B} has the following
pathname:

@example
.foo.baz
@end example

The default path component separator is dot.  A pathname beginning with
a component separator is called @dfn{absolute pathname}.  Absolute
pathnames uniquely identify corresponding statements.  If the leading
dot is omitted, the resulting pathname is called
@dfn{relative}.  Relative pathnames identify statements in relation to 
the current point of reference in the configuration file.

Any other punctuation character can be used as a component separator,
provided that it appears at the beginning of the pathname.  In other
words, only absolute pathnames allow for a change in component separators.

A block statement that has a tag is referred to by the statement's
name, followed by an equals sign, followed by the tag value.  For
example, the statement @samp{A} in the file below:

@example
program x @{
  bar @{
    baz 45;   # @r{A.}
  @}
@}
@end example

is identified by the following pathname:

@example
.program=x.bar.baz
@end example

The tag can optionally be enclosed in a pair of double quotes.  Such a
quoting becomes mandatory for tags that contain white space or path
component separator, e.g.:

@example
.program="a.out".bar.baz
@end example

@anchor{the --set option}
The @option{--set} command line option allows you to set configuration
variables from the command line.  Its argument consists of the
statement path and value, separated by a single equals sign (no
whitespace is permitted at either side of it).  For example, the
following option:

@example
--set .logging.facility=mail
@end example

@noindent
has the same effect as the following statement in the configuration
file:

@example
logging @{
    facility mail;
@}
@end example

Values set using this option override those set in the configuration
files.  This provides a convenient way for temporarily changing
configuration without altering configuration files.

Notice, that when using @option{--set}, the @samp{=} sign has two
purposes: first it separates statement path from the value, thus
forming an assignment, and secondly it can be used within the path
itself to introduce a tag.  To illustrate this, let's assume you have
the following statement in your configuration file:

@example
@group
program pop3d @{
    logging @{
       facility mail;
    @}
    server 0.0.0.0 @{
       transcript no;
    @}
@}
@end group
@end example

Now assume you wish to temporarily change logging facility to
@samp{local1}.  The following option will do this:

@example
--set .program=pop3d.logging.facility=local1
@end example

When splitting the argument to @option{--set}, the option parser
always looks for the rightmost equals sign.  Everything to the right
of it is the value, and everything to the left of it - the path.

If the tag contains dots (as the @code{server} statement in the
example above), you should either escape them with slashes or change
the pathname separator to some other character, e.g.:

@example
--set .program=pop3d.server='0\.0\.0\.0'.transcript=yes
@end example

@noindent
or

@example
--set /program=pop3d/server="0.0.0.0"/transcript=yes
@end example

@node Variables
@subsection Configuration Variables
@cindex variable expansion
@cindex macro variable
  Certain configuration statements allow for the use of variable
references in their values.  A variable reference has the form
@samp{$@var{variable}} or @samp{$@{@var{variable}@}}, where
@var{variable} is the variable name.  It is expanded to the actual
value of @var{variable} when Mailutils consults the configuration
statement in question.  

The two forms are entirely equivalent.  The form with curly braces is
normally used if the variable name is immediately followed by an
alphanumeric symbol, which will otherwise be considered part of it.
This form also allows for specifying the action to take if the
variable is undefined or expands to an empty value. 

During variable expansion, the forms below cause Mailutils to test
for a variable that is unset or null.  Omitting the colon results
in a test only for a variable that is unset.

@table @asis
@item $@{@var{variable}:-@var{word}@}
@dfn{Use Default Values}.  If @var{variable} is unset or null, the expansion
of @var{word} is  substituted.   Otherwise, the value of @var{variable} is
substituted.

@item $@{@var{variable}:=@var{word}@}
@dfn{Assign Default Values}.  If @var{variable} is unset or null, the
expansion  of @var{word} is assigned to variable.  The value of 
@var{variable} is then substituted.
                            
@item $@{@var{variable}:?@var{word}@}
@dfn{Display Error if Null or Unset}.  If @var{variable} is null or unset,
the expansion of @var{word} (or a message to that effect if @var{word} is
not present) is output to the current logging channel.  Otherwise, the
value of @var{variable} is substituted.

@item $@{@var{variable}:+@var{word}@}
@dfn{Use Alternate Value}.  If @var{variable} is null or unset, nothing is
substituted, otherwise the expansion of @var{word} is substituted.
@end table

The subsections below define variable names that are valid for use in
each configuration statement.

@node include
@subsection The @code{include} Statement
@anchor{Include} @c for backward-compatibility
@cindex include statement, configuration file
@kwindex include
  A special statement is provided that causes inclusion of the named
file.  It has the following syntax: 

@example
include @var{file};
@end example

When reading the configuration file, this statement is effectively
replaced with the content of @var{file}.  It is an error if @var{file}
does not exist.

In site-wide configuration file, @var{file} can be a directory name.
In this case, Mailutils will search this directory for a file with the
same name as the utility being executed.  If found, this file will be
loaded.

It is a common to end the site-wide configuration file with
an include statement, e.g.:

@example
include /etc/mailutils.d;
@end example

This allows each particular utility to have its own configuration
file.  Thus, @command{imap4d} will read
@file{/etc/mailutils.d/imap4d}, etc.

@node program statement
@subsection The @command{program} statement
@kwindex program
Another way to configure program-specific settings is by using the
@command{program} statement.  The syntax is as follows:

@example
program @var{progname} @{
   ...
@}
@end example

The @command{program} statement is allowed only in the site-wide
configuration file.  When encountered, its tag (@var{progname}) is
compared with the name of the program being run.  If two strings are
the same, the statements between curly braces are stored in a
temporary memory, otherwise the statement is ignored.  When entire
configuration file is loaded, the statements accumulated in the
temporary storage are processed.

Notice the difference between this statement and a per-program
configuration file loaded via an @code{include} statement.  No matter
where in the file the @command{program} statement is, its content will
be processed after the content of the enclosing file.  In the
contrast, the per-program configuration file loaded via @code{include}
is processed right where it is encountered.

@node logging statement
@subsection The @code{logging} Statement
@anchor{Logging Statement}
@kwindex logging
@subheading Syntax
@example
logging @{
  # @r{Send diagnostics to syslog.}
  syslog @var{boolean};
  
  # @r{Print message severity levels.}
  print-severity @var{boolean};
  
  # @r{Output only messages with a severity equal to or}
  # @r{greater than this one.}
  severity @var{string};
  
  # @r{Set syslog facility.}
  facility @var{name};

  # Log session ID
  session-id @var{boolean};
    
  # @r{Tag syslog messages with this string.}
  tag @var{text};
@}
@end example

@subheading Description
  The @code{logging} block statement configures where the diagnostic
output goes and how verbose it is.

@deffn {Configuration} syslog bool
If @samp{syslog} is set to @samp{yes}, the diagnostics will go to
syslog.  Otherwise, it goes to the standard error.
@end deffn

The default syslog facility is determined at compile time, it can be inspected
using the following command (@pxref{mailutils info}):

@example
$ mailutils info log_facility
@end example

@anchor{syslog facility}
@deffn {Configuration} facility name
Use syslog facility @var{name}.  Valid argument values are: @samp{user},
@samp{daemon}, @samp{auth}, @samp{authpriv}, @samp{mail}, @samp{cron},
@samp{local0} through @samp{local7} (all names case-insensitive), or
a facility number.
@end deffn

@deffn {Configuration} tag text
Tag syslog messages with @var{text}.  By default, program name is used
as syslog tag.
@end deffn

@deffn {Configuration} print-severity bool
Print Mailutils severity name before each message.
@end deffn

@deffn {Configuration} severity name
Output only messages with a severity equal to or greater than this
one.  Valid arguments are: @samp{debug}, @samp{info}, @samp{notice},
@samp{warning}, @samp{error}, @samp{crit}, @samp{alert}, @samp{emerg},
@end deffn

@deffn {Configuration} session-id bool
Print session ID with each diagnostic message.  This is useful for
programs that handle multiple user sessions simultaneously, such as
@command{pop3d} and @command{imap4d}.
@end deffn

@node debug statement
@subsection The @code{debug} Statement
@anchor{Debug Statement}
@kwindex debug
@subheading Syntax
@example
debug @{
  # @r{Set Mailutils debugging level.}
  level @var{spec};
  
  # @r{Prefix debug messages with Mailutils source locations.}
  line-info @var{bool};
@}
@end example

@subheading Description
@kwindex level
The @samp{debug} statement controls the amount of additional debugging
information output by Mailutils programs.  The @samp{level} statement
enables additional debugging information.  Its argument (@var{spec})
is a Mailutils debugging specification as described in
@ref{debugging}.

@kwindex line-info
The @samp{line-info} statement, when set to @samp{true} causes
debugging messages to be prefixed with locations in Mailutils source
files where they appear.  Normally, only Mailutils developers need
this option. 

@node mailbox statement
@subsection The @code{mailbox} Statement
@anchor{Mailbox Statement}
@kwindex mailbox
@subheading Syntax
@example
mailbox @{
  # @r{Use specified @var{url} as a mailspool.}
  mail-spool @var{url};
  
  # @r{Create mailbox @var{url} using @var{pattern}.}
  mailbox-pattern @var{pattern};
  
  # @r{Default mailbox type.}
  mailbox-type @var{type};
  
  # @r{Default user mail folder.}
  folder @var{dir};
@}
@end example

@subheading Description
The @code{mailbox} statement configures the location, name and type of
user mailboxes.

The mailbox location can be specified using @code{mail-spool} or
@code{mail-pattern} statements.

@deffn {Configuration} mail-spool @var{path}
The @code{mail-spool} statement specifies directory that holds user
mailboxes.  Once this statement is given, the @command{libmailutils}
library will assume that the mailbox of user @var{login} is kept in
file @file{@var{path}/@var{login}}.

Historically, @var{path} can contain mailbox type prefix, e.g.:
@samp{maildir:///var/spool/mail}, but such usage is discouraged in
favor of @code{mailbox-pattern} statement.
@end deffn

@deffn {Configuration} mailbox-pattern @var{url}
The @code{mailbox-pattern} statement is a preferred way of configuring
mailbox locations.  It supersedes @code{mail-spool} statement.

The @var{url} must be a valid mailbox URL (@pxref{Mailbox}), which 
may contain references to the @samp{user} variable
(@pxref{Variables}).  This variable will be expanded to the actual
user name.

@anchor{local URL parameters}
@cindex directory indexing
Optional URL parameters can be used to configure @dfn{indexed directory
structure}.  Such structure is a special way of storing mailboxes,
which allows for faster access in case of very large number of users. 

By default, all user mailboxes are stored in a single directory and
are named after user login names.  To find the mailbox for a given
user, the system scans the directory for the corresponding
file.  This usually implies linear search, so the time needed to
locate a mailbox is directly proportional to the ordinal number of
the mailbox in the directory.

GNU Mailutils supports three types of indexed directories:
@samp{direct}, @samp{reverse}, and @samp{hashed}.

@cindex direct indexing
@cindex indexing, direct
In direct indexed directory structure, @var{path} contains 26 subdirectories
named with lower-case letters of Latin alphabet.  The location of the
user mailbox is determined using the following algorithm:

@enumerate 1
@item Take the first letter of the user name.
@item Map it to a lower-case letter using @dfn{index mapping}
table.  The result gives the name of a sub-directory where the mailbox
is located.
@item Descend into this directory.
@end enumerate

For example, using this algorithm, the mailbox of the user
@samp{smith} is stored in file @file{@var{path}/s/smith}.

If each of single-letter subdirectories contains the
indexed directory structure, we have second level of indexing.  In
this case the file name of @samp{smith}'s mailbox is
@file{@var{path}/s/m/smith}.

@cindex reverse indexing
@cindex indexing, reverse
The @dfn{reverse} indexed structure uses the same principles, but the
indexing letters are taken from the @emph{end} of the user name,
instead of from the beginning.  For example, in the 2nd level reverse
indexed structure, the @samp{smith}'s mailbox is located in
@file{@var{path}/h/t/smith}.

@cindex hashed indexing
@cindex indexing, hashed
Finally, the @dfn{hashed} structure consists of 256 subdirectories
under @var{path}, named by 2-letter hex codes from @samp{00} to
@samp{FF}.  Mailboxes are stored in these subdirectories.  The name
of the subdirectory is computed by hashing first @var{level} letters
of the user name.  The hashing algorithm is:

@enumerate 1
@item Take next letter from the user name
@item Add its ASCII value to the hash sum.
@item Continue (1-2) until @var{level} letters are processed, or all
letters from the file name are used, whichever occurs first.
@item Convert the computed sum modulo 256 to a hex code.
@end enumerate

Indexed directory structures are configured using the following
arguments:

@table @asis
@kwindex type
@item type=@var{value}
Specifies the type of indexing.  Valid values are @samp{index}, for direct
indexed structure, @samp{rev-index} for reverse indexing, and
@samp{hash} for hashed structure.

@kwindex param
@item param=@var{number}
Specifies indexing level.

@kwindex user
@item user=@var{string}
Specifies indexing key.  The only meaningful value, as of Mailutils
version @value{VERSION} is @samp{user=$@{user@}}.
@end table

Let's assume the traditional mail layout, in which incoming
mails are stored in a UNIX mailbox named after the recipient user name
and located in @file{/var/mail} directory.
The @code{mailbox-pattern} for this case is:

@example
  mailbox-pattern "/var/mail/$@{user@}";
@end example

It is entirely equivalent to specifying @samp{mail-spool "/var/mail"}.

Now, if the layout is the same, but mailboxes are kept in
@samp{maildir} format, then the corresponding statement is:

@example
  mailbox-pattern "maildir:///var/mail/$@{user@}";
@end example

Finally, if the mailboxes are stored in a directly-indexed directory with
two levels of indexing, the URL is:

@example
  mailbox-pattern "maildir:///var/mail;type=index;param=2;user=$@{user@}";
@end example
@end deffn

If neither @code{mailbox-pattern} nor @code{mail-spool} are given, the
mailbox names are determined using the following algorithm:

@enumerate 1
@item If environment variable @env{FOLDER} is set, use its value.
@item Otherwise, if environment variable @env{MAIL} is set, use its
value.
@item If neither of these is set, construct the mailbox name by 
concatenating the built-in mail spool directory name, a directory
separator, and the user name.

The built-in mail spool directory name is determined at compile
time, using the @samp{_PATH_MAILDIR} define from the include file
@file{paths.h}.  If this value is not defined, @file{/var/mail} or
@file{/usr/spool/mail} is used.
@end enumerate

@deffn {Configuration} mailbox-type @var{type}
@vrindex MU_DEFAULT_SCHEME
Specifies the type of mailboxes.  By default, @samp{mbox} (UNIX mailbox)
is assumed.  This can be changed while configuring the package by
setting @code{MU_DEFAULT_SCHEME} configuration variable.  The default
value can be verified by running @command{mailutils info scheme}.
@end deffn

@deffn {Configuration} folder @var{dir}
@cindex plus expansion
Sets user mail folder directory.  Its value is used when expanding
@samp{plus-notation}, i.e. such mailbox names as @file{+inbox}.  The
@samp{+} sign is replaced by @var{dir}, followed by a directory
separator (@samp{/}).

The @var{dir} argument can contain mailbox type prefix, e.g
@samp{mh://Mail}.

The default folder name is @samp{Mail/}.
@end deffn

@node locking statement
@subsection The @command{locking} Statement
@anchor{Locking Statement}
@kwindex locking
@subheading Syntax
@example
locking @{
  # @r{Default locker flags.}
  flags @var{arg};
  
  # @r{Set timeout for acquiring the lock.}
  retry-timeout @var{arg};
  
  # @r{Set the maximum number of times to retry acquiring the lock.}
  retry-count @var{number};
  
  # @r{Expire locks older than this amount of time.}
  expire-timeout @var{number};
  
  # @r{Use @var{prog} as external locker program.}
  external-locker @var{prog};
@}
@end example

@subheading Description
This block statement configures various parameters used when locking
UNIX mailboxes in order to prevent simultaneous writes.

It is important to note, that locking applies only to traditional
UNIX mailboxes (@pxref{mbox}).  All other
mailbox types don't require locking.

@deffn {Configuration} flags @var{string}
Set locking flags.  Argument is a string consisting of one or more of
the following letters:

@table @asis
@item E
Use an external program to manage locks.  The program is given by the
@code{external-locker} statement (see below).

@item R
If the locking attempt failed, retry it.  This is the default.  The
number of retries, and time interval between the two successive
attempts is given by @code{retry-count} and @code{retry-timeout}
statements, correspondingly.

@item T
If a lock file exists, check its modification time and, if it is
older than a predefined amount of time, remove the lock.  The amount
of time is specified by @code{expire-timeout} statement.

@item P
Store the PID of the locking process in a lock file.
@end table
@end deffn

@deffn {Configuration} retry-count @var{number}
Number of locking attempts.  The @samp{P} flag must be set for this to
take effect.
@end deffn

@deffn {Configuration} retry-timeout @var{seconds}
Time interval, in seconds, between the two successive locking
attempts.  The @samp{P} flag must be set for this to take effect.
@end deffn

@deffn {Configuration} expire-timeout @var{seconds}
Remove existing lock file, if it is created more than this number of
seconds ago.  The @samp{T} flag must be set for this to take effect.
@end deffn

@deffn {Configuration} external-locker @var{string}
Determines the external locker program to use.  The @var{string}
argument is the valid command line, starting with the full program
name.  The @samp{E} flag must be set for this to take effect. 
@end deffn

@node mailer statement
@subsection The @code{mailer} Statement
@anchor{Mailer Statement}
@kwindex mailer
@subheading Syntax
@example
mailer @{
  url @var{url};
@}
@end example

@subheading Description
A @dfn{mailer} is a special logical entity GNU Mailutils uses for
sending messages.  Its internal representation is discussed in
@FIXME-ref{Mailer}.  The @code{mailer} statement configures it.

The mailer statement contains a single sub-statement:

@deffn {Configuration} url @var{str}
Set the mailer @acronym{URL}.
@end deffn

GNU Mailutils supports three types of mailer @acronym{URL}s, described
in the table below:

@table @asis
@item smtp://[@var{user}[:@var{pass}][;auth=@var{mech},...]@@]@var{host}[:@var{port}][;@var{params}]
@itemx smtps://[@var{user}[:@var{pass}][;auth=@var{mech},...]@@]@var{host}[:@var{port}][;@var{params}] 
Send messages using SMTP protocol.  @xref{SMTP Mailboxes}, for a
detailed description of the URL and its parts.

@item sendmail[://@var{progname}]
Use sendmail-compatible program
@var{progname}.  @dfn{Sendmail-compatible} means that the program must
support following command line options:

@table @option
@item -oi
Do not treat @samp{.} as message terminator.

@item -f @var{addr}
Use @var{addr} as the sender address.

@item -t
Get recipient addresses from the message.
@end table

@xref{Program Mailboxes,,sendmail}, for details.

@item prog://@var{progname}?@var{query}
A @dfn{prog} mailer.  This is a generalization of @samp{sendmail}
mailer that allows to use arbitrary external programs as mailers.

It is described in detain in @ref{Program Mailboxes,,prog}.
@end table

@node acl statement
@subsection The @code{acl} Statement
@anchor{ACL Statement}
@kwindex acl
@subheading Syntax
@example
acl @{
  # @r{Allow connections from this IP address.}
  allow [from] @var{ip};
  
  # @r{Deny connections from this IP address.}
  deny [from] @var{ip};
  
  # @r{Log connections from this IP address.}
  log [from] @var{ip} [@var{string}];
  
  /* @r{Execute supplied program if a connection from this
     IP address is requested.} */
  exec [from] @var{ip} @var{program};
  
  /* Use @var{program} to decide whether to allow connection
     from @var{ip}. */
  ifexec [from] @var{ip} @var{program};
@}
@end example

@subheading Description
The ACL statement defines an @dfn{Access Control List}, a special
structure that controls who can access the given Mailutils resource.

The @code{acl} block contains a list of access controls.  Each control
can be regarded as a function that returns a tree-state value:
@samp{True}, @samp{False} and @samp{Don't know}.  When a
remote party connects to the server, each of controls is tried in
turn.  If a control returns @samp{False}, access is denied.  If it
returns @samp{True}, access is allowed.  If it returns @samp{Don't
know}, then the next control is tried.  It is unclear whether to allow
access if the last control in list returned @samp{Don't know}.  GNU
Mailutils @value{VERSION} issues a warning message and allows access.
This default may change in future versions.  Users are advised to
write their ACLs so that the last control returns a definite answer
(either @code{True} or @code{False}).

In the discussion below, wherever @var{cidr} appears as an argument, it
can be replaced by any of: 

@itemize @bullet
@item An IPv4 address in dotted-quad notation.
@item An IPv6 address in numeric notation
@item A CIDR in the form @samp{@var{ip}/@var{mask}}, where @var{ip} is
an IP address (either IPv4 or IPv6), and @var{mask} is the network mask.
@item A symbolic host name.
@kwindex any
@item A word @samp{any}, which matches any IP address.
@end itemize

The following controls are understood:

@deffn {Configuration} allow [from] @var{cidr}
Allow connections from IP addresses matching this @var{cidr} block.
@end deffn

@deffn {Configuration} deny [from] @var{cidr}
Deny connections from IP addresses matching this @var{cidr} block.
@end deffn

@deffn {Configuration} ifexec [from] @var{cidr} @var{program}
When a connection from the @var{cidr} block is requested, execute
the program @var{program}.  If its exit code is @samp{0}, then allow
connection.  Otherwise, deny it.

The @var{program} argument undergoes variable expansion and word
splitting.  The following variables are defined:

@table @code
@item aclno
Ordinal number of the control in the ACL.  Numbers begin from
@samp{1}.

@item family
Connection family.  Mailutils version @value{VERSION} supports the following
families: @samp{AF_INET}, @samp{AF_INET6} and @samp{AF_UNIX}.

@item address
Remote IP address (for @samp{AF_INET} and @samp{AF_INET6}) or socket name (for
@samp{AF_UNIX}).  Notice that most Unixes return empty string instead
of the @samp{AF_UNIX} socket name, so do not rely on it.

@item port
Remote port number (for @samp{AF_INET} and @samp{AF_INET6}).
@end table
@end deffn

@deffn {Configuration} exec [from] @var{cidr} @var{program}
If a connection from the @var{cidr} block is requested, execute the given
@var{program}.  Do not wait for it to terminate, and ignore its exit
code.  The @var{program} is subject for variable expansion as in
@samp{ifexec}.
@end deffn

The following two controls are provided for logging purposes and as a
means of extensions.  They always return a @samp{Don't know} answer,
and therefore should not be used at the end of an ACL:

@deffn {Configuration} log [from] @var{cidr} [@var{string}]
Log connections from addresses in this @var{cidr}.  The
@code{MU_DIAG_INFO} channel is used.  If the logging goes to syslog,
it is translated to the @code{LOG_INFO} priority.

If @var{string} is not given, the format of the log entry depends on
the connection family, as described in the table below:

@table @asis
@item @{AF_INET @var{ip}:@var{port}@}
For inet IPv4 connections.  The variables @var{ip} and @var{port} are
replaced by the remote IP address and port number, correspondingly.

@item @{AF_UNIX@}
For connections over UNIX sockets.  The socket name, if available, may
be printed before the closing curly brace.
@end table

If @var{string} is supplied, it undergoes variable expansions as
described for the @samp{ifexec}.

For example, the following ACL makes a Mailutils server log every
incoming connection:

@example
  acl @{
     log from any "Connect from $@{address@}";
     ...
  @}
@end example

This was the default behavior for the versions of Mailutils up to
@samp{1.2}, so if you got used to its logs you might wish to add the
above in your configuration files.
@end deffn

@deffn {Configuration} exec [from] @var{cidr} @var{program}
If a connection from the @var{cidr} block is requested, execute
the given @var{program}.  Do not wait for it to terminate, and ignore
its exit code.
@end deffn

@node tcp-wrappers statement
@subsection The @code{tcp-wrappers} Statement
@anchor{Tcp-wrappers Statement}
@kwindex tcp-wrappers
@subheading Syntax
@example
tcp-wrappers @{
  # @r{Enable TCP wrapper access control.}
  enable @var{bool};
  
  # @r{Set daemon name for TCP wrapper lookups.}
  daemon @var{name};
  
  # @r{Use @var{file} for positive client address access control.}
  allow-table @var{file};
  
  # @r{Use file for negative client address access control.}
  deny-table @var{file};
@}
@end example

@subheading Description
The @code{tcp-wrappers} statements provides an alternative way to
control accesses to the resources served by GNU Mailutils.  This
statement is enabled if Mailutils is compiled with TCP wrappers
library @command{libwrap}.

Access control using TCP wrappers is based on two files, called
@dfn{tables}, containing access rules.  There are two tables: the
@dfn{allow table}, usually stored in file @file{/etc/hosts.allow}, and
the @dfn{deny table}, kept in file @file{/etc/hosts.deny}.  The rules
in each table begin with an identifier called @dfn{daemon name}.  A
utility that wishes to verify a connection, selects the entries having
its daemon name from the allow table.  A connection is allowed if it
matches any of these entries.  Otherwise, the utility retrieves all
entries with its daemon name from the deny table.  If any of these
matches the connection, then it is refused.  Otherwise, if neither
table contains matching entries, the connection is allowed.

The description of a TCP wrapper table format lies outside the scope of
this document.  Please, see @ref{ACCESS CONTROL FILES,,ACCESS CONTROL FILES,
hosts_access(5), hosts_access(5) man page}, for details.

@deffn {Configuration} enable @var{bool}
Enable access control using TCP wrappers.  It is on by default.
@end deffn

@deffn {Configuration} daemon @var{name}
Set daemon name for TCP wrapper lookups.  By default, the name of the
utility is used.  E.g.  @command{imap4d} uses @samp{imap4d} as the
daemon name.
@end deffn

@deffn {Configuration} allow-table @var{file}
Use @var{file} as allow table.  By default, @file{/etc/hosts.allow} is
used. 
@end deffn
  
@deffn {Configuration} deny-table @var{file}
Use @var{file} as negative table.  By default, @file{/etc/hosts.deny}
is used.
@end deffn

@node Server Settings
@subsection Server Settings
@cindex server settings, configuration
@cindex configuring servers
  GNU Mailutils offers several server applications: @command{pop3d},
@command{imap4d}, @command{comsatd}, to name a few.  Being quite
different in their purpose, they are very similar in some aspects of
their architecture.  First of all, they all support two operating
modes: @dfn{daemon}, where a program disconnects from the controlling
terminal and works in background, and @dfn{inetd}, where it
remains in foreground and communicates with the remote party via
standard input and output streams.  Secondly, when operating as
daemons, they listen to a preconfigured set of IP addresses and
ports, reacting to requests that arrive.

  To configure these aspects of functionality, GNU Mailutils provides
@dfn{Server Configuration Settings}, which is describes in this
subsection. 

@menu
* General Server Configuration::
* Server Statement::
@end menu

@node General Server Configuration
@subsubsection General Server Configuration
@cindex server configuration, general
@* Syntax:
@example
# @r{Set daemon mode.}
mode @samp{inetd|daemon};

# @r{Run in foreground.}
foreground @var{bool};

# @r{Maximum number of children processes to run simultaneously.}
max-children @var{number};

# @r{Store PID of the master process in @var{file}.}
pidfile @var{file};

# @r{Default port number.}
port @var{portspec};

# @r{Set idle timeout.}
timeout @var{time};
@end example

@* Description:
These statements configure general server-related issues.

@deffn {Configuration} mode @var{string};
Set operation mode of the server.  Two operation modes are supported:

@anchor{server mode}
@table @asis
@cindex daemon, server mode
@item daemon
Run as a standalone daemon, disconnecting from the controlling
terminal and continuing to run in the background.  In this case, it is
the server that controls what IP addresses and ports to listen on, who
is allowed to connect and from where, how many clients are allowed to
connect simultaneously, etc.  Most remaining configuration statements
are valid only in the daemon mode.

This is the preferred mode of operation for GNU Mailutils servers.

@cindex inetd, server mode
@item inetd
Operate as a subprocess of UNIX internet super-server program,
@command{inetd}.  @xref{Internet super-server,,,inetd(8), inetd(8) man
page}, for a detailed description of the operation of @command{inetd}
and its configuration.  In this case it is @command{inetd} that
controls all major connectivity aspects.  The Mailutils server program
communicates with it via standard input and output streams.

For historical reasons, this mode is the default, if no @code{mode}
statement is specified.  This will change in the future.
@end table
@end deffn

@deffn {Configuration} foreground @var{bool};
@*[daemon mode only]
@*Do not disconnect from the controlling terminal and remain in the
foreground. 
@end deffn

@deffn {Configuration} max-children @var{number};
@*[daemon mode only]
@*Set maximum number of child processes allowed to run simultaneously.
This equals the number of clients that can use the server
simultaneously.

The default is 20 clients.
@end deffn

@deffn {Configuration} pidfile @var{file};
After startup, store the PID of the main server process in
@var{file}.  When the process terminates, the file is removed.  As of
version @value{VERSION}, GNU Mailutils servers make no further use of
this file.  It is intended for use by automated startup scripts and
controlling programs (e.g. @pxref{Top, GNU pies,, pies, GNU Pies Manual}).
@end deffn

@deffn {Configuration} port @var{portspec};
@*[daemon mode only]
@*Set default port to listen to.  The @var{portspec} argument is either
a port number in decimal, or a symbolic service name, as listed in
@file{/etc/services} (@pxref{Internet network services list,,,
services(5), services(5) man page}).
@end deffn

@deffn {Configuration} timeout @var{time};
Sets maximum idle time out in seconds.  If a client does not send any
requests during @var{time} seconds, the child process terminates.
@end deffn

@node Server Statement
@subsubsection The @code{server} Statement
@cindex server statement
@kwindex server
@* Syntax:
@example
server @var{ipaddr}[:@var{port}] @{
  # @r{Run this server as a single process.}
  single-process @var{bool};
  
  # @r{Log the session transcript.}
  transcript @var{bool};

  # @r{Set idle timeout.}
  timeout @var{time};

  # Size of the queue of pending connections
  backlog <number: callback>;

  # @r{Kind of TLS encryption to use for this server.}
  tls @samp{no}|@samp{ondemand}|@samp{required}|@samp{connection};
    
  # @r{Set server specific ACLs.}
  acl @{ /* @xref{ACL Statement}. */ @};
@}
@end example

@* Description:

The @code{server} block statement configures a single TCP or UDP
server.  It takes effect only in daemon mode (@pxref{server mode}).
The argument to this statement specifies the IP address, and,
optionally, the port, to listen on for requests.  The @var{ipaddr}
part is either an IPv4 address in dotted-quad form, or a IPv6 address
enclosed in square brackets, or a symbolic host name which can be
resolved to such an address.  Specifying @samp{0.0.0.0} as the
@var{ipaddr} means listen on all available network interfaces.  The
@var{port} argument is either a port number in decimal, or a symbolic
service name, as listed in @file{/etc/services} (@pxref{Internet
network services list,,,services(5), services(5) man page}).  If
@var{port} is omitted, Mailutils uses the port set by @code{port}
statement (@pxref{General Server Configuration, port}), or, in its
absence, the default port number, which depends on a server being used
(e.g. 110, for @command{pop3d}, 143, for @command{imap4d}, etc.).  

Any number of @code{server} statements may be specified in a single
configuration file, allowing to set up the same service on several IP
addresses and/or port numbers, and with different configurations.

Statements within the @code{server} block statement configure this
particular server.

@deffn {Configuration} single-process @var{bool};
If set to true, this server will operate in single-process mode.  This
mode is intended for debugging only, do not use it on production
servers.
@end deffn

@deffn {Configuration} transcript @var{bool};
Enable transcript of the client-server interaction.  This may generate
excessive amounts of logging, which in turn may slow down the operation
considerably.

Session transcripts are useful in fine-tuning your configurations and
in debugging.  They should be turned off on most production servers.
@end deffn

@deffn {Configuration} timeout @var{time};
Set idle timeout for this server.  This overrides the global timeout
settings (@pxref{General Server Configuration, timeout}).
@end deffn

@deffn {Configuration} backlog @var{number};
Configures the size of the queue of pending connections
@end deffn

@deffn {Configuration} tls @var{mode};
Configure the use of TLS encryption.  The @var{mode} argument is one
of the following:

@table @asis
@item no
TLS is not used.  The corresponding command (@command{STLS}, for POP3,
@command{STARTTLS}, for @command{IMAP4}) won't be available even if
the TLS configuration is otherwise complete.

@item ondemand
TLS is initiated when the user issues the appropriate command.
This is the default when TLS is configured.

@item required
Same as above, but the use of TLS is mandatory.  The authentication
state is entered only after TLS negotiation has succeeded.

@item connection
TLS is always forced when the connection is established.  For
@command{pop3d} this means using POP3S protocol (or IMAP4S, for
@command{imap4d}).
@end table
@end deffn

@deffn {Configuration} acl
This statement defines a per-server Access Control List.  Its syntax
is as described in @ref{ACL Statement}.  Per-server ACLs complement,
but not override, global ACLs, i.e. if both global ACL and per-server
ACL are used, the connection is allowed only if both of them allow it,
and is denied if any one of them denies it.
@end deffn

@node auth statement
@subsection The @code{auth} Statement
@anchor{Auth Statement}
@cindex authorization
@cindex authentication
@kwindex auth
@subheading Syntax
@example
auth @{
  # @r{Set a list of modules for authentication.}
  authentication @var{module-list};
  
  # @r{Set a list of modules for authorization.}
  authorization @var{module-list};
@}
@end example

@subheading Description
Some mail utilities provide access to their services only after
verifying that the user is actually the person he is claiming
to be.  Such programs are, for example, @command{pop3d} and
@command{imap4d}.  The process of the verification is broken
down into two stages: @dfn{authorization} and @dfn{authentication}.
In @dfn{authorization} stage the program retrieves the information
about a particular user.  In @dfn{authentication} stage, this
information is compared against the user-supplied credentials.  Only if
both stages succeed is the user allowed to use the service.

A set of @dfn{modules} is involved in performing each stage.  For
example, the authorization stage can retrieve the user description
from various sources: system database, SQL database, virtual domain
table, etc.  Each module is responsible for retrieving the description
from a particular source of information.  The modules are arranged in
a @dfn{module list}.  The modules from the list are invoked in turn,
until one of them succeeds or the list is exhausted.  In the latter case 
the authorization fails.  Otherwise, the data returned by the succeeded
module are used in authentication.

Similarly, authentication may be performed in several ways.  The
authentication modules are also grouped in a list.  Each module
is tried in turn until either a module succeeds, in which case the
authentication succeeds, or the end of the list is reached.

For example, the authorization list

@example
  (system, sql, virtdomains)
@end example

@noindent
means that first the system user database (@file{/etc/password}) is
searched for a description of a user in question.  If the search fails,
the @acronym{SQL} database is searched.  Finally, if it also fails, the
search is performed in the virtual domain database.

@emph{Note}, that some authentication and/or authorization modules may
be disabled when configuring the package before compilation.  The names
of the disabled modules are nevertheless available for use in runtime
configuration options, but they represent a ``fail-only'' functionality,
e.g. if the package was compiled without @acronym{SQL} support then
the module @samp{sql} in the above example will always fail, thus
passing the execution on to the next module.

The @code{auth} statement configures authentication and authorization.

@deffn {Configuration} authorization @var{module-list}
Define a sequence of modules to use for authorization.  Modules will
be tried in the same order as listed in @var{module-list}.

The modules available for use in authorization list are:

@table @asis
@item system
User credentials are retrieved from the system user database
(@file{/etc/password}).
@item sql
User credentials are retrieved from a @acronym{SQL} database.
A separate configuration statement, @code{sql}, is used to configure
it (@pxref{sql statement}).
@item virtdomain
User credentials are retrieved from a ``virtual domain'' user
database.  Virtual domains are configured using @code{virtdomain}
statement (@pxref{virtdomain statement}).
@item radius
User credentials are retrieved using @acronym{RADIUS}.  @xref{radius
statement}, for a detailed description on how to configure it.
@item ldap
User credentials are retrieved from an @acronym{LDAP}
database.  @xref{ldap statement}, for an information on how to
configure it.
@end table

Unless overridden by @code{authorization} statement,
the default list of authorization modules is:

@enumerate 1
@item generic
@item system
@item pam
@item sql
@item virtual
@item radius
@item ldap
@end enumerate
@end deffn

@deffn {Configuration} authentication @var{module-list}
Define a sequence of modules to use for authentication.  Modules will
be tried in the same order as listed in @var{module-list}.

The following table lists modules available for use in @var{module-list}:

@table @asis
@item generic
The generic authentication type.  User password is hashed and compared
against the hash value returned in authorization stage.
@item system
The hashed value of the user password is retrieved from
@file{/etc/shadow} file on systems that support it.
@item sql
The hashed value of the user password is retrieved from a
@acronym{SQL} database using query supplied by @code{getpass}
statement (@pxref{sql statement, getpass}).
@item pam
The user is authenticated via pluggable authentication module
(@acronym{PAM}).  The @acronym{PAM} service name to be used is
configured in @code{pam} statement (@pxref{pam statement}).
@item radius
The user is authenticated on a remote @acronym{RADIUS}
server.  @xref{radius statement}.
@item ldap
The user is authenticated using @acronym{LDAP}.  @xref{ldap statement}.
@end table

Unless overridden by @code{authentication} statement,
the list of authentication modules is the same as for
@code{authorization}, i.e.:

@enumerate 1
@item generic
@item system
@item pam
@item sql
@item virtual
@item radius
@item ldap
@end enumerate
@end deffn

@node pam statement
@subsection PAM Statement
@anchor{PAM Statement}
@kwindex pam
@subheading Syntax
@example
pam @{
  # @r{Set PAM service name.}
  service @var{text};
@}
@end example

@subheading Description
The @code{pam} statement configures @acronym{PAM} authentication.  It
contains a single sub-statement:

@deffn {Configuration} service @var{text}
Define service name to look for in @acronym{PAM} configuration.  By
default, the base name of the Mailutils binary is used.
@end deffn

This statement takes effect only if @samp{pam} is listed in
@code{authentication} statement (@pxref{auth statement}).

@node virtdomain statement
@subsection The @code{virtdomain} Statement
@anchor{Virtdomain Statement}
@kwindex virtdomain
@subheading Syntax
@example
virtdomain @{
  # @r{Name of the virtdomain password directory.}
  passwd-dir @var{dir};
@}
@end example

@subheading Description
@dfn{Virtual mail domains} make it possible to handle several
mail domains each having a separate set of users, on a single server.
The domains are completely independent of each other, i.e. the same
user name can be present in several domains and represent different
users.

When authenticating to a server with virtual domain support enabled,
users must supply their user names with domain parts.  The server strips
off the domain part and uses it as a name of UNIX-format password
database file, located in the @dfn{domain password directory}.  The
latter is set using @code{passwd-dir} statement.

@deffn {Configuration} passwd-dir @var{dir}
Set virtual domain password directory.
@end deffn

For example, when authenticating user @samp{smith@@example.com},
the server will use password file named @file{@var{dir}/example.com}.
This file must be in UNIX passwd format (@pxref{password
file,,,passwd(5), passwd(5) man page}), with encrypted passwords
stored in it (as of GNU Mailutils version @value{VERSION}, there is no
support for shadow files in virtual password directories, although
this is planned for future versions).  Here is an example record from
this file:

@example
smith:Wbld/G2Q2Le2w:1000:1000:Email Account:/var/mail/domain/smith:/dev/null
@end example

Notice, that it must contain user names without domain parts.

The @code{pw_dir} field (the 6th field) is used to determine the
location of the maildrop for this user.  It is defined as
@file{@var{pw_dir}/INBOX}.  In our example, the maildrop for user
@samp{smith} will be located in file @file{/var/mail/domain/smith}.

If user did not supply his domain name, or if no matching record was
found in the password file, or if the file matching the domain name
does not exist, then GNU Mailutils falls back to alternative method.
First, it tries to determine the IP address of the remote party.  Then
the domain name corresponding to that address is looked up in the DNS
system.  Finally, this domain name is used as a name of the password
file.

@node radius statement
@subsection The @code{radius} Statement
@anchor{Radius Statement}
@kwindex radius
@subheading Syntax
@example
radius @{
  # Set radius configuration directory.
  directory @var{dir};
  # @r{Radius request for authorization.}
  auth @var{request};
  # @r{Radius request for getpwnam.}
  getpwnam @var{request};
  # Radius request for getpwuid.
  getpwuid @var{request};
@}
@end example
@subheading Description
The @code{radius} block statement configures @acronym{RADIUS
authentication} and authorization.

Mailutils uses GNU Radius library, which is configured via
@file{raddb/client.conf} file (@pxref{client.conf, Client Configuration,
Client Configuration, radius, GNU Radius Reference Manual}).  Its exact
location depends on configuration settings that were used while
compiling GNU Radius.  Usually it is @file{/usr/local/etc}, or
@file{/etc}.  This default can also be changed at run time using
@code{directory} statement:

@deffn {Configuration} directory @var{dir}
Set full path name to the GNU Radius configuration directory.
@end deffn

It authorization is used, the Radius dictionary file must declare the
the following attributes:

@multitable @columnfractions 0.4 0.2 0.4
@headitem Attribute    @tab Type    @tab Description
@kwindex GNU-MU-User-Name
@item GNU-MU-User-Name @tab string  @tab User login name
@kwindex GNU-MU-UID
@item GNU-MU-UID       @tab integer @tab UID
@kwindex GNU-MU-GID
@item GNU-MU-GID       @tab integer @tab GID
@kwindex GNU-MU-GECOS
@item GNU-MU-GECOS     @tab string  @tab GECOS
@kwindex GNU-MU-Dir
@item GNU-MU-Dir       @tab string  @tab Home directory
@kwindex GNU-MU-Shell
@item GNU-MU-Shell     @tab string  @tab User shell
@kwindex GNU-MU-Mailbox
@item GNU-MU-Mailbox   @tab string  @tab User mailbox
@kwindex GNU-MU-Quota
@item GNU-MU-Quota     @tab integer @tab Mail quota (in bytes)
@end multitable

@flindex mailutils.dict
A dictionary file with appropriate definitions is included in the
Mailutils distribution: @file{examples/config/mailutils.dict}.  This
file is not installed by default, you will have to manually copy it to
the GNU Radius @file{raddb/dict} directory and include it in the main
dictionary file @file{raddb/dictionary} by adding the following
statement:

@example
$INCLUDE dict/mailutils.dict
@end example

Requests to use for authentication and authorization are
configured using three statements: @code{auth}, @code{getpwnam} and
@code{getpwuid}.  Each statement takes a single argument: a string,
containing a comma-separated list of assignments.  An assignment
specifies a particular @dfn{attribute-value pair} (@pxref{Overview,
RADIUS Attributes,, radius, GNU Radius Reference Manual}) to send to
the server.  The left-hand side of the assignment is a symbolic attribute
name, as defined in one of Radius dictionaries (@pxref{dictionary
file, Dictionary of Attributes,, radius, GNU Radius Reference
Manual}).  The value is specified by the right-hand side of
assignment.  For example:

@example
"Service-Type = Authenticate-Only, NAS-Identifier = \"mail\""
@end example

The assignment may contain references to the following variables
(@pxref{Variables}):

@table @asis
@item user
The actual user name (for @code{auth} and @code{getpwnam}), or user ID
(for @code{getpwuid}).  For example:

@example
User-Name = $@{user@}
@end example

@item passwd
User password.  For examples:
@example
User-Password = $@{passwd@}
@end example
@end table

@deffn {Configuration} auth @var{pairlist}
Specifies the request to be sent to authenticate the user.  For example:

@example
auth "User-Name = $@{user@}, User-Password = $@{passwd@}";
@end example

The user is authenticated only if this request returns
@code{Access-Accept} (@pxref{Authentication Requests, Access-Accept,,
radius, GNU Radius Reference Manual}).  Any returned attribute-value
pairs are ignored. 
@end deffn

@deffn {Configuration} getpwnam @var{pairlist}
Specifies the request that returns user information for the
given user name.  For example:

@example
getpwnam "User-Name = $@{user@}, State = getpwnam, "
         "Service-Type = Authenticate-Only";
@end example

If the requested user account exists, the Radius server must return
@code{Access-Accept} packet with the following attributes:
@code{GNU-MU-User-Name}, @code{GNU-MU-UID}, @code{GNU-MU-GID},
@code{GNU-MU-GECOS}, @code{GNU-MU-Dir}, @code{GNU-MU-Shell}.

The attributes @code{GNU-MU-Mailbox} and @code{GNU-MU-Quota} are
optional.

If @code{GNU-MU-Mailbox} is present, it must contain a
valid mailbox @acronym{URL} (@pxref{Mailbox, URL}).  If
@code{GNU-MU-Mailbox} is not present, Mailutils constructs the
mailbox name using the settings from the @code{mailbox} configuration
statement (@pxref{Mailbox Statement}), or built-in defaults, if it is
not present.

If @code{GNU-MU-Quota} is present, it specifies the maximum mailbox
size for this user, in bytes.  In the absence of this attribute, 
mailbox size is unlimited.
@end deffn

@deffn {Configuration} getpwuid @var{pairlist}
Specifies the request that returns user information for the
given user ID.  In @var{pairlist}, the @samp{user} macro-variable is
expanded to the numeric value of ID.  For example:

@example
getpwuid "User-Name = $@{user@}, State = getpwuid, "
         "Service-Type = Authenticate-Only";
@end example

The reply to @code{getpwuid} request is the same as to @code{getpwnam}
request (see above).
@end deffn

@node sql statement
@subsection The @code{sql} Statement
@anchor{SQL Statement}
@kwindex sql
@subheading Syntax
@example
sql @{
  # @r{Set SQL interface to use.}
  interface @samp{mysql|odbc|postgres};
  # @r{SQL server host name.}
  host @var{arg};
  # @r{SQL user name.}
  user @var{arg};
  # @r{Password for the SQL user.}
  passwd @var{arg};
  # @r{SQL server port.}
  port @var{arg};
  # @r{Database name.}
  db @var{arg};
  # @r{Type of password returned by getpass query.}
  password-type @samp{plain | hash | scrambled};
  # @r{Set a field-map for parsing SQL replies.}
  field-map @var{list};
  # @r{SQL query returning the user's password.}
  getpass @var{query};
  # @r{SQL query to use for getpwnam requests.}
  getpwnam @var{query};
  # @r{SQL query to use for getpwuid requests.}
  getpwuid @var{query};
@}
@end example
@subheading Description

The @code{sql} statement configures access credentials to
@acronym{SQL} database and the queries for authentication and
authorization.

GNU Mailutils supports three types of @acronym{SQL} interfaces:
MySQL, PostgreSQL and ODBC.  The latter is a standard API for using
database management systems, which can be used to communicate with a
wide variety of DBMS.

@deffn {Configuration} interface @var{type}
Configures type of DBMS interface.  Allowed values for @var{type} are:

@table @asis
@item mysql
Interface with a MySQL server (@uref{http://www.mysql.org}).

@item odbc
Use ODBC interface.  See @uref{http://www.unixodbc.org}, for a detailed
description of ODBC configuration.

@item postgres
Interface with a PostgreSQL server (@uref{http://www.postgres.org}).
@end table
@end deffn

The database and database access credentials are configured using the
following statements:

@deffn {Configuration} host @var{arg}
The host running the @acronym{SQL} server.  The value can be either a
host name or an IP address in dotted-quad notation, in which case an
@acronym{INET} connection is used, or a full pathname to a file, in
which case a connection to @acronym{UNIX} socket is used.
@end deffn

@deffn {Configuration} port @var{arg}
TCP port the server is listening on (for @acronym{INET}
connections).  This parameter is optional.  Its default value depends on
the type of database being used.
@end deffn

@deffn {Configuration} db @var{arg};
Name of the database.
@end deffn

@deffn {Configuration} user @var{arg}
@acronym{SQL} user name.
@end deffn
  
@deffn {Configuration} passwd @var{arg};
Password to access the database.
@end deffn

@deffn {Configuration} password-encryption @var{arg};
Defines type of encryption used by the password returned by
@code{getpass} query (see below).  Possible arguments are:

@table @asis
@item plain
Password is in plain text.

@item crypt
@itemx hash
Password is encrypted by system @code{crypt} function
(@pxref{crypt,,,crypt(3), crypt(3) man page}).

@item scrambled
Password is encrypted by MySQL @code{password} function.
@end table
@end deffn

@deffn {Configuration} getpwnam @var{query}
Defines SQL query that returns information about the given user.  The
@var{query} is subject to variable expansion (@pxref{Variables}).  The
only variable defined is @samp{$user}, which expands to the user name.

@anchor{getpw column names}
The query should return a single row with the following columns:

@table @asis
@item name
User name.
@item passwd
User password.
@item uid
UID of the user.
@item gid
GID of the primary group.
@item gecos
Textual description of the user.
@item dir
User's home directory
@item shell
User's shell program.
@end table

The following columns are optional:

@table @asis
@item mailbox
Full pathname of the user's mailbox.  If not returned or NULL, the
mailbox is determined using the default algorithm (@pxref{Mailbox}).
@item quota
Upper limit on the size of the mailbox.  The value is either an
integer number optionally followed by one of the usual size suffixes:
@samp{K}, @samp{M}, @samp{G}, or @samp{T} (case-insensitive).
@end table
@end deffn

@deffn {Configuration} getpwuid @var{query}
Defines SQL query that returns information about the given UID.  The
@var{query} is subject to variable expansion (@pxref{Variables}).  The
only variable defined is @samp{$user}, which expands to the UID.

The query should return a single row, as described for @code{getpwnam}.
@end deffn

@deffn {Configuration} getpass @var{query}
Defines SQL query that returns the password of the given user.  The
@var{query} is subject to variable expansion (@pxref{Variables}).  The
only variable defined is @samp{$user}, which expands to the user name.

The query should return a row with a single column, which gives the
password.  The password can be encrypted as specified by the
@code{password-encryption} statement.
@end deffn

@deffn {Configuration} field-map @var{list}
Defines a translation map for column names.   The @var{list} is a
list of mappings.  Each mapping is a string
@samp{@var{name}=@var{column}}, where @var{name} is one of the names
described in @ref{getpw column names}, and @var{column} is the name of
the column in the returned row that should be used instead.  The effect of
this statement is similar to that of SQL @code{AS} keyword.  E.g. the
statement

@example
field-map (uid=user_id);
@end example

@noindent
has the same effect as using @samp{SELECT user_id AS uid} in the SQL
statement.
@end deffn

@node ldap statement
@subsection The @code{ldap} Statement
@anchor{LDAP Statement}
@kwindex ldap
@subheading Syntax
@example
ldap @{
  # @r{Enable LDAP lookups.}
  enable @var{bool};
  # @r{Set URL of the LDAP server.}
  url @var{url};
  # @r{Base DN for LDAP lookups.}
  base @var{string};
  # @r{DN for accessing LDAP database.}
  binddn @var{string};
  # @r{Password for use with binddn.}
  passwd @var{string};
  # @r{Use TLS encryption.}
  tls @var{bool};
  # @r{Set LDAP debugging level.}
  debug @var{number};
  # @r{Set a field-map for parsing LDAP replies.}
  field-map @var{list};
  # @r{LDAP filter to use for getpwnam requests.}
  getpwnam @var{string};
  # @r{LDAP filter to use for getpwuid requests.}
  getpwuid @var{filter};
@}
@end example
@subheading Description
The @code{ldap} statement configures the use of LDAP for authentication.

@deffn {Configuration} enable @var{bool}
Enables LDAP lookups.  If absent, @samp{enable On} is assumed.
@end deffn

@deffn {Configuration} url @var{url}
Sets the URL of the LDAP server.
@end deffn

@deffn {Configuration} base @var{string}
Defines base DN for LDAP lookups.
@end deffn

@deffn {Configuration} binddn @var{string}
Defines the DN for accessing LDAP database.
@end deffn

@deffn {Configuration} passwd @var{string}
Password for use when binding to the database.
@end deffn

@deffn {Configuration} tls @var{bool}
Enable the use of TLS when connecting to the server.
@end deffn

@deffn {Configuration} debug @var{number}
Set LDAP debug level.  Please refer to the OpenLDAP documentation, for
allowed @var{number} values and their meaning.
@end deffn

@deffn {Configuration} field-map @var{map} 
Defines a map for parsing LDAP replies.  The @var{map} is a list
of mappings@footnote{For backward compatibility, @var{map} can be a
string containing colon-delimited list of mappings.  Such usage is,
however, deprecated.}.  Each mapping is @samp{@var{field}=@var{attr}}, where
@var{attr} is the name of the LDAP attribute and @var{field} is a
field name that declares what information that attribute carries.
Available values for @var{field} are:

@table @asis
@item name
User name.
@item passwd
User password.
@item uid
UID of the user.
@item gid
GID of the primary group.
@item gecos
Textual description of the user.
@item dir
User's home directory
@item shell
User's shell program.
@end table

The default mapping is

@example
@group
  ("name=uid",
   "passwd=userPassword",
   "uid=uidNumber",
   "gid=gidNumber",
   "gecos=gecos",
   "dir=homeDirectory",
   "shell=loginShell")
@end group
@end example
@end deffn

@deffn {Configuration} getpwnam @var{string}
Defines the LDAP filter to use for @samp{getpwnam} requests.  The
default is:

@example
  (&(objectClass=posixAccount) (uid=$user))
@end example
@end deffn

@deffn {Configuration} getpwuid @var{string}
Defines the LDAP filter to use for @samp{getpwuid} requests.  The
default filter is:

@example
  (&(objectClass=posixAccount) (uidNumber=$user))
@end example
@end deffn

@node tls statement
@subsection The @code{tls} Statement
@anchor{TLS Statement}
@kwindex tls
@subheading Syntax
@example
tls @{
  # @r{Enable TLS support.}
  enable @var{bool};
  # @r{Specify SSL certificate file.}
  ssl-cert @var{string};
  # @r{Specify SSL certificate key file.}
  ssl-key @var{file};
  # @r{Specify trusted CAs file.}
  ssl-cafile @var{file};
  # @r{Set the priorities to use on the ciphers, methods, etc.}
  ssl-priorities @var{string};
  # @r{Configure safety checks for SSL key file.}
  key-file-safety-checks @var{list};
  # @r{Configure safety checks for SSL certificate.}
  cert-file-safety-checks @var{list};
  # @r{Configure safety checks for SSL CA file.}
  ca-file-safety-checks @var{list};
@}
@end example
@subheading Description

@deffn {Configuration} enable @var{bool}
Enable TLS support.  If absent, @samp{enable On} is assumed.
@end deffn

@deffn {Configuration} ssl-cert @var{string}
Specify SSL certificate file.
@end deffn

@deffn {Configuration} ssl-key @var{file}
Specify SSL certificate key file.
@end deffn

@deffn {Configuration} ssl-cafile @var{file}
Specify the trusted certificate authorities file.
@end deffn

@deffn {Configuration} ssl-priorities @var{string}
Set the priorities to use on the ciphers, key exchange methods, MACs
and compression methods.
@end deffn

@deffn {Configuration} key-file-safety-checks @var{list}
Configure safety checks for SSL key file.  Elements of the @var{list} are
names of individual checks, optionally prefixed with @samp{+} to enable or 
@samp{-} to disable the corresponding check.  Valid check names are:

@table @asis
@item none
Disable all checks.
@item all
Enable all checks.
@item gwrfil
Forbid group writable files.
@item awrfil
Forbid world writable files.
@item grdfil
Forbid group readable files.
@item ardfil
Forbid world writable files.
@item linkwrdir
Forbid symbolic links in group or world writable directories.
@item gwrdir
Forbid files in group writable directories.
@item awrdir
Forbid files in world writable directories,
@end table
@end deffn

@deffn {Configuration} cert-file-safety-checks @var{list}
Configure safety checks for SSL certificate.  See
@code{key-file-safety-checks} for a description of @var{list}.
@end deffn

@deffn {Configuration} ca-file-safety-checks @var{list}
Configure safety checks for SSL CA file.  See
@code{key-file-safety-checks} for a description of @var{list}.
@end deffn

@node gsasl statement
@subsection The @code{gsasl} Statement
@anchor{GSASL Statement}
@WRITEME
@kwindex gsasl
@subheading Syntax
@example
gsasl @{
  # @r{Name of GSASL password file.}
  cram-passwd @var{file};
  # @r{SASL service name.}
  service @var{string};
  # @r{SASL realm name.}
  realm @var{string};
  # @r{SASL host name.}
  hostname @var{string};
  # @r{Anonymous user name.}
  anonymous-user @var{string};
@}
@end example

@c -------------------------------------------------------------------

@node debugging
@section Debugging
@command{Mailutils} debugging output is controlled by a set of levels, each of
which can be set independently of others.  Each debug level consists of
a @dfn{category name}, which identifies the part of
@command{Mailutils} for which additional debugging is desired, and a
level number, which tells @command{Mailutils} how verbose should its
output be.

Valid debug levels are:

@table @asis
@item error
Displays error conditions which are normally not reported, but passed
to the caller layers for handling.
@item trace0 through trace9
Ten levels of verbosity, @samp{trace0} producing less output,
@samp{trace9} producing the maximum amount of output.
@item prot
Displays network protocol interaction, where applicable.
@end table

Implementation and applicability of each level differs between various
categories.  The full list of categories is available in 
file @file{libmailutils/diag/debcat} in the Mailutils source tree.
Most useful categories and levels implemented for them are discussed
later in this article.

@menu
* Level Syntax::
* Level BNF::
* Debugging Categories::
@end menu

@node Level Syntax
@subsection Level Syntax

Debug levels can be set either from the command line, by using the
@option{--debug-level} command line option, or from the configuration
file, using the @samp{.debug.level} statement.  In both cases, the
level is specified as a list of individual levels, delimited with
semicolons.  Each individual level can be specified as:

@table @asis
@item !@var{category}
Disables all levels for the specified @var{category}.
@item @var{category}
Enables all levels for the specified @var{category}.
@item @var{category}.@var{level}
For the given @var{category}, enables all levels from @samp{error} to
@var{level}, inclusive.
@item @var{category}.=@var{level}
Enables only the given @var{level} for this @var{category}.
@item @var{category}.!@var{level}
Disables all levels from @samp{error} to @var{level}, inclusive, for
this @var{category}.
@item @var{category}.!=@var{level}
Disables only the given @var{level} in this @var{category}.
@item @var{category}.@var{levelA}-@var{levelB}
Enables all levels in the range from @var{levelA} to @var{levelB}, inclusive.
@item @var{category}.!@var{levelA}-@var{levelB}
Disables all levels in the range from @var{levelA} to @var{levelB}, inclusive.
@end table

Additionally, a comma-separated list of level specifications is
allowed after the dot.  For example, the following specification:

@example
acl.prot,!=trace9,!trace2
@end example

enables in category @samp{acl} all levels, except @samp{trace9},
@samp{trace0}, @samp{trace1}, and @samp{trace2}.

@node Level BNF
@subsection BNF

The following specification in Backus-Naur form describes formally the
Mailutils debug level:

@example
<debug-spec> ::= <level-spec> | <debug-level-list>
<debug-level-list> ::= <debug-level> |
                       <debug-level-list> ";" <debug-level>
<debug-level> ::= <category> | "!" <category> |
                  <category> "." <level-list>
<level-list> ::= <level-spec> | <level-list> "," <level-spec>
<level-spec> ::=  <level> | <negate-level>
<negate-level> ::= "!" <level>
<level> ::= <level-number> | "=" <level-number> |
            <level-number> "-" <level-number>
<level-number> ::= "error" | "trace0" | "trace1" | "trace2" | "trace3" |
                   "trace4" | "trace5" | "trace6" | "trace7" |
                   "trace8" | "trace9" | "prot"
@end example

@node Debugging Categories
@subsection Debugging Categories

@table @asis
@item acl
This category enables debugging of Access Control Lists.  Available
levels are:

@table @asis
@item error
As usual, displays errors, not directly reported otherwise.
@item trace0
Basic tracing of ACL processing.
@item trace9
Traces the process of matching the ACL conditions.
@end table

@item config
This category affects configuration parser and/or lexical
analyzer.  The following levels are supported:

@table @asis
@item trace0
Minimal information about configuration statements.
@item trace2
Trace lexical structure of the configuration files.
@item trace7
Trace execution of the configuration parser.
@end table

Due to its specific nature, this category cannot be enabled from the
configuration file.  A special hook is provided to facilitate
debugging the configuration parser, namely, a pragmatic comment in
form: 

@example
#debug=@var{debug-level-list}
@end example

causes @var{debug-level-list} to be parsed as described above.  Thus, to
force debugging of the configuration parser, one would add the following
line at the very beginning of the configuration file: 

@example
#debug=config.trace7
@end example

@item mailbox
Operations over mailboxes.  This module supports the following levels:
@samp{error}, @samp{trace0}, @samp{trace1}, and @samp{prot}.  The
latter is used by remote mailbox support libraries.

@item auth
Enables debugging information about authentication and authorization.
This category supports the following levels: @samp{error},
@samp{trace0}, @samp{trace1}, and @samp{trace2}. 

In level @samp{trace0}, user data are reported along with the
@dfn{data source} they were obtained from.  The output may look like this:

@example
pop3d: source=system, name=gray, passwd=x, uid=120, gid=100,
gecos=Sergey Poznyakoff, dir=/home/gray, shell=/bin/bash,
mailbox=/var/mail/gray, quota=0, change_uid=1
@end example

In the @samp{trace1} level, additional flow traces are displayed.

In the level @samp{trace2}, a detailed flow trace is displayed, which
looks like the following:

@example
pop3d: Trying generic...
pop3d: generic yields 38=Function not implemented
pop3d: Trying system...
pop3d: system yields 0=Success
pop3d: Trying generic...
pop3d: generic yields 4135=Authentication failed
pop3d: Trying system...
pop3d: system yields 0=Success
@end example

@item mailer
Debugs mailer operations.  The following levels are supported: 

@table @asis
@item error
Displays mild error conditions.
@item trace0
Traces mailer operations in general: displays what part of the message
is being sent, etc.
@item trace6
When used together with @samp{prot}, displays security-sensitive
information (such as passwords, user keys, etc). in plaintext.  By
default, such information is replaced with asterisks to reduce the
possibility of security compromise.
@item trace7
When used together with @samp{prot}, displays the @dfn{payload}
information as it is being sent.  The @dfn{payload} is the actual
message contents, i.e. the part of SMTP transaction that goes after
the @samp{DATA} command and which ends with a terminating dot line.
Setting this level can generate huge amounts of information. 
@item prot
For SMTP mailer: outputs transcripts of SMTP sessions.
@end table

@emph{Note:} Unless in a very secure environment, it is advised to
avoid using level settings such as mailer.prot or mailer (without
explicit level part), because the resulting output tends to be
extremely copious and reveals sender private and security-sensitive
data.  If you wish to trace SMTP session flow, use @samp{mailer.=prot}
or at least @samp{mailer.prot,!trace6}. 

@item serve
This category provides debugging information for Mailutils IP
server objects.  It supports the @samp{error} and @samp{trace0} levels. 

@item folder
This category controls debugging information shown for operations
related to Mailutils folders. 

@item remote
The remote category is used by @command{imap4d} and @command{pop3d}
servers to request showing additional information in the session
transcripts.  This category takes effect only when the @code{transcript}
configuration variable is set.  Valid levels are:

@table @asis
@item trace6
Show security-sensitive information (user passwords, etc.)
@item trace7
Show payload information
@end table
@end table

@node frm and from
@section @command{frm} and @command{from} --- List Headers from a Mailbox
@UNREVISED

GNU mailutils provides two commands for listing messages in a mailbox.
These are @command{from} and @command{frm}.

The behavior of both programs is affected by the following
configuration file statements:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug   @tab @xref{debug statement}.
@item tls     @tab @xref{tls statement}.
@item mailbox @tab @xref{mailbox statement}.
@item locking @tab @xref{locking statement}.
@end multitable

@subheading @command{frm}
@pindex frm

The @command{frm} utility outputs a header information of
the selected messages in a mailbox.  By default, @command{frm} reads 
user's system mailbox and outputs the contents of @code{From} and
@code{Subject} headers for each message.  If a folder is specified in
the command line, the program reads that folder rather than the default
mailbox.

The following command line options alter the behavior of the program:

@table @option
@item -d
@itemx --debug
Enable debugging output.
@item -f @var{string}
@itemx --field @var{string}
Display the header named by @var{string} instead of @code{From}
@code{Subject} pair.
@item -l
@itemx --to
Include the contents of @code{To} header to the output.  The output field
order is then: @code{To} @code{From} @code{Subject}.
@item -n
@itemx --number
Prefix each line with corresponding message number.
@item -Q
@itemx --Quiet
Be very quiet.  Nothing is output except error messages.  This is useful
in shell scripts where only the return status of the program is
important.
@item -q
@itemx --query
Print a message only if there are unread messages in the mailbox.
@item -S
@itemx --summary
Print a summary line.
@item -s @var{attr}
@itemx --status @var{attr}
Only display headers from messages with the given status.
@var{Attr} may be one of the following: @samp{new}, @samp{read},
@samp{unread}.  It is sufficient to specify only first letter of
an @var{attr}.  Multiple @option{-s} options are allowed.
@item -t
@itemx --align
Tidy mode.  In this mode @command{frm} tries to preserve the alignment of
the output fields.  It also enables the use of BIDI algorithm for
displaying subject lines that contain text in right-to-left
orientation (such as Arabic or Hebrew).
@end table

@subheading @command{from}
@pindex from

The @command{from} utility displays sender and subject of each message
in a mailbox.  By default, it reads the user's system mailbox.  If the
program is given a single argument, it is interpreted as a name of the
user whose mailbox is to be read.  Obviously, permissions are required
to access that user's mailbox, so such invocations may be used only
by superuser.

The option @option{-f} (@option{--file}) instructs @command{from} to read
the given mailbox.

The full list of options, supported by @command{from} follows:

@table @option
@item -c
@itemx --count
Prints only a count of messages in the mailbox and exit.

@item -d
@itemx --debug
Prints additional debugging output.

@item -s @var{string}
@itemx --sender=@var{string}
Prints only mail whose @samp{From:} headers contain the supplied string.
@FIXME{Probably, this should test envelopes as well.}

@item -f @var{url}
@itemx --file=@var{url}
Examine mailbox from the given @var{url}.
@end table

@page
@node mail
@section @command{mail} --- Send and Receive Mail
@pindex mail
@UNREVISED

@command{Mail} is an enhanced version of standard @command{/bin/mail} program.
As well as its predecessor, it can be used either in sending mode or
in reading mode.  @command{Mail} enters sending mode when one or more
email addresses were specified in this command line.  In this mode the
program waits until user finishes composing the message, then attempts
to send it to the specified addresses and exits.
See @ref{Composing Mail}, for a detailed description of this behavior.

If the command line contained no email addresses, @command{mail} switches
to reading mode.  In this mode it allows to read and manipulate the
contents of the user system mailbox.  The @option{--file} (@option{-f})
command line option allows to specify another mailbox name.  For more
detail, see @ref{Reading Mail}.

In addition to the Mailutils configuration file, @command{mail} loads
the traditional @samp{mailrc}-style configuration files.  @xref{Mail
Configuration Files}, for a detailed description of their format.

@menu
* Invoking Mail::            Command Line Options.
* Specifying Messages::      How to Specify Message Sets.
* Composing Mail::           Composing Mail.
* Attachments::              Attaching Files.
* Reading Mail::             Reading Mail.
* Scripting::                Scripting.
* Mail Variables::           How to Alter the Behavior of @command{mail}.
* Mail Configuration Files:: Personal and System-wide Configuration Files.
@end menu

@node Invoking Mail
@subsection Invoking @command{mail}

General usage of @command{mail} program is:

@example
      mail [@var{option}...] [@var{address}...]
@end example
@noindent
If [@var{address}...] part is present, @command{mail} switches to
mail sending mode, otherwise it operates in mail reading mode.

@command{Mail} understands the following command line options:

@table @option
@item -A @var{file}
@itemx --attach=@var{file}
Attach @var{file} to the composed message.  The encoding, content
type, and content description are controlled by the
@option{--encoding}, @option{--content-type}, and
@option{--content-name} options, correspondingly.

The option @option{--attach=-} instructs @command{mail} to read the
file to be attached from the standard input.  Interactive shell is
disabled in this case.

@item --attach-fd=@var{fd}
Read attachment body from the file descriptor @var{fd}.  The
descriptor must be open for reading.  This option is useful when
calling @command{mail} from another program.

See the options @option{--encoding}, @option{--content-type}, 
@option{--content-name}, and @option{--content-filename}.

@item -a @var{header}:@var{value}
@itemx --append=@var{header}:@var{value}
Append the given header to the composed message.

@item --content-type=@var{type}
This options sets the content type to be used by all subsequent
@option{--attach} options.

@item --content-filename=@var{name}
Set the @samp{filename} parameter in the @samp{Content-Disposition}
header for the next @option{--attach-fd} option.

@item --content-name=@var{text}
Set the @samp{name} parameter (description) in the @samp{Content-Type}
header for the next @option{--attach} or @option{--attach-fd} option.

@item -E @var{command}
@itemx --exec=@var{command}
Execute @var{command} before opening the mailbox.  Any number of
@option{--exec} options can be given.  The commands will be executed
after sourcing configuration files (@pxref{Mail Configuration Files}),
but before opening the mailbox. 

@item -e
@itemx --exist
Return true if the mailbox contains some messages.  Return false
otherwise.

This is useful for writing shell scripts.

@item --encoding=@var{enc}
Sets content transfer encoding for use by the subsequent
@option{--attach} options.

@item -F
@itemx --byname
Record outgoing messages in a file named after the first recipient.
The name is the login-name portion of the address found first on the
@samp{To:} line in the mail header.  This option sets the @samp{byname}
variable, which see (@pxref{byname}).

@item -f
@itemx --file
Operate on the mailbox given by the first non-optional command line
argument.  If there is no such argument, read messages from the
user's @file{mbox} file.  @xref{Reading Mail}, for more details about
using this option.

@item -H
@itemx --headers
Print header summary to stdout and exit.

@item -i
@itemx --ignore
Ignore interrupts when composing the message.

@item -N
@itemx --nosum
Do not display initial header summary.

@item -n
@itemx --norc
Do not read the system-wide mailrc file.  @xref{Mail Configuration
Files}.

@item -p
@itemx --print
@itemx --read
Print all mail to standard output.  It is equivalent to issuing following
commands after starting @samp{mail -N}:
@example
@group
print *
quit
@end group
@end example
@noindent
except that @command{mail --print} does not change status of the messages.

@item -q
@itemx --quit
Cause interrupts to terminate program.

@item -r @var{address}
@itemx --return-address=@var{address}
Sets the return email address for outgoing mail.
@xref{return-address}.

@item -s @var{subj}
@itemx --subject=@var{subj}
Send a message with a Subject of @var{subj}.  Valid only in sending
mode.

@item -t
@itemx --to
Read recipients from the message header.  Ignore addresses listed in
the command line.

@item -u @var{user}
@itemx --user=@var{user}
Operate on @var{user}'s mailbox.  This is equivalent to:

@example
mail -f/@var{spool_path}/@var{user}
@end example

@noindent
with @var{spool_path} being the full path to your mailspool directory
@*(@file{/var/spool/mail} or @file{/var/mail} on most systems).
@end table

The program also understands the common mailutils options
(@pxref{Common Options}. 

@node Specifying Messages
@subsection How to Specify Message Sets

Many mail commands such as print and delete can be given a @dfn{message list}
to operate upon.  Wherever the message list is omitted, the command
operates on the current message.

The @dfn{message list} in its simplest form is one of:

@table @asis
@item .
Selects current message.  It is equivalent to empty message list.
@item *
Selects all messages in the mailbox.
@item ^
Selects first non-deleted message.
@item $
Selects last non-deleted message.
@end table

In its complex form, the @dfn{message list} is a comma or whitespace-separated
list of @dfn{message specifiers}.  A @dfn{message specifier} is one
of

@table @asis
@item Message Number
This specifier addresses the message with the given ordinal number
in the mailbox.
@item Message range
@dfn{Message range} is specified as two message numbers separated by
a dash.  It selects all messages with the number lying within that range.
@item Attribute specifier
An @dfn{Attribute specifier} is a colon followed by a single
letter.  The @dfn{Attribute specifier} addresses all messages in the
mailbox that have the given attribute.  These are the valid attribute
specifiers:

@table @samp
@item :d
Selects all deleted messages.
@item :n
Selects all recent messages, i.e. the messages that have not been
neither read not seen so far.
@item :o
Selects all messages that have been seen.
@item :r
Selects all messages that have been read.
@item :u
Selects all messages that have @emph{not} been read.
@item :t
Selects all tagged messages.
@item :T
Selects all untagged messages.
@end table
@item Header match
The @dfn{header match} is a string in the form:

@example
[@var{header}:]/@var{string}/
@end example
@noindent

It selects all messages that contain header field @var{header}
matching given @var{regexp}.  If the variable @code{regexp} is set,
the @var{string} is assumed to be a POSIX regexp.  Otherwise, a
header is considered to match @var{string} if the latter constitutes
a substring of the former (comparison is case-insensitive).

If @var{header}: part is omitted, it is assumed to be @samp{Subject:}.
@item Message body match
The @dfn{message body match} is a string in the form:

@example
:/@var{string}/
@end example
@noindent

It selects all messages whose body matches the string.  The matching
rules are the same as described under ``Header match''.
@end table

A @dfn{message specifier} can be followed by @dfn{message part
specifier}, enclosed in a pair of brackets.  A @dfn{message part
specifier} controls which part of a message should be operated upon.
It is meaningful only for multipart messages.  A @dfn{message part
specifier} is a comma or whitespace - separated list of part numbers
or ranges.  Each part number can in turn be @dfn{message part specifier},
thus allowing for operating upon multiply-encoded messages.

The following are the examples of valid message lists:

@node Composing Mail
@subsection Composing Mail

You can compose the message by simply typing the contents of it, line
by line.  But usually this is not enough, you would need to edit
your text, to quote some messages, etc.  @command{Mail} provides these
capabilities through @dfn{compose escapes}.  The @dfn{compose escapes}
are single-character commands, preceded by special @dfn{escape character},
which defaults to @samp{~}.  The combination @code{escape character + command}
is recognized as a compose escape only if it occurs at the beginning of
a line.  If the escape character must appear at the beginning of a
line, enter it twice.
The actual escape character may be changed by setting the value of
@code{escape} mail variable (@pxref{Mail Variables}).

@menu
* Quitting Compose Mode::
* Getting Help on Compose Escapes::
* Editing the Message::
* Modifying the Headers::
* Enclosing Another Message::
* Adding a File to the Message::
* Attaching a File to the Message::
* Printing And Saving the Message::
* Signing the Message::
* Printing Another Message::
* Inserting Value of a Mail Variable::
* Executing Other Mail Commands::
* Executing Shell Commands::
@end menu

@node Quitting Compose Mode
@subsubsection Quitting Compose Mode
@kyindex ~., mail escape
@kyindex ~x, mail escape

There are several commands allowing you to quit the compose mode.

Typing the end-of-file character (@samp{C-D}) on a line alone finishes
compose mode and sends the message to its destination.  The @samp{C-D}
character looses its special meaning if @code{ignoreeof} mail variable
is set.

If mail variable @code{dot} is set, typing dot (@samp{.}) on a line
alone achieves the same effect as @samp{C-D} above.

Finally, using @samp{~.} escape always quits compose mode and sends
out the composed message.

To abort composing of a message without sending it, type interrupt
character (by default, @samp{C-C}) twice.  This behavior is disabled
when mail variable @code{ignore} is set.  In this case, you can use
@samp{~x} escape to achieve the same effect.

@node Getting Help on Compose Escapes
@subsubsection Getting Help on Compose Escapes: ~?
@kyindex ~?, mail escape

The @samp{~?} escape prints on screen a brief summary of the available
compose escapes.  @emph{Please note}, that @samp{~h} escape prompts
for changing the header values, and does @emph{not} give help.

@node Editing the Message
@subsubsection Editing the Message: ~e and ~v
@kyindex ~e, mail escape
@kyindex ~v, mail escape

If you are not satisfied with the message as it is, you can edit it
using a text editor specified either by @code{EDITOR} or by
@code{VISUAL} environment variables.  The @samp{~e} uses the former,
and @samp{~v} uses the latter.

By default both escapes allow you to edit only the body of the
message.  However, if the @code{editheaders} variable is set,
@command{mail} will load into the editor the complete text of
the message with headers included, thus allowing you to change
the headers as well.

@node Modifying the Headers
@subsubsection Modifying the Headers: ~h, ~t, ~c, ~b, ~s

@cindex ~t, mail escape
To add new addresses to the list of message recipients, use @samp{~t}
command, e.g.:

@example
~t name1@@domain.net name2
@end example

@cindex ~c, mail escape
@cindex ~b, mail escape
To add addresses to @code{Cc} or @code{Bcc}, use @samp{~c} or @samp{~b}
escapes respectively.

@cindex ~s, mail escape
To change the @code{Subject} header, use @samp{~s} escape, e.g.:

@example
~s "Re: your message"
@end example

@cindex ~h, mail escape
Finally, to edit all headers, type @samp{~h} escape.  This will present
you with the values of @code{To}, @code{Cc}, @code{Bcc}, and
@code{Subject} headers allowing to edit them with normal text editing
commands.

@node Enclosing Another Message
@subsubsection Enclosing Another Message: ~m and ~M
@kyindex ~m, mail escape
@kyindex ~M, mail escape

If you are sending mail from within mail command mode, you can enclose
the contents of any message sent to you by using @samp{~m} or @samp{~M}
commands.  Typing @samp{~m} alone will enclose the contents of the
current message, typing @samp{~m 12} will enclose the contents of
message #12 and so on.

The @samp{~m} uses retained and ignored lists when enclosing headers,
the @samp{~M} encloses all header fields.

In both cases, the contents of @code{indentprefix} mail variable is
prepended to each line enclosed.

@node Adding a File to the Message
@subsubsection Adding a File to the Message: ~r and ~d

@cindex ~r, mail escape
@cindex ~<, mail escape
To append the contents of file @var{filename} to the message, type

@example
~r @var{filename}
@end example
@noindent
or

@example
~< @var{filename}
@end example
@noindent

@cindex ~d, mail escape
The @samp{~d} escape is a shorthand for

@example
~r dead.letter
@end example

@node Attaching a File to the Message
@subsubsection Attaching a File to the Message
@cindex ~+, mail escape
The @samp{~+} escape attaches a file to the message.  It takes one to
three arguments.  The first argument supplies the name of the file to
attach:

@example
~+ myfile.txt
@end example

The file will be attached with default content-type
@samp{application/octet-stream}, and encoding @samp{base64}
(these can be altered by the @option{--content-type} and
@option{--encoding} command line options, correspondingly).

Optional second argument defines the content type to be used instead
of the default one.  Optional third argument defines the encoding,
e.g.:

@example
~+ myfile.html text/html base64
@end example

@cindex ~l, mail escape
To list the files attached so far, use the @samp{~l} escape:

@example
~l
   1 myfile.html text/html base64
@end example

Each line of the listing contains the ordinal number of the attachment,
the name of the file, content-type and transfer encoding used.

@cindex ~^, mail escape
The @samp{~^} escape removes attachments.  Its argument is the number
of the attachment to remove, e.g.:

@example
~^ 1
@end example

@node Printing And Saving the Message
@subsubsection Printing And Saving the Message
@kyindex ~p, mail escape
@kyindex ~w, mail escape

The @samp{~p} escape types the contents of the message entered so far,
including headers, on your terminal.  You can save the message to
an arbitrary file using @samp{~w} escape.  It takes the filename as its
argument.

@node Signing the Message
@subsubsection Signing the Message: ~a and ~A
@kyindex ~a, mail escape
@kyindex ~A, mail escape

To save you the effort of typing your signature at the end of each
message, you can use @samp{~a} or @samp{~A} escapes.  If your signature
occupies one line only, save it to the variable @code{sign} and use
@samp{~a} escape to insert it.  Otherwise, if it is longer than one
line, save it to a file, store the name of this file in the
variable @code{Sign}, and use @samp{~A} escape to insert it into
the message.

@node Printing Another Message
@subsubsection Printing Another Message: ~f and ~F
@kyindex ~f, mail escape
@kyindex ~F, mail escape

Sometimes it is necessary to view the contents of another message,
while composing.  These two escapes allow it.  Both take the message
list as their argument.  If they are used without argument, the
contents of the current message is printed.  The difference between
@samp{~f} and @samp{~F} is that the former uses ignored and retained
lists to select headers to be displayed, whereas the latter prints
all headers.

@node Inserting Value of a Mail Variable
@subsubsection Inserting Value of a Mail Variable: ~i
@kyindex ~i, mail escape

The @samp{~i} escape enters the value of the named mail variable into
the body of the message being composed.

@node Executing Other Mail Commands
@subsubsection Executing Other Mail Commands: ~: and ~-
@kyindex ~:, mail escape
@kyindex ~-, mail escape

You can execute a mail command from within compose mode using @samp{~:}
or @samp{~-} escapes.  For example, typing

@example
~: from :t
@end example
@noindent

will display the from lines of all tagged messages.  Note, that executing
mail-sending commands from within the compose mode is not allowed.
An attempt to execute such a command will result in diagnostic message
``Command not allowed in an escape sequence'' being displayed.
Also, when starting compose mode immediately from the shell
(e.g. running @samp{mail address@@domain}), most mail commands are
meaningless, since there is no mailbox to operate upon.  In this case,
the only commands that can reasonably be used are: @code{alias},
@code{unalias}, @code{alternate}, @code{set}, and @code{unset}.

@node Executing Shell Commands
@subsubsection Executing Shell Commands: ~! and ~|
@kyindex ~!, mail escape
@kyindex ~|, mail escape

The @samp{~!} escape executes specified command and returns you to
@command{mail} compose mode without altering your message.  When used without
arguments, it starts your login shell.  The @samp{~|} escape pipes the
message composed so far through the given shell command and replaces the
message with the output the command produced.  If the command produced
no output, @command{mail} assumes that something went wrong and retains
the old contents of your message.

@c *********************************************************************

@node Attachments
@subsection Sending Attachments

The simplest way to attach a file from command line is by using the
@option{--attach} (@option{-A}) option.  Its argument specifies the
file to attach.  For example, the following will attach the content
of the file @file{archive.tar}:

@example
$ mail --attach=archive.tar
@end example

By default, the content type will be set to
@samp{application/octet-stream}, and the attachment will be encoded
using the @samp{base64} encoding.  To change the content type, use the
@option{--content-type} option.  For example, to send an HTML
attachment:

@example
$ mail --content-type=text/html --attach=in.html
@end example

The @option{--content-type} option affects all @option{--attach}
options that follow it.  To change the content type, simply add
another @option{--content-type} option.  For example, to send both
the HTML file and the archive:

@example
$ mail --content-type=text/html --attach=in.html \
       --content-type=application/x-tar --attach=archive.tar
@end example

Similarly, the encoding to use is set up by the @option{--encoding}
option.  As well as @option{--content-type}, this option affects all
attachments supplied after it in the command line, until changed by
the eventual next appearance of the same option.  Extending the above
example:

@example
$ mail --content-type=text/html --encoding=quoted-printable \
       --attach=in.html \
       --content-type=application/x-tar --encoding=base64 \
       --attach=archive.tar
@end example

Each attachment can also be assigned a @dfn{description} and a
@dfn{file name}.  Normally, these are the same as the file name
supplied with the @option{--attach} option.  However, you can change
either or both of them using the @option{--content-name} and
@option{--content-filename}, correspondingly.  Both of these options
affect only the next @option{--attach} (or @option{--attach-fd}, see
below) option.

All the examples above will enter the usual interactive shell,
allowing you to compose the body of the message.  If that's not
needed, the non-interactive use can be forced by redirecting
@file{/dev/null} to the standard input, e.g.:

@example
$ mail --attach=archive.tar < /dev/null
@end example

This will normally produce a message saying:

@example
mail: Null message body; hope that's ok
@end example

To suppress this message, unset the @samp{nullbodymsg} variable,
as shown in the example below:

@example
$ mail -E 'set nonullbodymsg' --attach=archive.tar < /dev/null
@end example

The option @option{--attach=-} forces @command{mail} to read the file
to be attached from the standard input stream.  This option disables
the interactive mode and sets @samp{nonullbodymsg} implicitly, so that
the above example can be rewritten as:

@example
$ mail --attach=- < archive.tar
@end example

Special option is provided to facilitate the use of @command{mail}
in scripts.  The @option{--attach-fd=@var{N}} instructs the program to
read the data to be attached from the file descriptor @var{N}.  The
above example is equivalent to:

@example
$ mail --attach-fd=0 < archive.tar
@end example

Attachments created with this option have neither filename nor 
description set, so normally the use of @option{--content-name} and/or
@option{--content-filename} is advised.

The following Perl program serves as an example of using
@command{mail} from a script to construct a MIME message on the fly.
It scans all mounted file systems for executable files that have
setuid or setgid bits set and reports the names of those files in
separate attachments.  Each attachment is named after the mountpoint
it describes.

The script begins with the usual prologue stating the modules that
will be used:

@example
#!/usr/bin/perl

use strict;
use autodie;
@end example

Then global variables are declared.  The @samp{@@rcpt} array contains
the email addresses of the recipients:

@example
my @@rcpt= 'root@@example.com';
@end example

The @samp{@@cmd} variable holds the @command{mail} command line.  It
will be augmented for each file system.  The initial value is set as
follows:

@example
my @@cmd = ('mail',
           '-E set nonullbodymsg',
           '--content-type=text/plain');
@end example

The @command{find} utility will be used to locate the files.  The
script will start as many instances as there are mountpoints.  Those
instances will be run in parallel and their standard output streams
will be connected to file descriptors passed to @command{mail}
invocation in @option{--attach-fd} options.

The descriptors will be held in @samp{@@fds} array.  This will prevent
them from being wiped out by the garbage collector.  Furthermore, care
should be taken to ensure that the @code{O_CLOEXEC} flag be not set
for these descriptors.  This sample script takes a simplistic approach:
it instructs Perl not to close first 255 descriptors when executing
another programs:

@example
my @@fds;
$^F = 255;
@end example

The following code obtains the list of mount points:

@example
open(my $in, '-|', 'mount -t nonfs,noproc,nosysfs,notmpfs');
while (<$in>) @{
    chomp;
    if (/^\S+ on (?<mpoint>.+) type (?<fstype>.+) /) @{
@end example

For each mountpoint, the @command{find} command line is constructed
and launched.  The file descriptor is pushed to the @samp{@@fds} array
to prevent it from being collected by the garbage collector:

@example
	open(my $fd, '-|',
	     "find $+@{mpoint@} -xdev -type f"
             . " \\( -perm -u+x -o -perm -g+x -o -perm -o+x \\)"
             . " \\( -perm -u+s -o -perm -g+s \\) -print");
	push @@fds, $fd;
@end example

Now, the @command{mail} command is instructed to create next
attachment from that file descriptor:

@example
        my $mpname = $+@{mpoint@};
        $mpname =~ tr@{/@}@{%@}; 
        push @@cmd,
             "--content-name=Set[ug]id files on $+@{mpoint@} (type $+@{fstype@})",
             "--content-filename=$mpname.list",
             '--attach-fd=' . fileno($fd);
    @}
@}
close $in;
@end example

Finally, the emails of the recipients are added to the command line,
the standard input is closed to make sure @command{mail} won't enter
the interactive mode and the constructed command is executed:

@example
push @@cmd, @@rcpt;
close STDIN;
system(@@cmd);
@end example


@c *********************************************************************

@node Reading Mail
@subsection Reading Mail

To read messages from a given mailbox, use one of the following ways of
invoking @command{mail}:

@table @code
@item mail
To read messages from your system mailbox.
@item mail -f
@itemx mail --file
To read messages from your mailbox (@file{$HOME/mbox}).  If the
@option{--user} option (see below) is also given, read messages
from that user's @file{mbox}.
@item mail -f @var{path_to_mailbox}
@itemx mail --file @var{path_to_mailbox}
To read messages from the specified mailbox.
@item mail -u @var{user}
@itemx mail --user=@var{user}
To read messages from the system mailbox belonging to @var{user}.
@end table

@emph{Please note}, that usual mailbox permissions won't allow you
to use the last variant of invocation, unless you are a super-user.
Similarly, the last but one variant is also greatly affected by the
permissions the target mailbox has.

Notice that @var{path_to_mailbox} is not an argument to
@option{--file} (@option{-f}) option, but rather the first
non-optional argument on the command line.  Therefore, the
following three invocations are equivalent:

@example
$ mail -fin mymbox
$ mail -f mymbox -in
$ mail --file -in mymbox
$ mail --file -i mymbox -n
@end example

Additionally, for conformance to the GNU standards, the
following form is also accepted:

@example
$ mail --file=mymbox -i -n
@end example

Unless you have started mail with @option{--norc} command line option,
it will read the contents of the system-wide configuration file.
Then it reads the contents of user configuration file, if any.
For detailed description of these files, see @ref{Mail Configuration Files}.
After this initial setup, @command{mail} displays the first page of header
lines and enters interactive mode.  In interactive mode, @command{mail}
displays its prompt (@samp{?}, if not set otherwise) and executes the
commands the user enters.

@menu
* Quitting the Program::
* Obtaining Online Help::
* Moving Within a Mailbox::
* Changing mailbox/directory::
* Controlling Header Display::
* Displaying Information::
* Displaying Messages::
* Marking Messages::
* Disposing of Messages::
* Saving Messages::
* Editing Messages::
* Aliasing::
* Replying::
* Controlling Sender Fields::
* Incorporating New Mail::
* Shell Escapes::
@end menu

@c **********************************
@node Quitting the Program
@subsubsection Quitting the Program

Following commands quit the program:

@table @samp
@item quit
Terminates the session.  If @command{mail} was operating upon user's system
mailbox, then all undeleted and unsaved messages that have been read and
are not marked with hold flag are saved to the user's mbox file
(@file{$HOME/mbox}).  The messages, marked with @code{delete} are removed.
The program exits to the Shell, unless saving the mailbox fails, in
which case user can escape with the exit command.

@item exit
@itemx ex
@itemx xit
Program exits to the Shell without modifying the mailbox it operates
upon.
@end table

Typing EOF (@samp{C-D}) alone is equivalent to @samp{quit}.

@node Obtaining Online Help
@subsubsection Obtaining Online Help
@kyindex help, mail command
@kyindex ?, mail command
@kyindex list, mail command
@kyindex version, mail command
@kyindex warranty, mail command

Following commands can be used during the session to request online
help:

@table @samp
@item help [@var{command}]
@itemx hel [@var{command}]
@itemx ? [@var{command}]
Display detailed command synopsis.  If no @var{command} is given, help for
all available commands is displayed.
@item list
@itemx *
Print a list of available commands.
@item version
@itemx ve
Display program version.
@item warranty
@itemx wa
Display program warranty statement.
@end table

@node Moving Within a Mailbox
@subsubsection Moving Within a Mailbox
@kyindex next, mail command
@kyindex prev, mail command

@table @samp
@item ^
Move to the first undeleted message.
@item $
Move to the last undeleted message.
@item next
@itemx n
Move to the next message.
@item previous
@itemx prev
Move to the previous message.
@end table

@node Changing mailbox/directory
@subsubsection Changing Mailbox/Directory
@kyindex chdir, mail command
@kyindex file, mail command
@kyindex folder, mail command

@table @samp
@item cd [@var{dir}]
@itemx chdir [@var{dir}]
@itemx ch [@var{dir}]
Change to the specified directory.  If @var{dir} is omitted, @env{$HOME} is
assumed.
@item file [@var{mailbox}]
@itemx fi [@var{mailbox}]
@itemx folder [@var{mailbox}]
@itemx fold [@var{mailbox}]
Read in the contents of the specified @var{mailbox}.  The current mailbox
is updated as if @code{quit} command has been issued.
If @var{mailbox} is omitted, the command prints the current mailbox
name followed by the summary information regarding it, e.g.:

@example
@cartouche
& fold
"/var/spool/mail/gray": 23 messages 22 unread
@end cartouche
@end example
@end table

@node Controlling Header Display
@subsubsection Controlling Header Display
@kyindex discard, mail command
@kyindex ignore, mail command
@kyindex retain, mail command

To control which headers in the message should be displayed, @command{mail}
keeps two lists: a @dfn{retained} header list and an @dfn{ignored}
header list.  If @dfn{retained} header list is not empty, only the
header fields listed in it are displayed when printing the message.
Otherwise, if @dfn{ignored} header list is not empty, only the headers
@emph{not listed} in this list are displayed.  The uppercase variants
of message-displaying commands can be used to print all the headers.

The following commands modify and display the contents of both lists.

@table @samp
@item discard [@var{header-field-list}]
@itemx di [@var{header-field-list}]
@itemx ignore [@var{header-field-list}]
@itemx ig [@var{header-field-list}]
Add @var{header-field-list} to the ignored list.  When used without
arguments, this command prints the contents of ignored list.
@item retain [@var{header-field-list}]
@itemx ret [@var{header-field-list}]
Add @var{header-field-list} to the retained list.  When used without
arguments, this command prints the contents of retained list.
@end table

@node Displaying Information
@subsubsection Displaying Information
@kyindex =, mail command
@kyindex headers, mail command
@kyindex from, mail command
@kyindex z, mail command
@kyindex size, mail command
@kyindex folders, mail command
@kyindex summary, mail command

@table @samp
@item =
Displays the current message number.
@item headers [@var{msglist}]
@itemx h [@var{msglist}]
Lists the current pageful of headers.
@item from [@var{msglist}]
@itemx f [@var{msglist}]
Lists the contents of @samp{From} headers for a given set of messages.
@item z [@var{arg}]
Presents message headers in pagefuls as described for @code{headers}
command.  When @var{arg} is @samp{.}, it is generally equivalent to
@code{headers}.  When @var{arg} is omitted or is @samp{+}, the next
pageful of headers is displayed.  If @var{arg} is @samp{-}, the
previous pageful of headers is displayed.  The latter two forms
of @code{z} command may also take a numerical argument meaning the
number of pages to skip before displaying the headers.  For
example:

@example
& z +2
@end example
@noindent
will skip two pages of messages before displaying the header summary.
@item size [@var{msglist}]
@itemx si [@var{msglist}]
Lists the message number and message size in bytes for each message in
@var{msglist}.
@item folders
Displays the value of @code{folder} variable.
@item summary
@itemx su
Displays current mailbox summary.  E.g.:

@example
@cartouche
& summary
"/var/spool/mail/gray": 23 messages 22 unread
@end cartouche
@end example
@end table

@node Displaying Messages
@subsubsection Displaying Messages
@kyindex print, mail command
@kyindex type, mail command
@kyindex Print, mail command
@kyindex Type, mail command
@kyindex decode, mail command
@kyindex struct, mail command
@kyindex top, mail command
@kyindex pipe, mail command
@kyindex |, mail command

@table @samp
@item print [@var{msglist}]
@itemx p [@var{msglist}]
@item type [@var{msglist}]
@itemx t [@var{msglist}]
Prints out the messages from @var{msglist}.  The variable @code{crt}
determines the minimum number of lines the body of the message must
contain in order to be piped through pager command specified
by environment variable @code{PAGER}.  If @code{crt} is set to a numeric
value, this value is taken as the minimum number of lines.  Otherwise,
if @code{crt} is set without a value then the height of the terminal
 screen is used to compute the threshold.  The number of lines on
screen is controlled by @code{screen} variable.
@item Print [@var{msglist}]
@itemx P [@var{msglist}]
@itemx Type [@var{msglist}]
@itemx T [@var{msglist}]
Like print but also prints out ignored header fields.
@item decode [@var{msglist}]
@itemx dec [@var{msglist}]
Print a multipart message.  The @code{decode} command decodes and prints
out specified message parts.  E.g.
@example
@cartouche
& decode 15[2]
+---------------------------------------
| Message=15[2]
| Type=message/delivery-status
| encoding=7bit
+---------------------------------------
Content-Type: message/delivery-status
...
@end cartouche
@end example
@item top [@var{msglist}]
@itemx to [@var{msglist}]
Prints the top few lines of each message in @var{msglist}.  The number
of lines printed is controlled by the variable @code{toplines} and
defaults to five.
@item pipe [@var{msglist}] [@var{shell-command}]
@itemx | [@var{msglist}] [@var{shell-command}]
Pipe the contents of specified messages through @var{shell-command}.  If
@var{shell-command} is empty but the string variable @code{cmd} is set,
the value of this variable is used as a command name.
@item struct [@var{msglist}]
Prints the @acronym{MIME} structure of each message from
@var{msglist}.  Empty @var{msglist} means current message.

Example:

@example
@cartouche
& struct 2
2      multipart/mixed            14k
2[1]   text/plain                 296
2[2]   application/octet-stream    5k
2[3]   text/x-diff                31k
@end cartouche
@end example
@end table

@node Marking Messages
@subsubsection Marking Messages
@kyindex tag, mail command
@kyindex hold, mail command
@kyindex preserve, mail command

@table @samp
@item tag [@var{msglist}]
@itemx ta [@var{msglist}]
Tag messages.  The tagged messages can be referred to in message list
using @samp{:t} notation.
@item untag [@var{msglist}]
@itemx unt [@var{msglist}]
Clear tags from specified messages.  To untag all messages tagged so far
type
@example
& untag :t
@end example
@item hold [@var{msglist}]
@itemx ho [@var{msglist}]
@itemx preserve [@var{msglist}]
@itemx pre [@var{msglist}]
Marks each message to be held in user's system mailbox.  This command
does not override the effect of @code{delete} command.
@end table

@node Disposing of Messages
@subsubsection Disposing of Messages
@kyindex delete, mail command
@kyindex undelete, mail command
@kyindex dt, mail command
@kyindex dp, mail command

@table @samp
@item delete [@var{msglist}]
@itemx d [@var{msglist}]
Mark messages as deleted.  Upon exiting with @code{quit} command these
messages will be deleted from the mailbox.  Until the end of current
session the deleted messages can be referred to in message lists using
:d notation.
@item undelete [@var{msglist}]
@itemx u [@var{msglist}]
Clear delete mark from the specified messages.
@item dp [@var{msglist}]
@itemx dt [@var{msglist}]
Deletes the current message and prints the next message.  If
@var{msglist} is specified, deletes all messages from the list and
prints the message, immediately following last deleted one.
@end table

@node Saving Messages
@subsubsection Saving Messages
@kyindex save, mail command
@kyindex Save, mail command
@kyindex write, mail command
@kyindex Write, mail command
@kyindex mbox, mail command
@kyindex touch, mail command
@kyindex copy, mail command
@kyindex Copy, mail command

@table @samp
@item save [[@var{msglist}] @var{file}]
@itemx s [[@var{msglist}] @var{file}]
Takes a message list and a file name or mailbox URL and appends each
message in turn to the end of that file or mailbox.  Mailbox URLs
begin with mailbox type specifier, such as @samp{mbox://},
@samp{maildir://}, etc.  The name of file or mailbox and number of
lines and characters appended to it is echoed on the terminal.  When
writing to file, the numbers represent exact number of lines and
characters appended to the file.  When @var{file} specifies a mailbox,
these numbers may differ by the amount of lines/characters needed to
represent message envelope for that specific mailbox type.

Each saved message is marked for deletion as if with @code{delete}
command, unless the variable @code{keepsave} is set.
@item Save [@var{msglist}]
@itemx S [@var{msglist}]
Like @code{save}, but the file to append messages to is named after the
sender of the first message in @var{msglist}.  For example:

@example
@cartouche
@group
& from 14 15
 U  14 smith@@noldor.org Fri Jun 30 18:11  14/358   The Save c
 U  15 gray@@noldor.org  Fri Jun 30 18:30  8/245    Re: The Sa
& Save 14 15
"smith" 22/603
@end group
@end cartouche
@end example
@noindent

i.e., 22 lines (603 characters) have been appended to the file ``smith''.
If the file does not exist, it is created.

@item write [[@var{msglist}] @var{file}]
@itemx w [[@var{msglist}] @var{file}]
Similar to @code{save}, except that only message body (without the
header) is saved.
@item Write [@var{msglist}]
@itemx W [@var{msglist}]
Similar to @code{Save}, except that only message body (without the
header) is saved.
@item mbox [@var{msglist}]
@itemx mb [@var{msglist}]
@itemx touch [@var{msglist}]
@itemx tou [@var{msglist}]
Mark list of messages to be saved in the user's mailbox (@file{$HOME/mbox})
upon exiting via @code{quit} command.  This is the default action for
all read messages, unless you have variable @code{hold} set.
@item copy [[@var{msglist}] @var{file}]
@itemx c [[@var{msglist}] @var{file}]
Similar to @code{save}, except that saved messages are not marked for
deletion.
@item Copy [@var{msglist}]
@itemx C [@var{msglist}]
Similar to @code{Save}, except that saved messages are not marked for
deletion.
@end table

@node Editing Messages
@subsubsection Editing Messages
@kyindex edit, mail command
@kyindex visual, mail command

These command allow to edit messages in a mailbox.  @emph{Please note},
that modified messages currently do not replace original ones. i.e.
you have to save them explicitly using your editor's @code{save}
command if you do not want the effects of your editing to be lost.

@table @samp
@item edit [@var{msglist}]
@itemx e [@var{msglist}]
Edits each message in @var{msglist} with the editor, specified in
@code{EDITOR} environment variable.
@item visual [@var{msglist}]
@itemx v [@var{msglist}]
Edits each message in @var{msglist} with the editor, specified in
@code{VISUAL} environment variable.
@end table

@node Aliasing
@subsubsection Aliasing
@kyindex alias, mail command
@kyindex group, mail command
@kyindex unalias, mail command
@kyindex alternates, mail command

@table @samp
@item alias [alias [@var{address}...]]
@itemx a [alias [@var{address}...]]
@itemx group [alias [@var{address}...]]
@itemx g [alias [@var{address}...]]
With no arguments, prints out all currently-defined aliases.
With one argument, prints out that alias.
With more than one argument, creates a new alias or changes an old one.
@item unalias [@var{alias}...]
@itemx una [@var{alias}...]
Takes a list of names defined by alias commands and discards the
remembered groups of users.  The alias names no longer have any
significance.
@item alternates @var{name}...
@itemx alt @var{name}...
The alternates command is useful if you have accounts on several
machines.  It can be used to inform mail that the listed addresses are
really you.  When you reply to messages, mail will not send a copy of
the message to any of the addresses listed on the alternates list.
If the alternates command is given with no argument, the current set of
alternate names is displayed.
@end table

@node Replying
@subsubsection Replying
@kyindex mail, mail command
@kyindex reply, mail command
@kyindex Reply, mail command
@kyindex respond, mail command
@kyindex Respond, mail command
@kyindex followup, mail command
@kyindex Followup, mail command

@table @samp
@item mail [@var{address}...]
@itemx m [@var{address}...]
Switches to compose mode.  After composing the message, sends messages to
the specified addresses.

@item reply [@var{msglist}]
@itemx respond [@var{msglist}]
@itemx r [@var{msglist}]

For each message in @var{msglist}, switches to compose mode and sends
the composed message to the sender and all recipients of the message.

@item Reply [@var{msglist}]
@itemx Respond [@var{msglist}]
@itemx R [@var{msglist}]

Like @code{reply}, except that the composed message is sent only to
originators of the specified messages.

Notice, that setting mail variable @code{flipr} (@pxref{Mail
Variables}) swaps the meanings of the two above commands,
so that @code{reply} sends the message to the sender and all
recipients of the message, whereas @code{Reply} sends it to
originators only.

@item followup [@var{msglist}]
@itemx fo [@var{msglist}]

Switches to compose mode.  After composing, sends the message to the
originators and recipients of all messages in @var{msglist}.

@item Followup [@var{msglist}]
@itemx F [@var{msglist}]

Similar to @code{followup}, but reply message is sent only to
originators of messages in @var{msglist}.
@end table

To determine the sender of the message @command{mail} uses the
list of sender fields (@pxref{Controlling Sender Fields}).  The first field
from this list is looked up in message headers.  If it is found
and contains a valid email address, this address is used as
the sender address.  If not, the second field is searched and
so on.  This process continues until a field is found in the
headers, or the sender field list is exhausted, whichever happens
first.

If the previous step did not determine the sender address, the
address from SMTP envelope is used.

Let's illustrate this.  Suppose your mailbox contains the following:

@example
@cartouche
 U  1 block@@helsingor.org  Fri Jun 30 18:30  8/245    Re: The Sa
& Print 1
From: Antonius Block <block@@helsingor.org>
To: Smeden Plog <plog@@helsingor.org>
Date: Tue, 27 Apr 2004 13:23:41 +0300
Reply-To: <root@@helsingor.org>
Subject: News

Hi
@end cartouche
@end example

@noindent
Now, you issue the following commands:

@example
@cartouche
& sender mail-followup-to reply-to from
& reply
To: <root@@helsingor.org>
Subject: Re: News

@end cartouche
@end example

@noindent
As you see, the value of @code{Reply-To} field was taken as the
sender address.

Now, let's try the following command sequence:

@example
# Clear the sender list
& nosender
# Set new sender list
& sender From
@end example

@noindent
Now, the @code{From} address will be taken:

@example
@cartouche
& reply
To: Antonius Block <block@@helsingor.org>
Subject: Re: News

@end cartouche
@end example

@node Controlling Sender Fields
@subsubsection Controlling Sender Fields
@kyindex sender, mail command
@kyindex nosender, mail command

Commands @code{sender} and @code{nosender} are used to manipulate
the contents of the sender field list.

If the command @code{sender} is used without arguments, it displays
the contents of the sender field list.  If arguments are given,
each argument is appended to the sender field list.  For example:

@example
@cartouche
& sender
Sender address is obtained from the envelope
& sender mail-followup-to reply-to
& sender
mail-followup-to
reply-to
& sender from
& sender
mail-followup-to
reply-to
from
@end cartouche
@end example

Command @code{nosender} is used to remove items from the sender
field list:

@example
@cartouche
& sender
mail-followup-to
reply-to
from
& nosender reply-to
& sender
mail-followup-to
from
@end cartouche
@end example

When used without arguments, this command clears the list:

@example
@cartouche
& nosender
Sender address is obtained from the envelope
@end cartouche
@end example

@node Incorporating New Mail
@subsubsection Incorporating New Mail
@kyindex incorporate, mail command

The @code{incorporate} (@code{inc}) command incorporates newly arrived
messages to the displayed list of messages.  This is done automatically
before returning to @command{mail} command prompt if the variable
@code{autoinc} is set.

@node Shell Escapes
@subsubsection Shell Escapes
@kyindex shell, mail command
@kyindex !, mail command

To run arbitrary shell command from @command{mail} command prompt, use
@code{shell} (@code{sh}) command.  If no arguments are specified, the
command starts the user login shell.  Otherwise, it uses its first
argument as a file name to execute and all subsequent arguments are
passed as positional parameters to this command.  The @code{shell}
command can also be spelled as @code{!}.

@c **********************************

@node Scripting
@subsection Scripting

@subsubheading Comments

The @samp{#} character introduces an end-of-line comment.  All characters
until and including the end of line are ignored.

@subsubheading Displaying Arbitrary Text
@kyindex echo, mail command

The @samp{echo} (@samp{ec}) command prints its arguments to stdout.

@subsubheading Sourcing External Command Files
@kyindex source, mail command

The command @samp{source @var{filename}} reads commands from the named
file.  Its minimal abbreviation is @samp{so}.

@anchor{Setting and Unsetting the Variables}
@subsubheading Setting and Unsetting the Variables
@kyindex set, mail command
@kyindex unset, mail command

The mail variables are set using @samp{set} (@samp{se}) command.  The
command takes a list of assignments.  The syntax of an assignment is

@table @samp
@item @var{name}=@var{string}
Assign a string value to the variable.  If @var{string} contains
whitespace characters it must be enclosed in a pair of
double-quote characters (@samp{"})
@item @var{name}=@var{number}
Assign a numeric value to the variable.
@item @var{name}
Assign boolean @code{True} value.
@item no@var{name}
Assign boolean @code{False} value.
@end table

Example:

@example
& set askcc nocrt indentprefix="> "
@end example
@noindent

This statement sets @code{askcc} to @code{True}, @code{crt} to
@code{False}, and @code{indentprefix} to ``> ''.

To unset mail variables use @samp{unset}(@samp{uns}) command.  The
command takes a list of variable names to unset.

Example:
To undo the effect of the previous example, do:

@example
& unset askcc crt indentprefix
@end example

When used without arguments, both @command{set} or @command{unset}
list all currently defined variables.  The form of this listing is
controlled by @code{variable-pretty-print} (@code{varpp}) variable.  If
it is set, a description precedes each variable, e.g.:

@example
# prompt user for subject before composing the message
ask
# prompt user for cc before composing the message
askcc
# output character set for decoded header fields
charset="auto"
# number of columns on terminal screen
columns=80
@end example

If @code{variable-pretty-print} is not set, only the settings are
shown, e.g.:

@example
ask
askcc
charset="auto"
columns=80
@end example

@kyindex variable, mail command
A special command is provided to list all internal @command{mail}
variables:

@example
variable [@var{names...}]
@end example

If used without arguments, it prints all known internal variables.  If
arguments are given, it displays only those internal variables that
are listed in command line.  For each variable, this command prints its
name, data type, current value and a short description.  For example:

@example
& variable ask datefield
ask, asksub
Type: boolean
Current value: yes
prompt user for subject before composing the message

datefield
Type: boolean
Current value: [not set]
get date from the `Date:' header, instead of the envelope
@end example

@subsubheading Setting and Unsetting Shell Environment Variables

Shell environment may be modified using @samp{setenv} (@samp{sete})
command.  The command takes a list of assignments.  The syntax of an
assignment is:

@table @samp
@item @var{name}=@var{value}
If variable @var{name} does not already exist in the environment,
then it is added to the environment with the value @var{value}.
If @var{name} does exist, then its value in the environment is
changed to @var{value}. 
@item @var{name}
Delete the variable @var{name} from the environment (``unset'' it).
@end table

@subsubheading Conditional Statements
@kyindex if, mail command
@kyindex else, mail command
@kyindex endif, mail command

The conditional statement allows to execute a set of mail commands
depending on the mode the @command{mail} program is in.  The conditional
statement is:

@example
if @var{cond}
...
else
...
endif
@end example
@noindent

where @samp{...} represents the set of commands to be executed in each
branch of the statement.  @var{cond} can be one of the following:

@table @samp
@item s
True if @command{mail} is operating in mail sending mode.
@item r
True if @command{mail} is operating in mail reading mode.
@item t
True if stdout is a terminal device (as opposed to a regular file).
@end table

The conditional statements can be nested to arbitrary depth.  The minimal
abbreviations for @samp{if}, @samp{else} and @samp{endif} commands are
@samp{i}, @samp{el} and @samp{en}.

Example:

@example
if t
set crt prompt="& "
else
unset prompt
endif
if s
alt gray@@farlep.net gray@@mirddin.farlep.net
set
@end example

@node Mail Variables
@subsection How to Alter the Behavior of @command{mail}

Following variables control the behavior of GNU @command{mail}:

@table @code
@kwindex append
@item append
@*Type: Boolean, Read-Only
@*Default: True
@vrindex append, mail variable

Messages saved in mbox are appended to the end rather than prepended.
This is the default and cannot be changed.  This variable exists only
for compatibility with other @command{mailx} implementations.

@kwindex appenddeadletter
@item appenddeadletter
@*Type: Boolean.
@*Default: False.
@vrindex appenddeadletter, mail variable

If this variable is @code{True}, the contents of canceled letter is
appended to the user's @file{dead.letter} file.  Otherwise it overwrites
its contents.

@kwindex askbcc
@item askbcc
@*Type: Boolean.
@*Default: False.
@vrindex askbcc, mail variable

When set to @code{True} the user will be prompted to enter @code{Bcc}
field before composing the message.

@kwindex askcc
@item askcc
@*Type: Boolean.
@*Default: True.
@vrindex askcc, mail variable

When set to @code{True} the user will be prompted to enter @code{Cc}
field before composing the message.

@kwindex asksub
@item asksub
@*Type: Boolean.
@*Default: True in interactive mode, False otherwise.
@vrindex asksub, mail variable

When set to @code{True} the user will be prompted to enter @code{Subject}
field before composing the message.

@kwindex autoinc
@item autoinc
@*Type: Boolean.
@*Default: True.
@vrindex autoinc, mail variable

Automatically incorporate newly arrived messages.

@kwindex autoprint
@item autoprint
@*Type: Boolean.
@*Default: False.
@vrindex autoprint, mail variable

Causes the delete command to behave like dp - thus, after deleting a
message, the next one will be typed automatically.

@kwindex bang
@item bang
@*Type: Boolean.
@*Default: False.
@vrindex bang, mail variable

When set, every occurrence of @code{!} in arguments to @code{!}
command is replaced with the last executed command.

@anchor{byname}
@kwindex byname
@item byname
@*Type: Boolean
@*Default: Unset
@vrindex byname, mail variable

Record outgoing messages in a file named after the first recipient.
The name is the login-name portion of the address found first on the
@samp{To:} line in the mail header.  This variable overrides the
@samp{record} variable.

It is set by the @option{--byname} (@option{-F}) command line option.

@anchor{datefield}
@kwindex datefield
@item datefield
@*Type: Boolean.
@*Default: False.
@vrindex datefield, mail variable

By default the date in a header summary is taken from the @acronym{SMTP}
envelope of the message.  Setting this variable tells @command{mail}
to use the date from @code{Date:} header field, converted to
local time.  Notice, that for messages lacking this field @command{mail}
will fall back to using @acronym{SMTP} envelope.

@xref{fromfield}.

@kwindex charset
@item charset
@*Type: string
@*Default: @samp{auto}
@vrindex charset, mail variable

The value of this variable controls the output character set for the
header fields encoding using RFC 2047.  If the variable is unset, no
decoding is performed and the fields are printed as they are.  If the
variable is set to @samp{auto}, @command{mail} tries to deduce the
name of the character set from the value of @code{LC_ALL} environment
variable.  Otherwise, its value is taken as the name of the charset.

@kwindex cmd
@item cmd
@*Type: String.
@*Default: Unset.
@vrindex cmd, mail variable

Contains default shell command for @code{pipe}.

@kwindex columns
@item columns
@*Type: Numeric.
@*Default: Detected at startup by querying the terminal device.  If this
fails, the value of environment variable @code{COLUMNS} is used.
@vrindex columns, mail variable

This variable contains the number of columns on terminal screen.

@kwindex crt
@item crt
@*Type: Boolean or Numeric
@*Default: True in interactive mode, False otherwise.
@vrindex crt, mail variable

The variable @code{crt} determines the minimum number of lines the body
of the message must contain in order to be piped through pager command
specified by environment variable @code{PAGER}.  If @code{crt} is set
to a numeric value, this value is taken as the threshold.  Otherwise,
if @code{crt} is set without a value, then the height of the terminal
screen is used to compute the threshold.  The number of lines on
screen is controlled by @code{screen} variable.

@kwindex debug
@item debug
@*Type: String to boolean
@*Default: Not set
@vrindex debug, mail variable

Sets mailutils debug level.  If set to string, the value must be a
valid Mailutils debugging specification.  @xref{Debug Statement}, for
a description.

If unset (i.e.  @code{set nodebug}), clears and disables all debugging
information.  If set to @samp{true} (i.e.  @code{set debug}), sets
maximum debugging (@samp{<trace7}) on mailbox and its underlying
objects.

@kwindex decode-fallback
@item decode-fallback
@*Type: String.
@*Default: @samp{none}.
@vrindex decode-fallback, mail variable

This variable controls the way to represent characters that cannot
be rendered using current character set.  It can have three values:

@table @samp
@item none
Such characters are not printed at all.  The conversion process stops
at the first character that cannot be rendered.

@item copy-pass
The characters are displayed @samp{as is}.  Notice, that depending on
your setup, this may screw-up your terminal settings.

@item copy-octal
Unprintable characters are represented by their octal codes.  Printable
ones are printed @samp{as is}.
@end table

@kwindex debug
@item debug
@*Type: Boolean
@*Default: Unset
@vrindex debug, mail variable

This variable is not used.  It exists for compatibility with other
@command{mailx} implementations and for future use.

@kwindex dot
@item dot
@*Type: Boolean.
@*Default: False.
@vrindex dot, mail variable

If @code{True}, causes @command{mail} to interpret a period alone on a line as the
terminator of a message you are sending.

@kwindex emptystart
@item emptystart
@*Type: Boolean.
@*Default: False.
@vrindex emptystart, mail variable

If the mailbox is empty, @command{mail} normally prints @samp{No mail for user} and
exits immediately.  If this option is set, @command{mail} will start no matter is
the mailbox empty or not.

@kwindex editheaders
@item editheaders
@*Type: Boolean.
@*Default: False.
@vrindex editheaders, mail variable

When set, @command{mail} will include message headers in the text to
be the @code{~e} and @code{~v} escapes, thus allowing you to customize
the headers.

@kwindex escape
@item escape
@*Type: String.
@*Default: ~
@vrindex escape, mail variable

If defined, the first character of this option gives the character to
denoting escapes.

@kwindex flipr
@item flipr
@*Type: Boolean
@*Default: Unset
@vrindex flipr, mail variable

If set, the variable @code{flipr} swaps the meanings of @code{reply}
and @code{Reply} commands (@pxref{Replying}).

@kwindex folder
@item folder
@*Type: String.
@*Default: Unset.
@vrindex folder, mail variable

The name of the directory to use for storing folders of messages.  If
unset, @env{$HOME} is assumed.

@anchor{fromfield}
@kwindex fromfield
@item fromfield
@*Type: Boolean.
@*Default: True.

By default the sender address is taken from the @samp{From} header.
Unsetting this variable tells @command{mail} to obtain it from the
@acronym{SMTP} envelope, instead.

@xref{datefield}.

@kwindex header
@item header
@*Type: Boolean.
@*Default: True, unless started with @option{--nosum} (@option{-N}) option.
@vrindex header, mail variable

Whether to run @code{headers} command automatically after entering
interactive mode.

@kwindex headline
@item headline
@*Type: String
@*Default: @samp{%>%a%4m %18f %16d %3l/%-5o %s}

A format string to use for the header summary.  The @samp{%} character
introduces a @dfn{format specifier}.  Valid format specifiers are:

@multitable @columnfractions 0.2 0.8
@headitem Letter @tab Meaning
@item %a @tab Message attributes.
@item %d @tab The date when the message was received.
@item %f @tab The address of the message sender.
@item %l @tab The number of lines of the message.
@item %m @tab Message number.
@item %o @tab The number of octets (bytes) in the message.
@item %s @tab Message subject (if any).
@item %S @tab Message subject (if any) in double quotes.
@item %> @tab A @samp{>} for the current message, otherwise a space.
@item %< @tab A @samp{<} for the current message, otherwise a space.
@item %% @tab A `%' character.
@end multitable

Some additional symbols are allowed between @samp{%} and the specifier
letter.  The @samp{-} character immediately following @samp{%}
indicates that this field should be left aligned.  Similarly, the
@samp{+} character indicates right alignment.  Default alignment
depends on the type of the specifier: the specifiers that produce
numeric values (@samp{%l}, @samp{%m}, and @samp{%o}) are aligned to
the right, whereas the ones producing string values are aligned to the
left.

A number following @samp{%} or the alignment flag, indicates the
field width.  Consider, for example, the following specifiers:

@table @asis
@item %m
Print current message number.  Take as much screen columns as necessary
to output it.

@item %4m
@itemx %+4m
Print current message number.  Occupy 4 screen columns, truncate the
output if it does not fit that width.  Align the output to the right. 

@item %-4m
Same as above, but align to the left.
@end table

@kwindex hold
@item hold
@*Type: Boolean.
@*Default: False.
@vrindex hold, mail variable

When set to @code{True}, the read or saved messages will be stored in
user's mailbox (@file{$HOME/mbox}).  Otherwise, they will be held in
system mailbox also.  This option is in effect only when operating
upon user's system mailbox.

@kwindex ignore 
@item ignore
@*Type: Boolean.
@*Default: False.
@vrindex ignore, mail variable

When set to @code{True}, @command{mail} will ignore keyboard interrupts
when composing messages.  Otherwise an interrupt will be taken as a
signal to abort composing.

@kwindex ignoreeof
@item ignoreeof
@*Type: Boolean.
@*Default: False.
@vrindex ignoreeof, mail variable

Controls whether typing EOF character terminates the letter being
composed.

@kwindex indentprefix
@item indentprefix
@*Type: String.
@*Default: "\t" (a tab character).
@vrindex indentprefix, mail variable

String used by the @code{~m} tilde escape for indenting quoted messages.

@kwindex inplacealiases
@item inplacealiases
@*Type: Boolean
@*Default: False

If set, @command{mail} will expand aliases in the address header field
before entering send mode (@pxref{Composing Mail}).  By default, the
address header fields are left intact while composing, the alias
expansion takes place immediately before sending message.

@kwindex keep
@item keep
@*Type: Boolean, Read-Only
@*Default: True
@vrindex append, mail variable

Truncate the user's system mailbox when it is empty, instead of
removing it.  This is the default and cannot be changed.  This variable
exists only for compatibility with other @command{mailx} implementations.

@kwindex keepsave
@item keepsave
@*Type: Boolean.
@*Default: False.
@vrindex keepsave, mail variable

Controls whether saved messages should be kept in system mailbox too.
This variable is in effect only when operating upon a user's system
mailbox.

@kwindex mailx
@item mailx
@*Type: Boolean.
@*Default: False.
@vrindex mailx, mail variable

When set, enables @dfn{mailx compatibility mode}.  This mode
has the following effects:

@itemize @bullet
@item When composing a message @command{mail} will ask
for @code{Cc} and @code{Bcc} addresses after composing the body.
The default behavior is to ask for these values before composing
the body.

@item In send mode, if the composition was interrupted, @command{mail}
will exit with zero status.  By default it exits with zero status only
if the message was sent successfully.
@end itemize

@kwindex metamail
@item metamail
@*Type: Boolean or String.
@*Default: True.
@vrindex metamail, mail variable

This variable controls operation of @code{decode} command.  If
it is unset, @code{decode} will not attempt any interpretation
of the content of message parts.  Otherwise, if @code{metamail}
is set to @code{true}, @code{decode} will use internal metamail
support to interpret message parts.  Finally, if @code{metamail}
is assigned a string, this string is treated as command line of
the external @command{metamail} command which will be used to
display parts of a multipart message.  For example:

@example
# Disable MIME interpretation:
set nometamail
# Enable built-in MIME support:
set metamail
# Use external program to display MIME parts:
set metamail="metamail -m mail -p"
@end example

@kwindex mimenoask
@item mimenoask
@*Type: String
@*Default: Empty
@vrindex mimenoask, mail variable

By default @command{mail} asks for confirmation before running
interpreter to view a part of the multi-part message.  If this variable
is set, its value is treated as a comma-separated list of MIME types
for which no confirmation is needed.  Elements of this list may include
shell-style globbing patterns, e.g. setting

@example
set mimenoask=text/*,image/jpeg
@end example

@noindent
will disable prompting before displaying any textual files, no
matter what their subtype is, and before displaying files with
type @samp{image/jpeg}.

@kwindex metoo
@item metoo
@*Type: Boolean.
@*Default: False.
@vrindex metoo, mail variable

Usually, when an alias is expanded that contains the sender, the sender
is removed from the expansion.  Setting this option causes the sender to
be included in the group.

@kwindex mode
@item mode
@*Type: String, Read-Only
@*Default: The name of current operation mode.
@vrindex mode, mail variable

This variable keeps the name of the current operation mode.  Its
possible values are:

@table @asis
@item headers
The program is started with the @option{--headers} (@option{-H}) command
line option (@pxref{Invoking Mail}).

@item exist
The program is started with the @option{--exist} (@option{-e}) command
line option (@pxref{Invoking Mail}).

@item print
The program is started with the @option{--print} (@option{-p}) command
line option (@pxref{Invoking Mail}).

@item read
The program operates in read mode.  This is the default.

@item send
The program operates in send mode.  This means it was given one or more
recipient addresses in the command line.
@end table

@kwindex nullbody
@item nullbody
@* Type: Boolean
@* Default: True
@vrindex nullbody, mail variable

Controls whether @command{mail} accepts messages with an empty
body.  The default value, @code{true}, means such messages are sent,
and a warning (traditionally saying @samp{Null message body; hope
that's ok}) is displayed.  The text of the warning can be set using
@code{nullbodymsg} variable (see below).

If @code{nullbody} is unset, @command{mail} will silently ignore such
messages.  This can be useful in @file{crontab} files, to avoid sending
mails when nothing important happens.  For example, the @file{crontab}
entry below will send mail only if the utility @command{some-prog}
outputs something on its standard output or error:

@example
@group
*/5 * * * * some-prog 2>&1 | \
   /bin/mail -E'set nonullbody' -s 'Periodic synchronization'
@end group
@end example

@kwindex showenvelope
@item showenvelope
@*Type: Boolean
@*Default: Unset

If this variable is set, the @code{print} command will include the
@acronym{STMP} envelope in its output.

@kwindex nullbodymsg
@item nullbodymsg
@*Type: String
@*Default: Null message body; hope that's ok 
@vrindex nullbodymsg

Keeps the text of the warning, displayed by @command{mail} before
sending an empty message.  When available, the translation of
this text, in accordance with the current locale, is displayed.

Unsetting this variable disables the warning.

@kwindex onehop
@item onehop
@*Type: Boolean
@*Default: Unset
@vrindex onehop, mail variable

This variable is not used.  It exists for compatibility with other
@command{mailx} implementations and for future use.

@kwindex outfolder
@item outfolder
@*Type: String.
@*Default: Unset.
@vrindex outfolder, mail variable

Contains the directory in which files created by @code{save},
@code{write}, etc. commands will be stored.  When unset, current
directory is assumed.

@kwindex page
@item page
@*Type: Boolean.
@*Default: False.
@vrindex page, mail variable

If set to @code{True}, the @code{pipe} command will emit a linefeed
character after printing each message.

@kwindex prompt
@item prompt
@*Type: String.
@*Default: "? "
@vrindex prompt, mail variable

Contains the command prompt sequence.

@kwindex quiet
@item quiet
@*Type: Boolean
@*Default: Unset
@vrindex quiet, mail variable

This variable is not used.  It exists for compatibility with other
@command{mailx} implementations and for future use.

@kwindex quit
@item quit
@*Type: Boolean.
@*Default: False, unless started with @option{--quit} (@option{-q}) option.
@vrindex quit, mail variable

When set, causes keyboard interrupts to terminate the program.

@kwindex rc
@item rc
@*Type: Boolean.
@*Default: True, unless started with @option{--norc} (@option{-N}) option.
@vrindex rc, mail variable

When this variable is set, @command{mail} will read the system-wide
configuration file upon startup.  See @ref{Mail Configuration Files}.

@kwindex readonly
@item readonly
@*Type: Boolean
@*Default: False
@vrindex readonly, mail variable

When set, mailboxes are opened in readonly mode.  In this mode, any
@command{mail} commands that alter the contents of the mailbox are
disabled.  These commands include, but are not limited to: 
@code{delete}, @code{save} and @code{mbox}.

@kwindex record
@item record
@*Type: String.
@*Default: Unset.
@vrindex record, mail variable

When set, any outgoing message will be saved to the named file.

@kwindex recursivealiases
@item recursivealiases
@*Type: Boolean
@*Default: True

When set, @command{mail} will expand aliases recursively.

@kwindex regex
@item regex
@*Type: Boolean.
@*Default: True.
@vrindex regex, mail variable

Setting this to @code{True} enables use of regular expressions in
@samp{/.../} message specifications.

@kwindex replyprefix
@item replyprefix
@*Type: String
@*Default: @samp{Re: }
@vrindex replyprefix, mail variable

Sets the prefix that will be used when constructing the subject line
of a reply message.

@kwindex replyregex
@item replyregex
@*Type: String
@*Default: @samp{^re: *}
@vrindex replyregex, mail variable

Sets the regular expression used to recognize subjects of reply
messages.  If the @code{Subject} header of the message matches this
expression, the value of @code{replyprefix} will not be prepended to
it before replying.  The expression should be a POSIX extended regular
expression.  The comparison is case-insensitive.

For example, to recognize usual English, Polish, Norwegian and German
reply subject styles, use:

@example
set replyregex="^(re|odp|aw|ang)(\\[[0-9]+\\])?:[[:blank:]]"
@end example

@noindent
(Notice the quoting of backslash characters).

@anchor{return-address}
@kwindex return-address
@item return-address
@*Type: String
@*Default: unset
@vrindex return-address, mail variable.

Sets the return email address to use when sending messages.  If unset,
the address is composed from the current user name and the host name.

@kwindex save
@item save
@*Type: Boolean.
@*Default: True.
@vrindex save, mail variable

When set, the aborted messages will be stored in the user's
@file{dead.file}.  See also @code{appenddeadletter}.

@kwindex screen
@item screen
@*Type: Numeric.
@*Default: Detected at startup by querying the terminal device.  If this
fails, the value of environment variable @code{LINES} is used.
@vrindex screen, mail variable

This variable contains the number of lines on terminal screen.

@kwindex sendmail
@item sendmail
@*Type: String.
@*Default: sendmail:/usr/lib/sendmail
@vrindex sendmail, mail variable

Contains URL of the mail transport agent.

@kwindex sendwait
@item sendwait
@*Type: Boolean
@*Default: Unset
@vrindex sendwait, mail variable

This variable is not used.  It exists for compatibility with other
@command{mailx} implementations and for future use.

@kwindex showto
@item showto
@*Type: Boolean
@*Default: False
@vrindex showto, mail variable

If the message was sent by the user, print its recipient address in
the header summary.

@kwindex Sign
@item Sign
@*Type: String.
@*Default: Unset.
@vrindex Sign, mail variable

Contains the filename holding users signature.  The contents of this
file is appended to the end of a message being composed by @code{~A}
escape.

@kwindex sign
@item sign
@*Type: String.
@*Default: Unset.
@vrindex sign, mail variable

Contains the user's signature.  The contents of this variable is appended
to the end of a message being composed by @code{~a} escape.  Use
@code{Sign} variable, if your signature occupies more than one line.

@kwindex showto
@item showto
@*Type: Boolean
@*Default: unset
@vrindex showto, mail variable

If this variable is set, @command{mail} will show @code{To:} addresses
instead of @code{From:} for all messages that come from the user that
invoked the program.

@kwindex subject
@item subject
@*Type: String.
@*Default: Unset.
@vrindex subject, mail variable

Contains default subject line.  This will be used when @code{asksub} is
off.

@kwindex toplines
@item toplines
@*Type: Numeric.
@*Default: 5
@vrindex toplines, mail variable

Number of lines to be displayed by @code{top} and @code{Top} commands.

@kwindex variable-strict
@item variable-strict
@itemx varstrict
@*Type: Boolean.
@*Default: False.

Setting this variable enables strict control over variable
settings.  In this mode, @command{mail} refuses to set read-only
variables.  Also, if the user is trying to set an unknown variable,
@command{mail} prints a warning.

@xref{Setting and Unsetting the Variables}.

@kwindex variable-pretty-print
@item variable-pretty-print
@itemx varpp
@*Type: Boolean.
@*Default: False.

If this variable is set, the listing output by @command{set} contains short
descriptions before each variable.  @xref{Setting and Unsetting the Variables}. 

@kwindex verbose
@item verbose
@*Type: Boolean.
@*Default: False.
@vrindex verbose, mail variable

When set, the actual delivery of messages is displayed on the user's terminal.

@kwindex xmailer
@item xmailer
@*Type: Boolean.
@*Default: Set.
@vrindex xmailer, mail variable

Controls whether the header @samp{X-Mailer} should be added to 
outgoing messages.  The default value of this header is

@example
X-Mailer: mail (GNU Mailutils @value{VERSION})
@end example

@end table

@node Mail Configuration Files
@subsection Personal and System-wide Configuration Files

After processing the usual Mailutils configuration files
(@pxref{configuration}), @command{mail} reads the contents of the two
command files: the system-wide command file, and the user's command
file.  Each line read from these files is processed like a usual
@command{mail} command.

When run with @option{--norc} (@option{-N}) option, @command{mail} does
not read the contents of system-wide configuration file.  The user's
file, if it exists, is always processed.

The user's configuration file is located in the user's home
directory and is named @file{.mailrc}.  The location and name of
the system-wide configuration file is determined when configuring the
package via @option{--with-mail-rc} option.  It defaults to
@file{@var{sysconfdir}/mail.rc}.

@page
@node messages
@section @command{messages} --- Count the Number of Messages in a Mailbox
@pindex messages

@command{Messages} prints on standard output the number of messages
contained in each folder specified in command line.  If no folders
are specified, it operates upon user's system mailbox.  For each
folder, the following output line is produced:

@example
Number of messages in @var{folder}: @var{number}
@end example

@noindent
where @var{folder} represents the folder name, @var{number} represents
the number of messages.

The following configuration file statements affect the behaviour of 
@command{messages}:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item tls           @tab @xref{tls statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@end multitable

In addition to the common mailutils options (@pxref{Common Options}),
the program accepts the following command line options:

@table @option
@item -q
@itemx --quiet
@itemx -s
@itemx --silent
Be quiet.  Display only number of messages per mailbox, without leading text.
@end table

@page
@node movemail
@section @command{movemail} --- Moves Mail from the User Maildrop to the Local File
@pindex movemail
The purpose of @command{movemail}, as its name implies, is to move mail
from one location to another.  For example, the following invocation:

@example
movemail /var/mail/smith INBOX
@end example

@noindent
moves messages from file @file{/var/mail/smith} to file @file{INBOX}.

The program was initially intended as a replacement for
@command{movemail} from GNU Emacs.  The @command{movemail} program is
run by Emacs @code{Rmail} module.  @xref{Rmail,,,emacs,Reading Mail
with Rmail}, for detailed description of @code{Rmail} interface.

Mailutils version of @command{movemail} is fully
backward-compatible with its Emacs predecessor, so it should run
flawlessly with older versions of Emacs.  Emacs versions
starting from 22.1 contain improved @code{Rmail} interface and
are able to take advantage of all new features mailutils
@command{movemail} provides.

Apart from that use, @command{movemail} proved to be a useful tool for
incorporating mail from remote mailboxes into the local one.  See
@uref{http://mailutils.org/wiki/Fetching_Mail_with_Movemail, Fetching
Mail with Movemail}, for a detailed discussion with usage recipes.

@menu
* Movemail Configuration::
* Ownership::            Setting Destination Mailbox Ownership
* Summary::              Short Movemail Invocation Summary
@end menu

@node Movemail Configuration
@subsection Movemail Configuration
@cindex movemail, configuration
The following configuration file statements affect the behavior of
@command{movemail}:

@deffn {Movemail Config} preserve @var{bool}
If @var{bool} is @samp{true}, do not remove messages from the source mailbox.
@end deffn

@deffn {Movemail Config} reverse @var{bool}
If @var{bool} is @samp{true}, reverse message sorting order.
@end deffn

@deffn {Movemail Config} emacs @var{bool}
If @var{bool} is @samp{true}, output information used by Emacs rmail interface.
@end deffn

@deffn {Movemail Config} ignore-errors @var{bool}
Continue moving messages after errors.  By default,
@command{mailfromd} exits immediately if it cannot copy a message.
@end deffn

@deffn {Movemail Config} program-id @var{fmt}
Set program identifier, i.e. a string which will prefix all
diagnostic messages issued by the program.  By default, program
name is used.

@anchor{movemail-program-id}
The @var{fmt} is a format string that may contain references to the
following variables (@pxref{Variables}):

@table @code
@item progname
The program name.

@item source
URL of the source mailbox.

@item source_user
User part of the source mailbox URL.

@item source_host
Host part of the source mailbox URL.

@item source_path
Path part of the source mailbox URL.

@item dest
URL of the destination mailbox

@item dest_user
User part of the destination mailbox URL.

@item dest_host
Host part of the destination mailbox URL.

@item dest_path
Path part of the destination mailbox URL.
@end table

Setting @code{program-id} may be necessary if several @code{movemail}
instances are run simultaneously (e.g. invoked from a script) to
discern between the instances.  For example:

@example
program-id "$@{progname@}: $@{source@} => $@{dest@}"
@end example
@end deffn

@deffn {Movemail Config} uidl @var{bool}
Avoid copying the message if a message with the same UIDL already
exists in the destination mailbox.
@end deffn

@deffn {Movemail Config} verbose @var{level}
Set verbosity level.
@end deffn

@deffn {Movemail Config} mailbox-ownership @var{method-list}
Define list of methods for setting ownership of the destination
mailbox.  The @var{method-list} argument can contain the following
elements:

@anchor{mailbox-ownership-methods}
@table @asis
@item copy-id
Copy owner UID and GID from the source mailbox.  This method works only
with local mailboxes, i.e.: @samp{mbox} (UNIX mailbox), @samp{maildir}
and @samp{mh}.

@item copy-name
Get owner name from the source mailbox URL and obtain UID and GID for
this user using mailutils authorization methods.

@item set-id=@var{uid}[:@var{gid}]
Set supplied @var{uid} and @var{gid}.  If @var{gid} is not supplied,
it is read from the @file{/etc/passwd} record for this UID.

@item set-name=@var{user}
Make destination mailbox owned by @var{user}.
@end table
@end deffn

@deffn {Movemail Config} max-messages @var{count}
Defines upper limit on the number of moved messages.  Movemail will
stop after transferring @var{count} messages.

By default, the number of messages is not limited.
@end deffn

@anchor{movemail-onerror}
@deffn {Movemail Config} onerror @var{actions}
Defines what to do if an error occurs when transferring a message.
@var{actions} is a list of one or more of the following keywords:

@table @asis
@item abort
Abort the transfer and terminate the program.  This is the default
action.

@item skip
Skip to the next message.

@item delete
Delete the affected message.

@item count
Count this message as processed.
@end table

Each keyword can be prefixed with @samp{no} to reverse its meaning.
@end deffn

The following standard Mailutils statements are supported:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item tls           @tab @xref{tls statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@item pam           @tab @xref{pam statement}.
@item sql           @tab @xref{sql statement}.
@item virtdomain    @tab @xref{virtdomain statement}.
@item radius        @tab @xref{radius statement}.
@item ldap          @tab @xref{ldap statement}.
@item auth          @tab @xref{auth statement}.
@end multitable

@node Ownership
@subsection Setting Destination Mailbox Ownership
@UNREVISED

@node Summary
@subsection Movemail Usage Summary

@example
movemail [@var{option}...] @var{inbox} @var{destfile} [@var{password}]
@end example

The first argument, @var{inbox}, is the @acronym{url} (@pxref{Mailbox}) of
the source mailbox.  The second argument, @var{destfile}, traditionally
means destination file, i.e. the UNIX mailbox to copy messages
to.  However, mailutils @command{movemail} extends the meaning of this
parameter.  You may actually specify any valid @acronym{url} as
@var{destfile} parameter.@footnote{Rmail does not use this
feature}.

For compatibility with older implementations of @command{movemail},
the @var{source} argument can also have the form:

@example
po:@var{username}[:@var{pop-server}]
@end example

@noindent
where @var{pop-server} is the IP address or hostname of a POP3 server
to connect to and @var{username} is the name of the user on that
server.  The password is then supplied by the third argument.

It is equivalent to the following URL:

@example
pop://@var{username}[:@var{password}]@@@var{pop-server}
@end example

In fact, whenever @var{source} refers to a remote mailbox, the
@var{password} argument can be used to pass the password.  However,
the safer @dfn{ticket} method is of course preferred.

Options are one or more of the following:

@table @option
@item --emacs
Output information used by Emacs @code{rmail} interface.

@item --ignore-errors
Try to continue after errors.

@item --max-messages=@var{count}
Process at most @var{count} messages.

@item --notify
Enable biff notification.

@item --onerror=@var{kw}[,@var{kw}...]
What to do on errors.  @xref{movemail-onerror, onerror statement}, for
a description of @var{kw}.

@item -P @var{modelist}
@itemx --owner=@var{modelist}
Control mailbox ownership.  @var{modelist} is a comma-separated list
of one or more ownership change methods.
@xref{mailbox-ownership-methods}, for a description of available
methods.

This option is useful only when running @command{movemail} as root.

@item -p
@itemx --preserve
@itemx --keep-messages
Don't remove transferred messages from the source mailbox.

@item --program-id=@var{fmt}
Set program identifier for diagnostics (default: the program name).
@xref{movemail-program-id}, for a description of its argument.

@item -r
@itemx --reverse
Reverse the order of retrieved messages.

@item -u
@itemx --uidl
Use UIDLs to avoid downloading the same message twice.

@item -v
@itemx --verbose
Increase verbosity level.
@end table

The common options are also understood (@pxref{Common Options}).

@page
@node readmsg
@section @command{readmsg} --- Extract Messages from a Folder
@pindex readmsg

The @command{readmsg} utility extracts messages from a mailbox
according to the criteria specified in the command line.  These
criteria are:

@enumerate
@item A lone @samp{*} means ``select all messages in the mailbox''.

@item
A list of message numbers may be specified.  Values
of  @samp{0}  and @samp{$} in the list both mean the last
message in the mailbox.  For example:
@example
readmsg 1 3 0
@end example
extracts three messages from the folder: the first, the third, and the last.

@item
Finally, the selection may be some text to match.  This will select a mail
message which exactly matches the specified text.  For example,
@example
readmsg staff meeting
@end example
extracts the message which contains the words @samp{staff meeting}.
Note that it will not match a message containing @samp{Staff Meeting}
-- the matching is case sensitive.  Normally only the first message
which matches the pattern is printed.
@end enumerate

Unless one of the informational options is used, at least one command
line argument must be present.  Informational options are:
@option{--help} (@option{-?}), @option{--usage}, and
@option{--version} (@option{-V}).

@menu
* Opt-readmsg::   Invocation of @command{readmsg}.
* Conf-readmsg::  Configuration of @command{readmsg}.
@end menu

@node Opt-readmsg
@subsection Invocation of @command{readmsg}.

@table @option
@item -a
@itemx --show-all
If a pattern is use for selection show all messages that match pattern
by default only the first one is presented.

@item -d
@itemx --debug
Display mailbox debugging information.

@item -f @var{mailbox}
@itemx --folder=@var{mailbox}
Specified the default mailbox.

@item -h
@itemx --header
Show the entire header and ignore the weedlist.

@item -n
@itemx --no-header
Do not print the message header.

@item -p
@itemx --form-feed
Put form-feed (Control-L) between messages instead of newline.

@anchor{weedlist option}
@item  -w @var{weedlist}
@itemx --weedlist=@var{weedlist}
A whitespace or coma separated list of header names to show per message.
Default is @option{--weedlist="From Subject Date To CC Apparently-"}.
@end table

See also @ref{Common Options}.

@node Conf-readmsg
@subsection Configuration of @command{readmsg}.

Following configuration statements affect the behavior of
@command{readmsg}:

@deffn {Readmsg Conf} header @var{bool}
If @var{bool} is @samp{true}, display entire headers.
@end deffn

@deffn {Readmsg Conf} weedlist @var{str}
Set the weedlist.  The @var{str} argument is
a string, containing a list of header names, separated by whitespace,
commands or colons.  This corresponds to the @option{--weedlist} command
line option (@pxref{Opt-readmsg, --weedlist}).
@end deffn

@deffn {Readmsg Conf} no-header @var{bool}
If @var{bool} is @samp{true}, exclude all headers.
@end deffn

@deffn {Readmsg Conf} form-feeds @var{bool}
If @var{bool} is @samp{true}, output formfeed character between
messages.
@end deffn

@deffn {Readmsg Conf} folder @var{url}
Set the @acronym{URL} of the mailbox folder to read.
@end deffn

@deffn {Readmsg Conf} show-all-match @var{bool}
If @var{bool} is @samp{true}, print all messages matching pattern, not
only the first.
@end deffn

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{Debug Statement}.
@item tls           @tab @xref{TLS Statement}.
@item mailbox       @tab @xref{Mailbox Statement}.
@item locking       @tab @xref{Locking Statement}.
@end multitable

@node sieve
@section @command{sieve}
@pindex sieve
@UNREVISED

Sieve is a language for filtering e-mail messages at time of final
delivery, described in RFC 3028.  GNU Mailutils provides two
implementations of this language: a stand-alone @dfn{sieve interpreter}
and a @dfn{sieve translator and filter}.  The following sections describe these
utilities in detail.

@menu
* sieve interpreter::   A Sieve Interpreter
* sieve2scm::           A Sieve to Scheme Translator and Filter
@end menu

@node sieve interpreter
@subsection A Sieve Interpreter

Sieve interpreter @command{sieve} allows to apply Sieve scripts to an
arbitrary number of mailboxes.  GNU @command{sieve} implements a superset
of the Sieve language as described in RFC 3028.  @xref{Sieve Language},
for a description of the Sieve language.  @xref{GNU Extensions}, for a
discussion of differences between the GNU implementation of Sieve and
its standard.

@menu
* Invoking Sieve::
* Sieve Configuration::
* Logging and Debugging::
* Extending Sieve::
@end menu

@node Invoking Sieve
@subsubsection Invoking @command{sieve}

The @command{sieve} invocation syntax is:

@example
sieve [@var{options}] @var{script}
@end example

@noindent
where @var{script} denotes the filename of the sieve program to parse,
and @var{options} is one or more of the following:

@table @option
@item -c
@itemx --compile-only
Compile script and exit.

@item --clear-library-path
@itemx --clearpath
Clear Sieve library path.  See also @ref{Sieve Configuration,
clear-library-path}.

@item --clear-include-path
Clear Sieve include path.  See also @ref{Sieve Configuration,
clear-include-path}. 

@item -d[@var{flags}]
@itemx --debug[=@var{flags}]
Specify debug flags.  The @var{flags} argument is a sequence of one or
more of the following letters:

@multitable @columnfractions .40 .45
@item @samp{g} @tab Enable main parser traces
@item @samp{T} @tab Enable mailutils traces
@item @samp{P} @tab Trace network protocols
@item @samp{t} @tab Enable sieve trace
@item @samp{i} @tab Trace the program instructions
@end multitable

@item -D
@itemx --dump
Compile the script, dump disassembled code on standard output and exit.

@item -e @var{address}
@itemx --email @var{address}
Override the user email address.  This is useful for @code{reject} and
@code{redirect} actions.  By default, the user email address is deduced
from the user name and the full name of the machine where
@command{sieve} is executed.  See also @ref{Sieve Configuration,
email}. 

@item -I @var{dir}
@itemx --includedir=@var{dir}
Append directory @var{dir} to the list of directories searched for
include files.  See also @ref{Sieve Configuration, include-path}.

@item -f
@itemx --mbox-url=@var{mbox}
Mailbox to sieve (defaults to user's system mailbox).  See also
@ref{Sieve Configuration, mbox-url}.

@item -k
@itemx --keep-going
Keep on going if execution fails on a message.  See also
@ref{Sieve Configuration, keep-going}.

@item -L @var{dir}
@itemx --libdir=@var{dir}
Append directory @var{dir} to the list of directories searched for
library files.  See also @ref{Sieve Configuration, library-path}.

@item --libdir-prefix=@var{dir}
Add @var{dir} to the beginning of the list of directories searched for
library files.

@item -M @var{url}
@itemx --mailer=@var{url}
Define the URL of the default mailer.

@item -n
@itemx --no-actions
@itemx --dry-run
Dry run: do not execute any actions, just print what would be done.

@item --no-program-name
Do not prefix diagnostic messages with the program name.

@item -t @var{ticket}
@itemx --ticket=@var{ticket}
Ticket file for mailbox authentication.  See also
@ref{Sieve Configuration, ticket}.

@item -v
@itemx --verbose
Log all actions executed.  See also @ref{Sieve Configuration, verbose}.
@end table

See also @ref{Common Options}.

@node Sieve Configuration
@subsubsection Sieve Configuration

The behavior of @command{sieve} is affected by the following
configuration statements:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item tls           @tab @xref{tls statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@item logging       @tab @xref{logging statement}.
@item mailer        @tab @xref{mailer statement}.
@end multitable

The following statements configure sieve-specific features:

@deffn {Sieve Conf} sieve @{ ...  @}
This block statement configures search paths @command{sieve} uses to
locate its loadable modules.  @xref{Require Statement}, for a detailed
information about loadable modules.

This statement may contain the following sub-statements:

@deffn {Sieve Conf} clear-library-path @var{bool}
If @var{bool} is @samp{true}, clear library search path.
@end deffn

@deffn {Sieve Conf} clear-include-path @var{bool}
If @var{bool} is @samp{true}, clear include search path.
@end deffn

@deffn {Sieve Conf} library-path @var{path}
Add directories to @command{sieve} library search path.  Argument is a
string containing a colon-separated list of directories.
@end deffn

@deffn {Sieve Conf} library-path-prefix @var{path}
Add directories to the beginning if the library search path.  Argument
is a string containing a colon-separated list of directories.
@end deffn

@deffn {Sieve Conf} include-path @var{path}
Add directories to the include search path.  Argument is a
string containing a colon-separated list of directories.
@end deffn
@end deffn

@deffn {Sieve Conf} keep-going @var{bool}
If @var{bool} is @samp{true}, do not abort if execution of a Sieve
script fails on a particular message.
@end deffn

@deffn {Sieve Conf} mbox-url @var{url}
Sets @acronym{URL} of the mailbox to be processed.
@end deffn

@deffn {Sieve Conf} ticket @var{file}
Sets the name of the ticket file for user authentication.
@end deffn

@deffn {Sieve Conf} debug @var{flags}
Sets Sieve debug flags.  @xref{Logging and Debugging}, for a detailed
description.
@end deffn

@deffn {Sieve Conf} verbose @var{bool}
If @var{bool} is @samp{true}, log all executed actions.
@end deffn

@deffn {Sieve Conf} line-info @var{bool}
If @var{bool} is @samp{true}, print source locations along with action
logs.  This statement takes effect only if @code{verbose true} is also
set.
@end deffn

@deffn {Sieve Conf} email @var{addr}
Set user e-mail address.  This is useful for @code{reject} and
@code{redirect} actions.  By default, the user email address is deduced
from the user name and the full name of the machine where @command{sieve} is
executed. 
@end deffn

@node Logging and Debugging
@subsubsection Logging and debugging

The default behavior of @command{sieve} is to remain silent about
anything except errors.  However, it is sometimes necessary to see
which actions are executed and on which messages.  This is particularly
useful when debugging the sieve scripts.  The @option{--verbose}
(@option{-v}) option outputs log of every action executed.

Option @option{--debug} allows to produce even more detailed debugging
information.  This option takes an argument specifying the
debugging level to be enabled.  The argument can consist of the
following letters:

@table @samp
@item t
This flag enables sieve tracing.  It means that every test will be logged
when executed.

@item T
This flag enables debugging of underlying @code{mailutils} library.

@item P
Trace network protocols: produces log of network transactions executed
while running the script.

@item g
Enable main parser traces.  This is useful for debugging the sieve grammar.

@item i
Trace the program instructions.  It is the most extensive debugging
level.  It produces the full execution log of a sieve program, showing
each instruction and states of the sieve machine.  It is only useful
for debugging the code generator.
@end table

@emph{Note}, that there should be no whitespace
between the short variant of the option (@option{-d}), and its
argument.  Similarly, when using long option (@option{--debug}),
its argument must be preceded by equal sign.

If the argument to @option{--debug} is omitted, it defaults to
@samp{TPt}. 

Option @option{--dump} produces the disassembled dump of the compiled
sieve program. 

By default @command{sieve} outputs all diagnostics on standard error and verbose
logs on standard output.  This behaviour is changed when
@option{--log-facility} is given in the command line (@FIXME-pxref{logging}).
This option causes @command{sieve} to output its diagnostics to
the given syslog facility.

@node Extending Sieve
@subsubsection Extending @command{sieve}

The basic set of sieve actions, tests and comparators may be extended
using loadable extensions.  The usual @code{require} mechanism is used for
that.

When processing arguments for @code{require} statement, @command{sieve}
uses the following algorithm:

@enumerate 1
@item Look up the name in a symbol table.  If the name begins with
@samp{comparator-} it is looked up in the comparator table.  If it
begins with @samp{test-}, the test table is searched instead.  Otherwise
the name is looked up in the action table.

@item If the name is found, the search is terminated.

@item Otherwise, transform the name.  First, any @samp{comparator-} or
@samp{test-} prefix is stripped.  Then, any character other than
alphanumeric characters, @samp{.} and @samp{,} is replaced with
dash (@samp{-}).  The name thus obtained is used as a file name
of an external loadable module. 

@item Try to load the module.  The module is searched in the
following search paths (in the order given):

@enumerate 1
@item Mailutils module directory.  By default it is
@file{$prefix/lib/mailutils}.

@item The value of the environment variable @env{LTDL_LIBRARY_PATH}.

@item Additional search directories specified with the.
@option{--libdir-prefix} command line option (@pxref{Invoking Sieve,
libdir-prefix}), or the @code{library-path-prefix} configuration
statement (@pxref{Sieve Configuration,library-path-prefix}).

@item Additional search directories specified with the
@code{library-path} statement (@pxref{Sieve Configuration,
library-path}) in Sieve configuration file.

@item Additional search directories specified with the.
@option{--libdir} command line option (@pxref{Invoking Sieve,libdir}).

@item Additional search directories specified with the
@code{#searchpath} Sieve directive (@pxref{#searchpath}).

@item System library search path: The system dependent library
search path (e.g. on Linux it is set by the contents of the file
@file{/etc/ld.so.conf} and the value of the environment variable
@env{LD_LIBRARY_PATH}).
@end enumerate

The value of @env{LTDL_LIBRARY_PATH} and @env{LD_LIBRARY_PATH} must be
a colon-separated list of absolute directories, for example,
@samp{"/usr/lib/mypkg:/lib/foo"}.

In any of these directories, @command{sieve} first attempts to find
and load the given filename.  If this fails, it tries to append the
following suffixes to the file name:

@enumerate 1
@item the libtool archive extension @samp{.la}

@item the extension used for native dynamic libraries on the host
platform, e.g., @samp{.so}, @samp{.sl}, etc.
@end enumerate

@item If the module is found, @command{sieve} executes its
initialization function (see below) and again looks up the name
in the symbol table.  If found, search terminates successfully.

@item If either the module is not found, or the symbol wasn't
found after execution of the module initialization function,
search is terminated with an error status.  @command{sieve} then displays
the following diagnostic message:

@example
source for the required action NAME is not available
@end example
@end enumerate
 
@c ***********************************************************************

@page
@node sieve2scm
@subsection A Sieve to Scheme Translator and Filter
@UNREVISED

A Sieve to Scheme Translator @command{sieve2scm} translates a given
Sieve script into an equivalent Scheme program and optionally executes
it.  The program itself is written in Scheme and requires presence of
Guile version 1.8 or newer on the system.  For more information on
Guile refer to @ref{Top,,Overview,guile,The Guile Reference Manual}.

@table @option
@item -f @var{filename}
@itemx --file @var{filename}
Set input file name.

@item -o @var{filename}
@itemx --output @var{filename}
Set output file name

@item -L @var{dirname}
@itemx --lib-dir @var{dirname}
Set sieve library directory name

@item -d @var{level}
@itemx --debug @var{level}
Set debugging level
@end table            

The Scheme programs produced by @command{sieve2scm} can be used with
@command{guimb} or @command{maidag}.

@c ***********************************************************************

@page
@node guimb
@section @command{guimb} --- A Mailbox Scanning and Processing Language
@pindex guimb

@command{Guimb} is an experimental tool that iterates over messages in
a mailbox (or several mailboxes), applying a Scheme function to each
of them.

A user-defined @dfn{scheme module} that supplies the function to apply
is specified using the @option{--source} or @option{--file} option.
The module must define at least the following function:

@deffn {User function} guimb-message @var{msg}
Processes message @var{msg}.  This function can alter the message
using Guile primitives supplied by mailutils.
@end deffn

The following function definitions are optional:

@deffn {User function} guimb-getopt @var{args}
If defined, this function is called after @command{guimb} has finished
processing the command line.  @var{args} is a list of unconsumed
command line arguments.

The function is intended to provide a way of configuring the module
from the command line.
@end deffn

@deffn {User function} guimb-end
If defined, this function is called after all mailboxes have been processed.
@end deffn

In the following example we define a module that prints
information about each message is the input mailbox, in a way similar
to @code{frm} utility:

@example
@group
(define-module (frm)
  :export (guimb-message))

(use-modules (mailutils mailutils))
             
(define (guimb-message msg)
  (display (mu-message-get-sender msg))
  (display " ")
  (display (mu-message-get-header msg "subject"))
  (newline))
@end group
@end example

The modules are looked up in directories listed in the global variable
@code{%load-path}.  New directories can be added to that variable on
the fly using the @option{-L} (@option{--load-path}) option.  For
example, if the sample module above was saved in a file
@file{frm.scm} somewhere in the load path, it can be applied to the
current user inbox by running the following command:

@example
guimb --file frm
@end example

@menu
* Specifying Scheme Program to Execute::
* Specifying Mailboxes to Operate Upon::
* Passing Options to Scheme::
* Command Line Option Summary::
@end menu

@node Specifying Scheme Program to Execute
@subheading Specifying Scheme Program to Execute

The Scheme module that defines message processing functions is given
via the following options:

@table @option
@item -s @var{module}
@itemx --source @var{module}
Load Scheme code from @var{module}.

This option stops further argument processing, and passes all
remaining arguments as the value of @var{args} argument to the
@code{guimb-getopt} function, if it is defined.

@item -f @var{module}
@itemx --file @var{module}
Load Scheme source code from @var{module}.  The remaining arguments
are processed in the usual way.  When using this option, you can pass
additional options and or arguments to the module by enclosing them in
@option{-@{} and @option{-@}} options (@pxref{Passing Options to Scheme}).
@end table

An experimental option is provided, that evaluates a supplied
Scheme expression right after loading the module:

@table @option
@item -e @var{expr}
@itemx --expression @var{expr}
Evaluate scheme expression.
@end table

@node Specifying Mailboxes to Operate Upon
@subheading Specifying Mailboxes to Operate Upon

There are four basic ways of passing mailboxes to @command{guimb}.

@table @code
@item guimb [@var{options}] [@var{mailbox}...]
The resulting mailbox is not saved, unless the user-supplied
scheme program saves it.
@item guimb [@var{options}] --mailbox @var{defmbox}
The contents of @var{defmbox} is processed and is replaced with the resulting
mailbox contents.  Useful for applying filters to user's mailbox.
@item guimb [@var{options}] --mailbox @var{defmbox} @var{mailbox} [@var{mailbox}...]
The contents of specified mailboxes is processed, and the resulting
mailbox contents is appended to @var{defmbox}.
@item guimb [@var{options}] --user @var{username} [@var{mailbox}...]
The contents of specified mailboxes is processed, and the resulting
mailbox contents is appended to the user's system mailbox.  This makes
it possible to use @command{guimb} as a mail delivery agent.
@end table

If no mailboxes are specified in the command line, @command{guimb} reads
and processes the system mailbox of the current user.

@node Passing Options to Scheme
@subheading Passing Options to Scheme

Sometimes it is necessary to pass some command line options to the
scheme procedure.  There are three ways of doing so.

When using @option{--source} (@option{-s}) option, the rest of the
command line following the option's argument is passed as the
@var{args} argument to the @code{guimb-getopt} function, if such
function is defined.  This allows for making guimb scripts executable
by the shell.  If your system supports @samp{#!} magic at the start of
scripts, add the following two lines to the beginning of your script
to allow for its immediate execution: 

@example
#! /usr/local/bin/guimb -s
!#
@end example

@noindent
(replace @samp{/usr/local/bin/} with the actual path to the @command{guimb}).

Otherwise, if you use the @option{--file} option, the additional
arguments can be passed to the Scheme program @option{-g} 
(@option{--guile-arg}) command line option.  For example:

@example
guimb --guile-arg -opt --guile-arg 24 --file @var{progfile}
@end example

In this example, the @code{guimb-getopt} function will get the
following argument

@example
( '-opt' 24 )
@end example

Finally, if there are many arguments to be passed to Scheme, it is more
convenient to enclose them in @option{-@{} and @option{-@}} escapes:

@example
guimb -@{ -opt 24 -@} --file @var{progfile}
@end example

@node Command Line Option Summary
@subheading Command Line Option Summary

This is a short summary of the command line options available to
@command{guimb}.

@table @option
@item -d
@itemx --debug
Start with debugging evaluator and backtraces.
@item -e @var{expr}
@itemx --expression @var{expr}
Execute given Scheme expression.
@item -L @var{dir}
@item --load-path @var{dir}
Insert @var{dir} at the beginning of the @code{%load-path} list.  The
argument is either a single directory name, or a list of such names,
delimited by @samp{:} characters.
@item -m @var{path}
@itemx --mail-spool=@var{path}
Set path to the mailspool directory
@item -f @var{progfile}
@itemx --file @var{progfile}
Read Scheme program from @var{progfile}.
@item -g @var{arg}
@itemx --guile-command @var{arg}
Append @var{arg} to the command line passed to Scheme program.
@item -@{ ... -@}
Pass all command line options enclosed between @option{-@{} and @option{-@}}
to Scheme program.
@item -m
@itemx --mailbox @var{mbox}
Set default mailbox name.
@item -u
@itemx --user @var{name}
Act as local MDA for user @var{name}.
@item -h
@itemx --help
Display help message.
@item  -v
@itemx --version
Display program version.
@end table

@page
@node maidag
@section maidag
@pindex maidag
@UNREVISED

The name @samp{maidag} stands for @i{Mai}l @i{d}elivery @i{ag}ent.  It
is a general-purpose @acronym{MDA} offering a rich set of
features.  It can operate both in traditional mode, reading the message
from its standard input, and in @acronym{LMTP} mode.  @command{Maidag}
is able to deliver mail to any mailbox format, supported by GNU
Mailutils.  These formats, among others, include @samp{smtp://},
@samp{prog://} and @samp{sendmail://} which are
equivalent to forwarding a message over @acronym{SMTP} to a remote
node.  Thus, @command{maidag} supersedes both @command{mail.local} and
@command{mail.remote} utilities from GNU Mailutils versions prior to
2.0.

@command{Maidag} is also able to process incoming messages using
Sieve, Scheme or Python scripts and, based on results of this
processing, to take a decision on whether to actually deliver and
where to deliver them.  Due to its extensive scripting facilities,
@command{maidag} offers much more flexibility than other popular
@acronym{MDA}s, such as @command{procmail}.

@menu
* Sendmail-maidag::         Using @command{maidag} with Sendmail.
* Exim-maidag::             Using @command{maidag} with Exim.
* MeTA1-maidag::            Using @command{maidag} with MeTA1.
* Mailbox Quotas::
* Maidag Scripting::
* Forwarding::
* Url-mode::                Delivering Messages to a URL.
* Remote Mailbox Delivery::
* Conf-maidag::             Maidag Configuration File Summary
@end menu

@node Sendmail-maidag
@subsection Using @command{maidag} with Sendmail.
@cindex Sendmail
When used as a @acronym{MDA} with Sendmail, @command{maidag} must be
invoked from the local mailer definition in the @file{sendmail.cf}
file.  It must have the following flags set: @samp{lswS}.  These mean:
the mailer is local, quote characters should be stripped off the
address before invoking the mailer, the user must have a valid account
on this machine and the userid should not be reset before calling the 
mailer.  Additionally, the flags @samp{fn} may be specified to allow
@command{maidag} to generate the usual @samp{From } envelope instead
of the one supplied by @command{sendmail}. 

If you wish to use @command{maidag} with non-local authentication,
such as @acronym{SQL} or @acronym{LDAP}, you also need to remove the
@samp{w} flag, since in that case the user is not required to have a
valid account on the machine that runs @command{sendmail}.

Here is an example of mailer definition in @file{sendmail.cf}

@example 
Mlocal, P=/usr/local/sbin/maidag,
        F=lsDFMAw5:/|@@qSPfhn9,
        S=EnvFromL/HdrFromL, R=EnvToL/HdrToL,
        T=DNS/RFC822/X-Unix,
        A=mail $u
@end example

To define local mailer in @samp{mc} source file, it will suffice to
set:

@example
define(`LOCAL_MAILER_PATH', `/usr/local/sbin/maidag')
define(`LOCAL_MAILER_ARGS', `mail $u')
@end example

@node Exim-maidag
@subsection Using @command{maidag} with Exim.
@cindex Exim

Using @command{maidag} with Exim is quite straightforward.  The
following example illustrates the definition of the appropriate transport
and director in @file{exim.conf}:

@example
# transport
maidag_pipe:
  driver = pipe
  command = /usr/local/sbin/maidag $local_part
  return_path_add
  delivery_date_add
  envelope_to_add
  
# director
maidag:
  driver = localuser
  transport = maidag_pipe
@end example

@node MeTA1-maidag
@subsection Using @command{maidag} with MeTA1.
@cindex LMTP
@cindex MeTA1
MeTA1 (@uref{http://meta1.org}) communicates with the delivery agent
using @acronym{LMTP}.

LMTP mode is enabled in @command{maidag} by the @samp{lmtp yes}
statement.  The socket to listen on must be specified using
@code{server} statement (@pxref{Server Settings}).  For the purposes of
this section, let's suppose @command{maidag} will listen on a
@acronym{UNIX} socket @file{/var/spool/meta1/lmtpsock}.  Then, the
following (minimal) @command{maidag} configuration will do the job:

@example
# @r{Start in LMTP mode.}
lmtp yes;
# @r{Run as daemon.}
mode daemon;
# @r{Switch to this group after startup.}
group meta1c;
# @r{Configure server:}
server unix:///var/spool/meta1/lmtpsock @{
  transcript no;
@};
@end example
  
To configure MeTA1 to use this socket, add the following statement to
the @samp{smtpc} section in @file{/etc/meta1/meta1.conf}:

@example
  LMTP_socket="lmtpsock";
@end example

@node Mailbox Quotas
@subsection Mailbox Quotas

@dfn{Mailbox quota} is a limit on the size of the mailbox.  When a
mailbox size reaches this limit, @command{maidag} stops accepting
messages for this recipient and returns an error condition to the
sender.  The error code is accompanied by the following error message:

@example
@var{user}: mailbox quota exceeded for this recipient
@end example

Furthermore, if accepting the incoming message would make the
mailbox size exceed the quota, such a message will be rejected as
well.  In this case, the error message is:

@example
@var{user}: message would exceed maximum mailbox size for this recipient
@end example

In both cases, the default return code will be @samp{service
unavailable} (corresponding to the @acronym{SMTP} return code
@samp{550}), unless the following statement is present in the
@command{maidag} configuration file:

@example
exit-quota-tempfail yes;
@end example

@noindent
in which case a temporary error will be returned.

The mailbox quota can be retrieved from the following sources:

@enumerate 1
@item Authentication method.
@item @acronym{DBM} file.
@item @acronym{SQL} database.
@end enumerate

@menu
* DBM Quotas::          Keeping Quotas in DBM File.
* SQL Quotas::          Keeping Quotas in SQL Database.
@end menu

@node DBM Quotas
@subsubsection Keeping Quotas in DBM File

To use @acronym{DBM} quota database, GNU Mailutils must
be compiled with one of the following command line options:
@option{--with-gdbm}, @option{--with-berkeley-db}, @option{--with-ndbm},
@option{--with-tokyocabinet}, or @option{--with-kyotocabinet}.
Examine the output of @command{maidag --show-config-options}, if not sure. 

The quota database should have the following structure:

@table @asis
@item Key
Key represents the user name.  Special key @samp{DEFAULT} means default
quota value, i.e. the one to be used if the user is not explicitly
listed in the database.

@item Value
Mailbox quota for this user.  If it is a number, it represents the
maximum mailbox size in bytes.  A number may optionally be followed by
@samp{kb} or @samp{mb}, meaning kilobytes and megabytes, respectively.

A special value @samp{NONE} means no mailbox size limit for this user.
@end table

Here is an example of a valid quota database

@example
# Default quota value:
DEFAULT         5mb

# Following users have unlimited mailbox size
root            NONE
smith           NONE

# Rest of users
plog            26214400
karin           10mB
@end example

To use the @acronym{DBM} quota database, specify its absolute name using
@code{quota-db} configuration statement, e.g.:

@example
quota-db /etc/mail/quota.db;
@end example

@node SQL Quotas
@subsubsection Keeping Quotas in SQL Database

Configuration statement @code{quota-query} allows to specify a special
query to retrieve the quota from the database.  Currently (as of mailutils
version @value{VERSION}) it is assumed that this table can be accessed
using the credentials set in @samp{sql} configuration statement
(@pxref{SQL Statement}).

For example, suppose you have the following quota table:

@example
create table mailbox_quota (
  user_name varchar(32) binary not null,
  quota int,
  unique (user_name)
);
@end example

@noindent

To retrieve user quota the following query can be used:

@example
SELECT quota FROM mailbox_quota WHERE user_name='$@{user@}'
@end example

There are no special provisions for specifying group quotas, similar to
@samp{DEFAULT} in @acronym{DBM} databases.  This is because group quotas can
easily be implemented using @acronym{SQL} language.  @command{Maidag}
always uses the first tuple from the set returned by mailbox quota
query.  So, you may add a special entry to the @code{mailbox_quota}
table that would keep the group quota.  In the discussion below we assume
that the @code{user_name} column for this entry is lexicographically
less than any other user name in the table.  Let's suppose the group
quota name is @samp{00DEFAULT}.  Then the following query:

@example
SELECT quota
FROM mailbox_quota
WHERE user_name IN ('$@{user@}','00DEFAULT')
ORDER BY user_name DESC
@end example

@noindent
will return two tuples if the user is found in
@code{mailbox_quota}.  Due to @code{ORDER} statement, the first tuple
will contain the quota for the user, which will be used by
@command{maidag}.  On the other hand, if the requested user name is not
present in the table, the above query will return a single tuple
containing the group quota.

The following configuration statement instructs @command{maidag} to
use this query for retrieving the user quota:

@example
quota-query "SELECT quota "
            "FROM mailbox_quota "
            "WHERE user_name IN ('$@{user@}','00DEFAULT') "
            "ORDER BY user_name DESC";
@end example

@node Maidag Scripting
@subsection Maidag Scripting
@command{Maidag} can use global or per-user @dfn{mail filters} to
decide whether to deliver the message, and where to deliver it.  As of
Mailutils version @value{VERSION}, such mail filters may be written in
the following languages:

@itemize @bullet
@item Sieve
@xref{Sieve Language}.

@item Scheme
@item Python
@end itemize

Mail filters to use are specified using @samp{script} configuration
statement.  The following meta-symbols can be used in its argument:

@table @asis
@item ~
@itemx %h
Expands to the recipient home directory.

@item %u
Expands to the recipient user name.
@end table

By default, the filename extension decides which scripting language will
be used.  User can alter the choice using @samp{language} configuration
statement.  For example:

@example
language "python"
script "~/.maidag-py-filter"
@end example

@menu
* Sieve Maidag Filters::
* Scheme Maidag Filters::
* Python Maidag Filters::
@end menu

@node Sieve Maidag Filters
@subsubsection Sieve Maidag Filters
@kwindex script
The file name of the Sieve filter to use is specified using
@samp{script} configuration statement.  For example, the following
configuration statement:

@example
script "~/.maidag.sv"
@end example

@noindent
instructs @command{maidag} to use file @file{.maidag.sv} in the
recipient home directory as a Sieve filter.

Normal message delivery is attempted if execution of the Sieve code
ended with @code{keep} action (either implicit or explicit).

Other Sieve actions are executed as described in @ref{Actions}.  For
example, to deliver message to another mailbox, use the
@code{fileinto} action. 

Any modifications to headers or body of the message performed by the
Sieve code will be visible in the delivered message.

@node Scheme Maidag Filters
@subsubsection Scheme Maidag Filters
@kwindex script
The file name of the Scheme mail filter is specified using
@samp{script} configuration statement.  For example, the following
configuration statement:

@example
script "~/.maidag.scm"
@end example

@noindent
instructs `maidag' to use file `.maidag.scm' in the recipient home
directory as a Scheme filter.

@node Python Maidag Filters
@subsubsection Python Maidag Filters
@kwindex script

The file name of the Python mail filter is specified using
@samp{script} configuration statement.  For example, the following
configuration statement:

@example
script "~/.maidag.py"
@end example

@noindent
instructs `maidag' to use file `.maidag.py' in the recipient home
directory as a Python filter.

@noindent
A simple example of a mail filter written in Python:

@example
from mailutils import *
import maidag
import re

msg = message.Message (maidag.message)
hdr = msg.header

try:
    if 'List-Post' in hdr and 'Received' in hdr \
       and hdr['Received'].find ('fencepost.gnu.org') != -1:

        # check envelope's sender address
        m = re.search (r'([\w\-]+)-bounces\+([\w]+)=.*',
                       msg.envelope.get_sender ())
        if m:
            lbox = m.group (1)
            user = m.group (2)
            # open destination mailbox and append message
            dst = mailbox.MailboxDefault ('~/Mail/%s' % lbox)
            dst.open ('ac')
            dst.append_message (msg)
            dst.close ()
            # set deleted flag so maidag will not deliver msg elsewhere
            msg.attribute.set_deleted ()
except Exception:
    pass
@end example

@node Forwarding
@subsection Forwarding
@cindex forward
@dfn{Forward file} is a special file in the user's home directory that
contains the email address of the mailbox where the user wants to
forward his mail.  Normally, forward files are processed by
@acronym{MTA}.  However, there are some @acronym{MTA} that lack this
feature.  One of them is MeTA1.

@command{Maidag} provides a forwarding feature that is useful to
compensate the lack of it.

@kwindex forward-file
Name of the forward file is given using @code{forward-file}
configuration statement.  A common usage is:

@example
forward-file .forward;
@end example

The forward file is always searched in the recipient home directory.

@kwindex forward-file-checks
Before actually using the file, a number of safety checks are
performed on it.  If the file fails to pass one of these checks, no
forwarding is performed and the message is delivered as usual.  These
checks can be configured using @code{forward-file-checks} statement.
Its argument is a list of the following keywords:

@table @asis
@item groupwritablefile
@itemx file_iwgrp
The file must not be group writable.

@item worldwritablefile
@itemx file_iwoth
The file must not be world writable.

@item linkedfileinwritabledir
@itemx link
The file cannot be a symlink in a writable directory.

@item fileingroupwritabledir
@itemx dir_iwgrp
The file cannot reside in a group writable directory.

@item fileinworldwritabledir
@itemx dir_iwoth
The file cannot reside in a world writable directory.

@item all
All of the above checks.
@end table

The default is @samp{forward-file-checks all}.

Each of these keywords may be prefixed by @samp{no} to disable this
particular check.  For example:

@example
forward-file-checks (nodir_iwoth, nodir_iwgrp);
@end example

@node Url-mode 
@subsection Delivering Messages to a URL.
When invoked with the @option{--url} command line option,
@command{maidag} treats its arguments as a list of mailbox
@acronym{URL}s and attempts to deliver the message to each of them.

For example:

@example
$ maidag --url maildir:///home/smith/Mail
@end example

@node Remote Mailbox Delivery
@subsection Remote Mailbox Delivery
@command{Maidag} can be used to deliver mail to remote mailboxes, such
as @samp{imap} or @samp{smtp}.  If the mailbox @acronym{URL}
is @samp{smtp} or @samp{sendmail}, the message is
actually forwarded over @acronym{SMTP} to the remote node, so
@command{maidag} acts as a message transfer agent.  For example:

@example
$ maidag --url smtp://10.10.1.100:24
@end example

This command line will send the message to the machine
@samp{10.10.1.100} using port @samp{24} (private mail system).

The @samp{prog} mailbox may be of special use.  Delivering to
this mailbox results in invoking the specified command with the given
arguments and passing the message to its standard input.  There are two
ways to specify a @samp{prog} mailbox:

@table @asis
@item prog://@var{program}?@var{args}
Here, @var{program} is the absolute pathname of the program binary,
and @var{args} are its arguments, separated by @samp{&} signs.

@item |@var{program} @var{args}
In this notation, @var{args} are command line arguments separated by
white space.
@end table

In both cases, @var{args} do not include @code{argv[0]}.

The @samp{prog} mailbox may be used, in particular, to implement
mailing lists with MeTA1.

For example, suppose that the @command{maidag} configuration contains:

@example
auth @{
  authorization sql:system;
  authentication generic:system;
@}

sql @{
  interface mysql;
  db mail;
  getpwnam "SELECT user as name, mailbox, "
           "'x' as passwd, 500 as uid, 2 as gid, "
           "'/nonexistent' as dir, '/sbin/nologin' as shell "
           "FROM userdb "
           "WHERE user='$@{user@}'";
@}
@end example

Then, the following entries in the @samp{userdb} table implement
@email{mailman@@yourdomain} mailing list:

@example
mysql> select * from userdb;
+---------------------+---------------------------------------+
| user                | mailbox                               |
+---------------------+---------------------------------------+
| mailman             | |/usr/bin/mailman post mailman        |
| mailman-admin       | |/usr/bin/mailman admin mailman       |
| mailman-bounces     | |/usr/bin/mailman bounces mailman     |
| mailman-confirm     | |/usr/bin/mailman confirm mailman     |
| mailman-join        | |/usr/bin/mailman join mailman        |
| mailman-leave       | |/usr/bin/mailman leave mailman       |
| mailman-owner       | |/usr/bin/mailman owner mailman       |
| mailman-request     | |/usr/bin/mailman request mailman     |
| mailman-subscribe   | |/usr/bin/mailman subscribe mailman   |
| mailman-unsubscribe | |/usr/bin/mailman unsubscribe mailman |
+---------------------+---------------------------------------+
@end example

@node Conf-maidag
@subsection Maidag Configuration File Summary

The behavior of @command{maidag} is affected by the following configuration
statements:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@item pam           @tab @xref{pam statement}.
@item sql           @tab @xref{sql statement}.
@item virtdomain    @tab @xref{virtdomain statement}.
@item radius        @tab @xref{radius statement}.
@item ldap          @tab @xref{ldap statement}.
@item auth          @tab @xref{auth statement}.
@item mailer        @tab @xref{mailer statement}.
@item server        @tab @xref{Server Settings}.  Used only in
@acronym{LMTP} mode.
@item acl           @tab @xref{acl statement}.
@item tcp-wrappers  @tab @xref{tcp-wrappers statement}.
@end multitable

@deffn {Maidag Config} ex-multiple-delivery-success @var{bool}
In case of multiple delivery, exit with code 0 if at least one
delivery has succeeded.
@end deffn

@deffn {Maidag Config} ex-quota-tempfail @var{bool}
Indicate temporary failure if the recipient is over his mail quota.
By default, permanent failure is returned.  @xref{Mailbox Quotas}.
@end deffn

@deffn {Maidag Config} quota-db @var{file}
Set the name of DBM quota database file.  @xref{DBM Quotas}.
@end deffn

@deffn {Maidag Config} sieve-filter @var{pattern}
Set file name or name pattern of the Sieve filter file.
@xref{Sieve Maidag Filters}.
@end deffn

@deffn {Maidag Config} message-id-header @var{name}
When logging Sieve actions, identify messages by the value of this
header.
@end deffn

@deffn {Maidag Config} guile-filter @var{pattern}
File name or name pattern for Guile filter file.
@xref{Scheme Maidag Filters}.
@end deffn

@deffn {Maidag Config} debug @var{flags}
Set additional debugging flags.  Valid flags are:

@table @asis
@item g
Print @command{guimb} stack traces.

@item t
Enable @command{sieve} trace (@code{MU_SIEVE_DEBUG_TRACE}).

@item i
Enable @command{sieve} instructions trace
(@code{MU_SIEVE_DEBUG_INSTR}).

@item l
Log executed Sieve actions.
@end table
@end deffn

@deffn {Maidag Config} stderr @var{bool}
Log to stderr instead of syslog.
@end deffn

@deffn {Maidag Config} forward-file @var{file}
Process forward file @var{file}.  @xref{Forwarding}.
@end deffn

@deffn {Maidag Config} forward-file-checks @var{list}
Configure safety checks for the forward file.
@xref{Forwarding, forward-file-checks}.
@end deffn

@deffn {Maidag Config} lmtp @var{bool}
Run in @acronym{LMTP} mode.
@end deffn

@deffn {Maidag Config} group @var{list}
In @acronym{LMTP} mode, retain supplementary groups from @var{list}.
@end deffn

@deffn {Maidag Config} listen @var{url}
In @acronym{LMTP} mode, listen on @var{url}.  Valid @acronym{URL}s are:
@samp{tcp://@var{host}:@var{port}} (note that port is mandatory),
@samp{file://@var{socket-file-name}} or
@samp{socket://@var{socket-file-name}}.
@end deffn

@deffn {Maidag Config} reuse-address @var{bool}
Reuse existing address (@acronym{LMTP} mode).  Default is @samp{yes}.
@end deffn

@page
@node mimeview
@section mimeview
@pindex mimeview

  For each file given in its command line, @command{mimeview} attempts
to autodetect its type and invoke an appropriate file viewer.

  To detect the file type, @command{mimeview} uses @file{mime.types}
file.  This file is a part of Common UNIX Printing System,
@ref{mime.types,,,mime.types(5), mime.types man page}.  By default
@command{mimeview} searches for @file{mime.types} in
@file{$prefix/etc/cups/}@footnote{The exact location is determined at
configuration time by setting environment variable
@env{DEFAULT_CUPS_CONFDIR}.  On most sites running 

@example
./configure DEFAULT_CUPS_CONFDIR=/etc/cups
@end example

@noindent
should be recommended.}, however its exact location can be specified
at runtime as well (see @option{--mimetypes} below).

  Once file MIME type is successfully determined, @command{mimeview}
consults @file{mailcap} files in order to determine how to display
the file.  It does so essentially in the same manner as
@command{metamail} utility, i.e., it scans all files specified
in @code{METAMAIL} environment variable until it finds an entry
describing the desired file format or until the list of files is
exhausted.  If @code{METAMAIL} variable is not set, @command{mimeview}
uses the following default path instead:

@example
$HOME/.mailcap:/usr/local/etc/mailcap:\
 /usr/etc/mailcap:/etc/mailcap:\
 /etc/mail/mailcap:/usr/public/lib/mailcap
@end example

@menu
* Mimeview Invocation::
* Mimeview Config::
@end menu

@node Mimeview Invocation
@subsection Mimeview Invocation

  The following table summarizes options specific for @command{mimeview}:

@table @option
@item -a[@var{type-list}]
@itemx --no-ask[=@var{type-list}]
By default @command{mimeview} asks for confirmation before running
interpreter to view a message.  If this option is used without
argument, it disables the default behavior for all message
types.  Otherwise, if argument @var{type-list} is given, it specifies
a comma-separated list of MIME types for which no questions should be
asked.  Elements of this list may include shell-style globbing
patterns, e.g. setting

@example
--no-ask='text/*,image/jpeg'
@end example

@noindent
will disable prompting before displaying any textual files, no
matter what their subtype is, and before displaying files with
type @samp{image/jpeg}.

  Notice, that when the long form is used, its argument
must be separated from the option by a single equal sign, as shown
in the example above.  When the short form (@option{-a}) is used, its argument
must follow the option immediately, without any intervening whitespace,
e.g.  @option{-a'text/*'}). 

@item -d[@var{flags}]
@itemx --debug[=@var{flags}]
Enables debugging output.  @var{Flags} is a sequence of characters
specifying the desired debugging level.  Following characters are
meaningful in @var{flags}:

@table @asis
@item g
Enables debugging of @file{mime.types} parser

@item l
Enables debugging of @file{mime.types} lexical analyzer (warning:
produces @emph{very} copious output)

@item 1
Prints basic information about actions to be executed and reports
about exit status of executed commands.

@item 2
Additionally displays each file name along with its MIME type

@item 3
Additionally traces the process of looking up the matching entry
in @code{mailcap} files.

@item digits from 4 to 9
The same as 3, currently.
@end table

If @var{flags} are not given, the default @samp{9} is assumed.

@item --metamail[=@var{file}]
Run @command{metamail} to display files, instead of using the internal
mechanisms.  If @var{file} is specified, it is taken as
@command{metamail} command line.

@item -h
@itemx --no-interactive
@itemx --print
This options tells @command{mimeview} that it should run in
non-interactive mode.  In this mode prompting is disabled, and
the normal mailcap @code{command} field is not executed.  Instead
@command{mimeview} will execute the command specified in
the @code{print} field.  If there is nothing in the print field,
the mailcap entry is ignored and the search continues for a matching
mailcap entry that does have a @code{print} field.

Notice, that unlike in @command{metamail -h}, this option does
not force @command{mimeview} to send the output to the printer
daemon.

When used with @option{--metamail} option, this option passes
@option{-h} flag to the invocation of @command{metamail}.

By default @command{mimeview} behaves as if given
@option{--no-interactive} option whenever its standard input is not
a @asis{tty} device.

@item -n
@itemx --dry-run
Do not do anything, just print what would be done.  Implies
@option{--debug=1}, unless the debugging level is set up explicitly.

@item -t @var{file}
@itemx --mimetypes @var{file}
Use @var{file} as @file{mime.types} file.  If @var{file} is a
directory, use @file{@var{file}/mime.types}
@end table

@node Mimeview Config
@subsection Mimeview Config

The following configuration statements affect the behavior of
@command{mimeview}:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug @tab @xref{Debug Statement}.
@end multitable

@deffn {Mimeview Config} debug @var{number}
Set @command{mimeview} debug level.  @xref{Mimeview Invocation,
--debug}, for a description of debug levels.
@end deffn

@deffn {Mimeview Config} mimetypes @var{file}
Read @var{file} instead of the default @file{mime.types}. 
@end deffn

@deffn {Mimeview Config} metamail @var{program}
Use @var{program} to display files.
@end deffn

@page
@node pop3d
@section POP3 Daemon
@pindex pop3d

The @command{pop3d} daemon implements the Post Office Protocol
Version 3 server.

@command{pop3d} has two operation modes:

@table @asis
@item Inetd
The server is started from @file{/etc/inetd.conf} file:

@example
pop3  stream tcp nowait  root  /usr/local/sbin/pop3d pop3d
@end example

This is the default operation mode.

@item Standalone
The server runs as daemon, forking a child for each new connection.
@end table

The server operation mode is configured using @code{mode} statement
(@pxref{Server Settings, mode}).

@menu
* Login delay::
* Auto-expire::
* Bulletins::
* Conf-pop3d::           Pop3d Configuration
* Command line options::
@end menu

@node Login delay
@subsection Login delay

  POP3 clients often login frequently to check for new mail.  Each new
connection implies authenticating the user and opening his maildrop
and can be very resource consuming.  To reduce server load, it is
possible to impose a minimum delay between any two consecutive logins.
This is called @samp{LOGIN-DELAY} capability and is described in RFC
2449.

  As of version @value{VERSION}, GNU Mailutils @command{pop3d} allows
to set global login delay, i.e. such enforcement will affect all POP3
users.  If a user attempts to log in before the specified login delay
expires, he will get the following error message:

@example
-ERR [LOGIN-DELAY] Attempt to log in within the minimum login delay interval
@end example

The message will be issued after a valid password is entered.  This prevents
this feature from being used by malicious clients for account
harvesting.

  To enable the login delay capability, specify the minimum delay
using @code{login-delay} configuration statement, e.g.:

@example
login-delay 60;
@end example

  The @command{pop3d} utility keeps each user's last login time in a
special DBM file, called @dfn{login statistics database}, so to be
able to use this feature, Mailutils must be compiled with DBM support.
By default, the login statistics database is called
@file{/var/run/pop3-login.db}.  You can change its name using
@code{stat-file} configuration statement:

@example
login-delay 60;
stat-file /tmp/pop.login.db;
@end example

  The login delay facility will be enabled only if @command{pop3d} is
able to access the statistics database for both reading and
writing.  If it is not, it will report this using @command{syslog} and
start up without login delay restrictions.  A common error message
looks like:

@example
Unable to open statistics db: Operation not permitted
@end example

  You can check whether your @command{pop3d} uses login delays by
connecting to it and issuing the @samp{CAPA} command.  If login delays
are in use, there response will contain the string @samp{LOGIN-DELAY
@var{n}}, where @var{n} is the actual login delay value.

@node Auto-expire
@subsection Auto-expire

  Automatic expiration of messages allows you to limit the period of
time users are permitted to keep their messages on the server.  It is
enabled by @code{expire} configuration statement:

@table @code
@item expire @var{n};
Enable automatic expiration of messages after @var{n} days.
@end table

  The current implementation works as follows.  When a message is
downloaded by @code{RETR} or @code{TOP} command, it is marked with
@samp{X-Expire-Timestamp: @var{n}} header, where @var{n} is current
value of UNIX timestamp.  The exact expiration mechanism 
depends on you.  Mailutils allows you two options:

@enumerate
@item
Expired messages are deleted by @command{pop3d} upon closing the
mailbox.  You specify this mechanism using @code{delete-expired}
configuration statement:

@table @command
@item delete-expired @var{bool};
If @var{bool} is @samp{true}, delete expired messages after receiving
the @code{QUIT} command.
@end table

@item
Expired messages remain in the mailbox after closing it.  The system
administrator is supposed to run a cron job that purges the mailboxes.
Such a cron job can be easily implemented using @command{sieve} from
GNU Mailutils and the following script:

@example
@group
require "timestamp";
# @r{Replace "5" with the desired expiration period}
if timestamp :before "X-Expire-Timestamp" "now - 5 days"
  @{
    discard;
  @}
@end group
@end example

This script will remove expired messages 5 days after the
retrieval.  Replace @samp{5} with the desired expiration period and
make sure it equals the argument to @command{expire} configuration keyword.
@end enumerate

The statement @code{expire 0} means the client is not permitted to
leave mail on the server.  It always implies @code{delete-expired true}. 

@node Bulletins
@subsection Bulletins

  The bulletin feature allows you to send important announcements to
all POP3 users without mailing them.  It works by creating a
@dfn{bulletin source mailbox} and sending the announcements to it.

  After a user successfully authenticates, @command{pop3d} checks the
last @dfn{bulletin number} the user receives.  The bulletin number
refers to the number of the bulletin message in the bulletin source
mailbox.  If the latter contains more messages, these are appended to
the user mailbox.

  The user last bulletin number can be kept in two places.  First, it
can be stored in file @file{.popbull} in his home directory.  Secondly,
if Mailutils is compiled with DBM support, the numbers can be kept in
a DBM file, supplied via @code{bulletin-db} configuration statement.  If
both the database and the @file{.popbull} file are present, the data
from the database take precedence.

  To enable this feature, use the following configuration statements:

@table @code
@item bulletin-source @var{mbox}
Set the @acronym{URL} of the bulletin source mailbox.

@item bulletin-db @var{file}
Set the name of the database file to keep last bulletin numbers in.
@end table

  The following example instructs @command{pop3d} to look for the
bulletin messages in @acronym{MH} folder @file{/var/spool/bull/mbox}
and to keep the database of last delivered bulletin numbers in
@file{/var/spool/bull/numbers.db}:

@example
@group
bulletin-source mh:/var/spool/bull/mbox;
bulletin-db /var/spool/bull/numbers.db;
@end group
@end example

@node Conf-pop3d
@subsection Pop3d Configuration

The following configuration file statements affect the behavior of
@command{pop3d}.

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item tls           @tab @xref{tls statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@item logging       @tab @xref{logging statement}.
@item pam           @tab @xref{pam statement}.
@item sql           @tab @xref{sql statement}.
@item virtdomain    @tab @xref{virtdomain statement}.
@item radius        @tab @xref{radius statement}.
@item ldap          @tab @xref{ldap statement}.
@item auth          @tab @xref{auth statement}.
@item server        @tab @xref{Server Settings}.
@item acl           @tab @xref{acl statement}.
@item tcp-wrappers  @tab @xref{tcp-wrappers statement}.
@end multitable

@deffn {Pop3d Conf} undelete @var{bool}
On startup, clear deletion marks from all the messages.
@end deffn

@deffn {Pop3d Conf} expire @var{n}
Automatically expire read messages after @var{n}
days.  @xref{Auto-expire}, for a detailed description.
@end deffn

@deffn {Pop3d Conf} delete-expired @var{bool}
Delete expired messages upon closing the mailbox.  @xref{Auto-expire},
for a detailed description.
@end deffn

@deffn {Pop3d Conf} tls-required @var{bool}
Always require @code{STLS} command before entering authentication
phase.
@end deffn

@deffn {Pop3d Conf} login-delay @var{duration}
Set the minimal allowed delay between two successive logins.
@xref{Login delay}, for more information.
@end deffn

@deffn {Pop3d Conf} stat-file @var{file}
Set the name of login statistics file for the @code{login-delay}
facility.  @xref{Login delay}, for more information.
@end deffn

@deffn {Pop3d Conf} bulletin-source @var{file}
Get bulletins from the specified mailbox.  @xref{Bulletins}, for a
detailed description.
@end deffn

@deffn {Pop3d Conf} bulletin-db @var{file}
Set bulletin database file name.  @xref{Bulletins}, for a
detailed description.
@end deffn

@node Command line options
@subsection Command line options

The following table summarizes all @command{pop3d} command line options.

@table @option
@item -d[@var{number}]
@itemx --daemon[=@var{number}]
Run in standalone mode.  An optional @var{number} specifies the maximum number
of child processes allowed to run simultaneously.  When it is omitted,
it defaults to 10 processes.
@emph{Please note}, that there should be no whitespace between the
@option{-d} and its parameter.

@item -i
@itemx --inetd
Run in inetd mode.

@item --foreground
Remain in foreground.
@end table

The Mailutils common options are also understood.  @xref{Common Options}.
@page
@node imap4d
@section IMAP4 Daemon
@pindex imap4d

GNU @command{imap4d} is a daemon implementing @sc{imap4} rev1 protocol
for accessing and handling electronic mail messages on a server.  It can
be run either as a standalone program or from @file{inetd.conf} file.

@menu
* Namespace::       Namespace.
* Conf-imap4d::     Configuration.
* Starting imap4d:: Invocation Options.
@end menu

@node Namespace
@subsection Namespace
@cindex namespace
@cindex IMAP4 namespace

GNU @command{imap4d} supports a notion of @dfn{namespaces} defined
in RFC 2342.  A namespace is a set of directories upon which the user
has certain permissions.  It should be understood that these permissions
apply only if the underlying filesystem allows them.

The three namespaces supported by @command{imap4d} are:

@table @asis
@item Personal Namespace
A namespace that is within the personal scope of the authenticated user
on a particular connection.  The user has all permissions on this namespace.

@item Other Users' Namespace
A namespace that consists of mailboxes from the ``Personal Namespaces''
of other users.  The user can read and list mailboxes from this
namespace.  However, he is not allowed to use @samp{%} and @samp{*}
wildcards with @command{LIST} command, that is he can access a
mailbox only if he knows exactly its location.

@item Shared Namespace
A namespace that consists of mailboxes that are intended to be shared
amongst users and do not exist within a user's Personal Namespace.
The user has all permissions on this namespace.
@end table

@noindent
By default, @command{imap4d} starts with the following namespaces:

@table @asis
@item Personal Namespace
The home directory of the user, if exists.

@item Other Users' Namespace
Empty

@item Shared Namespace
Empty
@end table

@emph{Note}, that this means that by default, a user won't be able to
see or otherwise access mailboxes residing in the directories other than
his own home.

To change these defaults, use @code{shared-namespace} and
@code{other-namespace} configuration statements:

@table @command
@item shared-namespace @var{list}
Set shared namespace.

@item other-namespace @var{list}
Set other users' namespace.
@end table

For both statements, the argument is a list of directories that belong
to this namespace, e.g.:

@example
shared-namespace (/var/spool/mail,/var/mail);
@end example

If during the session the user creates a mailbox within either of
these namespaces, the mode of the mailbox is determined by the
following configuration statements:

@table @command
@item shared-mailbox-mode @var{mode}
Set file mode for mailboxes created in shared namespace.

@item other-mailbox-mode @var{mode}
Set file mode for mailboxes created in other users' namespace.
@end table

In both cases, the argument, @var{mode} is a list of symbolic mode
settings, similar to that used by @command{chmod}.  It is a list of
comma-separated mode change commands.  Each command begins with a
letter @samp{g}, which means set mode bits for file group, or
@samp{o}, which means set mode bits for other users (note, that there
is no @samp{u} specifier, since user ownership of his mailbox cannot
be changed).  This letter is followed by an @samp{=} (or @samp{+}), and
a list of modes to be set.  This list can contain only two letters:
@samp{r} to set read permission, and @samp{w} to set write permission.

For example, the following statement sets read and write permissions
for the group:

@example
shared-namespace-mode g=rw;
@end example

@node Conf-imap4d
@subsection Configuration of @command{imap4d}.

The behavior of @command{imap4d} is altered by the following
configuration statements:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug         @tab @xref{debug statement}.
@item tls           @tab @xref{tls statement}.
@item mailbox       @tab @xref{mailbox statement}.
@item locking       @tab @xref{locking statement}.
@item logging       @tab @xref{logging statement}.
@item pam           @tab @xref{pam statement}.
@item sql           @tab @xref{sql statement}.
@item virtdomain    @tab @xref{virtdomain statement}.
@item radius        @tab @xref{radius statement}.
@item ldap          @tab @xref{ldap statement}.
@item auth          @tab @xref{auth statement}.
@item server        @tab @xref{Server Settings}.
@item acl           @tab @xref{acl statement}.
@item tcp-wrappers  @tab @xref{tcp-wrappers statement}.
@end multitable

@deffn {Imap4d Conf} shared-namespace @var{list}
Set shared namespace.  @var{List} is a list of
strings.  @xref{Namespace}, for a detailed description.
@end deffn

@deffn {Imap4d Conf} other-namespace @var{list}
Set other users' namespace.  @var{List} is a list of
strings.  @xref{Namespace}, for a detailed description.
@end deffn

@deffn {Imap4d Conf} shared-mailbox-mode @var{str}
Set file mode for mailboxes created within shared namespace.
@xref{Namespace}, for a detailed description.
@end deffn

@deffn {Imap4d Conf} other-mailbox-mode @var{str}
Set file mode for mailboxes created within other users' namespace.
@xref{Namespace}, for a detailed description.
@end deffn

@deffn {Imap4d Conf} login-disabled @var{bool}
Disable @code{LOGIN} command, if @var{bool} is @samp{true}.
@end deffn

@deffn {Imap4d Conf} create-home-dir @var{bool}
Create nonexistent user home directories.  See also home-dir-mode, below.
@end deffn

@deffn {Imap4d Conf} home-dir-mode @var{mode}
Set file mode for created user home directories.  Mode is specified in
octal.

The default value for @var{mode} is @samp{700} (@samp{drwx------} in
@code{ls} terms).  
@end deffn

@deffn {Imap4d Conf} tls-required @var{bool}
Require successful @code{STARTTLS} command before entering
authentication phase.
@end deffn

@deffn {Imap4d Conf} preauth @var{mode}
Configure PREAUTH mode.  Valid arguments are:

@table @asis
@item prog:///@var{program-name}
@command{Imap4d} invokes an external program to authenticate the
connection.  The command line is obtained from the supplied string,
by expanding the following meta-variables:

@table @code
@item $@{client_address@}
Remote IP address in dotted-quad notation;

@item $@{client_port@}
Remote port number;

@item $@{server_address@}
Local IP address;

@item $@{server_port@}
Local port number.
@end table

If the connection is authenticated, the program should print the
user name, followed by a newline character, on its standard
output and exit with code @samp{0}.

Otherwise, it should exit with a non-zero exit code.

@item ident[://:@var{port}]
The remote machine is asked about the requester identity
using the identification protocol (RFC 1413).  Both plaintext and
DES encrypted replies are understood.  Optional @var{port} specifies
the port to use, if it differs from the default @samp{113}.  It can be
either a decimal port number or a symbolic name of a service, listed
in @file{/etc/services}.

@item stdio
PREAUTH mode is enabled automatically if imap4d is started
from command line in interactive mode (@option{-i} command line
option).  The current login name is used as the user name.
@end table
@end deffn

@deffn {Imap4d Conf} preauth-only @var{bool}
If @var{bool} is @samp{true}, use only preauth mode.  If unable to
setup it, disconnect immediately.
@end deffn

@deffn {Imap4d Conf} ident-keyfile @var{file}
Set DES keyfile for decoding encrypted ident responses.  Used with
@samp{ident://} preauth mode.
@end deffn

@deffn {Imap4d Conf} ident-encrypt-only @var{bool}
Use only encrypted IDENT responses.
@end deffn

@deffn {Imap4d Conf} id-fields @var{list}
Set list of fields to return in response to ID command.

Valid field names are:

@table @asis
@item name
Package name (@samp{GNU Mailutils}).

@item version
Package version (@samp{@value{VERSION}}).

@item vendor
Vendor name (@samp{GNU}).

@item support-url
The string @samp{http://www.gnu.org/software/mailutils}

@item address
The string @samp{51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA}.

@item os
OS name.

@item os-version
OS version number.

@item command
Name of the @command{imap4d} binary.

@item arguments
Invocation command line.

@item environment
List of environment variables with their values.
@end table

@end deffn

@node Starting imap4d
@subsection Starting @command{imap4d}

@command{imap4d} may run either in @dfn{standalone} or in @dfn{inetd}
operation modes.  When run in ``standalone'' mode, the server disconnects
from the terminal and runs as a daemon, forking a child for each new
connection.

The ``inetd'' mode allows to start the server from
@file{/etc/inetd.conf} file.  This is the default operation mode. 

@example
imap4  stream tcp nowait  root  /usr/local/sbin/imap4d imap4d
@end example

@subheading Command Line Options

@table @option
@item -d[@var{number}]
@itemx --daemon[=@var{number}]
Run in standalone mode.  An optional @var{number} specifies the maximum number
of child processes the daemon is allowed to fork.  When it is omitted,
it defaults to 20 processes.
@emph{Please note}, that there should be no whitespace between the
@option{-d} and its parameter.

@item -i
@itemx --inetd
Run in inetd mode.

@item --foreground
Run in foreground.

@item --preauth
Start in preauth mode

@item --test
Run in test mode.
@end table

See also @ref{Common Options}.

@page
@node comsatd
@section Comsat Daemon
@pindex comsatd

Comsatd is the server which receives reports of incoming mail and
notifies users, wishing to get this service.  It can be started
either from @file{inetd.conf} or as a standalone daemon.

@menu
* Starting comsatd::       Invocation.
* Configuring comsatd::    Configuration of @command{comsatd}.
* dot.biffrc::             A per-user configuration file.
@end menu

@node Starting comsatd
@subsection Starting @command{comsatd}

@table @option
@item -d
@itemx --daemon
Run as a standalone daemon.

@item -i
@itemx --inetd
The server is started from @file{/etc/inetd.conf} file:

@example
comsat dgram  udp wait  root  /usr/sbin/comsatd \
comsatd -c /etc/comsat.conf
@end example

This is the default operation mode.

@item -t
@itemx --test
Test mode.  In this mode, @command{comsatd} takes two arguments:
@acronym{URL} of a mailbox and @acronym{QID} of the message from that
mailbox, e.g.:

@example
$ comsatd --test /var/mail/root 34589
@end example

@item --foreground
Don't detach from the controlling terminal, remain in foreground.
@end table

See also @ref{Common Options}.

@node Configuring comsatd
@subsection Configuring @command{comsatd}

Following configuration statements affect the behavior of
@command{comsatd}:

@multitable @columnfractions 0.3 0.6
@headitem Statement @tab Reference
@item debug   @tab @xref{debug statement}.
@item logging @tab @xref{logging statement}.
@item mailbox @tab @xref{mailbox statement}.
@item locking @tab @xref{locking statement}.
@item acl     @tab @xref{acl statement}.
@end multitable

@menu
* General Settings::
* Security Settings::
@end menu

@node General Settings
@subsubsection General Settings

These statements control the general behavior of the comsat daemon:

@deffn {Comsatd Conf} max-lines @var{number}
Set maximum number of message body lines to be output.
@end deffn

@deffn {Comsatd Conf} allow-biffrc @var{bool}
Enable or disable processing of user's @file{.biffrc} file.  By default,
it is enabled.
@end deffn

@node Security Settings
@subsubsection Security Settings

These statements control the way @command{comsatd} fights possible
flooding attacks.

@deffn {Comsatd Conf} max-requests @var{number}
Set maximum number of incoming requests per
@samp{request-control-interval}.
@end deffn

@deffn {Comsatd Conf} request-control-interval @var{duration}
Set the request control interval.
@end deffn

@deffn {Comsatd Conf} overflow-delay-time @var{duration}
Set initial amount of time to sleep, after the first overflow occurs.
@end deffn

@deffn {Comsatd Conf} overflow-control-interval @var{duration}
Set overflow control interval.  If two consecutive overflows happen
within that interval, the overflow-delay-time is doubled.
@end deffn

@node dot.biffrc
@subsection A per-user Configuration File

By default, when a notification arrives, @command{comsatd} prints subject,
from headers and the first five lines from the new message to the user's
tty.  The user is allowed to change this behavior by using his own
configuration file.  This file should be located in the user's home
directory and should be named @file{.biffrc}.  It must be owned by the
user and have its permissions bits set to 0600. (@emph{Please note},
that the use of per-user configuration files may be disabled, by
specifying @samp{allow-biffrc no} in the main configuration file, see
@pxref{Configuring comsatd}).

The @file{.biffrc} file consists of a series of statements.  Each
statement occupies one line and defines an action to be taken upon
arrival of a new mail.  Very long lines may be split using @samp{\} as
the last character on the line.  As usual, comments may be introduced with
@samp{#} character.

The actions specified in @file{.biffrc} file are executed in turn.
The following actions are defined:

@table @asis
@item beep
Produce an audible signal.
@item echo [-n] @var{string} [@var{string}...]
Output the arguments to the user's terminal device.  If several
arguments are given they will be output separated by single
spaces.  The newline character will be printed at the end of the
output, unless the @option{-n} option is used.
@item exec @var{prog} @var{arglist}
Execute program @var{prog} with arguments from @var{arglist}.  @var{prog}
must be specified with absolute pathname.  It may not be a setuid or
setgid program.
@end table

In the description above, @var{string} denotes any sequence of
characters.  This sequence must be enclosed in a pair of double-quotes,
if it contains whitespace characters.  The @samp{\} character inside a
string starts a C escape sequence.  Following meta-characters may be
used in strings:

@table @asis
@item $u
Expands to username
@item $h
Expands to hostname
@item $H@{name@}
Expands to value of message header @samp{name}.
@item $B(@var{c},@var{l})
Expands to message body.  @var{c} and @var{l} give maximum number of
characters and lines in the expansion.  When omitted, they default to 400, 5.
@end table

@subsubheading Example I

Dump to the user's terminal the contents of @samp{From} and
@samp{Subject} headers followed by at most 5 lines of message body.
@example
@group
echo "Mail to \a$u@@$h\a\n---\n\
From: $H@{from@}\n\
Subject: $H@{Subject@}\n\
---\n\
$B(,5)\
---\n"
@end group
@end example

@noindent
The above example can also be written as:
@example
@group
echo Mail to \a$u@@$h\a
echo ---
echo From: $H@{From@}
echo Subject: $H@{Subject@}
echo ---
echo $B(,5)
echo ---
@end group
@end example

@subsubheading Example II

Produce a bell, then pop up the xmessage window on display :0.0 with
the text formatted in the same manner as in the previous example.

@example
@group
beep
exec /usr/X11R6/bin/xmessage \
-display :0.0 -timeout 10 "Mail to $u@@$h \n---\n\
From: $H@{from@}\n\
Subject: $H@{Subject@}\n\
---\n\
$B(,5)\
---\n"
@end group
@end example

@page
@node mh
@section MH --- The MH Message Handling System

@include mu-mh.texi

@page
@node mailutils
@section mailutils
@pindex mailutils
The @command{mailutils} utility is a multi-purpose tool shipped with
Mailutils.  It can be used for various mail and database-related
tasks, as well as an auxiliary tool for compiling and linking programs
with Mailutils. 

@menu
* mailutils invocation syntax::
* mailutils help::                Display a terse help summary.
* mailutils info::                Show Mailutils configuration.
* mailutils cflags::              Show compiler options.
* mailutils ldflags::             List libraries required to link.
* mailutils stat::                Show mailbox status.
* mailutils query::               Query configuration values.
* mailutils 2047::                Decode/encode email message headers.
* mailutils filter::              Apply a chain of filters to the input.
* mailutils acl::                 Test access control lists.
* mailutils wicket::              Scan wickets for matching URLs.
* mailutils dbm::                 DBM management tool.
* mailutils logger::              Log data using Mailutils log facility.
* mailutils pop::                 POP3 client shell.
* mailutils imap::                IMAP4 client shell.
* mailutils send::                Send a message.
* mailutils smtp::                Run a SMTP session.
@end menu

@node mailutils invocation syntax
@subsection Invocation Syntax
@command{Mailutils} is a command line tool.  Its invocation syntax is:

@example
mailutils [@var{options}] @var{command} [@var{args}]
@end example

where @var{options} are options that affect the behavior of
@command{mailutils} as a whole, @var{command} instructs it what it is to do
and @var{args} are any arguments the @var{command} needs in order to be
executed. 

The commands are:

@table @asis
@item 2047
Decodes or encodes email message headers.
@item acl
Tests Mailutils access control lists.
@item cflags
Shows compiler options needed to compile with Mailutils.
@item dbm
Invokes a DBM management tool.
@item ;filter
Applies a chain of filters to the input.
@item help
Displays a terse help summary.
@item imap
Invokes an IMAP4 client shell (in development).
@item info
Displays information about Mailutils compile-time configuration.
@item ldflags
Constructs a @command{ld}(1) command line for linking a program with Mailutils.
@item logger
Logs information using Mailutils log facility.
@item pop
Invokes a POP3 client shell.
@item query
Queries configuration values.
@item wicket
Scans wicket for matching URLs
@end table

@node mailutils help
@subsection mailutils help
The @command{mailutils help} command lists all available options and command
names along with short descriptions of what each of them does.  It is
similar to the @command{mailutils --help} option. 

A command name can be supplied as an argument to
@command{help}, in which case it will display a help page for that
particular command, e.g.: 

@example
mailutils help ldflags
@end example

will output help for the @command{ldflags} command.  It is synonymous
to the @option{--help} option used with that particular command, e.g.:
@command{mailutils ldflags --help}.

@node mailutils info
@subsection mailutils info
The @command{mailutils info} command displays information about Mailutils
compile-time configuration.  In normal form its output lists a single
configuration flag per line, e.g.: 

@example
$ mailutils info
VERSION=2.99.93
SYSCONFDIR=/etc
MAILSPOOLDIR=/var/mail/
SCHEME=mbox
LOG_FACILITY=mail
IPV6
USE_LIBPAM
HAVE_LIBLTDL
WITH_GDBM
WITH_GNUTLS
WITH_GSASL
@end example

A configuration flag can consist either of a single word, indicating
that a particular capability has been enabled at compile time, or of a
keyword/value pair delimited by an equal sign, which indicates a
particular value used by default for that feature.  For example,
@samp{IPV6} means that Mailutils was compiled with support for IPv6,
whereas @samp{SYSCONFDIR=/etc} means that the default place for
configuration files is in @file{/etc} directory. 

Such short output is convenient for using @command{mailutils info} in scripts
to decide whether it is possible to use a given feature.  To assist
human users, the @option{--verbose} (@option{-v}) option is provided.
It prints a short description next to each flag: 

@example
$ mailutils info --verbose
VERSION=2.99.93           - Version of this package
SYSCONFDIR=/etc           - System configuration directory
MAILSPOOLDIR=/var/mail/   - Default mail spool directory
SCHEME=mbox               - Default mailbox type
LOG_FACILITY=mail         - Default syslog facility
IPV6                      - IPv6 support
USE_LIBPAM                - PAM support
HAVE_LIBLTDL              - a portable `dlopen' wrapper library
WITH_GDBM                 - GNU DBM
WITH_GNUTLS               - TLS support using GNU TLS
WITH_GSASL                - SASL support using GNU SASL
@end example

@node mailutils cflags
@subsection mailutils cflags
The @command{mailutils cflags} command shows compiler options needed to
compile a C source with Mailutils.  It is intended for use in
configuration scripts and Makefiles, e.g.:

@example
CFLAGS=-g -O2 `mailutils cflags`
@end example

@node mailutils ldflags
@subsection mailutils ldflags
The @command{mailutils ldflags} command is a counterpart of @command{cflags}
which is used for linking.  It constructs a @command{ld} command line
for linking a program with Mailutils.

When used without arguments, it outputs @command{ld} arguments which
would link only with the core Mailutils library @file{libmailutils}, e.g.: 

@example
$ mailutils ldflags
-L/usr/local/lib -lmailutils 
@end example

This command accepts a number of keywords which allow to select a
particular subset of Mailutils libraries to link with.  In particular,
the argument @samp{all} instructs it to link in all available libraries: 

@example
$ mailutils ldflags all
-L/usr/local/lib -lmu_mbox -lmu_mh -lmu_maildir -lmu_imap -lmu_pop \
-lmu_mailer -lmu_compat -lmailutils -lmu_auth -lgsasl -lgnutls -lgcrypt \
-lldap -lgnuradius -lpam -ldl 
@end example

Other available keywords are:

@table @asis
@item mbox
Link in the UNIX mbox format support.
@item mh
Link in the MH format support.
@item maildir
Link in the Maildir format support.
@item imap
Link in the IMAP protocol support.
@item pop
Link in the POP protocol support.
@item nntp
Link in the NNTP protocol support.
@item mailer
Enable support for mailers.
@item sieve
Link in the support for Sieve mail filtering language.
@item dbm
Link in the support for DBM databases (libmu_dbm library).
@item auth
Link in the Mailutils authentication library.
@item guile
Provide Guile language bindings.
@item python
Provide Python language bindings.
@end table

@node mailutils stat
@subsection mailutils stat
The command @command{mailutils stat} shows status of a mailbox.  The
name or URL of the mailbox to operate upon is supplied in the first
argument.  If not given, the command will display status of the
invoking user system mailbox.

@example
$ mailutils stat
type: maildir
path: /var/mail/smith
URL: /var/mail/smith
size: 3498
messages: 24
recent messages: 3
first unseen: 20
uidvalidity: 1338543026
next uid: 87
access: 2016-12-15 09:15:08 +0200
@end example

The output format is controlled by the @option{--format} (@option{-c})
option.  Its argument is the desired format string, composed of
ordinary characters, which are reporduced on standard output verbatim,
backslash sequences, and format specifiers, beginning with @samp{%}.

@dfn{Backslash sequences} are interpreted as in C.

A @dfn{format specifier} consists of a leading @samp{%} followed by a
letter.  Optional @samp{:} may occur between @samp{%} and the letter.
Its presense instructs the program to print the description of the
corresponding value before the value itself.

The following format sequences are understood:

@table @asis
@item %f
Name of the mailbox as supplied in the command line.  If
@command{mailutils stat} was used without explicit mailbox argument,
@samp{%f} is equivalent to @samp{%U}.
@item %t
Type of the mailbox (@samp{mbox}, @samp{maildir}, etc.).  The
description string is @samp{type}.
@item %p
Path to the mailbox.  In case of remote mailboxes, it is the path
part of the mailbox URL.  Description string: @samp{path}.
@item %U
URL of the mailbox.  Description string: @samp{URL}.
@item %s
Size of the mailbox in octets.  Description string: @samp{size}.
@item %c
Number of messages in the mailbox.  Description string:
@samp{messages}.
@item %r
Number of recent (unread) messages in the mailbox.  Description string:
@samp{recent messages}.
@item %u
Index of the first unseen message.  Description string: @samp{first unseen}.
@item %v
The UIDVALIDITY value.  Description string: @samp{uidvalidity}.
@item %n
The UID value which will be assigned to the new message to be
incorporated into the mailbox.  Description string: @samp{next uid}.
@item %a
Access time of the mailbox, as a number of seconds since the epoch.
@item %A
Access time of the mailbox in human-readable format.
@end table

@node mailutils query
@subsection mailutils query
The @command{mailutils query} command queries values from Mailutils
configuration files.  It takes one or more configuration paths
(@pxref{Paths}) as its arguments.  On output, it displays the values
it found, each value on a separate line.  If the requested value is a
block statement it is displayed in full.  For example, if main
configuration file contained:

@example
logging @{
   syslog yes;
   facility mail;
@}
@end example

Then:

@example
$ mailutils query .logging.syslog
syslog yes;
$ mailutils query .logging.syslog .logging.facility
syslog yes;
facility mail;
$ mailutils query .logging
logging @{
  syslog yes;
  facility mail;
@};
@end example

Several command line options allow to modify output format.  The
@option{--value} option instructs the command to output only values:

@example
$ mailutils query --value .logging.syslog
yes
@end example

The @option{--path} option instructs it to print full pathnames for
each value: 

@example
$ mailutils query --path .logging.syslog
logging.syslog: yes
@end example

The @option{--program} option instructs @command{mailutils} to behave as if
it was called under another program name.  For example, the following
command:

@example
$ mailutils query --program=pop3d .server.transcript
@end example

will return the value of the @samp{.server.transcript} statement which
the @command{pop3d} utility would see.

By default, @command{mailutils query} operates on the main configuration
file.  Another configuration file can be supplied using the
@option{--file} (@option{-f}) option:

@example
$ mailutils query --file /usr/local/etc/file.conf .pidfile
@end example

@node mailutils 2047
@subsection mailutils 2047
The @command{mailutils 2047} command is a filter for decoding or encoding
email message headers formatted in accordance with RFC 2047 (see
@uref{http://www.faqs.org/rfcs/rfc2047.html}.  By default, it operates
in encode mode and assumes the @samp{iso-8859-1} encoding.  If
arguments are supplied in the command line, they are treated as the
text to operate upon.  Otherwise the command acts as a UNIX filter,
reading lines from the standard input and printing results on the
standard output.

For example:

@example
$ mailutils 2047 'Keld J@o{}rn Simonsen <keld@@dkuug.dk>'
=?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= <keld@@dkuug.dk>
@end example

The decode mode can be requested via the @option{--decode}
(@option{-d}) option:

@example
$ mailutils 2047 --decode '=?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= \
 <keld@@dkuug.dk>'
Keld J@o{}rn Simonsen <keld@@dkuug.dk>
@end example

The @option{--charset} (@option{-c}) option changes the default
character set.  It is meaningful both in decode and in encode modes.
In decode mode it instructs the utility to convert the output to the
given character set.  In encode mode it indicates the encoding of the
input data, which will be reflected in the resulting string:

@example
$ mailutils 2047 --charset=utf-8 'Keld J@o{}rn Simonsen <keld@@dkuug.dk>'
=?utf-8?Q?Keld J=C3=B8rn Simonsen <keld@@dkuug.dk>?=
@end example

The @option{--encoding} (@option{-E}) option can be used in encode
mode to change the output encoding.  Valid arguments for this option
are: @samp{quoted-printable} (the default) or @samp{base64}. 

The @option{--newline} (@option{-n}) option prints an additional
newline character after each line of output.

@node mailutils filter
@subsection mailutils filter
The @command{mailutils filter} command applies a chain of filters to the
input.  The filters to apply and their arguments are given  
in the command line.  The full invocation syntax is:

@example
 mailutils filter [@var{option}] @var{filter-chain}
@end example

The syntax for @var{filter-chain} in Backus-Naur form follows:

@example
<filter-chain> ::= <filter> | <filter-chain> "+" <filter>
<filter> ::= <filter-spec> <@var{ARG}>* 
<filter-spec> ::= <@var{WORD}> | "~" <@var{WORD}>
@end example

@noindent
where @var{<WORD>} stands for the filter name and @var{<ARG>}
represents filter arguments.  To obtain a list of known filter names,
run:

@example
mailutils filter --list
@end example

Filters are applied in the order of their appearance, from left to
right and operate in encode mode.  The plus sign has the same meaning
as pipe in shell.  The default mode can be changed using the
@option{--decode} (@option{-d}) and @option{--encode} (@option{-e}) options.
Whatever the default mode is, a @samp{~} character before filter
name reverts the mode for that filter alone. 

For example, to encode the contents of file @file{file.txt} in Base64
run:

@example
mailutils filter base64 < file.txt
@end example

To convert it to base64 and use CRLF as line delimiters, run:

@example
mailutils filter base64 + crlf < file.txt
@end example

The following command will decode the produced output:

@example
mailutils filter --decode crlf + base64
@end example

It can also be written as

@example
mailutils filter ~crlf + ~base64
@end example

The following example converts the input from ISO-8859-2 to UTF-8,
quotes eventual @samp{From} occurring at the beginning of a line,
encodes the result in Base64 and changes line delimiters to CRLF:

@example
mailutils filter iconv iso-8859-2 utf-8 + from + base64 + crlf
@end example

This final example removes UNIX-style comments from the input and
joins continuation lines:

@example
mailutils filter --decode inline-comment -S '#' + linecon 
@end example

Such invocation can be useful in shell scripts to facilitate
configuration file processing.

@node mailutils acl
@subsection mailutils acl
The @command{mailutils acl} command tests Mailutils Access Control Lists.  By
default it reads ACL from the Mailutils configuration file section
@samp{acl}.  The command takes a list of IP addresses as its
arguments, applies the ACL to each of them in turn and prints the result.

To select the ACL to test, two options are provided.  The
@option{--file} (@option{-f}) option supplies the name of
configuration file to read instead of the default one.  The
@option{--path} (@option{-p} option supplies the pathname
(@pxref{Paths}) of the ACL section to use instead of the default @samp{.acl}.  For example, to test ACL in section @samp{server 213.130.1.232} of file @file{/etc/pop3d.conf} use:

@example
mailutils acl --file=/etc/pop3d.conf \
       --path=/server="213.130.1.232"/acl @var{address}
@end example

As an example of its use, consider file @file{test.conf} with the
following contents:

@example
acl @{
        deny from 10.10.10.1;
        deny from 10.10.1.0/24;
        log from any "Connect from $@{address@}";
        allow from 10.0.0.0/8;
        allow from 192.168.1.0/24;
        deny from any;
@}
@end example 

Then, running @command{mailutils acl --file=test.conf 127.0.0.1} you will get:

@example
Testing 127.0.0.1:
mailutils: Connect from 127.0.0.1
127.0.0.1: deny
@end example

More examples:

@example
$ mailutils acl --file=test.conf 127.0.0.1 10.10.10.1 \
         10.10.1.3 10.5.3.1 192.168.1.0 192.168.2.0
Testing 127.0.0.1:
mailutils: Connect from 127.0.0.1
127.0.0.1: deny
Testing 10.10.10.1:
10.10.10.1: deny
Testing 10.10.1.3:
10.10.1.3: deny
Testing 10.5.3.1:
mailutils: Connect from 10.5.3.1
10.5.3.1: accept
Testing 192.168.1.0:
mailutils: Connect from 192.168.1.0
192.168.1.0: accept
Testing 192.168.2.0:
mailutils: Connect from 192.168.2.0
192.168.2.0: accept
@end example

The @command{mailutils} option @option{--debug-level} will give you a deeper
insight into the address matching algorithm:

@example
$ mailutils --debug-level=acl.trace9 acl --file test.conf 127.0.0.1
Testing 127.0.0.1:
mailutils: Checking sockaddr 127.0.0.1
mailutils: 1:deny: Does 10.10.10.1/255.255.255.255 match 127.0.0.1? no; 
mailutils: 2:deny: Does 10.10.1.0/255.255.255.0 match 127.0.0.1? no; 
mailutils: 3:log: Does any match 127.0.0.1? yes; 
mailutils: Expanding "Connect from $@{address@}";
mailutils: Expansion: "Connect from 127.0.0.1";. 
mailutils: Connect from 127.0.0.1
mailutils: 4:accept: Does 10.0.0.0/255.0.0.0 match 127.0.0.1? no; 
mailutils: 5:accept: Does 192.168.0.0/255.255.0.0 match 127.0.0.1? no; 
mailutils: 6:deny: Does any match 127.0.0.1? yes; 
127.0.0.1: deny
@end example

@xref{Debugging Categories,acl}.

@node mailutils wicket
@subsection mailutils wicket
The @command{mailutils wicket} command looks up matching URLs in the
Mailutils ticket file (by default, @file{~/.mu-tickets}) and prints
them.  The URLs to look for are supplied in the command line.

Consider the following ticket file as an example:

@example
smtp://foo:bar@@*
smtp://bar:baz@@gnu.org
*://baz:qux@@*
*://quux:bar@@gnu.org
@end example

Now, running @command{mailutils wicket smtp://bar@@gnu.org} will show:

@example
smtp://bar@@gnu.org: /home/@var{user}/.mailutils-tickets:2
@end example

@noindent
(where @var{user} is your login name).  This means that this URL
matches the line 2 in your @file{.mailutils-tickets} file.  The
@command{wicket} command does not show the actual matching line to
avoid revealing eventual security-sensitive information.  You can
instruct it to do so using the @option{--verbose} (@option{-v})
option:

@example
$ mailutils wicket -v smtp://bar@@gnu.org
smtp://bar@@gnu.org: /home/@var{user}/.mu-tickets:2: smtp://bar:***@@gnu.org
@end example

As you see, even in that case the tool hides the actual password part
by replacing it with three asterisks.  If you are working in a secure
environment, you can tell @command{mu wicket} to show passwords as
well, by supplying the @option{-v} option twice.

A counterpart of @option{--verbose} is the @option{--quite}
(@option{-q}) option, which instructs @command{wicket} to suppress any
output, excepting error messages.  This can be used in scripts, which
analyze the @command{mailutils wicket} exit code to alter the control flow.

The @command{mailutils wicket} tool exits with code 0 if all URLs were
matched and with code 1 if some of them were not matched in the ticket
file.  If an error occurred, the code 2 is returned.

@node mailutils dbm
@subsection mailutils dbm
The @command{mailutils dbm} tool manages DBM files using @file{libmu_dbm}
The invocation syntax is:

@example
mailutils dbm @var{subcommand} [@var{options}] @var{file} [@var{keys}]
@end example
@noindent
or
@example
mailutils dbm [@var{options}] @var{subcommand} @var{file} [@var{keys}]
@end example

@noindent
where @var{subcommand} selects the operation mode, @var{options}
modify the tool behavior and @var{file} specifies the DBM file to
operate upon.  Some @var{command}s allow for optional @var{keys} to be
specified.

The @var{file} argument can be either a DBM file name or a Database URL. 

@menu
* Create a Database::
* Add Records to a Database::
* Delete Records::
* List the Database::
* Dump the Database::
* Dump Formats::
* Dbm Exit Codes::
@end menu

@node Create a Database
@subsubsection Create a Database
The @option{create} subcommand and its synonym @option{load} instruct
the tool to create a new database: 

@example
mailutils dbm create file.db
@end example

If the argument file already exists, it will be truncated prior to
adding new records to it.

The data to populate the database with are read from the standard
input.  The @command{mailutils dbm} command supports several formats for
these data, which are discussed later.  In the simplest case (a so
called @samp{format 0.0}) each input line must consist of two fields
separated by any amount of whitespace.  The first field is treated as
a key and the second one as the corresponding value. 

The usual way to read data from a file is, of course, by redirecting
the file to the standard input as in: 

@example
mailutils dbm create file.db < input.txt
@end example

There is also a special option for that purpose: @option{--file}
(@option{-f}).  Thus, the following command is equivalent to the one
above:

@example
mailutils dbm create --file input.txt file.db 
@end example

The @option{--file} option has the advantage that it allows, in
conjunction with another options, for copying input file metadata
(owner UID, GID and file mode) to the created database.  For example,
the following command ensures that the created database file will have
the same metadata as the input file: 

@example
mailutils dbm create --file input.txt --copy-permissions file.db
@end example

The @option{--copy-permissions} (@option{-P}) option is the one that
does the job.

There are also other ways to control mode and ownership of the created
database, which are described below. 

More advanced dump formats (e.g.  @samp{version 1.0} format) carry
additional information about the file, including its original name,
ownership and mode.  If input is in one of these formats, the file
name argument becomes optional.  If it is not supplied, the name
stored in the input stream will be used.  For example, supposing that
the file @file{users.dump} is in format 1.0, the following command
suffices to restore the original filename, ownership, mode and, of
course, data:

@example
mailutils dbm create --file users.dump
@end example

@node Add Records to a Database
@subsubsection Add Records to a Database
The @option{add} subcommand adds records to a database.  Records are
read from the standard input and must be formatted as for
@option{create}:

@example
mailutils dbm add file.db
@end example

If the argument file does not exist, it will be created.  

Adding a record with a key which is already present in the database
produces an error.  To replace existing records, use the
@option{replace} subcommand instead.   

The same options that affect the behavior of @option{create} apply to
@option{add} and @samp{replace} as well, e.g.:

@example
mailutils dbm replace --file input.txt --copy-permissions file.db
@end example

@node Delete Records
@subsubsection Delete Records
To delete records, use the @option{delete} subcommand.  It reads a
list of keys to delete to be specified as arguments in the command
line: 

@example
mailutils dbm delete file.db foo bar
@end example

The command above will delete from @file{file.db} records with keys
@samp{foo} and @samp{bar}.  

It is not an error to attempt to delete a key that does not exist in
the database, although such use will produce a warning message.

By default, keys are matched literally.  It is also possible to use
various pattern matching techniques, depending on the option
specified. 

The @option{--glob} (@option{-G}) option instructs the tool to use UNIX globbing pattern matching.  For example, the command below will delete all keys starting with @samp{foo} and ending with a decimal digit:

@example
mailutils dbm delete file.db 'foo*[0-9]'
@end example

@noindent
(note the quoting necessary to prevent shell from interpreting the
metacharacters itself).

Another option, @option{--regex} (@option{-R}) instructs @command{mailutils}
to treat supplied keys as extended regular expressions: 

@example
mailutils dbm delete --regex file.db 'foo.*[0-9]@{1,3@}'
@end example

Both options are affected by the @option{--ignore-case} (@option{-i})
option, which turns on case-insensitive matching.

Using pattern matching to delete records can be a risky operation as
selecting a wrong pattern will lead to removing wrong records.  It is
recommended to first use the list mode described below to verify that
the patterns match the right keys.

@node List the Database
@subsubsection List the Database
The @option{list} command lists the content of the database:

@example
mailutils dbm list file.db
@end example

By default, entire content is listed on the standard output.

If supplied more than one command line argument, this mode treats the
rest of arguments after the database file name as the keys to look for
and lists only records with these keys:

@example
$ mailutils dbm list file.db foo bar
foo 1
bar 56
@end example

The @option{--glob} and @option{--regex} options instruct the tool to
use UNIX globbing or extended regular expression matching,
correspondingly.  These were described in detail above. 

@node Dump the Database
@subsubsection Dump the Database

The @option{dump} subcommand dumps the database to the standard output
in a format suitable for backup or sending over the network (a
version 1.0 format). 

@example
mailutils dbm dump file.db < file.dump
@end example

The produced file is suitable for input to the @option{create} (@option{load}) command.  Among other uses, it provides an easy way to convert databases between various formats supported by Mailutils.  For example this is how to convert the database file @file{file.db} to the GDBM database @file{new.db}:

@example
mailutils dbm dump file.db | mailutils dbm create gdbm://new.db
@end example

Both @option{list} and @option{dump} subcommands share the same set of
options.  In fact, they are pretty similar, except that use different
defaults.  The @option{list} subcommand is designed to produce a
human-readable output, whereas the dump subcommand is oriented towards
backup purposes.

@node Dump Formats
@subsubsection Dump Formats
As of version @value{VERSION}, @command{mailutils dbm} supports two formats
for dumping DBM databases.  Both formats are line-oriented.  Comments
are introduced with a sharp (@samp{#}) sign in the column 0 of a line,
followed by at least one white space character (space or tab).  Sharp
sign followed by a colon (@samp{#:}) introduces a @dfn{pragmatic
comment}, which carries some additional information to the loader. 

@anchor{dump version 0.0}
The @dfn{version 0.0} format is suitable for databases whose records
contain only ASCII data.  In this format, each record occupies a
separate line, which consists of the key and value separated by a
single @sc{tab} character.  Empty lines are ignored.  For example: 

@example
$ mailutils list /etc/mail/users.db
root    guessme
smith   pAssword
qed     fooBar
@end example

The output in version 0.0 format is human readable and can be used as
input to the popauth utility (@FIXME-pxref{popauth}.  However, version 0.0
has serious drawbacks.  First of all, it is not suitable for databases
that contain binary data.  Secondly, it cannot properly handle keys
beginning with a sharp sign or containing @sc{tab}.  The version 1.0
format is free from these drawbacks. 

@anchor{dump version 1.0}
The @dfn{version 1.0} dump format begins with a @dfn{header}
containing important information about the file, such as its file
name, ownership and file mode.  This information is stored in
pragmatic comments and allows @command{mailutils dbm load} to easily recreate
an exact copy of the file.  The following comments are defined:

@table @asis
@item #:version=1.0
Indicates that the data that follow are in version 1.0 format. 
@item #:filename=@var{s}
Original database file name, without directory parts. 
@item #:uid=@var{n}
Owner UID. 
@item #:user=@var{s}
Owner name. 
@item #:gid=@var{n}
Owner GID 
@item #:group=@var{s}
Owner group name. 
@item #:mode=@var{o}
File mode in octal
@end table
    
Following this header are actual data.  Each record is output in two
parts: key and value.  Each part begins with a @samp{#:len=@var{n}}
construct on a line by itself, where @var{n} is the length of the data
in decimal.  This line is followed by one or more lines of the actual
data, encoded in base64.  The data are formatted so that each line
does not exceed 76 bytes in length (not counting the terminating
newline).  An example of this format follows: 

@example
# Database dump file created by GNU Mailutils 2.99.93 on
# Tue Nov  1 13:28:03 2011
#:version=1.0
#:file=users.db
#:uid=0,user=root,gid=25,group=mail,mode=640
#:len=6
c21pdGgA
#:len=9
cEFzc3dvcmQA
#:len=5
cm9vdAA=
#:len=8
Z3Vlc3NtZQA=
#:len=4
cWVkAA==
#:len=7
Zm9vQmFyAA==
@end example

@node Dbm Exit Codes
@subsubsection Dbm Exit Codes
The table below summarizes exit codes used by @command{mailutils dbm}:

@multitable @columnfractions 0.2 0.3 0.5
@headitem Code  @tab Symbolic name @tab Meaning
@item 0 @tab EX_OK @tab Successful termination
@item 64 @tab EX_USAGE @tab Command line usage error
@item 65 @tab EX_DATAERR @tab Error in user-supplied data: the input
file is badly formatted, or some of the data supplied in the command
line are invalid (e.g. user name, uid or the like), etc.
@item 66 @tab EX_NOINPUT @tab Cannot open input file
@item 67 @tab EX_NOUSER  @tab No such user or UID when trying to set
output file ownership 
@item 69 @tab EX_UNAVAILABLE @tab Operation cannot be performed due to
some kind of problem (e.g. access to the file denied, etc.)
@item 70 @tab EX_SOFTWARE @tab Internal software error
@item 74 @tab EX_IOERR @tab Input/output error
@end multitable

@node mailutils logger
@subsection mailutils logger
The @command{mailutils logger} tool logs information using Mailutils log facility.  

Syntax:

@example
mailutils logger [@var{options}] [@var{message}]
@end example

The @var{message} argument, if supplied, gives the text to log.  If not supplied, the utility reads lines of text from standard input or a file (if the @option{--file} option is given) and sends them to log:

@example
# Send text to log
$ mailutils logger I am here
# Log each line from file.txt
$ mailutils logger --file file.txt
# Read stdin and log it:
$ mailutils logger
@end example

The default logging channel is bound to standard error.  To bind it to
syslog, use the @option{--syslog} command line option.  In that case
@command{mailutils} uses facility @samp{user} and priority @samp{err}.  You
can change this by using the @option{--priority} (@option{-p}) option.
Its argument is either a syslog facility name or facility and severity
names separated by a dot.  For example, the following invocation will use
facility @samp{auth}, severity @samp{info}: 

@example
mailutils logger --priority auth.info
@end example

The syslog tag can be set using the @option{--tag} (@option{-t}) option:

@example
mailutils logger --tag myprog
@end example

The default tag is @samp{mu-logger}.

The @option{--severity} (@option{-s}) option sets the Mailutils
severity level.  Its argument can be any of the following:
@samp{debug}, @samp{info}, @samp{notice}, @samp{warning},
@samp{error}, @samp{crit}, @samp{alert}, @samp{emerg}. 

Finally, the @option{--locus} (@option{-l}) option binds log messages
to a location in a file.  Its argument has the following syntax:

@example
@var{file}:@var{line}[:@var{col}]
@end example

@noindent
where @var{file} is the file name, @var{line} is the line number and
optional @var{col} is the column number in that file.

For example, the following invocation:

@example
mailutils logger --locus mailutils.conf:34 Suspicious statement
@end example

will send the following to the log:

@example
mu-logger: mailutils.conf:34: Suspicious statement
@end example

@node mailutils pop
@subsection mailutils pop
The @command{mailutils pop} command invokes an interactive POP3 client shell.
It reads commands from the standard input, executes them and displays
the results on the standard output.  If the standard input is
connected to a terminal, the readline and history facilities are
enabled (provided that Mailutils is configured with GNU Readline). 

The @command{mailutils pop} commands form two major groups.  POP3 protocol
commands interact with the remote POP3 server and display responses
obtained from it.  These commands are named after their POP3
equivalents.  Another group, @dfn{internal commands}, are used to
configure the shell itself.

@subsubheading POP protocol commands
@table @asis
@item connect [-tls] @var{hostname} [@var{port}]
Open connection to @var{hostname}.  If the @option{-tls} option is
given, TLS encryption (also known as POPS protocol) will be used.  If
@var{port} argument is not given, the command uses port 110 for a
plain POP connection or 995 for POPS (if @option{-tls} is given).  

@item stls
Start TLS negotiation.  This command is valid only after successful
unencrypted connection has been initiated (using @command{connect}
without @option{-tls} argument).

@item user @var{name}
Send user name to the server.  The @command{pass} command must follow.

@item pass [@var{password}] 
Send password.  This command is valid only after @command{user}.  If
the @var{password} argument is omitted, the shell will ask you to
enter it.  While entering, both echoing and history recording will be
disabled.  Use this to avoid compromising your password.

@item apop @var{user} [@var{password}] 
Authenticate with APOP.   If the @var{password} argument is omitted,
you will be asked to supply it.  While entering, both echoing and
history recording will be disabled. 

@item capa [-reread] [@var{name}...] 
List server capabilities.  Any number of arguments is accepted.  If given, the shell will display only the named capabilities, otherwise it displays entire list.  By default @command{capa} reuses the response of its previous invocation (if there was any), instead of resending the @samp{CAPA} command to the server.  To force it do so, use the @option{-reread} option. 

@item noop 
Send a @samp{NOOP} (@dfn{no operation}) command to the server.

@item stat
Get the mailbox size and number of messages in it.

@item uidl [@var{number}]
Shows unique message identifiers.  Without arguments, shows
identifiers for each message in the mailbox.  If @var{number} is
given, the command returns the UIDL of that particular message only.

@item list [@var{number}]
Lists messages.  See above for the meaning of @var{number}.  Each line
of the produced listing contains describes a single message and
contains at least the message number and size in bytes.  Depending on
the POP3 server implementation, additional fields may be present.  For
example, Mailutils @command{pop3d} can also output number of lines in
the message in the additional third field. 

@item retr @var{number}
Retrieve a message.

@item top @var{msgno} [@var{number}] 
Display message headers and first @var{number} (default 5) of lines of its body.

@item dele @var{number}
Mark message for deletion.

@item rset
Remove deletion marks.

@item quit
Quit pop3 session.

@item disconnect
Close existing connection.
@end table

@subsubheading Internal commands
@table @asis
@item verbose [on|off|mask|unmask] [secure [payload]]
Control output verbosity.  Without arguments the @command{verbose}
command shows current settings.

The argument @samp{off} (the default) turns off all additional output.
The @samp{verbose on} command enables POP3 protocol tracing output.
Additional arguments can be used to provide more verbosity.  The
@samp{secure} argument enables display of user passwords in the trace
output and the @samp{payload} argument enables showing payload data
(e.g. response body sent in the reply to @samp{RETR} command, etc.)
Thus, the full diagnostics output is obtained by 

@example
verbose on secure payload
@end example

The @samp{mask} and @samp{unmask} arguments allow to disable and
enable such additional verbosity.  For example, supposing the command
above is in action, the following command will suppress the display of
user passwords in the traces:

@example
verbose mask secure
@end example

Similarly, @command{verbose unmask secure} will turn it back again.

@item prompt @var{string}
Set command prompt.  The argument can contain @dfn{variable
references} in any of the following forms:

@example
$@var{name}
$@{@var{name}@}
@end example

@noindent
where @var{name} is the variable name.  Such references are expanded
to the actual value of the variable at the time of expansion.  The
following variables are defined:

@multitable @columnfractions 0.4 0.6
@headitem Variable @tab Expansion
@item user @tab Login name of the authenticated POP3 user.  If the session is not authenticated yet, expands to @samp{[nouser]}.
@item host @tab Name of the remote host, or @samp{[nohost]} if no
connection is established. 
@item program-name @tab Name of the program, as typed on the command
line to invoke it. 
@item canonical-program-name @tab @samp{mailutils}
@item package @tab @samp{Mailutils}
@item version @tab Mailutils version number (@value{VERSION})
@item status @tab Session status.  One of: @samp{disconnected},
@samp{connected} or @samp{logged in}.
@end multitable

For example:

@example
prompt "[$@{user@}@@$host "
@end example

Notice the use of quotes to include the space character in the prompt.

@item exit
Exit the program.

@item help [@var{command}]
@itemx ? [@var{command}]
Without arguments displays a list of commands with possible arguments
and short descriptions.

With one argument, displays a terse description for the given @var{command}.

@item history
Shows command history.
@end table

@node mailutils imap
@subsection mailutils imap
The @command{mailutils imap} command invokes an interactive IMAP4 client
shell.  It reads commands from the standard input, executes them and
displays the results on the standard output.  The shell is similar to
the @command{mailutils pop} (@pxref{mailutils pop}) shell.

@subsubheading IMAP protocol commands

Most commands in this group correspond (with minor differences) to
IMAP commands described in RFC 3501@footnote{See
@uref{http://www.faqs.org/rfcs/rfc3501.html}.}.

@deffn {imap command} connect [-tls] @var{host} [@var{port}]
Opens connection to the server @var{host}.  If the @option{-tls}
option is given, TLS encryption (also known as IMAPS protocol) will be
used.  If @var{port} argument is not supplied, the command uses port
143 for a plain IMAP connection or 993 for IMAPS (if @option{-tls} is
given).
@end deffn

@deffn {imap command} capability [-reread] [@var{name}...]
Lists server capabilities.  Any number of @var{name}s is accepted.  If
at least one is given, the shell will display only the named
capabilities, otherwise it displays the entire list.  By default,
@command{capability} reuses the response of its previous invocation
(if there was any), instead of resending the CAPABILITY command to the
server.  To force it do so, use the @option{-reread} option. 
@end deffn

@deffn {imap command} starttls
Starts TLS negotiation.  This command is valid only after unencrypted
connection has been successfully initiated using connect without the
@option{-tls} option.
@end deffn

@deffn {imap command} login @var{user} [@var{password}] 
Logs in to the server as @var{user} with optional @var{password}.  If
the pass argument is omitted, the shell will ask you to enter it.
While entering, both echoing and history recording will be disabled.
Use this to avoid compromising your password.
@end deffn

@deffn {imap command} logout
@deffnx {imap command} quit
Quits the imap session.
@end deffn

@deffn {imap command} id [-test @var{kw}] [@var{arg}...]
Sends IMAP ID command.  See RFC
2971@footnote{@uref{http://www.faqs.org/rfcs/rfc2971.html}}, for a
discussion of arguments.  By default, this command outputs entire ID
list. If, however, the @option{-test} option is given, it will check whether
the keyword @var{kw} is defined and display its value if so.  
@end deffn

@deffn {imap command} check
Requests a server checkpoint.
@end deffn

@deffn {imap command} select [@var{mbox}]
Selects the named mailbox. Without argument, selects @samp{INBOX}. 
@end deffn

@deffn {imap command} examine [@var{mbox}]
Examines the named mailbox, i.e. selects it in read-only mode.  If
@var{mbox} is not given, @samp{INBOX} is assumed.
@end deffn

@deffn {imap command} status @var{mbox} @var{kw} [@var{kw}...]
Gets mailbox status.  Valid keywords (@var{kw} arguments) are:
@samp{MESSAGES}, @samp{RECENT}, @samp{UIDNEXT}, @samp{UIDVALIDITY},
and @samp{UNSEEN}.  Keywords are case-insensitive. 
@end deffn

@deffn {imap command} fetch @var{msgset} @var{items}
Fetches message data.  See RFC 3501, section
6.4.5@footnote{@uref{http://tools.ietf.org/html/rfc3501#section-6.4.5}},
for a discussion of its arguments.
@end deffn

@deffn {imap command} store @var{msgset} @var{items}
Alters mailbox data.  See RFC 3501, section
6.4.6@footnote{@uref{http://tools.ietf.org/html/rfc3501#section-6.4.6}},
for a discussion of its arguments. 
@end deffn

@deffn {imap command} close
Closes the currently selected mailbox (with expunge). 
@end deffn

@deffn {imap command} unselect
Closes the currently selected mailbox (without expunge). 
@end deffn

@deffn {imap command} delete @var{mbox}
Deletes the mailbox @var{mbox}. 
@end deffn

@deffn {imap command} rename @var{old-name} @var{new-name}
Renames existing mailbox @var{old-name} to @var{new-name}.
@end deffn

@deffn {imap command} expunge
Permanently removes messages marked for deletion. 
@end deffn

@deffn {imap command} create @var{name}
Creates new mailbox with the given @var{name}.
@end deffn

@deffn {imap command} append [-time @var{datetime}] [-flag @var{flag}] @var{mailbox} @var{file}
Reads an RFC-822 message from @var{file} and appends it to the
@var{mailbox}.  Use the @option{-time} option to supply envelope date
for the message.  Use the @option{-flag} option to supply message
flags.  For example:  

@example
append -time "25-Aug-2002 18:00:00 +0200" -flag \Seen INBOX input.msg
@end example
@end deffn

@deffn {imap command} list @var{ref} @var{mbox}
Lists matching mailboxes.  See RFC 3501, section
6.3.8@footnote{@uref{http://tools.ietf.org/html/rfc3501#section-6.3.8}},
for a discussion of its arguments.
@end deffn

@deffn {imap command} lsub @var{ref} @var{mbox}
Lists subscribed mailboxes (RFC 3501, section 6.3.9@footnote{@uref{http://tools.ietf.org/html/rfc3501#section-6.3.9}}). 
@end deffn

@deffn {imap command} subscribe @var{mbox}
Subscribes to a mailbox. 
@end deffn

@deffn {imap command} unsubscribe @var{mbox}
Removes mailbox @var{mbox} from the subscription list. 
@end deffn

@deffn {imap command} noop
Sends a @dfn{no operation} command. 
@end deffn

@deffn {imap command} disconnect
Closes existing connection. 
@end deffn

@subsubheading Internal commands
The @code{imap} shell implements the same set of internal commands as
@code{pop} shell: @xref{mailutils pop, Internal commands}.  There is
only one imap-specific internal command:

@deffn {imap command} uid [on|off]
Controls the UID mode.  When the UID mode is on, the commands
@code{fetch} and @code{store} operate on and return message UIDs
instead of their sequence numbers.  

To examine the current state of the UID mode, issue the @code{uid}
command without arguments.
@end deffn

@node mailutils send
@subsection mailutils send
Reads an RFC-822 message from a file and sends it over to a specified
SMTP server.  The syntax is: 

@example
mailutils send [@var{options}] @var{host} @var{file}
@end example

@noindent
where @var{host} defines the SMTP server through which to send the
message, and @var{file} is the name of the input file containing the
message.  For example, to send a message from file @file{input.msg}
using SMTP service at localhost, one would write:

@example
$ mailutils send localhost input.msg
@end example

The @var{host} argument can be an IP address, hostname, or a
valid SMTP URL. 

The following command line options are understood:

@table @option
@item -F @var{address}
@itemx --from=@var{address}
Supplies envelope sender address.

@item -T @var{address}
@itemx --rcpt=@var{address}
Supplies envelope recipient address.  It can be specified multiple
times.

@item -t
@itemx --read-recipients
Instructs the program to read recipient email addresses from the
message @samp{To:}, @samp{Cc:}, and @samp{Bcc:} headers.
@end table
    
@node mailutils smtp
@subsection mailutils smtp
The @code{mailutils smtp} command invokes an interactive SMTP client
shell.  It reads commands from the standard input, executes them and
displays the results on the standard output.  If the standard input is
connected to a terminal, the readline and history facilities are
enabled (provided that Mailutils is configured with GNU Readline).

@subsubheading Initializing connection

@deffn {smtp command} connect [-tls] @var{host} [@var{port}]
Connects to SMTP server at @var{host} (IP address or host name).  If
the @option{-tls} option is given, TLS encryption (also known as SMTPS
protocol) will be used.  The default port number is 25 for plain SMTP
and 465 for SMTPS.  Explicit @var{port} argument overrides the default
value.  
@end deffn

@subsubheading Connection parameters

A number of parameters is associated with an open connection:

@table @asis
@item domain
Domain name used in EHLO statement.  Defaults to the current host name. 
@end table

The following parameters are used for ESMTP authentication:

@table @asis
@item username
User name. 
@item password
User password. 
@item service
GSASL service name. 
@item realm
Realm name. 
@item host
Host name.
@item url
SMTP URL.  It can contain all of the above. Default is smtp:// 
@end table

These parameters are manipulated using the following statements:

@deffn {smtp command} set @var{param} @var{value} [@var{param} @var{value}...]
Sets parameter @var{param} to @var{value}.  Several parameters can be
set with one @command{set} statement.  
@end deffn

@deffn {smtp command} clear [@var{param}...]
Unset the supplied connection parameters.  If used without arguments,
unsets all parameters.  
@end deffn

@deffn {smtp command} list [@var{param}...]
Lists the values of the connection parameters.  If used without
arguments, lists all parameters. 
@end deffn

@subsubheading SMTP commands
@deffn {smtp command} ehlo [@var{domain}]
Sends the ESMTP greeting.  Unless @var{domain} is supplied, the
connection parameter @samp{domain} is used.  
@end deffn

@deffn {smtp command} capa [@var{name}...]
Lists the server capabilities. 
@end deffn

@deffn {smtp command} starttls
Initiates encrypted connection.  This command is disabled if the
connection is opened with the @option{-tls} option.
@end deffn

@deffn {smtp command} auth @var{mech} [@var{mech}...]
Authenticate using the supplied mechanisms.
@end deffn

@deffn {smtp command} rset
Reset the session state.
@end deffn

@deffn {smtp command} from [@var{email}]
Sets sender email address.  If used without arguments, prints the
sender email address.
@end deffn

@deffn {smtp command} to [@var{email}]
Sets recipient email address.  If used without arguments, prints all
recepient names collected so far.
@end deffn

@deffn {smtp command} smtp @var{command} [@var{args}...]
Sends the @var{command} with its arguments verbatim. 
@end deffn

@deffn {smtp command} quit
Quits the SMTP session. 
@end deffn

@deffn {smtp command} send [@var{file}]
Reads the message from @var{file} and sends it.  If @var{file} is not
supplied, the action depends on whether a @code{send} command was used
prevously within the same session.  If so, @command{mailutils} will
first ask whether to reuse the already supplied message.  If not, it
will start an editor, allowing you to enter the new message.  When you
exit from the editor, you will be prompted what to do with the
message: send, edit, or quit (discard) it.
@end deffn

@subsubheading Internal commands

Internal commands are the same as in @code{pop} shell: @xref{mailutils
pop, Internal commands}.