@c This is part of the GNU Mailutils manual.
@c Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008
@c 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.

* 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.

* mail.local::        Deliver Mail to the Local Mailbox.
* mail.remote::       Pseudo-Sendmail Interface for Mail Delivery.

* mimeview::          Universal File Viewer.

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

* mh::                The MH Message Handling System.

* mailutils-config::  Get the Information about the Mailutils Build.
@end menu

@node command line
@section Command Line
@UNREVISED

@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:

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

  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:

@smallexample
@group
Usage: sieve [-cv?V] [--compile-only] [--debug[=FLAGS]]
             [--email=ADDRESS] SCRIPT
@end group
@end smallexample
@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.
@end table

@node configuration
@section Mailutils Configuration File
@cindex Mailutils configuration file
@cindex mailutils.rc
@UNREVISED

  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.rc}, where @var{sysconfdir} stands
for the system configuration directory set when compiling the package.
You can obtain the value of @var{sysconfdir} by running

@smallexample
$ mailutils-config --info sysconfdir
@end smallexample

@noindent
or

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

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

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

@item Per-user configuration file.

A per user configuration file is located in the user home directory
and is named @samp{.@var{prog}}, where @var{prog} is the name of the
utility. For example, the per-user configuration file for
@command{sieve} utility is named @file{.sieve}.

@xopindex{no-user-config, described}
This configuration file is not read if the @option{--no-user-config}
command line option was given.

@xopindex{config-file, described}
@item Additional configuration file, if specified using the
@option{--config-file} command line option.
@end enumerate

The order in which configuration files are loaded defines the
precedence of their settings. Thus, the settings from additional
configuration file override those set in per-user configuration file.
The latter, in their turn, take precedence over the settings from the
site-wide configuration file.

@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 does not
complain, and the utility falls 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:

@smallexample
imap4d: Info: parsing file `/etc/mailutils.rc'
imap4d: Info: finished parsing file `/etc/mailutils.rc'
@end smallexample

Specifying this option more than once adds more verbosity to this
output. If this option is given two times, GNU Mailutils will print
any 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):

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

@xopindex{config-lint, described}
  To test configuration file without actually starting 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

@smallexample
$ imap4d --config-help > imap4d.rc
@end smallexample

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

@menu
* conf-syntax::         Configuration File Syntax
* Include::             Include Statement
* Logging Statement::
* Debug Statement::
* Mailbox Statement::
* Locking 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
@UNREVISED
  Configuration files consist of a series of statements. 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::
* Block Statements::
@end menu

@node Comments
@subsubsection Comments
@cindex comments, configuration file
@cindex comments, single-line
@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:

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

@cindex comments, multi-line
@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
are allowed to appear within a multi-line one.

@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{;}), unless it contains a @dfn{here-document}
(see below), in which case semicolon is optional.

  Examples of simple statements:

@smallexample
pidfile /var/run/imap4d.pid;
transcript yes;
@end smallexample

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

  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{:}.

@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 \\ @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.:

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

  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:

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

@anchor{here-document}
@item Here-document
@cindex here-document
  @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 lines that follow 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:

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

  Body of a here-document is interpreted the same way as
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:

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

  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: 

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

  However, terminated semicolon after a here-document is optional.

@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:

@smallexample
shared-namespace ("/home", "/var/spool/common");
@end smallexample

  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. @samp{shared-namespace /home;} is
equivalent to @samp{shared-namespace (/home);}.
@end table

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

@smallexample
@group
tcp-wrappers @{
  enable yes;
  allow-syslog-priority info;
  deny-syslog-priority notice;
@}
@end group
@end smallexample

  The closing curly brace may be followed by a semicolon, although
this is not required.
  
@node Include
@subsection Include Statement 
@cindex include statement, configuration file
@kwindex include
  An @dfn{include statement} is a special statement that causes
inclusion of a named file. This statement has the following syntax:

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

If @var{file} names a regular file, the contents of this file is
included in this point. Otherwise, if @var{file} names a directory,
Mailutils searches in that directory for a file whose name coincides
with the name of utility being executed, and includes this file, if it
exists.

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

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

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

@node Logging Statement
@subsection Logging Statement
@kwindex logging
@subheading Syntax
@smallexample
logging @{
  # @r{Set syslog facility.}
  facility @var{name};
  # @r{Tag syslog messages with this string.}
  tag @var{text};
@}
@end smallexample

@subheading Description
  The @code{logging} block statement provides configuration for
programs that use @command{syslog} for diagnostics. The default
syslog facility is determined at compile time, it can be inspected
using the following command:

@smallexample
$ mailutils-config --info log_facility
@end smallexample

@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

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

@subheading Description
The @code{debug} statement configures debugging output. Although it
is mostly useful for Mailutils developers, it may be of interest for
casual users as well. In particular, you may use it to obtain more
information about Mailutils actions, which may help in configuring it,
or in filling a bug report.

Debugging output is controlled by a set of levels, each of which can be
enabled or disabled independently of others. A @dfn{debugging
level} consists of a module name, which defines a Mailutils module
affected by this level, and a level number, which defines the
verbosity of the debugging output. Valid debugging levels are:

@float Table, debugging levels
@caption{Debugging levels}
@table @asis
@item error
Display only error messages.

@item trace0 through trace7
Eight levels of verbosity, @samp{trace0} producing less output,
@samp{trace7} producing maximum possible output.

@item prot
Display network protocol interactions, where appropriate.
@end table
@end float

The most important debugging modules are:

@table @asis
@item acl
Debug access control lists. @FIXME-xref{Debugging ACLs}.

@item config
Debug 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 debugging module cannot be enabled
using @code{level} statement below. The @option{--debug-level}
command line option should be used instead
(@FIXME-pxref{debug-level}). Alternatively, you may use the following
hook, provided to facilitate debugging of the configuration parser: a
@dfn{pragmatic comment} in form:

@smallexample
#debug=@var{level}
@end smallexample

is understood as a request to set debugging level of module
@samp{config} to @var{level}.

@item ip_server
IP based servers, such as @command{imap4d} and @command{pop3d}. This
module supports @samp{trace0} and @samp{error} levels. @xref{Server
Settings}, for more information about servers.

@item udp_server
UDP based servers, such as @command{comsatd}. This module supports
@samp{trace0} and @samp{error} levels. @xref{Server Settings}, for
more information about servers. 

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

@item sieve
Debug Sieve parser and run-time evaluator. Currently supported levels
are @samp{error}, @samp{trace1} and @samp{trace7}.
@end table

@deffn {Configuration} level spec
This statement enables debugging levels given by @var{spec}. The
argument is an list of debugging specifications or a string with
specifications delimited by semicolons. The syntax of a specification
is:

@smallexample
  @var{module}[[:]=@var{level}]
@end smallexample

@noindent
where @var{module} is the name of a module, and @var{level} is the
level to be set. The level may be optionally prefixed with the
following symbols:

@table @samp
@item !
All levels except this one. E.g. @samp{config=!trace7} means
set all debugging levels, except @samp{trace7} for the @samp{config}
module.

@item <
All levels up to and including this. The words @samp{up to} refer to
the position of levels in @ref{debugging levels} table, so that, e.g.
@samp{<trace2} means levels @samp{error}, @samp{trace0}, @samp{trace1}
and @samp{trace2}.
@end table

Both prefixes can be used together, in this order: @samp{!<}. This
means all levels except this one and ones listed before it in
the table.

A comma before equal sign, as in @samp{mailbox:=<trace7} means set
this debugging levels in all modules, invoked by this one.

The @var{level} in the level specification can also be a
comma-separated list of valid levels, e.g.:

@smallexample
   mailbox=<trace2,!<trace4
@end smallexample

@noindent
which means ``levels trace3 and trace4''.

The following example illustrates two equivalent ways of setting
debugging level in a configuration file:

@smallexample
  level ("mailbox=!proto", "acl=<trace7");
  level "mailbox=!proto;acl=<trace7";
@end smallexample

The @option{--debug-level} command line option overrides the settings
of the @code{level} configuration statement.
@end deffn

@deffn {Configuration} line-info @var{bool}
If @var{bool} is @samp{true} (@pxref{boolean value}), each debugging
message will be preceded by a corresponding source file location,
i.e. the file name and line number where this message was generated.
@end deffn


@node Mailbox Statement
@subsection Mailbox Statement
@kwindex mailbox
@subheading Syntax
@smallexample
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 smallexample

@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{pattern}
The @code{mailbox-pattern} statement is a modern way of configuring
mailbox locations. It superceeds @code{mail-spool} statement.

The @var{pattern} is valid @dfn{mailbox URL}, which 
may contain references to @samp{user} macro-variable
(@FIXME-pxref{macro-variables}). This macro-variable will be expanded
to the actual user name. The full syntax for @var{pattern} is:

@smallexample
  [@var{type}://]@var{path}[;@var{args}]
@end smallexample

@noindent
where:

@table @var
@item type
Specifies the mailbox type. It must be one of mailbox types,
supported by Mailutils. @FIXME-xref{Mailbox URLs}. By default,
@samp{local} is assumed. @FIXME{Verify this}.

@item path
The path pattern.

@item args
A semicolon-separated list of optional arguments, configuring
indexed directory structure.

@cindex directory indexing
An @dfn{indexed directory 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 sub-directory name.
@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 subirectories 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 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 user incoming
mails are stored in UNIX mailbox format in @file{/var/mail} directory.
The @code{mailbox-pattern} for this case is:

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

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:

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

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

@smallexample
  mailbox-pattern "maildir:///var/mail;type=index;param=2;user=$@{user@}";
@end smallexample
@end table
@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} its value is used.
@item Otherwise, if environment variable @env{MAIL} is set, its value
is used.
@item If neither of these is set, the mailbox name is constructed 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 @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 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-config --info scheme}.
@end deffn

@deffn {Configuration} folder @var{dir}
@cindex plus expansion
Sets user mail folder directory. Its value is using 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 Locking Statement
@kwindex locking
@subheading Syntax
@smallexample
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 smallexample

@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 maildrops in
UNIX mailbox format. All other mailbox types do not 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
@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}
Set command line of an external locker program. The @samp{E} flag
must be set for this to take effect. 
@end deffn

@node ACL Statement
@subsection ACL Statement
@kwindex acl
@subheading Syntax
@smallexample
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 smallexample

@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 definitive answer
(either @code{True} or @code{False}).

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

@itemize @bullet
@item An IPv4 address in dotted-quad notation.
@item A CIDR in the form @samp{@var{ip}/@var{mask}}, where @var{ip} is
an IPv4 address, and @var{mask} is a decimal number in the range
@samp{0--32}.
@item A symbolic host name.
@kwindex any
@item A word @samp{any}, that stands for @samp{0.0.0.0/0}.
@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.
@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 the @var{string} is specified, it undergoes macro expansion and the
result of it is used as the log entry. The following macro variables
are expanded:

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

@item family
Connection family. Mailutils version @value{VERSION} supports two
families: @samp{AF_INET} and @samp{AF_UNIX}.

@item address
Remote IP address (for @samp{AF_INET}) 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}).
@end table

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

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

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 Tcp-wrappers Statement
@kwindex tcp-wrappers
@subheading Syntax
@smallexample
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};
  # @r{Log allowed accesses at this syslog priority.}
  allow-syslog-priority @var{prio};
  # @r{Log denied accesses at this syslog priority.}
  deny-syslog-priority @var{prio};
@}
@end smallexample

@subsection 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}. Each
utility wishing to verify a connection, select 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.

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

@deffn {Configuration} allow-syslog-priority @var{prio};
Log allowed accesses using syslog priority @var{prio}.
@end deffn

@deffn {Configuration} deny-syslog-priority @var{prio};
Log denied accesses using syslog priority @var{prio}.
@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
mode: a @dfn{daemon} mode, where a program disconnects from the controlling
terminal and works in background, and an @dfn{inetd} mode, 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 we will describe in this
subsection. 

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

@node General Server Configuration
@subsubsection General Server Configuration
@cindex server configuration, general
@subsubheading Syntax
@smallexample
# @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 smallexample

@subsubheading 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 itself
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 (@FIXME-pxref{mention pies}).
@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};
Set 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 Server Statement
@cindex server statement
@kwindex server
@subsubheading Syntax
@smallexample
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};
  # @r{Set server specific ACLs.}
  acl @{ /* @xref{ACL Statement}. */ @};
@}
@end smallexample

@subsubheading 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 symbolic host
name which can be resolved to such an address via DNS. 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 global timeout
settings (@pxref{General Server Configuration, timeout}).
@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 Auth Statement
@cindex authorization
@cindex authentication
@kwindex auth
@subheading Syntax
@smallexample
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 smallexample

@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

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

@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

@FIXME{This may be inaccurate:}
Unless overridden by @code{authorization} statement,
the default list of authorization modules is:

@smallexample
  (system, sql, virtdomains)
@end smallexample
@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

@FIXME{This list is inaccurate:}
Unless overridden by @code{authentication} statement,
the list of authentication modules is:

@smallexample
  (generic, system, pam, sql)
@end smallexample
@end deffn

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

@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 Virtdomain Statement
@kwindex virtdomain
@subheading Syntax
@smallexample
virtdomain @{
  # @r{Name of the virtdomain password directory.}
  passwd-dir @var{dir};
@}
@end smallexample

@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 usernames 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@@domain.tld},
the server will use password file named @file{@var{dir}/domain.tld}.
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:

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

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 Radius Statement
@kwindex radius
@subheading Syntax
@smallexample
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 smallexample
@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:

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

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:

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

An assignment may contain references to the following macro-variables
(@FIXME-pxref{macro-variables}):

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

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

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

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

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

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:

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

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} (@FIXME-pxref{urls}). 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:

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

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

@node SQL Statement
@subsection SQL Statement
@UNREVISED
@kwindex sql
@subheading Syntax
@smallexample
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{map};
  # @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 smallexample
@subsection 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

@node LDAP Statement
@subsection LDAP Statement
@UNREVISED
@kwindex ldap
@subheading Syntax
@smallexample
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{map};
  # @r{LDAP filter to use for getpwnam requests.}
  getpwnam @var{string};
  # @r{LDAP filter to use for getpwuid requests.}
  getpwuid @var{filter};
@}
@end smallexample

@node TLS Statement
@subsection TLS Statement
@UNREVISED
@kwindex tls
@subheading Syntax
@smallexample
tls @{
  # @r{Enable client TLS encryption.}
  tls @var{bool};
  # @r{Specify SSL certificate file.}
  ssl-cert @var{bool};
  # @r{Specify SSL certificate key file.}
  ssl-key @var{file};
  # @r{Specify trusted CAs file.}
  ssl-cafile @var{file};
@}
@end smallexample

@node GSASL Statement
@subsection GSASL Statement
@UNREVISED
@kwindex gsasl
@subheading Syntax
@smallexample
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 smallexample




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

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

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

@subheading @command{frm}
@pindex frm

The @command{frm} command outputs a header information of
the selected messages in a mailbox. By default, @command{frm} reads the
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 program uses following option groups: @FIXME-xref{mailbox}.

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

@table @option
@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 user
name 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.

Option @option{-f} (@option{--file}) instructs the program 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 from addresses containing the supplied string.
FIXME: only @code{From:} header is examined.

@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

@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 a mailbox. The URL of the mailbox to operate upon is
taken from the argument of @option{--file} command line option. If it
is not specified, the user's system mailbox is assumed. For more
detail, see @ref{Reading Mail}.

@menu
* Invoking Mail::            Command Line Options.
* Specifying Messages::      How to Specify Message Sets.
* Composing Mail::           Composing Mail.
* 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:

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

The program uses following option groups: @FIXME-xref{mailbox}.

@command{Mail} understands following command line options:

@table @option
@item -e
@itemx --exist
Return true if the mailbox contains some messages. Return false
otherwise.
This is useful for writing shell scripts.
@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 --exec
@item -f[@var{file}]
@itemx --file[=@var{file}]
Operate on mailbox @var{file}. If this option is not specified, the default
is user's system mailbox. If it is specified without argument, the
default is @file{$HOME/mbox}.
@emph{Please note}, that there should be no whitespace between the
short variant of the option (@option{-f}), and its parameter. Similarly,
when using long option (@option{--file}), its argument must be preceded by
equal sign.
@item -F
@itemx --byname
Save messages according to sender. Currently this option is not implemented.
@item -H
@itemx --headers
Print header summary to stdout and exit.
@item -i
@itemx --ignore
Ignore interrupts.
@item -m @var{path}
@itemx --mail-spool=@var{path}
Set path to the mailspool directory
@item -n
@itemx --norc
Do not read the system-wide mailrc file. @xref{Mail Configuration Files}.
@item -N
@itemx --nosum
Do not display initial header summary.
@item -p
@itemx --print
@itemx -r
@itemx --read
Print all mail to standard output. It is equivalent to issuing following
commands after starting @samp{mail -N}:
@smallexample
@group
print *
quit
@end group
@end smallexample
@item -q
@itemx --quit
Cause interrupts to terminate program.
@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
Switch to sending mode.
@item -u @var{user}
@itemx --user=@var{user}
Operate on @var{user}'s mailbox. This is equivalent to:

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

@noindent
with @var{spool_path} being the full path to your mailspool directory
@*(@file{/var/spool/mail} or @file{/var/mail} on most systems).
@item -?
@itemx --help
Display a help message.
@itemx --usage
Display a short usage summary.
@item -V
@itemx --version
Print program version and exit.
@end table

@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:

@smallexample
[@var{header}:]/@var{string}/
@end smallexample
@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:

@smallexample
:/@var{string}/
@end smallexample
@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::
* 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
@subsubheading 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
@subsubheading 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
@subsubheading 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
@subsubheading Modifying the Headers: ~h, ~t, ~c, ~b, ~s

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

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

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

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

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

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
@subsubheading 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
@subsubheading Adding a File to the Message: ~r and ~d

To append the contents of file @var{filename} to the message, type

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

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

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

@smallexample
~r dead.letter
@end smallexample

@node Printing And Saving the Message
@subsubheading 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
@subsubheading 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
@subsubheading 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
@subsubheading 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
@subsubheading 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

@smallexample
~: from :t
@end smallexample
@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
@subsubheading 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 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 --file
To read messages from your mailbox (@file{$HOME/mbox}).
@item mail --file=@var{path_to_mailbox}
To read messages from the specified mailbox.
@item 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.

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
@subsubheading 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
@subsubheading 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
@subsubheading 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
@subsubheading 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.:

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

@node Controlling Header Display
@subsubheading 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
@subsubheading 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:

@smallexample
& z +2
@end smallexample
@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.:

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

@node Displaying Messages
@subsubheading Displaying Messages
@kyindex print, mail command
@kyindex type, mail command
@kyindex Print, mail command
@kyindex Type, mail command
@kyindex decode, 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.
@smallexample
@cartouche
& decode 15[2]
+---------------------------------------
| Message=15[2]
| Type=message/delivery-status
| encoding=7bit
+---------------------------------------
Content-Type: message/delivery-status
...
@end cartouche
@end smallexample
@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.
@end table

@node Marking Messages
@subsubheading 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
@smallexample
& untag :t
@end smallexample
@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
@subsubheading 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
@subsubheading 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 and appends each message in turn to
the end of the file. The name of file and number of characters appended
to it is echoed on the terminal. 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:

@smallexample
@group
@cartouche
& 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 cartouche
@end group
@end smallexample
@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
@subsubheading 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
@subsubheading 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
@subsubheading 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:

@smallexample
@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 smallexample

@noindent
Now, you issue the following commands:

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

@end cartouche
@end smallexample

@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:

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

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

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

@end cartouche
@end smallexample

@node Controlling Sender Fields
@subsubheading 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:

@smallexample
@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 smallexample

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

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

When used without arguments, this command clears the list:

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

@node Incorporating New Mail
@subsubheading 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
@subsubheading 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}.

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

The mail variables may be 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:

@smallexample
& set askcc nocrt indentprefix="> "
@end smallexample
@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:

@smallexample
& unset askcc crt indentprefix
@end smallexample

@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:

@smallexample
if @var{cond}
...
else
...
endif
@end smallexample
@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:

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

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

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

@table @code
@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.

@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.

@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.

@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.

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

Automatically incorporate newly arrived messages.

@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.

@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.

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

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

@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.

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

Contains default shell command for @code{pipe}.

@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.

@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.

@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

@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.

@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.

@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.

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

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

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

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

@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.

@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.

@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.

@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.

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

Controls whether typing EOF character terminates the letter being
composed.

@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.

@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.

@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.

@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

@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:

@smallexample
# 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 smallexample

@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

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

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

@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.

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

Setting this variable does not affect the operation mode of the program.

@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:

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

@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.

@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.

@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.

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

Contains the command prompt sequence.

@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.

@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}.

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

When set, any outgoing message will be saved to the named file.

@item recursivealiases
@*Type: Boolean
@*Default: True

When set, @command{mail} will expand aliases recursively.

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

Setting this to @code{True} enables use of regular expressions in
@samp{/.../} message specifications.

@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.

@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:

@smallexample
set replyregex="^(re|odp|aw|ang)(\\[[0-9]+\\])?:[[:blank:]]"
@end smallexample

@noindent
(Notice the quoting of backslash characters).

@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}.

@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.

@item sendmail
@*Type: String.
@*Default: sendmail:/usr/lib/sendmail
@vrindex sendmail, mail variable

Contains the URL of mail transport agent.

@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.

@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.

@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.

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

Contains default subject line. This will be used when @code{asksub} is
off.

@item toplines
@*Type: Numeric.
@*Default: 5
@vrindex toplines, mail variable

Number of lines to be displayed by @code{top} and @code{Top} commands.

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

When set, the actual delivery of messages is displayed on the user's terminal.

@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

@smallexample
X-Mailer: mail (GNU Mailutils @value{VERSION})
@end smallexample

@end table

@node Mail Configuration Files
@subsection Personal and System-wide Configuration Files

Upon startup, @command{mail} reads the contents of the two command files:
the system-wide configuration file, and the user's configuration
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:

@smallexample
Number of messages in @var{folder}: @var{number}
@end smallexample

@noindent
where @var{folder} represents the folder name, @var{number} represents
the number of messages.

The program uses following option groups: @FIXME-xref{mailbox}.

The program accepts 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.
@item -?
@itemx --help
Output help message and exit.
@item --usage
Output short usage summary and exit.
@item -V
@itemx --version
Output program version and exit.
@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:

@smallexample
movemail /var/mail/smith INBOX
@end smallexample

@noindent
moves messages from file @file{/var/mail/smith} to file @file{INBOX}.

You will probably never have to run this program manually. It is
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 completely
backward-compatible with its Emacs predecessor, so it should run
flawlessly with older versions of Emacs. Emacs version 21.4, which is
being developed at the time of this writing, will contain improved
@code{Rmail} interface for work with mailutils @command{movemail}.

@menu
* Movemail Options::     Description of the Available Options
* Summary::              Short Movemail Invocation Summary
@end menu

@node Movemail Options
@subsection Movemail Options

This subsection discusses @command{movemail} options from the point of
view of an Emacs @code{Rmail} user.

To set various options to @command{movemail} from @code{Rmail}, use
@code{rmail-movemail-flags} variable, or @samp{Rmail Movemail Flags}
section from the menu. 

Some POP servers return messages in reversed order. To fix the
order, use @option{-p} option or its synonym @option{--reverse}.

If the remote server supports @acronym{TLS} encryption, use
@option{--tls} to instruct @command{movemail} to initiate encrypted
connection.

Quite a few options control how @command{movemail} handles mail
locking (a way of preventing simultaneous access to the source
mailbox). By default, before accessing mailbox @var{file},
@command{movemail} will first see if the file named
@file{@var{file}.lock} (so called @dfn{lock file}) exists. If so, it
will assume that the mailbox is being used by another program and will
sleep one second. If @file{@var{file}.lock} file disappears after this
wait period, the program will proceed. Otherwise, it will repeat this
action ten times. If after ten wait periods the lock file does not
disappear, @command{movemail} gives up and exits.

If the lock file does not exist, @command{movemail} will create it,
thereby indicating to other programs that the mailbox is being used,
and will proceed to copying messages to the destination file. When
finished, @command{movemail} closes the mailbox and removes the lock
file.

Several options control this behavior. To change the default sleep period
use @option{--lock-retry-timeout}. Its argument is the timeout value
in seconds.

To change number of retries, use @option{--lock-retry-count}. For
example, setting @code{rmail-movemail-flags} to

@smallexample
--lock-retry-timeout=2 --lock-retry-count=5
@end smallexample

@noindent
instructs @command{movemail} to make five attempts to acquire the lock
file, with two-second intervals between the attempts.

You may also force @command{movemail} to remove the lock file if it is
older than a given amount of time (a so called @dfn{stale lock
file}). To do so, use the following option:

@smallexample
--lock-expire-timeout=@var{seconds}
@end smallexample

The @option{--lock-expire-timeout} sets the number of seconds after
which a lock file is considered stale.

There are special programs that can be used to lock and unlock
mailboxes. A common example of such programs is @command{dotlock}. If
you wish to use such @dfn{external locking program} instead of the
default mailutils locking mechanism, use option
@option{--external-locker}. Argument to this option specifies the full
name of the external program to use.

@node Summary
@subsection Summary of Movemail Usage

@smallexample
movemail [@var{option}...] @var{inbox} @var{destfile} [@var{remote-password}]
@end smallexample

The first argument, @var{inbox}, is the @acronym{url} (@pxref{URL}) 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}. Finally, optional third argument is a traditional way of
specifying user passwords for remote (@acronym{POP} or @acronym{IMAP})
mailboxes.

Following is the summary of available command line options:

@table @option
@item --emacs
Output information used by Emacs rmail interface

@item -p
@itemx --preserve
@itemx --keep-messages
Preserve the source mailbox

@item -r
@itemx --reverse
Reverse the sorting order

@item --license
Print GPL license and exit

@item --external-locker=@var{program}
Use given @var{program} as the external locker program.

@item --lock-expire-timeout=@var{seconds}
Set number of seconds after which the lock expires

@item --lock-flags=@var{flags}
Set locker flags. @var{flags} is composed of the following letters:
@samp{E} -- use external locker program @command{dotlock},
@samp{R} -- retry 10 times if acquiring of the lock failed (see also
@option{--lock-retry-count} below), @samp{T} -- remove stale locks
after 10 minutes (see also @option{--lock-expire-timeout},
and @samp{P} -- write process @acronym{PID} to the lock file.

@item --lock-retry-count=@var{number}
Set the maximum number of times to retry acquiring the lockfile

@item --lock-retry-timeout=@var{seconds}
Set timeout for acquiring the lockfile

@item -m @var{url}
@itemx --mail-spool @var{URL}
Use specified URL as a mailspool directory

@item --tls[=@var{bool}]
Enable (default) or disable TLS support

@end table

@page
@node readmsg
@section @command{readmsg} --- Extract Messages from a Folder
@pindex readmsg

The program, readmsg, extracts with the selection argument messages from
a mailbox. Selection can be specify by:

@enumerate
@item A lone ``*'' means select all messages in the mailbox.

@item
A list of message numbers may be specified. Values
of  ``0''  and ``$'' in the list both mean the last
message in the mailbox. For example:
@smallexample
readmsg 1 3 0
@end smallexample
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,
@smallexample
readmsg staff meeting
@end smallexample
extracts the message which contains the words ``staff meeting.''  Note that it
will not match a message containing ``Staff Meeting'' - the matching  is  case
sensitive.   Normally only the first message which matches the pattern will be
printed.
@end enumerate

@subsubheading Command line options

@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.

@item  -w @var{weedlist}
@itemx --weedlist=@var{weedlist}
A whitespace or coma separated list of header names to show per message.
Default is --weedlist=''From Subject Date To CC Apparently-''
@end table

@page
@node sieve
@section @command{sieve}
@pindex sieve

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
* sieve.scm::           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::
* Logging and Debugging::
* Extending Sieve::
@end menu

@node Invoking Sieve
@subsubheading Invoking @command{sieve}

The @command{sieve} invocation syntax is:

@smallexample
sieve [@var{options}] @var{script}
@end smallexample

@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 -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 mailutil 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 sieve is
executed.

@item -f
@itemx --mbox-url=@var{mbox}
Mailbox to sieve (defaults to user's system mailbox)

@item -k
@itemx --keep-going
Keep on going if execution fails on a message

@item -n
@itemx --no-actions
Dry run: do not execute any actions, just print what would be done.

@item -t @var{ticket}
@itemx --ticket=@var{ticket}
Ticket file for mailbox authentication

@item -v
@itemx --verbose
Log all actions executed.
@end table

Apart from these, @command{sieve} understands the options from the
following groups: @code{sieve}, @code{mailbox}, @code{mailer},
@code{logging}.

@node Logging and Debugging
@subsubheading 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 @samp{t}
This flag enables sieve tracing. It means that every test will be logged
when executed.

@item @samp{T}
This flag enables debugging of underlying @code{mailutils} library.

@item @samp{P}
Trace network protocols: produces log of network transactions executed
while running the script.

@item @samp{g}
Enable main parser traces. This is useful for debugging the sieve grammar.

@item @samp{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} output 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
@subsubheading Extending @command{sieve}

The basic set of sieve actions, tests and comparators may be extended
using loadable extensions. 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 used 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
@code{#searchpath} directive.

@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:

@smallexample
source for the required action NAME is not available
@end smallexample
@end enumerate
 
@c ***********************************************************************

@page
@node sieve.scm
@subsection A Sieve to Scheme Translator and Filter

A Sieve to Scheme Translator @command{sieve.scm} 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 1.4 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{sieve.scm} can be used with
@command{guimb} or @command{mail.local}.

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

@page
@node guimb
@section @command{guimb} --- A Mailbox Scanning and Processing Language
@pindex guimb

@command{Guimb} is for mailboxes what @command{awk} is for text files.
It processes mailboxes, applying the user-supplied scheme procedures
to each of them in turn and saves the resulting output in mailbox
format.

The program uses following option groups: @FIXME-xref{mailbox}.

@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 program or expression to be executed is passed to
@command{guimb} via the following options:

@table @option
@item -s @var{file}
@itemx --source @var{file}
Load Scheme source code from @var{file}.
@item -c @var{expr}
@itemx --code @var{expr}
Execute given scheme expression.
@end table

The above switches stop further argument processing, and pass all
remaining arguments as the value of @code{(command-line)}.

If the remaining arguments must be processed by @command{guimb} itself,
use following options:

@table @option
@item -e @var{expr}
@itemx --expression @var{expr}
Execute scheme expression.
@item -f @var{file}
@itemx --file @var{file}
Load Scheme source code from @var{file}.
@end table

You can specify both of them. In this case, the @var{file} is read
first, then @var{expr} is executed. You may still pass any additional
arguments to the script using @option{--guile-arg} option.

@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 allows
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}) or @option{--code}
(@option{-c}) options, all the rest of the command line following
the option's argument is passed to Scheme program verbatim. 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:

@smallexample
#! /usr/local/bin/guimb -s
!#
@end smallexample

@noindent
(replace @samp{/usr/local/bin/} with the actual path to the @command{guimb}).

Otherwise, if you use @option{--file} or @option{--expression} options,
the additional arguments may be passed to the Scheme program @option{-g}
(@option{--guile-arg}) command line option. For example:

@smallexample
guimb --guile-arg -opt --guile-arg 24 --file @var{progfile}
@end smallexample

In this example, the scheme procedure will see the following command line:

@smallexample
@var{progfile} -opt 24
@end smallexample

Finally, if there are many arguments to be passed to Scheme, it is more
convenient to enclose them in @option{-@{} and @option{-@}} escapes:

@smallexample
guimb -@{ -opt 24 -@} --file @var{progfile}
@end smallexample

@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 -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 mail.local
@section @command{mail.local} --- Deliver Mail to the Local Mailbox
@pindex mail.local

@command{mail.local} reads the standard input up to an end-of-file
and appends the received data to the local mailboxes.

@menu
* Invocation::     Mail.local options
* MTA::            Using mail.local with various MTAs
* Mailbox Quotas:: Setting up mailbox quotas.
* Sieve Filters::  Implementing user-defined Sieve mail filters.
* Scheme Filters:: Implementing user-defined Scheme mail filters. 
@end menu

@node Invocation
@subsection Invoking @command{mail.local}

General usage of @command{mail.local} program is:
                                                                                
@smallexample
      mail.local [@var{option}...] @var{recipient} [@var{recipient} ...]
@end smallexample

@noindent
If recipient part is present is a FQDN, @command{mail.local} 
will attempt to deliver to a virtual host.
                                                                                
The program uses following option groups: @FIXME-xref{mailbox}, @FIXME-xref{auth},
@FIXME-xref{logging}, @FIXME-xref{sieve}.

@table @option
@item -f @var{addr}
@itemx --from @var{addr}
Specify the sender's name. This option forces @command{mail.local} to
add @samp{From } envelope to the beginning of the message. If it is
not specified, @command{mail.local} first looks into the first line
from the standard input. If it starts with @samp{From }, it is assumed
to contain a valid envelope. If it does not, @command{mail.local}
creates the envelope by using current user name and date.

@item -h
@itemx --help
Display usage summary and exit.

@item -L
@itemx --license
Display GNU General Public License and exit.

@item -m @var{path}
@itemx --mail-spool @var{path}
Specify path to mailspool directory.

@item -q
@itemx --quota-db @var{file}
Specify path to DBM mailbox quota database (@pxref{Mailbox Quotas}). 

@item --quota-query
Specify SQL query that should be used to obtain user mailbox
quotas from the SQL database (@pxref{Mailbox Quotas}).

@item -s @var{pattern}
@itemx --source @var{pattern}
Set name pattern for user-defined mail filters written in Scheme
(@pxref{Scheme Filters}). The
metacharacters @samp{%u} and @samp{%h} in the pattern are expanded to
the current recipient user name and home directory correspondingly.

This option is available only if the package has been configured to
use Guile extension language.
@item -S @var{pattern}
@itemx --sieve @var{pattern}
Set name pattern for user-defined mail filters written is Sieve
(@pxref{Sieve Filters}). The
metacharacters @samp{%u} and @samp{%h} in the pattern are expanded to
the current recipient user name and home directory correspondingly.
@item -t @var{number}
@itemx --timeout @var{number}
Wait @var{number} seconds for acquiring the lockfile. If it doesn't
become available after that amount of time, return failure. The timeout
defaults to 5 minutes.
@item -x @var{flags}
@itemx --debug @var{flags}
Enable debugging. The debugging information will be output using syslog.
The @var{flags} is a string consisting of the following flags:
Debug flags are:

@table @samp
@item g
Start with guile debugging evaluator and backtraces. This is convenient
for debugging user-defined filters (@pxref{Scheme Filters}).

@item T
Enable libmailutil traces (@code{MU_DEBUG_TRACE}).

@item P
Enable network protocol traces (@code{MU_DEBUG_PROT})

@item t
Enable sieve trace (@code{MU_SIEVE_DEBUG_TRACE})

@item l
Enable sieve action logs
@end table

The digits in the range @samp{0} -- @samp{9} used in @var{flags} set
@command{mail.local} debugging level.
@item -v
@itemx --version
Display program version and exit.
@item --ex-multiple-delivery-success
Don't return errors when delivering to multiple recipients.
@item --ex-quota-tempfail
Return temporary failure if disk or mailbox quota is exceeded. By
default, 'service unavailable' is returned if the message exceeds
the mailbox quota.
@end table

@node MTA
@subsection Using @command{mail.local} with Various MTAs

This section explains how to invoke @command{mail.local} from
configuration files of various Mail Transport Agents.

All examples in this section suppose that @command{mail.local}
must receive following command line switches:

@smallexample
-s %h/.filter.scm -q /etc/mail/userquota
@end smallexample

@menu
* Sendmail::    Using @command{mail.local} with Sendmail.
* Exim::        Using @command{mail.local} with Exim.
@end menu

@node Sendmail
@subsubheading Using @command{mail.local} with Sendmail

The @command{mail.local} must be invoked from the local mailer
definition in the @file{sendmail.cf} file. It must have the
following flags set @samp{lswS}, meaning the mailer is local,
the 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, @samp{fn} flags may be specified to allow
@command{mail.local} to generate usual @samp{From } envelope
instead of the one supplied by sendmail.

If you wish to use mail.local with SQL authentication, you may
wish 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}

@smallexample 
Mlocal, P=/usr/local/libexec/mail.local,
        F=lsDFMAw5:/|@@qSPfhn9,
        S=EnvFromL/HdrFromL, R=EnvToL/HdrToL,
        T=DNS/RFC822/X-Unix,
        A=mail $u
@end smallexample

To define local mailer in @samp{mc} source file, it will suffice to
set:

@smallexample
define(`LOCAL_MAILER_PATH', `/usr/local/libexec/mail.local')
define(`LOCAL_MAILER_ARGS', `mail $u')
@end smallexample

@node Exim
@subsubheading Using @command{mail.local} with Exim

Using @command{mail.local} with Exim is quite straightforward. The
following example illustrates the definition of appropriate transport
and director in @file{exim.conf}:

@smallexample
# transport
mail_local_pipe:
  driver = pipe
  command = /usr/local/libexec/mail.local $local_part
  return_path_add
  delivery_date_add
  envelope_to_add
  
# director
mail_local:
  driver = localuser
  transport = mail_local_pipe
@end smallexample

@node Mailbox Quotas
@subsection Setting up Mailbox Quotas

Sometimes it is necessary to limit the maximum size of a user's
mailbox. Such maximum size is called @dfn{mailbox quota} for this
user.

When delivering a message, @command{mail.local} first checks if
the mailbox quota is specified for the recipient. If so,
@command{mail.local} computes the difference between the quota
value and the actual size of the recipient's mailbox. This difference
represents the maximum size of the message the receipient's mailbox is
able to accommodate. Let's call it @var{msize}. Depending on its value,
@command{mail.local} takes decision on whether to deliver the message.
There are three possible cases:

@enumerate 1
@item @var{msize} equals zero. This means that the mailbox size has
reached its limit). In this case the message is not delivered and
the sender receives following notification message:

@smallexample
@var{user}: mailbox quota exceeded for this recipient
@end smallexample

@item @var{msize} is less than the size of the message
@command{mail.local} is about to deliver. In this case the message is
not delivered and the sender receives following notification message:

@smallexample
@var{user}: message would exceed maximum mailbox size for this recipient
@end smallexample

@item @var{msize} is greater than or equal to the size of the
message. In this case @command{mail.local} does deliver the message.
@end enumerate

Version @value{VERSION} of GNU mailutils is able to retrieve 
mailbox quotas from a @sc{dbm} or @sc{sql} database.

@menu
* DBM Quotas::          Keeping Quotas in DBM Database.
* SQL Quotas::          Keeping Quotas in SQL Database.
@end menu

@node DBM Quotas
@subsubsection Keeping Quotas in DBM Database

To use the @sc{dbm} quota database, your copy of @code{mailutils} must
be compiled with @sc{dbm} support (one of @option{--with-gdbm},
@option{--with-db2}, @option{--with-ndbm}, @option{--with-dbm} options
to @code{configure}). Examine the of
@command{mail.local --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
The 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 limitation for this user.
@end table

Here is an example of a valid quota database

@smallexample
# Default quota value:
DEFAULT         5mb

# Following users have unlimited mailbox size
root            NONE
smith           NONE

# Rest of users
plog            26214400
karin           10mB
@end smallexample

To use the @sc{dbm} database, specify its full name using @option{-q}
or @samp{--quota-db} in the invocation of @command{mail.local}. For
example, in @command{sendmail} @code{.mc} file:

@smallexample
define(`LOCAL_MAILER_PATH', `/usr/local/libexec/mail.local')
define(`LOCAL_MAILER_ARGS', `mail -q /etc/mail/quota.db $u')
@end smallexample

@node SQL Quotas
@subsubsection Keeping Quotas in SQL Database

Option @option{--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 same credentials as @sc{sql} authentication tables
(@FIXME-xref{daemon}, for the detailed discussion of @option{--sql-} options).

For example, suppose you have the following quota table:

@smallexample
create table mailbox_quota (
  user_name varchar(32) binary not null,
  quota int,
  unique (user_name)
);
@end smallexample

@noindent

To retrieve the quota for user @code{%u} you may then use the
following query:

@smallexample
SELECT quota
FROM mailbox_quota
WHERE user_name='%u'
@end smallexample

There is no special provisions for specifying group quotas, similar to
@samp{DEFAULT} in @sc{dbm} databases. This is because group quotas can
easily be implemented using @sc{sql} language. @command{Mail.local}
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. For the following discussion,
it is important that the @code{user_name} column for this entry be
lexicographically less than any other user name in the table. Let's
suppose the group quota name is @samp{00DEFAULT}. Then the following
query:

@smallexample
SELECT quota
FROM mailbox_quota
WHERE user_name IN ('%u','00DEFAULT')
ORDER BY user_name DESC
@end smallexample

@noindent
will return two tuples if user @code{%u} 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{mail.local}. On the other hand, if user name @code{%u} is not
present in the table, the above query will return a single tuple
containing the group quota.

To summarize this, here is a working @file{mailutils.rc} entry for
@command{mail.local}:

@smallexample
:mail.local \
      --sql-db MAILAUTH \
      --sql-host some.host.net \
      --sql-user mail.local \
      --sql-passwd guessme \
      --quota-query "SELECT quota \
                     FROM mailbox_quota \
                     WHERE user_name IN ('%u','00DEFAULT') \
                     ORDER BY user_name DESC"
@end smallexample
                     

@node Sieve Filters
@subsection Implementing User-defined Sieve Mail Filters

@node Scheme Filters
@subsection Implementing User-defined Scheme Mail Filters

@page
@node mail.remote
@section @command{mail.remote} --- Pseudo-Sendmail Interface for Mail Delivery
@pindex mail.remote

[FIXME]

@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, see
@code{man mime.types} for the description of its syntax. [FIXME:
provide an xref to CUPS]. 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 @var{DEFAULT_CUPS_CONFDIR}. On most sites running

@smallexample
./configure DEFAULT_CUPS_CONFDIR=/etc/cups
@end smallexample

@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:

@smallexample
$HOME/.mailcap:/usr/local/etc/mailcap:\
 /usr/etc/mailcap:/etc/mailcap:\
 /etc/mail/mailcap:/usr/public/lib/mailcap
@end smallexample

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

@smallexample
--no-ask='text/*,image/jpeg'
@end smallexample

@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


@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:

@smallexample
pop3  stream tcp nowait  root  /usr/local/sbin/pop3d pop3d
@end smallexample

This is the default operation mode.

@item Standalone
The server runs as daemon, forking a child for each new connection. This
mode is triggered by @option{-d} command line switch.
@end table

The program uses following option groups: @FIXME-xref{mailbox},
@FIXME-xref{daemon}, @FIXME-xref{logging}, @FIXME-xref{auth}.

@menu
* Login delay::
* Auto-expire::
* Bulletins::
* 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:

@smallexample
-ERR [LOGIN-DELAY] Attempt to log in within the minimum login delay interval
@end smallexample

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 in
seconds with @option{--login-delay} option, for example:

@smallexample
$ pop3d --login-delay=60
@end smallexample

  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 at run time
using @option{--stat-file}:

@smallexample
$ pop3d --login-delay=60 --stat-file=/tmp/pop.login
@end smallexample

  Notice, that there is no need to include the @samp{.db} suffix in the
file name.

  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. The common error message
looks like:

@smallexample
Unable to open statistics db: Operation not permitted
@end smallexample

  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 @option{--expire} command line option:

@smallexample
$ pop3d --expire=@var{days}
@end smallexample

@noindent
Here, @var{days} specifies the minimum server retention period, in
days, for retrieved messages on the server.

  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 @option{--delete-expired}
command line option.

@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:

@smallexample
@group
require "timestamp";
# @r{Replace "5" with the desired expiration period}
if timestamp :before "X-Expire-Timestamp" "now - 5 days"
  @{
    discard;
  @}
@end group
@end smallexample

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 @option{--expire} command.
@end enumerate

The option @option{--expire=0} means the client is not permitted to
leave mail on the server. It always implies @option{--delete-expired}. 

@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 @option{--bulletin-db} command line option. 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 command line options:

@table @option
@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.
Be sure not to specify @samp{.db} extension.
@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}:

@smallexample
@group
$ pop3d --bulletin-source=mh:/var/spool/bull/mbox \
        --bulletin-db=/var/spool/bull/numbers
@end group
@end smallexample
        
@node Command line options
@subsection Command line options

The following table summarizes all @command{pop3d} command line options.

@table @option
@item --bulletin-db=@var{file}
Set the name of the database file to keep last bulletin numbers in.
Be sure not to specify @samp{.db} extension. @xref{Bulletins}.

@item --bulletin-source=@var{mbox}
Set the @acronym{URL} of the bulletin source mailbox. @xref{Bulletins}.

@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 --delete-expired
Delete expired messages upon closing the mailbox. @xref{Auto-expire}.

@item --expire=@var{days}
Expire read messages after the given number of days. If @var{days} is
0, this option implies @option{--delete-expired}. @xref{Auto-expire}.

@item -i
@itemx --inetd
Run in inetd mode.

@item -h
@itemx --help
Display short help message and exit.

@item --login-delay=@var{seconds}
Sets the minimum allowed delay between closing a pop3d session and
opening it again with the same user name. @xref{Login delay}.

@item -m @var{path}
@itemx --mail-spool=@var{path}
Set path to the mailspool directory

@item -p @var{number}
@itemx --port @var{number}
Listen on given port @var{number}. This option is meaningful only in
standalone mode. It defaults to port 110.

@item --stat-file=@var{filename}
Sets the name of the login timestamp database, used with
@option{--login-delay}. By default, these data are kept in
@file{/var/run/pop3-login}. Be sure to specify the file name
@emph{without} DBM-specific suffix. @xref{Login delay}.

@item -t @var{number}
@itemx --timeout @var{number}
Set idle timeout to given @var{number} of seconds. Default is 600 seconds (10
minutes). The daemon breaks the connection if it receives no commands
from the client within that number of seconds.

@item --tls-required
Always require @code{STLS} command before entering authentication phase.

@item -v
@itemx --version
Display program version and exit.

@item --undelete
Remove all deletion marks from the messages after opening the mailbox.

@end table

@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.
* 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 @option{--shared-namespace} and
@option{--other-namespace} options.

@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. 

@smallexample
imap4  stream tcp nowait  root  /usr/local/sbin/imap4d imap4d
@end smallexample

The program uses following option groups: @FIXME-xref{mailbox},
@FIXME-xref{daemon}, @FIXME-xref{logging}, @FIXME-xref{auth}.

@subheading Command Line Options

@table @option
@item --create-home-dir[=@var{mode}]
If a user logs in and his home directory does not exist, create
it. Optional @var{mode} is an octal number specifying the permissions
to be set on the created directory. It is not modified by the current
@code{umask} value. The default value for @var{mode} is @samp{700}
(@samp{drwx------} in @code{ls} terms). 
@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 -h
@itemx --help
Display short help message and exit.
@item -i
@itemx --inetd
Run in inetd mode.
@item -m @var{path}
@itemx --mail-spool=@var{path}
Set path to the mailspool directory
@item -O @var{pathlist}
@itemx --other-namespace=@var{pathlist}
Set the list of directories forming the ``Other User's'' namespace.
@var{pathlist} is a list of directory names separated by colons.
@item -p @var{number}
@itemx --port @var{number}
Listen on given port @var{number}. This option is meaningful only in
standalone mode. It defaults to port 143.
@item -S @var{pathlist}
@itemx --shared-namespace=@var{pathlist}
Set the list of directories, forming the ``Shared''
namespace. @var{pathlist} is a list of directory names separated by colons.
@item -t @var{number}
@itemx --timeout @var{number}
Set idle timeout to given @var{number} of seconds. Default is 1800 seconds (30
minutes). The daemon breaks the connection if it receives no commands
from the client within that number of seconds.
@item -v
@itemx --version
Display program version and exit.
@end table

@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}

@command{Comsatd} uses following option groups: @FIXME-xref{mailbox},
@FIXME-xref{daemon}, @FIXME-xref{logging}.

@table @option
@item -c @var{file}
@itemx --config @var{file}
Read configuration from given @var{file}. For more information about
comsatd configuration files, see @ref{Configuring comsatd}.
@item -d
@itemx --daemon
Run as a standalone daemon.
@item -i
@itemx --inetd
The server is started from @file{/etc/inetd.conf} file:

@smallexample
comsat dgram  udp wait  root  /usr/sbin/comsatd \
comsatd -c /etc/comsat.conf
@end smallexample

This is the default operation mode.
@item -m @var{path}
@itemx --mail-spool=@var{path}
Set path to the mailspool directory
@item -p @var{number}
@itemx --port @var{number}
Specify the port number to listen on. Default is 512.
@item -v
@itemx --version
Output version and exit successfully.
@item -h
@itemx --help
Display short help message and exit.
@end table

@node Configuring comsatd
@subsection Configuring @command{comsatd}

The configuration parameters for @command{comsatd} are kept in a single
configuration file. The file uses line-oriented format: each line
contains a single statement. Comments are introduced with the @samp{#}
sign and empty lines are ignored. You can specify the configuration
file to use by using @option{-c} or @option{--config} command line switch.

The configuration file statements can logically be subdivided into
@dfn{General Settings}, @dfn{Security Settings} and @dfn{Access Control
Lists}. The following sections address each of these statement group in
detail.

@menu
* General Settings::
* Security Settings::
* Access Control Lists::
@end menu

@node General Settings
@subsubheading General Settings

These statements control the general behavior of the comsat daemon:

@table @asis
@item max-lines @var{number}
Set maximum number of message body lines to be output.
@item allow-biffrc ( yes | no )
Enable or disable processing of user's @file{.biffrc} file. By default,
it is enabled.
@end table

@node Security Settings
@subsubheading Security Settings

These statements control the way @command{comsatd} fights possible
flooding attacks.

@table @asis
@item max-requests @var{number}
Set maximum number of incoming requests per @samp{request-control-interval}.
@item request-control-interval @var{number}
Set the request control interval (seconds).
@item overflow-delay-time @var{number}
Set the initial amount of time to sleep, after the first overflow occurs.
@item overflow-control-interval @var{number}
Set the overflow control interval. If two consecutive overflows happen
within @var{number} seconds, the overflow-delay-time is doubled.
@end table

@node Access Control Lists
@subsubheading Access Control Lists

Access control lists determine from which addresses @command{comsatd}
will receive mail notification messages.

The access control lists are introduced in configuration file using
keyword @samp{acl}. General format for an ACL rule is

@smallexample
acl @var{action} @var{netlist}
@end smallexample

@noindent
Here, @var{action} specifies the action to be taken when a request
arrives from one of the networks, listed in @var{netlist}. There are
two possible actions: @samp{allow} and @samp{deny}.

The @var{netlist} is a whitespace-separated list of network numbers.
Each network number may be specified in one of the following forms:

@table @asis
@item @var{netnum}
Means a single host with IP address @var{netnum}.
@item @var{netnum}/@var{netmask}
@item @var{netnum}/@var{masklen}
@item @samp{any}
Denotes any IP address. It is equivalent to @samp{0.0.0.0/0}.
@end table

Upon receiving a notification message, @command{comsatd} compares its
source address against each ACL rule in the order of their appearance
in the configuration file. The first rule that matches the packet
determines whether the message will be processed or rejected. If
no matching rule was found, the default rule applies. Currently, default
rule is

@smallexample
acl allow any
@end smallexample

@noindent
If you don't need such behavior, specify the default rule explicitly.
For example, the common use would be:

@smallexample
@group
acl allow 127.0.0.1
acl deny any
@end group
@end smallexample

@noindent
which makes @command{comsatd} receive the notification messages from
localhost only.

@node dot.biffrc
@subheading 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

@subheading 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.
@smallexample
@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 smallexample

@noindent
The above example can also be written as:
@smallexample
@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 smallexample

@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.

@smallexample
@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 smallexample

@page
@node mh
@section @acronym{MH} --- The MH Message Handling System

@include mu-mh.texi

@page
@node mailutils-config
@section @command{mailutils-config} --- Get the Information about the Mailutils Build
@pindex mailutils-config

This program is designed for developers wishing to link their programs
against libmailbox. It allows to examine the particulars of the
current build of Mailutils and to get the command line parameters
necessary for compiling and linking an application with Mailutils
libraries.

@menu
* Compiler Flags::      Getting Compiler Flags.
* Loader Flags::        Getting Loader Flags.
* General Information:: Obtaining General Build Information.
@end menu

@node Compiler Flags
@subheading Getting Compiler Flags

When invoked with the option @option{--compile}, or its short form
@option{-c}, @command{mailutils-config} prints the flags
that must be given to the compiler for compiling the program using
Mailutils functions. An example usage:

@smallexample
cc -omyprog.o `mailutils-config --compile` myprog.c
@end smallexample               

@node Loader Flags
@subheading Getting Loader Flags

The @option{--link}, or its short form @option{-l} prints to the
standard output the loader flags necessary to link a program against
Mailutils libraries.

When invoked without arguments, it produces the flags necessary to
link against the basic library of Mailutils: @file{libmailbox}.
Arguments may be given that alter this behavior. These are:

@table @samp

@item auth
Print flags to link against @file{libmuauth}, the library adding new
authentication methods to @file{libmailbox}.

@item guile
Print flags to link against @file{libmu_scm}, the Guile interface
library.

@item mbox
Link against @code{mbox} format library.

@item mh
Link against @code{mh} format library.

@item maildir
Link against @code{maildir} format library.

@item mailer
Link against @code{mailer} library.

@item imap
Link against @code{imap} format library.

@item pop
Link against @code{pop} format library.

@item all
Link against all Mailutils format libraries.
@end table

The order of arguments does not matter.

For example, if you wrote a program @file{myprog.c} that uses
standard @sc{unix} mailbox format, @sc{mh} format and the
Guile interface, then you would link it with the following
command:

@smallexample
cc -omyprog myprog.o `mailutils-config --link mbox mh guile`
@end smallexample

@node General Information
@subheading Obtaining General Build Information

The @option{--info}, or @option{-i} retrieves the options (flags) used
when building Mailutils. It may be used with or without
arguments.

When used without arguments, it prints the list of all
build flags, e.g.:

@smallexample
$ mailutils-config --info
VERSION=0.4.1
USE_LIBPAM
HAVE_LIBLTDL
WITH_GDBM
WITH_GNUTLS
WITH_GSASL
WITH_GUILE
WITH_PTHREAD
WITH_READLINE
HAVE_MYSQL
ENABLE_VIRTUAL_DOMAINS
ENABLE_IMAP
ENABLE_POP
ENABLE_MH
ENABLE_MAILDIR
ENABLE_SMTP
ENABLE_SENDMAIL
@end smallexample

This option also accepts any number of arguments. When these are
given, each argument is treated as a name of a build flag. 
@command{Mailutils-config} checks if such a flag was defined and
prints its full name if so. It exits with zero code if all the
flags given on the command line are defined. Otherwise, it
exits with code of 1.

The comparison of the flag names is case-insensitive. The arguments
given need not include the leading prefix (i.e. the characters up
to and including the first underscore character).

Given the previous example, the invocation

@smallexample
$ mailutils --info readline use_libpam pop
@end smallexample

@noindent
will produce the following output:

@smallexample
WITH_READLINE
USE_LIBPAM
ENABLE_POP
@end smallexample

@noindent
and will exit with a zero status.

The following command:

@smallexample
$ mailutils --info readline gssapi pop
@end smallexample

@noindent
will exit with status 1, and will print:

@smallexample
WITH_READLINE
ENABLE_POP
@end smallexample

@noindent
since @code{WITH_GSSAPI} flag is not defined.

The flags and their meanings are:

@table @asis
@c @item VERSION=" VERSION,
@item USE_LIBPAM
The Mailutils uses @sc{pam} libraries.

@item HAVE_LIBLTDL
The GNU wrapper library @file{libltdl} is present and is used
by Mailutils. @xref{Using libltdl,,,libtool,Using libltdl}, for
more information on @file{libltdl} library.

@item WITH_BDB2
Support for Berkeley DB is compiled in (the package was configured with
@option{--with-db2} option).

@item WITH_NDBM
Support for NDBM is compiled in (the package was configured with
@option{--with-ndbm} option).

@item WITH_OLD_DBM
Support for old style DBM is compiled in (the package was configured with
@option{--with-dbm} option).

@item WITH_GDBM
Support for GNU DBM is compiled in (the package was configured with
@option{--with-gdbm} option). @xref{Top,,Introduction,gdbm,The GNU DBM Manual},
for more information about this library.

@item WITH_GNUTLS
Support for GnuTLS (a Transport Layer Security Library) is compiled in
(the package was configured with @option{--with-gnutls} option).

@item WITH_GSASL
Support for GNU SASL is compiled in (the package was configured with
@option{--with-gsasl} option). @xref{Top,,Introduction,gsasl,The GNU SASL Manual},
for more information about this library.

@item WITH_GSSAPI
Support for @sc{gssapi} is compiled in (the package was configured with
@option{--with-gssapi} option).

@item WITH_GUILE
Support for Guile extension language is built (the package was
configured with @option{--with-guile} option).
@xref{Top,,Overview,guile,The Guile Reference Manual},
for more information about Guile.

@item WITH_PTHREAD
The @sc{posix} thread support is compiled in.

@item WITH_READLINE
The readline support is enabled (the package was
configured with @option{--with-readline} option).
@xref{Top,,,readline,The GNU Readline Library}, for more information.

@item HAVE_MYSQL
Authentication via MySQL is supported (the package was
configured with @option{--enable-mysql} option).

@item ENABLE_VIRTUAL_DOMAINS
Support for mail virtual domains is enabled (the package was
configured with @option{--enable-virtual-domains} option).

@item ENABLE_IMAP
Support for @sc{imap4} protocol is enabled.

@item ENABLE_POP
Support for @sc{pop3} protocol is enabled.

@item ENABLE_MH
Support for mailboxes in @sc{mh} format is enabled.

@item ENABLE_MAILDIR
Support for mailboxes in @sc{Maildir} format is enabled.

@item ENABLE_SMTP
Support for @sc{smtp} mailer is enabled.

@item ENABLE_SENDMAIL
Support for Sendmail mailer is enabled.
@end table