Provided by: heirloom-mailx_12.5-1build1_amd64 bug

NAME

       mailx - send and receive Internet mail

SYNOPSIS

       mailx [-BDdEFintv~] [-s subject] [-a attachment ] [-c cc-addr] [-b bcc-addr] [-r from-
              addr] [-h hops] [-A account] [-S variable[=value]] to-addr . . .
       mailx [-BDdeEHiInNRv~] [-T name] [-A account] [-S variable[=value]] -f [name]
       mailx [-BDdeEinNRv~] [-A account] [-S variable[=value]] [-u user]

DESCRIPTION

       Mailx is an intelligent mail processing system, which has a command syntax reminiscent  of
       ed(1)  with  lines replaced by messages.  It is based on Berkeley Mail 8.1, is intended to
       provide the functionality of the POSIX mailx command,  and  offers  extensions  for  MIME,
       IMAP,  POP3, SMTP, and S/MIME.  Mailx provides enhanced features for interactive use, such
       as caching and disconnected operation for IMAP, message threading, scoring, and filtering.
       It is also usable as a mail batch language, both for sending and receiving mail.

       The following options are accepted:

       -A name
              Executes  an account command (see below) for name after the startup files have been
              read.

       -a file
              Attach the given file to the message.

       -B     Make standard input and standard output line-buffered.

       -b address
              Send blind carbon copies to list.  List should be a comma-separated list of names.

       -c address
              Send carbon copies to list of users.

       -D     Start in disconnected mode; see  the  description  for  the  disconnected  variable
              option.

       -d     Enables  debugging  messages  and disables the actual delivery of messages.  Unlike
              -v, this option is intended for mailx development only.

       -e     Just check if mail is present in the system mailbox.  If yes, return an exit status
              of zero, else, a non-zero value.

       -E     If an outgoing message does not contain any text in its first or only message part,
              do not send it but discard  it  silently,  effectively  setting  the  skipemptybody
              variable  at  program  startup.   This  is useful for sending messages from scripts
              started by cron(8).

       -f [file]
              Read in the contents of the user's mbox (or the  specified  file)  for  processing;
              when  mailx  is  quit,  it writes undeleted messages back to this file.  The string
              file is handled as described for the folder command below.

       -F     Save the message to send in a  file  named  after  the  local  part  of  the  first
              recipient's address.

       -H     Print header summaries for all messages and exit.

       -h hops
              Invoke  sendmail with the specified hop count.  This option has no effect when SMTP
              is used for sending mail.

       -i     Ignore tty interrupt signals.  This is particularly  useful  when  using  mailx  on
              noisy phone lines.

       -I     Shows  the  `Newsgroup:'  or  `Article-Id:'  fields  in  the  header summary.  Only
              applicable in combination with -f.

       -n     Inhibits reading /etc/nail.rc upon startup.  This option should  be  activated  for
              mailx  scripts  that  are invoked on more than one machine, because the contents of
              that file may differ between them.

       -N     Inhibits the initial display of message headers when reading mail or editing a mail
              folder.

       -q file
              Start  the  message  with the contents of the specified file.  May be given in send
              mode only.

       -r address
              Sets the From address. Overrides any from  variable  specified  in  environment  or
              startup  files.   Tilde escapes are disabled.  The -r address options are passed to
              the mail transfer agent unless SMTP is used.  This option exists for  compatibility
              only; it is recommended to set the from variable directly instead.

       -R     Opens any folders read-only.

       -s subject
              Specify  subject on command line (only the first argument after the -s flag is used
              as a subject; be careful to quote subjects containing spaces).

       -S variable[=value]
              Sets the internal option variable and, in case of a string option, assigns value to
              it.

       -T name
              Writes  the  `Message-Id:'  and `Article-Id:' header fields of each message read in
              the file name.  Implies -I.  Compressed files are  handled  as  described  for  the
              folder command below.

       -t     The  message  to be sent is expected to contain a message header with `To:', `Cc:',
              or `Bcc:' fields giving its recipients.  Recipients specified on the  command  line
              are ignored.

       -u user
              Reads the mailbox of the given user name.

       -v     Verbose mode.  The details of delivery are displayed on the user's terminal.

       -V     Print mailx's version and exit.

       -~     Enable tilde escapes even if not in interactive mode.

   Sending mail
       To send a message to one or more people, mailx can be invoked with arguments which are the
       names of people to whom the mail will be sent.  The user is then expected to type  in  his
       message,  followed  by  an  `control-D'  at  the  beginning  of a line.  The section below
       Replying to or originating mail, describes some features of mailx available to  help  when
       composing letters.

   Reading mail
       In  normal  usage  mailx  is given no arguments and checks the user's mail out of the post
       office, then prints out a one line header of each message found.  The current  message  is
       initially  the first message (numbered 1) and can be printed using the print command which
       can be abbreviated `p').  The user can move among the messages much as  he  moves  between
       lines  in  ed(1),  with the commands `+' and `-' moving backwards and forwards, and simple
       numbers.

   Disposing of mail
       After examining a message the user can delete `d')  the  message  or  reply  `r')  to  it.
       Deletion  causes the mailx program to forget about the message.  This is not irreversible;
       the message can be undeleted `u') by giving its  number,  or  the  mailx  session  can  be
       aborted  by  giving  the  exit  `x')  command.   Deleted  messages  will, however, usually
       disappear never to be seen again.

   Specifying messages
       Commands such as print and delete can be given a list of message numbers as  arguments  to
       apply  to a number of messages at once.  Thus `delete 1 2' deletes messages 1 and 2, while
       `delete 1-5' deletes messages 1 through 5.  In sorted or threaded mode (see the  sort  and
       thread  commands),  `delete  1-5'  deletes  the  messages  that  are  located between (and
       including) messages 1 through 5 in the sorted/threaded  order,  as  shown  in  the  header
       summary.  The following special message names exist:

       :n     All new messages.

       :o     All old messages (any not in state read or new).

       :u     All unread messages.

       :d     All deleted messages (for the undelete command).

       :r     All read messages.

       :f     All `flagged' messages.

       :a     All answered messages (cf. the markanswered variable).

       :t     All messages marked as draft.

       :k     All `killed' messages.

       :j     All messages classified as junk.

       .      The current message.

       ;      The message that was previously the current message.

       ,      The  parent message of the current message, that is the message with the Message-ID
              given in the `In-Reply-To:' field or the last entry of the `References:'  field  of
              the current message.

       -      The  next  previous undeleted message, or the next previous deleted message for the
              undelete command.  In sorted/threaded mode, the next previous such message  in  the
              sorted/threaded order.

       +      The  next  undeleted message, or the next deleted message for the undelete command.
              In sorted/threaded mode, the next such message in the sorted/threaded order.

       ^      The first undeleted message, or the first deleted message for the undelete command.
              In sorted/threaded mode, the first such message in the sorted/threaded order.

       $      The last message.  In sorted/threaded mode, the last message in the sorted/threaded
              order.

       &x     In threaded mode, selects the message addressed  with  x,  where  x  is  any  other
              message  specification,  and  all  messages  from  the  thread  that  begins at it.
              Otherwise, it is identical to x.  If x is omitted, the thread  beginning  with  the
              current message is selected.

       *      All messages.

       `      All messages that were included in the message list for the previous command.

       /string
              All messages that contain string in the subject field (case ignored).  See also the
              searchheaders  variable.   If  string  is  empty,  the  string  from  the  previous
              specification of that type is used again.

       address
              All  messages  from  address.   By default, this is a case-sensitive search for the
              complete email address.  If the allnet variable is set, only the local part of  the
              addresses  is  evaluated for the comparison.  Otherwise if the showname variable is
              set, a case-sensitive search for the complete real name of a sender  is  performed.
              The  IMAP-style  (from address) expression can be used instead if substring matches
              are desired.

       (criterion)
              All messages that satisfy the given IMAP-style SEARCH criterion.   This  addressing
              mode  is  available  with  all  types  of  folders; for folders not located on IMAP
              servers, or for servers unable to execute the SEARCH command,  mailx  will  perform
              the  search  locally.   Strings  must  be  enclosed  by  double quotes `"' in their
              entirety if they contain white  space  or  parentheses;  within  the  quotes,  only
              backslash  `\' is recognized as an escape character.  All string searches are case-
              insensitive.  When the description indicates that the `envelope' representation  of
              an address field is used, this means that the search string is checked against both
              a list constructed as

              ("real name" "source-route" "local-part" "domain-part")

              for each address, and the addresses without real names from the  respective  header
              field.  Criteria can be nested using parentheses.

       (criterion1 criterion2 ... criterionN)
              All messages that satisfy all of the given criteria.

       (or criterion1 criterion2)
              All  messages  that  satisfy  either criterion1 or criterion2, or both.  To connect
              more than two criteria using `or', (or) specifications  have  to  be  nested  using
              additional parentheses, as with `(or a (or b c))'; `(or a b c)' means ((a or b) and
              c).  For a simple `or' operation of independent  criteria  on  the  lowest  nesting
              level,  it is possible to achieve similar effects by using three separate criteria,
              as with `(a) (b) (c)'.

       (not criterion)
              All messages that do not satisfy criterion.

       (bcc string)
              All messages that contain string in  the  `envelope'  representation  of  the  Bcc:
              field.

       (cc string)
              All messages that contain string in the `envelope' representation of the Cc: field.

       (from string)
              All  messages  that  contain  string  in the `envelope' representation of the From:
              field.

       (subject string)
              All messages that contain string in the Subject: field.

       (to string)
              All messages that contain string in the `envelope' representation of the To: field.

       (header name string)
              All messages that contain string in the specified Name: field.

       (body string)
              All messages that contain string in their body.

       (text string)
              All messages that contain string in their header or body.

       (larger size)
              All messages that are larger than size (in bytes).

       (smaller size)
              All messages that are smaller than size (in bytes).

       (before date)
              All messages that were received before date; date must be  in  the  form  d[d]-mon-
              yyyy,  where  d[d] is the day of the month as one or two digits, mon is the name of
              the month—one of `Jan', `Feb', `Mar', `Apr', `May',  `Jun',  `Jul',  `Aug',  `Sep',
              `Oct', `Nov', or `Dec', and yyyy is the year as four digits; e.g. "30-Aug-2004".

       (on date)
              All messages that were received on the specified date.

       (since date)
              All messages that were received since the specified date.

       (sentbefore date)
              All messages that were sent on the specified date.

       (senton date)
              All messages that were sent on the specified date.

       (sentsince date)
              All messages that were sent since the specified date.

       ()     The  same  criterion as for the previous search.  This specification cannot be used
              as part of another criterion.  If the previous command line contained more than one
              independent criterion, the last of those criteria is used.

       A  practical  method  to read a set of messages is to issue a from command with the search
       criteria first to check for appropriate messages, and to read each single message then  by
       typing ``' repeatedly.

   Replying to or originating mail
       The  reply  command  can be used to set up a response to a message, sending it back to the
       person who it was from.  Text the user types in then, up to an  end-of-file,  defines  the
       contents  of  the  message.   While  the  user  is composing a message, mailx treats lines
       beginning with the character `~' specially.  For instance, typing `~m' (alone on  a  line)
       will  place a copy of the current message into the response right shifting it by a tabstop
       (see indentprefix variable, below).  Other escapes will set up  subject  fields,  add  and
       delete  recipients  to  the message, attach files to it and allow the user to escape to an
       editor to revise the message or to a shell to run some commands.  (These options are given
       in the summary below.)

   Ending a mail processing session
       The  user  can  end a mailx session with the quit (`q') command.  Messages which have been
       examined go to the user's mbox file unless they have been deleted in which case  they  are
       discarded.  Unexamined messages go back to the post office.  (See the -f option above).

   Personal and systemwide distribution lists
       It  is  also  possible  to create a personal distribution lists so that, for instance, the
       user can send mail to `cohorts' and have it go to a group of people.  Such  lists  can  be
       defined by placing a line like

               alias cohorts bill ozalp jkf mark kridle@ucbcory

       in the file .mailrc in the user's home directory.  The current list of such aliases can be
       displayed with the alias command in mailx.  System wide distribution lists can be  created
       by  editing  /etc/aliases,  see  aliases(5) and sendmail(8); these are kept in a different
       syntax.  In mail the user sends, personal aliases will be expanded in mail sent to  others
       so  that  they  will  be  able  to  reply  to the recipients.  System wide aliases are not
       expanded when the mail is sent, but any reply returned to the machine will have the system
       wide alias expanded as all mail goes through sendmail.

   Recipient address specifications
       When  an  address  is  used to name a recipient (in any of To, Cc, or Bcc), names of local
       mail folders and pipes to external commands can also be specified;  the  message  text  is
       then written to them.  The rules are: Any name which starts with a `|' character specifies
       a pipe, the command string following the `|' is executed and the message is  sent  to  its
       standard  input;  any  other  name  which  contains  a  `@' character is treated as a mail
       address; any other name which starts with a `+' character specifies  a  folder  name;  any
       other  name  which  contains  a  `/'  character  but  no `!'  or `%' character before also
       specifies a folder name; what remains is treated as a mail  address.   Compressed  folders
       are handled as described for the folder command below.

   Network mail (Internet / ARPA, UUCP, Berknet)
       See  mailaddr(7)  for  a  description of network addresses.  Mailx has a number of options
       which can be set in the .mailrc file to alter its behavior; thus `set askcc'  enables  the
       askcc feature.  (These options are summarized below).

   MIME types
       For  any  outgoing attachment, mailx tries to determine the content type.  It does this by
       reading MIME type files whose lines have the following syntax:

               type/subtype      extension [extension . . .]

       where type/subtype are strings describing the file contents, and extension is the part  of
       a  filename starting after the last dot.  Any line not immediately beginning with an ASCII
       alphabetical character is ignored by mailx.  If there is a match with the extension of the
       file to attach, the given type/subtype pair is used.  Otherwise, or if the filename has no
       extension, the content types text/plain or application/octet-stream are  used,  the  first
       for  text  or  international  text files, the second for any file that contains formatting
       characters other than newlines and horizontal tabulators.

   Character sets
       Mailx normally detects the character  set  of  the  terminal  using  the  LC_CTYPE  locale
       setting.   If  the  locale cannot be used appropriately, the ttycharset variable should be
       set to provide an explicit value.  When reading messages, their text is converted  to  the
       terminal character set if possible.  Unprintable characters and illegal byte sequences are
       detected and replaced by Unicode substitute characters or question marks unless the print-
       all-chars is set at initialization time.

       The character set for outgoing messages is not necessarily the same as the one used on the
       terminal.  If an outgoing text message contains characters not representable in  US-ASCII,
       the  character  set being used must be declared within its header.  Permissible values can
       be declared using the sendcharsets variable, separated by commas; mailx tries each of  the
       values  in  order  and uses the first appropriate one.  If the message contains characters
       that cannot be represented in any of the given character sets, the  message  will  not  be
       sent,  and  its  text  will be saved to the `dead.letter' file.  Messages that contain NUL
       bytes are not converted.

       Outgoing attachments are converted if they are plain text.  If the  sendcharsets  variable
       contains  more than one character set name, the ~@ tilde escape will ask for the character
       sets for individual attachments if it is invoked without arguments.

       Best results are usually achieved when mailx is run in a UTF-8 locale on a  UTF-8  capable
       terminal.   In this setup, characters from various countries can be displayed, while it is
       still  possible  to  use  more  simple  character  sets  for  sending  to  retain  maximum
       compatibility with older mail clients.

   Commands
       Each  command  is  typed on a line by itself, and may take arguments following the command
       word.  The command need not be typed in its entirety – the first command which matches the
       typed  prefix  is used.  For commands which take message lists as arguments, if no message
       list is given, then the next message forward which satisfies the command's requirements is
       used.   If  there  are  no  messages  forward  of the current message, the search proceeds
       backwards, and if there are no good messages at all, mailx types `applicable messages' and
       aborts the command.  If the command begins with a # sign, the line is ignored.

       The arguments to commands can be quoted, using the following methods:

       ·      An  argument  can  be enclosed between paired double-quotes "" or single-quotes '';
              any white space, shell word expansion, or backslash characters  within  the  quotes
              are  treated  literally  as  part  of the argument.  A double-quote will be treated
              literally within single-quotes and vice versa.  These  special  properties  of  the
              quote  marks  occur  only  when  they  are  paired  at the beginning and end of the
              argument.

       ·      A backslash outside  of  the  enclosing  quotes  is  discarded  and  the  following
              character is treated literally as part of the argument.

       ·      An  unquoted  backslash at the end of a command line is discarded and the next line
              continues the command.

       Filenames, where expected, are subjected to the following transformations, in sequence:

       ·      If the filename begins with an unquoted plus  sign,  and  the  folder  variable  is
              defined,  the  plus  sign  will  be  replaced  by  the value of the folder variable
              followed by a slash. If the folder variable  is  unset  or  is  set  to  null,  the
              filename will be unchanged.

       ·      Shell  word expansions are applied to the filename.  If more than a single pathname
              results from this expansion and  the  command  is  expecting  one  file,  an  error
              results.

       The following commands are provided:

       -      Print  out  the preceding message.  If given a numeric argument n, goes to the n'th
              previous message and prints it.

       ?      Prints a brief summary of commands.

       !      Executes the shell (see sh(1) and csh(1)) command which follows.

       |      A synonym for the pipe command.

       account
              (ac) Creates, selects or lists an email account.  An account is formed by  a  group
              of commands, primarily of those to set variables.  With two arguments, of which the
              second is a `{', the first argument gives an account name, and the following  lines
              create  a  group  of commands for that account until a line containing a single `}'
              appears.  With one argument, the previously  created  group  of  commands  for  the
              account  name  is executed, and a folder command is executed for the system mailbox
              or inbox of that account.  Without  arguments,  the  list  of  accounts  and  their
              contents are printed.  As an example,

                  account myisp {
                      set folder=imaps://mylogin@imap.myisp.example
                      set record=+Sent
                      set from="myname@myisp.example (My Name)"
                      set smtp=smtp.myisp.example
                  }

              creates an account named `myisp' which can later be selected by specifying `account
              myisp'.

       alias  (a) 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.

       alternates
              (alt) The alternates command  is  useful  if  the  user  has  accounts  on  several
              machines.   It  can be used to inform mailx that the listed addresses all belong to
              the invoking user.  When he replies to messages, mailx 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.

       answered
              (ans) Takes a message list and marks each message as a having been answered.   This
              mark  has  no  technical  meaning in the mail system; it just causes messages to be
              marked in the header summary, and makes them specially addressable.

       cache  Only applicable to cached IMAP mailboxes;  takes  a  message  list  and  reads  the
              specified messages into the IMAP cache.

       call   Calls a macro (see the define command).

       cd     Same as chdir.

       certsave
              Only  applicable  to  S/MIME signed messages.  Takes a message list and a file name
              and saves the certificates contained within the message  signatures  to  the  named
              file  in both human-readable and PEM format.  The certificates can later be used to
              send encrypted messages to the messages' originators by setting the  smime-encrypt-
              user@host variable.

       chdir  (ch)  Changes  the  user's  working  directory  to that specified, if given.  If no
              directory is given, then changes to the user's login directory.

       classify
              (cl) Takes a list of messages and examines their contents  for  characteristics  of
              junk mail using Bayesian filtering.  Messages considered to be junk are then marked
              as such.  The junk mail database is not changed.

       collapse
              (coll) Only applicable to threaded mode.   Takes  a  message  list  and  makes  all
              replies  to  these messages invisible in header summaries, unless they are in state
              `new'.

       connect
              (conn) If operating in disconnected mode on an IMAP mailbox, switch to online  mode
              and  connect  to  the  mail  server  while  retaining  the mailbox status.  See the
              description of the disconnected variable for more information.

       copy   (c) The copy command does the same thing that save does, except that  it  does  not
              mark the messages it is used on for deletion when the user quits.  Compressed files
              and IMAP mailboxes are handled as described for the folder command.

       Copy   (C) Similar to copy, but saves the messages in a file named after the local part of
              the sender address of the first message.

       decrypt
              (dec)  For  unencrypted  messages,  this  command  is identical to copy.  Encrypted
              messages are first decrypted, if possible, and then copied.

       Decrypt
              (Dec) Similar to decrypt, but saves the messages in a file named  after  the  local
              part of the sender address of the first message.

       define (def)  Defines  a  macro.   A  macro  definition  is  a sequence of commands in the
              following form:

                  define name {
                      command1
                      command2
                      ...
                      commandN
                  }

              Once defined, a macro can be explicitly invoked using the call command, or  can  be
              implicitly invoked by setting the folder-hook or folder-hook-fullname variables.

       defines
              Prints the currently defined macros including their contents.

       delete (d)  Takes  a  list of messages as argument and marks them all as deleted.  Deleted
              messages will not be saved in mbox, nor will  they  be  available  for  most  other
              commands.

       discard
              Same as ignore.

       disconnect
              (disco) If operating in online mode on an IMAP mailbox, switch to disconnected mode
              while retaining the mailbox  status.   See  the  description  of  the  disconnected
              variable  for  more  information.   A  list  of messages may optionally be given as
              argument; the  respective  messages  are  then  read  into  the  cache  before  the
              connection  is  closed.   Thus `disco *' makes the entire current mailbox available
              for disconnected use.

       dp or dt
              Deletes the current message and prints the next  message.   If  there  is  no  next
              message, mailx says `at EOF'.

       draft  Takes a message list and marks each message as a draft.  This mark has no technical
              meaning in the mail system; it just causes messages to  be  marked  in  the  header
              summary, and makes them specially addressable.

       echo   Echoes its arguments, resolving special names as documented for the folder command.
              The escape sequences `\a', `\b', `\c', `\f', `\n',  `\r',  `\t',  `\v',  `\\',  and
              `\0num' are interpreted as with the echo(1) command.

       edit   (e)  Takes  a  list  of  messages  and  points the text editor at each one in turn.
              Modified contents are discarded unless the writebackedited variable is set.

       else   Marks the end of the then-part of an if statement and the beginning of the part  to
              take effect if the condition of the if statement is false.

       endif  Marks the end of an if statement.

       exit   (ex  or  x)  Effects  an immediate return to the Shell without modifying the user's
              system mailbox, his mbox file, or his edit file in -f.

       file   (fi) The same as folder.

       flag   (fl) Takes a message list and marks the messages as  `flagged'  for  urgent/special
              attention.   This  mark has no technical meaning in the mail system; it just causes
              messages to be  highlighted  in  the  header  summary,  and  makes  them  specially
              addressable.

       folders
              With  no arguments, list the names of the folders in the folder directory.  With an
              existing folder as an argument, lists then names of folders below the named folder;
              e.g.  the  command  `folders  @' lists the folders on the base level of the current
              IMAP server.  See also the imap-list-depth variable.

       folder (fold) The folder command  switches  to  a  new  mail  file  or  folder.   With  no
              arguments, it tells the user which file he is currently reading.  If an argument is
              given, it will write out changes (such as deletions)  the  user  has  made  in  the
              current file and read in the new file.  Some special conventions are recognized for
              the name.  # means the previous file, % means the invoking user's  system  mailbox,
              %user means user's system mailbox, & means the invoking user's mbox file, and +file
              means a file in the folder directory.  %:filespec expands  to  the  same  value  as
              filespec,  but  the  file is handled as a system mailbox e. g. by the mbox and save
              commands.  If the name matches  one  of  the  strings  defined  with  the  shortcut
              command,  it  is replaced by its long form and expanded.  If the name ends with .gz
              or .bz2, it is treated  as  compressed  with  gzip(1)  or  bzip2(1),  respectively.
              Likewise,  if  name  does  not  exist,  but  either name.gz or name.bz2 exists, the
              compressed file is used.  If name refers to a  directory  with  the  subdirectories
              `tmp',  `new',  and  `cur', it is treated as a folder in maildir format.  A name of
              the form

                     protocol://[user@]host[:port][/file]

              is taken as  an  Internet  mailbox  specification.   The  supported  protocols  are
              currently  imap (IMAP v4r1), imaps (IMAP with SSL/TLS encryption), pop3 (POP3), and
              pop3s (POP3 with SSL/TLS encryption).  If  user  contains  special  characters,  in
              particular  `/'  or  `%',  they must be escaped in URL notation, as `%2F' or `%25'.
              The optional file part applies to IMAP only; if it is omitted, the default  `INBOX'
              is  used.   If  mailx  is  connected to an IMAP server, a name of the form @mailbox
              refers to the mailbox on that server.  If the `folder' variable refers to  an  IMAP
              account, the special name `%' selects the `INBOX' on that account.

       Followup
              (F)  Similar to Respond, but saves the message in a file named after the local part
              of the first recipient's address.

       followup
              (fo) Similar to respond, but saves the message in a file named after the local part
              of the first recipient's address.

       followupall
              Similar  to  followup,  but  responds to all recipients regardless of the flipr and
              Replyall variables.

       followupsender
              Similar to Followup, but responds to the sender only regardless of  the  flipr  and
              Replyall variables.

       forward
              (fwd)  Takes  a  message and the address of a recipient and forwards the message to
              him.  The text of the original message is included in the new one, with  the  value
              of  the  fwdheading  variable printed before.  The fwdignore and fwdretain commands
              specify which header fields are included in the new message.  Only the  first  part
              of a multipart message is included unless the forward-as-attachment option is set.

       Forward
              (Fwd)  Similar  to  forward,  but saves the message in a file named after the local
              part of the recipient's address.

       from   (f) Takes a list of messages and prints their message headers,  piped  through  the
              pager if the output does not fit on the screen.

       fwdignore
              Specifies  which  header  fields  are to be ignored with the forward command.  This
              command has no effect when the forward-as-attachment option is set.

       fwdretain
              Specifies which header  fields  are  to  be  retained  with  the  forward  command.
              fwdretain  overrides  fwdignore.   This  command has no effect when the forward-as-
              attachment option is set.

       good   (go) Takes a list of messages and marks all of them as not being junk  mail.   Data
              from  these  messages  is  then  inserted  into  the  junk mail database for future
              classification.

       headers
              (h) Lists the current range of headers, which is an 18-message  group.   If  a  `+'
              argument is given, then the next 18-message group is printed, and if a `-' argument
              is given, the previous 18-message group is printed.

       help   A synonym for ?.

       hold   (ho, also preserve) Takes a message list and marks each message therein to be saved
              in  the  user's  system  mailbox  instead of in mbox.  Does not override the delete
              command.  mailx deviates from the POSIX standard with this  command,  as  a  `next'
              command  issued  after  `hold'  will display the following message, not the current
              one.

       if     Commands in mailx's startup  files  can  be  executed  conditionally  depending  on
              whether the user is sending or receiving mail with the if command.  For example:

                      if receive
                              commands . . .
                      endif

              An else form is also available:

                      if receive
                              commands . . .
                      else
                              commands . . .
                      endif

              Note  that the only allowed conditions are receive, send, and term (execute command
              if standard input is a tty).

       ignore Add the list of header fields named to the ignored  list.   Header  fields  in  the
              ignore  list  are  not  printed  on  the  terminal when a message is printed.  This
              command is very handy for suppression of certain machine-generated  header  fields.
              The  Type  and  Print  commands  can  be  used  to print a message in its entirety,
              including ignored fields.  If ignore is executed with no arguments,  it  lists  the
              current set of ignored fields.

       imap   Sends  command  strings directly to the current IMAP server.  Mailx operates always
              in IMAP selected state on the current  mailbox;  commands  that  change  this  will
              produce undesirable results and should be avoided.  Useful IMAP commands are:

              create Takes the name of an IMAP mailbox as an argument and creates it.

              getquotaroot
                     Takes  the name of an IMAP mailbox as an argument and prints the quotas that
                     apply to the mailbox.  Not all IMAP servers support this command.

              namespace
                     Takes no arguments and prints the  Personal  Namespaces,  the  Other  User's
                     Namespaces,  and  the  Shared Namespaces.  Each namespace type is printed in
                     parentheses; if there are  multiple  namespaces  of  the  same  type,  inner
                     parentheses  separate  them.   For  each namespace, a namespace prefix and a
                     hierarchy separator is listed.  Not all IMAP servers support this command.

       inc    Same as newmail.

       junk   (j) Takes a list of messages and marks all of them as junk mail.  Data  from  these
              messages is then inserted into the junk mail database for future classification.

       kill   (k)  Takes a list of messages and `kills' them.  Killed messages are not printed in
              header summaries, and are ignored by the next command.  The kill command also  sets
              the  score  of the messages to negative infinity, so that subsequent score commands
              will not unkill them again.  Killing is only effective for the current session on a
              folder; when it is quit, all messages are automatically unkilled.

       list   Prints the names of all available commands.

       Mail   (M)  Similar to mail, but saves the message in a file named after the local part of
              the first recipient's address.

       mail   (m) Takes as argument login names and distribution group names and  sends  mail  to
              those people.

       mbox   Indicate  that a list of messages be sent to mbox in the user's home directory when
              mailx is quit.  This is the default action for messages if unless the  hold  option
              is  set.   mailx  deviates  from  the POSIX standard with this command, as a `next'
              command issued after `mbox' will display the following  message,  not  the  current
              one.

       move   (mv)  Acts  like copy, but marks the messages for deletion if they were transferred
              successfully.

       Move   (Mv) Similar to move, but moves the messages to a file named after the  local  part
              of the sender address of the first message.

       newmail
              Checks  for  new  mail in the current folder without committing any changes before.
              If new mail is present, a message is printed.  If the header variable is  set,  the
              headers of each new message are also printed.

       next   (n)  like  +  or  CR)  Goes  to the next message in sequence and types it.  With an
              argument list, types the next matching message.

       New    Same as unread.

       new    Same as unread.

       online Same as connect.

       noop   If the current folder is located on an IMAP or POP3 server, a NOOP command is sent.
              Otherwise, no operation is performed.

       Pipe   (Pi)  Like  pipe  but  also  pipes  ignored  header  fields  and  all parts of MIME
              multipart/alternative messages.

       pipe   (pi) Takes a message list and a shell command and pipes the  messages  through  the
              command.   Without  an  argument,  the current message is piped through the command
              given by the cmd variable.  If the  page variable is set, every message is followed
              by a formfeed character.

       preserve
              (pre) A synonym for hold.

       Print  (P)  Like  print  but  also  prints out ignored header fields and all parts of MIME
              multipart/alternative messages.  See also print, ignore, and retain.

       print  (p) Takes a message list and types out each message on the user's terminal.  If the
              message  is  a  MIME  multipart message, all parts with a content type of `text' or
              `message' are shown, the other are hidden except for their headers.   Messages  are
              decrypted and converted to the terminal character set if necessary.

       probability
              (prob)  For  each  word  given  as argument, the contents of its junk mail database
              entry are printed.

       quit   (q) Terminates the session, saving all undeleted, unsaved messages  in  the  user's
              mbox  file  in  his  login  directory,  preserving all messages marked with hold or
              preserve or never referenced in his system mailbox, and removing all other messages
              from  his  system mailbox.  If new mail has arrived during the session, the message
              `You have new mail' is given.  If given while editing a mailbox file  with  the  -f
              flag,  then  the edit file is rewritten.  A return to the Shell is effected, unless
              the rewrite of edit file fails, in which case the user can  escape  with  the  exit
              command.

       redirect
              (red) Same as resend.

       Redirect
              (Red) Same as Resend.

       remove (rem) Removes the named folders.  The user is asked for confirmation in interactive
              mode.

       rename (ren) Takes the name of an existing folder and the name  for  the  new  folder  and
              renames  the  first  to  the second one.  Both folders must be of the same type and
              must be located on the current server for IMAP.

       Reply  (R) Reply to originator.  Does not  reply  to  other  recipients  of  the  original
              message.

       reply  (r)  Takes  a  message  list and sends mail to the sender and all recipients of the
              specified message.  The default message must not be deleted.

       replyall
              Similar to reply, but responds to  all  recipients  regardless  of  the  flipr  and
              Replyall variables.

       replysender
              Similar  to  Reply,  but  responds  to  the sender only regardless of the flipr and
              Replyall variables.

       Resend Like resend, but does not add any header lines.  This is not  a  way  to  hide  the
              sender's identity, but useful for sending a message again to the same recipients.

       resend Takes  a list of messages and a user name and sends each message to the named user.
              `Resent-From:' and related header fields are prepended  to  the  new  copy  of  the
              message.

       Respond
              Same as Reply.

       respond
              Same as reply.

       respondall
              Same as replyall.

       respondsender
              Same as replysender.

       retain Add  the  list of header fields named to the retained list.  Only the header fields
              in the retain list are shown on the terminal when a message is printed.  All  other
              header  fields  are suppressed.  The Type and Print commands can be used to print a
              message in its entirety.  If retain is executed with no  arguments,  it  lists  the
              current set of retained fields.

       Save   (S) Similar to save, but saves the messages in a file named after the local part of
              the sender of the first message instead of taking a filename argument.

       save   (s) Takes a message list and a filename and appends each message in turn to the end
              of  the  file.   If  no  filename is given, the mbox file is used.  The filename in
              quotes, followed by the line count and character count  is  echoed  on  the  user's
              terminal.   If  editing  a  system  mailbox,  the messages are marked for deletion.
              Compressed files and IMAP mailboxes are handled as described  for  the  -f  command
              line option above.

       savediscard
              Same as saveignore.

       saveignore
              Saveignore  is to save what ignore is to print and type.  Header fields thus marked
              are filtered out when saving a message by save  or  when  automatically  saving  to
              mbox.   This  command  should  only be applied to header fields that do not contain
              information needed to decode the message, as MIME content  fields  do.   If  saving
              messages  on  an IMAP account, ignoring fields makes it impossible to copy the data
              directly on the server, thus operation usually becomes much slower.

       saveretain
              Saveretain is to save what retain is to print and type.  Header fields thus  marked
              are  the  only  ones saved with a message when saving by save or when automatically
              saving to mbox.  Saveretain overrides saveignore.   The  use  of  this  command  is
              strongly discouraged since it may strip header fields that are needed to decode the
              message correctly.

       score  (sc) Takes a message list and a floating point number and adds the  number  to  the
              score  of  each  given  message.   All  messages  start at score 0 when a folder is
              opened.  When the score of a message becomes negative,  it  is  `killed'  with  the
              effects  described  for  the  kill command; otherwise if it was negative before and
              becomes positive, it is `unkilled'.  Scores only  refer  to  the  currently  opened
              instance of a folder.

       set    (se)  With no arguments, prints all variable values, piped through the pager if the
              output does not fit on the screen.  Otherwise, sets option.  Arguments are  of  the
              form  option=value  (no space before or after =) or option.  Quotation marks may be
              placed around any part of the assignment statement to quote blanks  or  tabs,  i.e.
              `set  indentprefix="->"'.   If  an argument begins with no, as in `set nosave', the
              effect is the same as invoking the unset command with the  remaining  part  of  the
              variable (`unset save').

       seen   Takes a message list and marks all messages as having been read.

       shell  (sh) Invokes an interactive version of the shell.

       shortcut
              Defines  a  shortcut name and its string for expansion, as described for the folder
              command.  With no arguments, a list of defined shortcuts is printed.

       show   (Sh) Like print, but performs neither MIME decoding nor decryption so that the  raw
              message text is shown.

       size   Takes a message list and prints out the size in characters of each message.

       sort   Create  a  sorted representation of the current folder, and change the next command
              and the addressing modes such that they refer to  messages  in  the  sorted  order.
              Message  numbers are the same as in regular mode.  If the header variable is set, a
              header summary in the new order is also printed.  Possible sorting criteria are:

              date   Sort the messages by their `Date:' field, that is  by  the  time  they  were
                     sent.

              from   Sort messages by the value of their `From:' field, that is by the address of
                     the sender.  If the showname variable is set, the  sender's  real  name  (if
                     any) is used.

              size   Sort the messages by their size.

              score  Sort the messages by their score.

              status Sort the messages by their message status (new, read, old, etc.).

              subject
                     Sort the messages by their subject.

              thread Create a threaded order, as with the thread command.

              to     Sort  messages  by the value of their `To:' field, that is by the address of
                     the recipient.  If the showname variable is set, the recipient's  real  name
                     (if any) is used.

              If no argument is given, the current sorting criterion is printed.

       source The source command reads commands from a file.

       thread (th)  Create  a threaded representation of the current folder, i.e. indent messages
              that are replies to other messages in the  header  display,  and  change  the  next
              command  and  the addressing modes such that they refer to messages in the threaded
              order.  Message numbers are the same as in unthreaded mode.  If the header variable
              is set, a header summary in threaded order is also printed.

       top    Takes  a  message  list  and prints the top few lines of each.  The number of lines
              printed is controlled by the variable toplines and defaults to five.

       touch  Takes a message list and marks the messages for saving in  the  mbox  file.   mailx
              deviates  from  the  POSIX  standard  with this command, as a `next' command issued
              after `mbox' will display the following message, not the current one.

       Type   (T) Identical to the Print command.

       type   (t) A synonym for print.

       unalias
              Takes a list of names defined by alias commands and discards the remembered  groups
              of users.  The group names no longer have any significance.

       unanswered
              Takes a message list and marks each message as not having been answered.

       uncollapse
              (unc) Only applicable to threaded mode.  Takes a message list and makes the message
              and all replies to it visible in header summaries again.  When  a  message  becomes
              the  current  message,  it is automatically made visible.  Also when a message with
              collapsed replies is printed, all of these are automatically uncollapsed.

       undef  Undefines each of the named macros.  It is not an error to use a name that does not
              belong to one of the currently defined macros.

       undelete
              (u) Takes a message list and marks each message as not being deleted.

       undraft
              Takes a message list and marks each message as a draft.

       unflag Takes a message list and marks each message as not being `flagged'.

       unfwdignore
              Removes  the  header  field  names  from the list of ignored fields for the forward
              command.

       unfwdretain
              Removes the header field names from the list of retained  fields  for  the  forward
              command.

       ungood Takes  a  message  list and undoes the effect of a good command that was previously
              applied on exactly these messages.

       unignore
              Removes the header field names from the list of ignored fields.

       unjunk Takes a message list and undoes the effect of a junk command  that  was  previously
              applied on exactly these messages.

       unkill Takes  a  message  list  and  `unkills'  each  message.  Also sets the score of the
              messages to 0.

       Unread Same as unread.

       unread (U) Takes a message list and marks each message as not having been read.

       unretain
              Removes the header field names from the list of retained fields.

       unsaveignore
              Removes the header field names from the list of ignored fields for saving.

       unsaveretain
              Removes the header field names from the list of retained fields for saving.

       unset  Takes a list of option names and discards their remembered values; the  inverse  of
              set.

       unshortcut
              Deletes the shortcut names given as arguments.

       unsort Disable  sorted  or  threaded  mode  (see  the sort and thread commands), return to
              normal message order and, if the header variable is set, print a header summary.

       unthread
              (unth) Same as unsort.

       verify (verif) Takes a message list and verifies each message.  If a  message  is  not  an
              S/MIME  signed  message,  verification  will fail for it.  The verification process
              checks if the message was signed using a valid certificate, if the message sender's
              email  address  matches  one  of those contained within the certificate, and if the
              message content has been altered.

       visual (v) Takes a message list and invokes the display editor on each message.   Modified
              contents are discarded unless the writebackedited variable is set.

       write  (w) For conventional messages, the body without all headers is written.  The output
              is decrypted and converted to its native format, if necessary.  If the output  file
              exists,  the  text is appended.—If a message is in MIME multipart format, its first
              part is written to the specified file as for conventional messages, and the user is
              asked for a filename to save each other part; if the contents of the first part are
              not to be saved, `write /dev/null' can be used.   For  the  second  and  subsequent
              parts, if the filename given starts with a `|' character, the part is piped through
              the remainder of the filename interpreted as a shell command.   In  non-interactive
              mode,  only  the  parts  of the multipart message that have a filename given in the
              part header are written, the other are discarded.  The original  message  is  never
              marked  for deletion in the originating mail folder.  For attachments, the contents
              of the destination file are overwritten if the file previously existed.  No special
              handling of compressed files is performed.

       xit    (x) A synonym for exit.

       z      Mailx  presents  message  headers  in  windowfuls  as  described  under the headers
              command.  The z command scrolls to the next window of messages.  If an argument  is
              given,  it  specifies the window to use.  A number prefixed by `+' or `-' indicates
              that the window is calculated in  relation  to  the  current  position.   A  number
              without  a  prefix specifies an absolute window number, and a `$' lets mailx scroll
              to the last window of messages.

       Z      Similar to z, but scrolls to the next or previous window that contains at least one
              new or `flagged' message.

   Tilde escapes
       Here  is a summary of the tilde escapes, which are used when composing messages to perform
       special functions.  Tilde escapes are only recognized at the beginning of lines.  The name
       `tilde  escape'  is somewhat of a misnomer since the actual escape character can be set by
       the option escape.

       ~!command
              Execute the indicated shell command, then return to the message.

       ~.     Same effect as typing the end-of-file character.

       ~<filename
              Identical to ~r.

       ~<!command
              Command is executed using the shell.  Its standard  output  is  inserted  into  the
              message.

       ~@ [filename . . . ]
              With no arguments, edit the attachment list.  First, the user can edit all existing
              attachment data.  If an attachment's file name is left empty,  that  attachment  is
              deleted  from the list.  When the end of the attachment list is reached, mailx will
              ask for further attachments, until an  empty  file  name  is  given.   If  filename
              arguments  are  specified,  all  of  them are appended to the end of the attachment
              list.  Filenames which contain white space can only be  specified  with  the  first
              method (no filename arguments).

       ~A     Inserts  the string contained in the Sign variable (same as `~i Sign').  The escape
              sequences `\t' (tabulator) and `\n' (newline) are understood.

       ~a     Inserts the string contained in the sign variable (same as `~i sign').  The  escape
              sequences `\t' (tabulator) and `\n' (newline) are understood.

       ~bname . . .
              Add the given names to the list of carbon copy recipients but do not make the names
              visible in the Cc: line (`blind' carbon copy).

       ~cname . . .
              Add the given names to the list of carbon copy recipients.

       ~d     Read the file `dead.letter' from the user's home directory into the message.

       ~e     Invoke the text editor on the message collected so far.  After the editing  session
              is finished, the user may continue appending text to the message.

       ~fmessages
              Read the named messages into the message being sent.  If no messages are specified,
              read in the current message.  Message  headers  currently  being  ignored  (by  the
              ignore  or retain command) are not included.  For MIME multipart messages, only the
              first printable part is included.

       ~Fmessages
              Identical to ~f, except all message headers and all MIME parts are included.

       ~h     Edit the message header fields `To:', `Cc:', `Bcc:', and `Subject:' by typing  each
              one  in turn and allowing the user to append text to the end or modify the field by
              using the current terminal erase and kill characters.

       ~H     Edit the message header fields `From:', `Reply-To:', `Sender:', and `Organization:'
              in  the  same  manner  as  described  for  ~h.  The default values for these fields
              originate from the from,  replyto,  and  ORGANIZATION  variables.   If  this  tilde
              command  has been used, changing the variables has no effect on the current message
              anymore.

       ~ivariable
              Insert the value of the specified  variable  into  the  message  adding  a  newline
              character  at  the  end.   If  the  variable is unset or empty, the message remains
              unaltered.   The  escape  sequences  `\t'  (tabulator)  and  `\n'   (newline)   are
              understood.

       ~mmessages
              Read  the  named  messages into the message being sent, indented by a tab or by the
              value of indentprefix.  If no messages are specified,  read  the  current  message.
              Message  headers  currently being ignored (by the ignore or retain command) are not
              included.  For MIME multipart messages, only the first printable part is included.

       ~Mmessages
              Identical to ~m, except all message headers and all MIME parts are included.

       ~p     Print out the message collected so far, prefaced by the message header  fields  and
              followed  by  the  attachment list, if any.  If the message text is longer than the
              screen size, it is piped through the pager.

       ~q     Abort the message being sent, copying the message to `dead.letter'  in  the  user's
              home directory if save is set.

       ~rfilename
              Read the named file into the message.

       ~sstring
              Cause the named string to become the current subject field.

       ~tname . . .
              Add the given names to the direct recipient list.

       ~v     Invoke  an alternate editor (defined by the VISUAL option) on the message collected
              so far.  Usually, the alternate editor will be a screen editor.  After  the  editor
              is quit, the user may resume appending text to the end of the message.

       ~wfilename
              Write the message onto the named file.  If the file exists, the message is appended
              to it.

       ~x     Same as ~q, except that the message is not saved to the `dead.letter' file.

       ~|command
              Pipe the message through the command as a filter.  If the command gives  no  output
              or  terminates  abnormally,  retain  the original text of the message.  The command
              fmt(1) is often used as command to rejustify the message.

       ~:mailx-command
              Execute the given mailx command.  Not all commands, however, are allowed.

       ~_mailx-command
              Identical to ~:.

       ~~string
              Insert the string of text in the message prefaced by a single  ~.   If  the  escape
              character  has  been changed, that character must be doubled in order to send it at
              the beginning of a line.

   Variable options
       Options are controlled via set  and  unset  commands,  see  their  entries  for  a  syntax
       description.   An  option  is also set if it is passed to mailx as part of the environment
       (this is not restricted to specific variables as in the POSIX standard).  A value given in
       a  startup  file  overrides  a value imported from the environment.  Options may be either
       binary, in which case it is only significant to see  whether  they  are  set  or  not;  or
       string, in which case the actual value is of interest.

   Binary options
       The binary options include the following:

       allnet Causes only the local part to be evaluated when comparing addresses.

       append Causes  messages  saved  in  mbox  to be appended to the end rather than prepended.
              This should always be set.

       ask or asksub
              Causes mailx to prompt for the subject of each message sent.  If the user  responds
              with simply a newline, no subject field will be sent.

       askatend
              Causes  the prompts for `Cc:' and `Bcc:' lists to appear after the message has been
              edited.

       askattach
              If set, mailx asks for files to attach at the end of each message.  Responding with
              a newline indicates not to include an attachment.

       askcc  Causes the user to be prompted for additional carbon copy recipients (at the end of
              each message if askatend or bsdcompat is set).  Responding with a newline indicates
              the user's satisfaction with the current list.

       askbcc Causes  the user to be prompted for additional blind carbon copy recipients (at the
              end of each message if askatend or bsdcompat is set).  Responding  with  a  newline
              indicates the user's satisfaction with the current list.

       asksign
              Causes  the  user  to be prompted if the message is to be signed at the end of each
              message.  The smime-sign variable is ignored when this variable is set.

       autocollapse
              Causes threads to be collapsed automatically when threaded mode is entered (see the
              collapse command).

       autoinc
              Same as newmail.

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

       autothread
              Causes threaded mode (see the thread command) to be entered  automatically  when  a
              folder is opened.

       bang   Enables  the substitution of `!'  by the contents of the last command line in shell
              escapes.

       bsdannounce
              Causes automatic display of a header summary after executing a folder command.

       bsdcompat
              Sets some cosmetical features to traditional BSD style;  has  the  same  affect  as
              setting  `askatend'  and all other variables prefixed with `bsd', setting prompt to
              `& ', and changing the default pager to more.

       bsdflags
              Changes the letters printed in the first column of a header summary to  traditional
              BSD style.

       bsdheadline
              Changes the display of columns in a header summary to traditional BSD style.

       bsdmsgs
              Changes some informational messages to traditional BSD style.

       bsdorder
              Causes  the `Subject:' field to appear immediately after the `To:' field in message
              headers and with the ~h tilde command.

       bsdset Changes the output format of the set command to traditional BSD style.

       chained-junk-tokens
              Normally, the Bayesian junk mail filter bases its classifications  on  single  word
              tokens extracted from messages.  If this option is set, adjacent words are combined
              to pairs, which are then used as additional  tokens.   This  usually  improves  the
              accuracy of the filter, but also increases the junk mail database five- to tenfold.

       datefield
              The  date  in  a header summary is normally the date of the mailbox `From ' line of
              the message.  If this variable is set, the date as  given  in  the  `Date:'  header
              field is used, converted to local time.

       debug  Prints  debugging  messages  and  disables the actual delivery of messages.  Unlike
              verbose, this option is intended for mailx development only.

       disconnected
              When an IMAP mailbox is selected and this variable is set,  no  connection  to  the
              server  is  initiated.   Instead,  data is obtained from the local cache (see imap-
              cache).  Mailboxes that are not present in the cache and messages that have not yet
              entirely been fetched from the server are not available; to fetch all messages in a
              mailbox at once, the command `copy * /dev/null' can be used while still  in  online
              mode.   Changes that are made to IMAP mailboxes in disconnected mode are queued and
              committed later when a connection to that server is opened in  online  mode.   This
              procedure  is  not  completely reliable since it cannot be guaranteed that the IMAP
              unique identifiers (UIDs) on the server still match the ones in the cache  at  that
              time.  Data is saved to `dead.letter' when this problem occurs.

       disconnected-user@host
              The  specified account is handled as described for the disconnected variable above,
              but other accounts are not affected.

       dot    The binary option dot causes mailx to interpret a period alone on  a  line  as  the
              terminator of a message the user is sending.

       editheaders
              When  a  message  is  edited  while  being  composed, its header is included in the
              editable text.  `To:', `Cc:', `Bcc:', `Subject:', `From:', `Reply-To:',  `Sender:',
              and  'Organization:'  fields  are  accepted  within  the  header,  other fields are
              ignored.

       emptybox
              If  set,  an  empty  mailbox  file  is  not  removed.    This   may   improve   the
              interoperability with other mail user agents when using a common folder directory.

       emptystart
              If  the  mailbox  is  empty,  mailx  normally  prints  `No mail for user' and exits
              immediately.  If this option is set, mailx starts even with an empty mailbox.

       flipr  Exchanges the Respond with the respond commands and vice-versa.

       forward-as-attachment
              Original messages are normally sent as inline text with the  forward  command,  and
              only the first part of a multipart message is included.  With this option, messages
              are sent as MIME message/rfc822 attachments, and all of their parts  are  included.
              The  fwdignore  and  fwdretain  options  are ignored when the forward-as-attachment
              option is set.

       fullnames
              When replying to a message, mailx normally  removes  the  comment  parts  of  email
              addresses,  which  by convention contain the full names of the recipients.  If this
              variable is set, such stripping is not performed, and comments are retained.

       header Causes the header summary to be written at startup and after commands  that  affect
              the  number  of messages or the order of messages in the current folder; enabled by
              default.

       hold   This option is used to hold messages in the system mailbox by default.

       ignore Causes interrupt signals from the terminal to be ignored and echoed as @'s.

       ignoreeof
              An option related to dot is ignoreeof which makes mailx refuse to accept a control-
              d as the end of a message.  Ignoreeof also applies to mailx command mode.

       imap-use-starttls
              Causes  mailx  to  issue  a  STARTTLS  command  to make an unencrypted IMAP session
              SSL/TLS encrypted.  This functionality is not supported by all servers, and is  not
              used if the session is already encrypted by the IMAPS method.

       imap-use-starttls-user@host
              Activates imap-use-starttls for a specific account.

       keep   This  option causes mailx to truncate the user's system mailbox instead of deleting
              it when it is empty.  This should always be set, since it prevents malicious  users
              from creating fake mail folders in a world-writable spool directory.

       keepsave
              When  a  message is saved, it is usually discarded from the originating folder when
              mailx is quit.  Setting this option causes all saved message to be retained.

       markanswered
              When a message is replied to and this variable is set, it is marked as having  been
              answered.   This  mark  has no technical meaning in the mail system; it just causes
              messages to be marked in the header summary, and makes them specially addressable.

       metoo  Usually, when a group 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.

       newmail
              Checks for new mail in the current folder each time the  prompt  is  printed.   For
              IMAP mailboxes, the server is then polled for new mail, which may result in delayed
              operation if the connection to the server is slow.  A maildir folder  must  be  re-
              scanned to determine if new mail has arrived.

              If this variable is set to the special value nopoll, an IMAP server is not actively
              asked for new mail, but new mail may still be detected and announced with any other
              IMAP command that is sent to the server.  A maildir folder is not scanned then.

              In  any  case, the IMAP server may send notifications about messages that have been
              deleted on the server by another process or client.   In  this  case,  `Expunged  n
              messages'  is  printed  regardless  of  this variable, and message numbers may have
              changed.

       noheader
              Setting the option noheader is the same as giving the -N flag on the command line.

       outfolder
              Causes the filename given in the record variable and the sender-based filenames for
              the Copy and Save commands to be interpreted relative to the directory given in the
              folder variable rather than to the current  directory  unless  it  is  an  absolute
              pathname.

       page   If  set,  each  message  the  pipe  command  prints  out  is followed by a formfeed
              character.

       piperaw
              Send messages to the  pipe  command  without  performing  MIME  and  character  set
              conversions.

       pop3-use-apop
              If  this  variable is set, the APOP authentication method is used when a connection
              to a POP3 server is initiated.   The  advantage  of  this  method  over  the  usual
              USER/PASS authentication is that the password is not sent over the network in clear
              text.  The connection fails if the server does not support the APOP command.

       pop3-use-apop-user@host
              Enables pop3-use-apop for a specific account.

       pop3-use-starttls
              Causes mailx to issue a STLS command to make an unencrypted  POP3  session  SSL/TLS
              encrypted.   This functionality is not supported by all servers, and is not used if
              the session is already encrypted by the POP3S method.

       pop3-use-starttls-user@host
              Activates pop3-use-starttls for a specific account.

       print-all-chars
              This option causes all characters to be considered printable.  It is only effective
              if  given  in  a  startup  file.  With this option set, some character sequences in
              messages may put the user's terminal in an undefined state when printed; it  should
              only be used as a last resort if no working system locale can be found.

       print-alternatives
              When a MIME message part of type multipart/alternative is displayed and it contains
              a subpart of type text/plain, other parts are  normally  discarded.   Setting  this
              variable  causes  all subparts to be displayed, just as if the surrounding part was
              of type multipart/mixed.

       quiet  Suppresses the printing of the version when first invoked.

       record-resent
              If both this variable and the record  variable  are  set,  the  resend  and  Resend
              commands  save  messages to the record folder as it is normally only done for newly
              composed messages.

       reply-in-same-charset
              If this variable is set, mailx first tries to use the same  character  set  of  the
              original  message  for  replies.   If  this  fails,  the  sendcharsets  variable is
              evaluated as usual.

       Replyall
              Reverses the sense of reply and Reply commands.

       save   When the user aborts a message with two RUBOUT (interrupt characters) mailx  copies
              the partial letter to the file `dead.letter' in the home directory.  This option is
              set by default.

       searchheaders
              If this option is set, then a message-list specifier in the form `/x:y' will expand
              to  all  messages containing the substring `y' in the header field `x'.  The string
              search is case insensitive.

       sendwait
              When sending a message, wait until the mail transfer agent exits  before  accepting
              further  commands.   If the mail transfer agent returns a non-zero exit status, the
              exit status of mailx will also be non-zero.

       showlast
              Setting this option causes mailx to start at the last message instead of the  first
              one when opening a mail folder.

       showname
              Causes  mailx  to  use  the  sender's real name instead of the plain address in the
              header field summary and in message specifications.

       showto Causes the recipient of the message to be  shown  in  the  header  summary  if  the
              message was sent by the user.

       skipemptybody
              If an outgoing message does not contain any text in its first or only message part,
              do not send it but discard it silently (see also the -E option).

       smime-force-encryption
              Causes mailx to refuse sending unencrypted messages.

       smime-sign
              If this variable is set, outgoing  messages  are  S/MIME  signed  with  the  user's
              private  key.  Signing a message enables a recipient to verify that the sender used
              a valid certificate, that the email addresses in the certificate match those in the
              message  header,  and  that  the message content has not been altered.  It does not
              change the message text, and people will be able to read the message as usual.

       smime-no-default-ca
              Do not load the default CA locations when verifying S/MIME signed  messages.   Only
              applicable if S/MIME support is built using OpenSSL.

       smtp-use-starttls
              Causes mailx to issue a STARTTLS command to make an SMTP session SSL/TLS encrypted.
              Not all servers support this command; because of common implementation defects,  it
              cannot be automatically determined whether a server supports it or not.

       ssl-no-default-ca
              Do  not  load the default CA locations to verify SSL/TLS server certificates.  Only
              applicable if SSL/TLS support is built using OpenSSL.

       ssl-v2-allow
              Accept SSLv2 connections.  These are normally not  allowed  because  this  protocol
              version is insecure.

       stealthmua
              Inhibits  the  generation of the `Message-Id:' and `User-Agent:' header fields that
              include obvious references to mailx.  There are two pitfalls associated with  this:
              First, the message id of outgoing messages is not known anymore.  Second, an expert
              may still use the remaining information in the header to track down the originating
              mail user agent.

       verbose
              Setting  the  option  verbose is the same as using the -v flag on the command line.
              When mailx runs in verbose  mode,  details  of  the  actual  message  delivery  and
              protocol  conversations  for  IMAP,  POP3,  and  SMTP, as well as of other internal
              processes, are displayed on the user's terminal, This is sometimes useful to  debug
              problems.   Mailx  prints  all  data that is sent to remote servers in clear texts,
              including passwords, so care should be taken that no unauthorized option  can  view
              the screen if this option is enabled.

       writebackedited
              If  this  variable  is set, messages modified using the edit or visual commands are
              written back to the current folder when it is quit.   This  is  only  possible  for
              writable folders in mbox format.  Setting this variable also disables MIME decoding
              and decryption for the editing commands.

   String Options
       The string options include the following:

       attrlist
              A sequence of characters to print in the `attribute' column of  a  header  summary,
              each  for one type of messages in the following order: new, unread but old, new but
              read, read and old, saved, preserved, mboxed,  flagged,  answered,  draft,  killed,
              start  of  a  collapsed  thread,  collapsed,  classified  as  junk.  The default is
              `NUROSPMFATK+-J', or `NU  *HMFATK+-J' if bsdflags or the SYSV3 environment variable
              are set.

       autobcc
              Specifies  a  list  of  recipients  to  which  a blind carbon copy of each outgoing
              message will be sent automatically.

       autocc Specifies a list of recipients to which a carbon copy of each outgoing message will
              be sent automatically.

       autosort
              Causes  sorted  mode  (see  the  sort command) to be entered automatically with the
              value of this option as sorting method when a folder is opened.

       cmd    The default value for the pipe command.

       crt    The valued option crt is used as a threshold to determine how long a  message  must
              be before PAGER is used to read it.  If crt is set without a value, then the height
              of the terminal screen stored in the system is used to compute the  threshold  (see
              stty(1)).

       DEAD   The  name  of  the  file  to  use  for  saving  aborted messages.  This defaults to
              `dead.letter' in the user's home directory.

       EDITOR Pathname of the text editor to use in the edit  command  and  ~e  escape.   If  not
              defined, then a default editor is used.

       encoding
              The  default  MIME  encoding  to  use  in outgoing text messages and message parts.
              Valid values are 8bit or quoted-printable.  The default is 8bit.  In case the  mail
              transfer  system  is  not ESMTP compliant, quoted-printable should be used instead.
              If there is no need to encode a message, 7bit transfer mode is used, without regard
              to the value of this variable.  Binary data is always encoded in base64 mode.

       escape If  defined,  the  first character of this option gives the character to use in the
              place of ~ to denote escapes.

       folder The name of the directory to use for storing folders of messages.  All folder names
              that  begin  with  `+'  refer to files below that directory.  If the directory name
              begins with a `/', mailx considers it to be an absolute  pathname;  otherwise,  the
              folder directory is found relative to the user's home directory.

              The directory name may also refer to an IMAP account; any names that begin with `+'
              then refer to IMAP mailboxes on that account.  An IMAP folder is normally given  in
              the form

                  imaps://mylogin@imap.myisp.example

              In  this  case, the `+' and `@' prefixes for folder names have the same effect (see
              the folder command).

              Some IMAP servers do not accept the creation of mailboxes in  the  hierarchy  base;
              they  require that they are created as subfolders of `INBOX'.  With such servers, a
              folder name of the form

                  imaps://mylogin@imap.myisp.example/INBOX.

              should be used (the last character is the server's  hierarchy  delimiter).   Folder
              names  prefixed by `+' will then refer to folders below `INBOX', while folder names
              prefixed by `@' refer to folders below the hierarchy base.  See the imap  namespace
              command for a method to detect the appropriate prefix and delimiter.

       folder-hook
              When  a  folder  is opened and this variable is set, the macro corresponding to the
              value of this variable is executed.  The  macro  is  also  invoked  when  new  mail
              arrives,  but message lists for commands executed from the macro only include newly
              arrived messages then.

       folder-hook-fullname
              When a folder named fullname is opened, the macro corresponding  to  the  value  of
              this  variable is executed.  Unlike other folder specifications, the fully expanded
              name of a folder, without metacharacters, is used to avoid ambiguities.  The  macro
              specified  with  folder-hook  is  not  executed if this variable is effective for a
              folder (unless it is explicitly invoked within the called macro).

       from   The address (or a list of addresses) to put into the `From:' field of  the  message
              header.   If  replying to a message, these addresses are handled as if they were in
              the alternates list.  If the machine's hostname is not valid at the  Internet  (for
              example  at  a  dialup machine), either this variable or hostname have to be set to
              get correct Message-ID header fields.  If from contains more than one address,  the
              sender variable must also be set.

       fwdheading
              The  string  to print before the text of a message with the forward command (unless
              the forward-as-attachment  variable  is  set).   Defaults  to  ``--------  Original
              Message  --------''  if  unset.   If  it  is set to the empty string, no heading is
              printed.

       headline
              A format string to use for the header summary, similar to printf  formats.   A  `%'
              character introduces a format specifier.  It may be followed by a number indicating
              the field width.  If the field is a  number,  the  width  may  be  negative,  which
              indicates that it is to be left-aligned.  Valid format specifiers are:

                  %a    Message attributes.
                  %c    The score of the message.
                  %d    The date when the message was received.
                  %e    The indenting level in threaded mode.
                  %f    The address of the message sender.
                  %i    The message thread structure.
                  %l    The number of lines of the message.
                  %m    Message number.
                  %o    The number of octets (bytes) in the message.
                  %s    Message subject (if any).
                  %S    Message subject (if any) in double quotes.
                  %t    The position in threaded/sorted order.
                  %>    A `>' for the current message, otherwise ` '.

                  %<    A `<' for the current message, otherwise ` '.
                  %%    A `%' character.

              The         default         is         `%>%a%m %18f %16d %4l/%-5o %i%s',         or
              `%>%a%m %20f  %16d %3l/%-5o %i%S' if bsdcompat is set.

       hostname
              Use this string as hostname when expanding local addresses  instead  of  the  value
              obtained from uname(2) and getaddrinfo(3).

       imap-auth
              Sets  the  IMAP  authentication  method.   Valid  values  are `login' for the usual
              password-based authentication (the default), `cram-md5', which is a  password-based
              authentication  that does not send the password over the network in clear text, and
              `gssapi' for GSSAPI-based authentication.

       imap-auth-user@host
              Sets the IMAP authentication method for a specific account.

       imap-cache
              Enables caching of IMAP mailboxes.  The value of this  variable  must  point  to  a
              directory  that is either existent or can be created by mailx.  All contents of the
              cache can be deleted by mailx at any time; it is not safe to make assumptions about
              them.

       imap-keepalive
              IMAP  servers  may  close the connection after a period of inactivity; the standard
              requires this to be at  least  30  minutes,  but  practical  experience  may  vary.
              Setting this variable to a numeric value greater than 0 causes a NOOP command to be
              sent each value seconds if no other operation is performed.

       imap-list-depth
              When retrieving the list of folders on an IMAP server, the  folders  command  stops
              after  it  has reached a certain depth to avoid possible infinite loops.  The value
              of this variable sets the maximum depth allowed.  The default is 2.  If the  folder
              separator  on  the current IMAP server is a slash `/', this variable has no effect,
              and the folders command does not descend to subfolders.

       indentprefix
              String used by the `~m' and  `~M'  tilde  escapes  and  by  the  quote  option  for
              indenting  messages,  in  place of the normal tab character (^I).  Be sure to quote
              the value if it contains spaces or tabs.

       junkdb The location of the junk mail database.  The string is treated like a folder  name,
              as described for the folder command.

              The  files  in the junk mail database are normally stored in compress(1) format for
              saving space.  If processing time is considered more important,  uncompress(1)  can
              be  used  to store them in plain form.  Mailx will then work using the uncompressed
              files.

       LISTER Pathname of the directory lister to use in the folders command  when  operating  on
              local mailboxes.  Default is /bin/ls.

       MAIL   Is  used  as  the user's mailbox, if set.  Otherwise, a system-dependent default is
              used.  Can be a protocol:// string (see the folder command for more information).

       MAILX_HEAD
              A string to put at the beginning of each new message.  The  escape  sequences  `\t'
              (tabulator) and `\n' (newline) are understood.

       MAILX_TAIL
              A  string  to  put  at  the  end  of  each  new message.  The escape sequences `\t'
              (tabulator) and `\n' (newline) are understood.

       maximum-unencoded-line-length
              Messages that contain lines longer than the value of this variable are  encoded  in
              quoted-printable even if they contain only ASCII characters.  The maximum effective
              value is 950.  If set to  0,  all  ASCII  text  messages  are  encoded  in  quoted-
              printable.    S/MIME   signed  messages  are  always  encoded  in  quoted-printable
              regardless of the value of this variable.

       MBOX   The name of the mbox file.  It can be the name of a folder.  The default is  `mbox'
              in the user's home directory.

       NAIL_EXTRA_RC
              The  name of an optional startup file to be read after ~/.mailrc.  This variable is
              ignored if it is imported from the environment; it has an effect only if it is  set
              in  /etc/nail.rc  or  ~/.mailrc  to  allow  bypassing  the configuration with e. g.
              `MAILRC=/dev/null'.  Use this file for commands that are not  understood  by  other
              mailx implementations.

       newfolders
              If  this  variable  has  the  value maildir, newly created local folders will be in
              maildir format.

       nss-config-dir
              A directory that contains the files certN.db to retrieve certificates,  keyN.db  to
              retrieve  private keys, and secmod.db, where N is a digit.  These are usually taken
              from   Mozilla    installations,    so    an    appropriate    value    might    be
              `~/.mozilla/firefox/default.clm'.   Mailx  opens these files read-only and does not
              modify them.  However, if the files are modified by Mozilla while mailx is running,
              it  will  print  a `Bad database' message.  It may be necessary to create copies of
              these files that are exclusively used by mailx then.  Only applicable if S/MIME and
              SSL/TLS support is built using Network Security Services (NSS).

       ORGANIZATION
              The value to put into the `Organization:' field of the message header.

       PAGER  Pathname  of  the  program  to use in the more command or when crt variable is set.
              The default paginator pg(1) or, in BSD compatibility mode, more(1) is used if  this
              option is not defined.

       password-user@host
              Set  the password for user when connecting to host.  If no such variable is defined
              for a host, the user will be asked for a password on  standard  input.   Specifying
              passwords  in  a  startup  file  is  generally  a security risk, the file should be
              readable by the invoking user only.

       pipe-content/subcontent
              When a MIME message part of content/subcontent type is displayed or it  is  replied
              to,  its text is filtered through the value of this variable interpreted as a shell
              command.  Special care must be taken when using such commands as mail  viruses  may
              be  distributed  by this method; if messages of type application/x-sh were filtered
              through the shell, for example, a message sender  could  easily  execute  arbitrary
              code on the system mailx is running on.

       pop3-keepalive
              POP3  servers  may  close the connection after a period of inactivity; the standard
              requires this to be at  least  10  minutes,  but  practical  experience  may  vary.
              Setting this variable to a numeric value greater than 0 causes a NOOP command to be
              sent each value seconds if no other operation is performed.

       prompt The string printed when a command is accepted.  Defaults to `? ', or to `& ' if the
              bsdcompat variable is set.

       quote  If  set,  mailx starts a replying message with the original message prefixed by the
              value  of  the  variable  indentprefix.   Normally,   a   heading   consisting   of
              `Fromheaderfield  wrote:' is printed before the quotation.  If the string noheading
              is assigned to the quote variable, this heading is omitted.  If the string  headers
              is  assigned,  the headers selected by the ignore/retain commands are printed above
              the message body, thus quote acts like an automatic ~m command then.  If the string
              allheaders  is  assigned,  all  headers are printed above the message body, and all
              MIME parts are included, thus quote acts like an automatic ~M command then.

       record If defined, gives the pathname of the folder used to record all outgoing mail.   If
              not defined, then outgoing mail is not so saved.  When saving to this folder fails,
              the message is not sent but saved to the `dead.letter' file instead.

       replyto
              A list of addresses to put into the `Reply-To:' field of the  message  header.   If
              replying to a message, such addresses are handled as if they were in the alternates
              list.

       screen When mailx initially prints the message headers, it determines the number to  print
              by  looking  at  the  speed  of the terminal.  The faster the terminal, the more it
              prints.  This option overrides this calculation  and  specifies  how  many  message
              headers are printed.  This number is also used for scrolling with the z command.

       sendcharsets
              A  comma-separated  list  of character set names that can be used in Internet mail.
              When a message that contains characters not representable in US-ASCII  is  prepared
              for sending, mailx tries to convert its text to each of the given character sets in
              order and uses the first appropriate one.  The default is `utf-8'.

              Character sets assigned to this variable should be ordered in ascending complexity.
              That is, the list should start with e.g.  `iso-8859-1' for compatibility with older
              mail clients, might contain some other language-specific character sets, and should
              end with `utf-8' to handle messages that combine texts in multiple languages.

       sender An  address  that is put into the `Sender:' field of outgoing messages.  This field
              needs not normally be present.  It is,  however,  required  if  the  `From:'  field
              contains more than one address.  It can also be used to indicate that a message was
              sent on behalf of somebody other; in this case, `From:' should contain the  address
              of  the  person  that  took  responsibility  for  the message, and `Sender:' should
              contain the address of the person that  actually  sent  the  message.   The  sender
              address is handled as if it were in the alternates list.

       sendmail
              To  use  an alternate mail delivery system, set this option to the full pathname of
              the program to use.  This should be used with care.

       SHELL  Pathname of the shell to use in the ! command and the ~! escape.  A  default  shell
              is used if this option is not defined.

       Sign   A string for use with the ~A command.

       sign   A string for use with the ~a command.

       signature
              Must  correspond to the name of a readable file if set.  The file's content is then
              appended to each singlepart message  and  to  the  first  part  of  each  multipart
              message.   Be  warned  that  there  is  no possibility to edit the signature for an
              individual message.

       smime-ca-dir
              Specifies a directory with  CA  certificates  for  verification  of  S/MIME  signed
              messages.  The format is the same as described in SSL_CTX_load_verify_locations(3).
              Only applicable if S/MIME support is built using OpenSSL.

       smime-ca-file
              Specifies a file with CA certificates for verification of S/MIME  signed  messages.
              The  format  is  the  same  as described in SSL_CTX_load_verify_locations(3).  Only
              applicable if S/MIME support is built using OpenSSL.

       smime-cipher-user@host
              Specifies a cipher to use when generating S/MIME encrypted messages for  user@host.
              Valid  ciphers  are rc2-40 (RC2 with 40 bits), rc2-64 (RC2 with 64 bits), des (DES,
              56 bits) and des-ede3 (3DES, 112/168 bits).   The  default  is  3DES.   It  is  not
              recommended to use the other ciphers unless a recipient's client is actually unable
              to handle 3DES since they are comparatively weak; but even so, the recipient should
              upgrade his software in preference.

       smime-crl-file
              Specifies  a  file  that  contains a CRL in PEM format to use when verifying S/MIME
              messages.  Only applicable if S/MIME support is built using OpenSSL.

       smime-crl-dir
              Specifies a directory that contains files with CRLs  in  PEM  format  to  use  when
              verifying  S/MIME  messages.   Only  applicable  if  S/MIME  support is built using
              OpenSSL.

       smime-encrypt-user@host
              If this variable is set, messages to user@host are encrypted  before  sending.   If
              S/MIME support is built using OpenSSL, the value of the variable must be set to the
              name of a file that contains a certificate in PEM format.   If  S/MIME  support  is
              built  using  NSS,  the  value  of  this  variable  is  ignored,  but  if  multiple
              certificates for user@host are  available,  the  smime-nickname-user@host  variable
              should  be  set.   Otherwise  a  certificate  for  the  recipient  is automatically
              retrieved from the certificate database, if possible.

              If a message is sent to multiple recipients, each of them for whom a  corresponding
              variable  is  set  will receive an individually encrypted message; other recipients
              will continue to  receive  the  message  in  plain  text  unless  the  smime-force-
              encryption  variable is set.  It is recommended to sign encrypted messages, i.e. to
              also set the smime-sign variable.

       smime-nickname-user@host
              Specifies the nickname of a certificate to be used  when  encrypting  messages  for
              user@host .  Only applicable if S/MIME support is built using NSS.

       smime-sign-cert
              Points  to a file in PEM format that contains the user's private key as well as his
              certificate.  Both are used with S/MIME for signing and decrypting messages.   Only
              applicable if S/MIME support is built using OpenSSL.

       smime-sign-cert-user@host
              Overrides  smime-sign-cert  for  the specific addresses.  When signing messages and
              the value of the from variable is set to user@host,  the  specific  file  is  used.
              When  decrypting  messages,  their  recipient fields (To: and Cc:) are searched for
              addresses for which such a variable is set.  Mailx always uses  the  first  address
              that  matches,  so  if  the  same  message  is  sent to more than one of the user's
              addresses using different encryption keys, decryption might fail.  Only  applicable
              if S/MIME support is built using OpenSSL.

       smime-sign-nickname
              Specifies that the named certificate be used for signing mail.  If this variable is
              not set, but a single certificate matching the current from address is found in the
              database,  that  one  is  used automatically.  Only applicable if S/MIME support is
              built using NSS.

       smime-sign-nickname-user@host
              Overrides smime-sign-nickname for a specific address.  Only  applicable  if  S/MIME
              support is built using NSS.

       smtp   Normally,  mailx  invokes  sendmail(8)  directly to transfer messages.  If the smtp
              variable is set, a SMTP connection to the server specified by  the  value  of  this
              variable  is  used  instead.   If the SMTP server does not use the standard port, a
              value of server:port can be given, with port as a name or as a number.

              There are two possible methods to get SSL/TLS encrypted SMTP sessions:  First,  the
              STARTTLS  command can be used to encrypt a session after it has been initiated, but
              before any user-related data has been sent; see smtp-use-starttls  above.   Second,
              some  servers accept sessions that are encrypted from their beginning on. This mode
              is configured by assigning smtps://server[:port] to the smtp variable.

              The SMTP transfer is executed in a child process; unless either the sendwait or the
              verbose  variable  is set, this process runs asynchronously.  If it receives a TERM
              signal, it will abort and save the message to the `dead.letter' file.

       smtp-auth
              Sets the SMTP authentication method.  If set to `login', or if unset and smtp-auth-
              user  is  set, AUTH LOGIN is used.  If set to `cram-md5', AUTH CRAM-MD5 is used; if
              set to  `plain',  AUTH  PLAIN  is  used.   Otherwise,  no  SMTP  authentication  is
              performed.

       smtp-auth-user@host
              Overrides  smtp-auth for specific values of sender addresses, depending on the from
              variable.

       smtp-auth-password
              Sets the global password for SMTP AUTH.  Both user and password have  to  be  given
              for AUTH LOGIN and AUTH CRAM-MD5.

       smtp-auth-password-user@host
              Overrides  smtp-auth-password for specific values of sender addresses, depending on
              the from variable.

       smtp-auth-user
              Sets the global user name for SMTP AUTH.  Both user and password have to  be  given
              for AUTH LOGIN and AUTH CRAM-MD5.

              If  this  variable  is  set but neither smtp-auth-password or a matching smtp-auth-
              password-user@host can be found, mailx  will  as  for  a  password  on  the  user's
              terminal.

       smtp-auth-user-user@host
              Overrides  smtp-auth-user for specific values of sender addresses, depending on the
              from variable.

       ssl-ca-dir
              Specifies a directory with CA  certificates  for  verification  of  SSL/TLS  server
              certificates.   See  SSL_CTX_load_verify_locations(3)  for  more information.  Only
              applicable if SSL/TLS support is built using OpenSSL.

       ssl-ca-file
              Specifies  a  file  with  CA  certificates  for  verification  of  SSL/TLS   server
              certificates.   See  SSL_CTX_load_verify_locations(3)  for  more information.  Only
              applicable if SSL/TLS support is built using OpenSSL.

       ssl-cert
              Sets the file name for a SSL/TLS client certificate required by some servers.  Only
              applicable if SSL/TLS support is built using OpenSSL.

       ssl-cert-user@host
              Sets  an  account-specific  file  name for a SSL/TLS client certificate required by
              some servers.  Overrides ssl-cert for the specified account.   Only  applicable  if
              SSL/TLS support is built using OpenSSL.

       ssl-cipher-list
              Specifies  a  list  of  ciphers  for  SSL/TLS connections.  See ciphers(1) for more
              information.  Only applicable if SSL/TLS support is built using OpenSSL.

       ssl-crl-file
              Specifies a file that contains a CRL in PEM format to use  when  verifying  SSL/TLS
              server certificates.  Only applicable if SSL/TLS support is built using OpenSSL.

       ssl-crl-dir
              Specifies  a  directory  that  contains  files  with CRLs in PEM format to use when
              verifying SSL/TLS server certificates.  Only applicable if SSL/TLS support is built
              using OpenSSL.

       ssl-key
              Sets  the file name for the private key of a SSL/TLS client certificate.  If unset,
              the name of the certificate file is used.  The  file  is  expected  to  be  in  PEM
              format.  Only applicable if SSL/TLS support is built using OpenSSL.

       ssl-key-user@host
              Sets  an  account-specific  file  name  for  the  private  key  of a SSL/TLS client
              certificate.  Overrides ssl-key for the  specified  account.   Only  applicable  if
              SSL/TLS support is built using OpenSSL.

       ssl-method
              Selects a SSL/TLS protocol version; valid values are `ssl3', and `tls1'.  If unset,
              the method is selected automatically, if possible.

       ssl-method-user@host
              Overrides ssl-method for a specific account.

       ssl-rand-egd
              Gives the pathname to an entropy daemon socket, see RAND_egd(3).

       ssl-rand-file
              Gives the pathname to a file with entropy data, see RAND_load_file(3).  If the file
              is a regular file writable by the invoking user, new data is written to it after it
              has been loaded.  Only applicable if SSL/TLS support is built using OpenSSL.

       ssl-verify
              Sets the  action  to  be  performed  if  an  error  occurs  during  SSL/TLS  server
              certificate  validation.   Valid  values  are  `strict'  (fail and close connection
              immediately), `ask' (ask whether to continue on standard input),  `warn'  (print  a
              warning and continue), `ignore' (do not perform validation).  The default is `ask'.

       ssl-verify-user@host
              Overrides ssl-verify for a specific account.

       toplines
              If  defined,  gives the number of lines of a message to be printed out with the top
              command; normally, the first five lines are printed.

       ttycharset
              The character set of the terminal mailx operates on.  There is normally no need  to
              set  this  variable  since mailx can determine this automatically by looking at the
              LC_CTYPE locale setting; if this succeeds, the value is  assigned  at  startup  and
              will  be  displayed  by  the  set  command.   Note  that  this is not necessarily a
              character set name that can be used in Internet messages.

       VISUAL Pathname of the text editor to use in the visual command and ~v escape.

ENVIRONMENT VARIABLES

       Besides the variables described above, mailx uses the following environment strings:

       HOME   The user's home directory.

       LANG, LC_ALL, LC_COLLATE, LC_CTYPE, LC_MESSAGES
              See locale(7).

       MAILRC Is used as startup file instead of  ~/.mailrc  if  set.   When  mailx  scripts  are
              invoked  on  behalf  of  other users, this variable should be set to `/dev/null' to
              avoid side-effects from reading their configuration files.

       NAILRC If this variable is set and MAILRC is not set, it is read as startup file.

       SYSV3  Changes the letters printed in the first column of a header summary.

       TMPDIR Used as directory for temporary files instead of /tmp, if set.

FILES

       ~/.mailrc
              File giving initial commands.

       /etc/nail.rc
              System wide initialization file.

       ~/.mime.types
              Personal MIME types.

       /etc/mime.types
              System wide MIME types.

EXAMPLES

   Getting started
       The mailx command has two distinct usages, according to  whether  one  wants  to  send  or
       receive mail.  Sending mail is simple: to send a message to a user whose email address is,
       say, <bill@host.example>, use the shell command:

           $ mailx bill@host.example

       then type your message.  Mailx will prompt you for a message subject  first;  after  that,
       lines  typed  by you form the body of the message.  When you reach the end of the message,
       type an EOT (control-d) at the beginning of a line, which will cause mailx to  echo  `EOT'
       and return you to the shell.

       If,  while  you are composing the message you decide that you do not wish to send it after
       all, you can abort the letter with a RUBOUT.  Typing a single RUBOUT causes mailx to print
       `(Interrupt  --  one  more  to kill letter)'.  Typing a second RUBOUT causes mailx to save
       your partial letter on the file `dead.letter' in your home directory and abort the letter.
       Once you have sent mail to someone, there is no way to undo the act, so be careful.

       If  you  want  to  send the same message to several other people, you can list their email
       addresses on the command line.  Thus,

           $ mailx sam@workstation.example bob@server.example
           Subject: Fees
           Tuition fees are due next Friday.  Don't forget!
           <Control-d>
           EOT
           $

       will send the reminder to <sam@workstation.example>.  and <bob@server.example>.

       To read your mail, simply type

           $ mailx

       Mailx will respond by typing its version number and date and then listing the messages you
       have  waiting.   Then  it  will  type  a  prompt and await your command.  The messages are
       assigned numbers starting with 1—you refer to the  messages  with  these  numbers.   Mailx
       keeps  track  of which messages are new (have been sent since you last read your mail) and
       read (have been read by you).  New messages have an N next to them in the  header  listing
       and  old,  but  unread  messages  have a U next to them.  Mailx keeps track of new/old and
       read/unread messages by putting a header field called Status into your messages.

       To look at a specific message, use the type command, which may be abbreviated to simply  t
       .  For example, if you had the following messages:

           O 1 drfoo@myhost.example Wed Sep  1 19:52  18/631 "Fees"
           O 2 sam@friends.example  Thu Sep  2 00:08  30/895

       you could examine the first message by giving the command:

           type 1

       which might cause mailx to respond with, for example:

           Message  1:
           From drfoo@myhost.example Wed Sep  1 19:52:25 2004
           Subject: Fees
           Status: R

           Tuition fees are due next Wednesday.  Don't forget!

       Many mailx commands that operate on messages take a message number as an argument like the
       type command.  For these commands, there is a notion of a current message.  When you enter
       the  mailx  program, the current message is initially the first (or the first recent) one.
       Thus, you can often omit the message number and use, for example,

           t

       to type the current message.  As a further shorthand, you can type  a  message  by  simply
       giving its message number.  Hence,

           1

       would type the first message.

       Frequently, it is useful to read the messages in your mailbox in order, one after another.
       You can read the next message in mailx by simply typing a newline.  As a special case, you
       can type a newline as your first command to mailx to type the first message.

       If,  after  typing a message, you wish to immediately send a reply, you can do so with the
       reply command.  This command, like type, takes a message number  as  an  argument.   mailx
       then  begins  a message addressed to the user who sent you the message.  You may then type
       in your letter in reply, followed by a <control-d> at the beginning of a line, as before.

       Note that mailx copies the subject header from the original message.  This  is  useful  in
       that  correspondence  about  a  particular  matter  will  tend  to retain the same subject
       heading, making it easy to recognize.  If there are other header fields  in  the  message,
       like `Cc:', the information found will also be used.

       Sometimes  you  will  receive  a  message that has been sent to several people and wish to
       reply only to the person who sent it.  Reply with a capital R replies to  a  message,  but
       sends a copy to the sender only.

       If  you wish, while reading your mail, to send a message to someone, but not as a reply to
       one of your messages, you can send the message directly with the mail command, which takes
       as  arguments  the  names  of  the recipients you wish to send to.  For example, to send a
       message to <frank@machine.example>, you would do:

           mail frank@machine.example

       To delete a message from the mail folder, you can use the delete command.  In addition  to
       not  saving  deleted messages, mailx will not let you type them, either.  The effect is to
       make the message disappear altogether, along with its number.

       Many features of mailx can be tailored to your liking  with  the  set  command.   The  set
       command  has  two  forms, depending on whether you are setting a binary option or a valued
       option.  Binary options are either on or off.  For example, the askcc option informs mailx
       that  each  time  you  send a message, you want it to prompt you for a `Cc:' header, to be
       included in the message.  To set the askcc option, you would type

           set askcc

       Valued options are values which mailx uses to adapt to  your  tastes.   For  example,  the
       record option tells mailx where to save messages sent by you, and is specified by

           set record=Sent

       for example.  Note that no spaces are allowed in set record=Sent .

       Mailx  includes  a simple facility for maintaining groups of messages together in folders.
       To use the folder facility, you must tell mailx where you wish to keep your folders.  Each
       folder  of  messages will be a single file.  For convenience, all of your folders are kept
       in a single directory of your choosing.  To tell mailx where your folder directory is, put
       a line of the form

           set folder=letters

       in  your  .mailrc file.  If, as in the example above, your folder directory does not begin
       with a `/', mailx will assume that your folder directory is to be found starting from your
       home directory.

       Anywhere  a  file  name  is  expected,  you can use a folder name, preceded with `+'.  For
       example, to put a message into a folder with the save command, you can use:

           save +classwork

       to save the current message in the classwork folder.  If the classwork folder does not yet
       exist,  it  will be created.  Note that messages which are saved with the save command are
       automatically removed from your system mailbox.

       In order to make a copy of a message in a  folder  without  causing  that  message  to  be
       removed  from  your  system mailbox, use the copy command, which is identical in all other
       respects to the save command.

       The folder command can be used to direct mailx to the contents of a different folder.  For
       example,

           folder +classwork

       directs  mailx to read the contents of the classwork folder.  All of the commands that you
       can use on your system mailbox are also applicable to folders, including type, delete, and
       reply.  To inquire which folder you are currently editing, use simply:

           folder

       To list your current set of folders, use the folders command.

       Finally,  the help command is available to print out a brief summary of the most important
       mailx commands.

       While typing in a message to be sent to others, it is often useful to be  able  to  invoke
       the  text editor on the partial message, print the message, execute a shell command, or do
       some other auxiliary function.  Mailx provides these capabilities through tilde escapes  ,
       which  consist  of  a tilde (~) at the beginning of a line, followed by a single character
       which indicates the function to be performed.  For example,  to  print  the  text  of  the
       message so far, use:

           ~p

       which  will  print  a  line of dashes, the recipients of your message, and the text of the
       message so far.  A list of the most important tilde escapes is available with `~?'.

   IMAP or POP3 client setup
       First you need the following data from your ISP: the host name of the IMAP or POP3 server,
       user  name  and  password  for  this  server, and a notice whether the server uses SSL/TLS
       encryption.  Assuming the host name is `server.myisp.example' and your user name for  that
       server  is `mylogin', you can refer to this account using the folder command or -f command
       line option with

           imaps://mylogin@server.myisp.example

       (This string is not necessarily the same as your Internet mail address.)  You can  replace
       `imaps://'  with `imap://' if the server does not support SSL/TLS.  (If SSL/TLS support is
       built using NSS, the nss-config-dir variable must  be  set  before  a  connection  can  be
       initiated,  see  above).   Use  `pop3s://' or `pop3://' if the server does not offer IMAP.
       You should use IMAP if you can, though; first because it requires fewer network operations
       than  POP3  to  get  the  contents  of  the mailbox and is thus faster; and second because
       message attributes are maintained by the IMAP server, so you can  easily  distinguish  new
       and old messages each time you connect.  Even if the server does not accept IMAPS or POP3S
       connections, it is possible that it supports the STARTTLS method to make a session SSL/TLS
       encrypted  after  the  initial  connection  has  been performed, but before authentication
       begins.  The only reliable method to see if this works is to try it; enter one of

           set imap-use-starttls
           set pop3-use-starttls

       before you initiate the connection.

       As you probably want messages to be deleted from this account after saving them, prefix it
       with  `%:'.   The  shortcut command can be used to avoid typing that many characters every
       time you want to connect:

           shortcut myisp %:imaps://mylogin@server.myisp.example

       You might want to put this string into  a  startup  file.   As  the  shortcut  command  is
       specific to this implementation of mailx and will confuse other implementations, it should
       not be used in ~/.mailrc, instead, put

           set NAIL_EXTRA_RC=~/.nailrc

       in ~/.mailrc and create a file ~/.nailrc containing the shortcut command above.   You  can
       then  access  your  remote mailbox by invoking `mailx -f myisp' on the command line, or by
       executing `fi myisp' within mailx.

       If you want to use more than one IMAP mailbox on a server, or if you want to use the  IMAP
       server  for  mail  storage too, the account command (which is also mailx-specific) is more
       appropriate than the shortcut command.  You can put the following in ~/.nailrc:

           account myisp {
               set folder=imaps://mylogin@server.myisp.example
               set record=+Sent MBOX=+mbox outfolder
           }

       and can then access incoming mail for this account by invoking `mailx  -A  myisp'  on  the
       command line, or by executing `ac myisp' within mailx.  After that, a command like `copy 1
       +otherfolder' will refer to otherfolder on the IMAP server.  In particular,  `fi  &'  will
       change  to  the  mbox  folder, and `fi +Sent' will show your recorded sent mail, with both
       folders located on the IMAP server.

       Mailx will ask you for a password string each time you connect to a  remote  account.   If
       you  can  reasonably trust the security of your workstation, you can give this password in
       the startup file as

           set password-mylogin@server.myisp.example="SECRET"

       You should change the permissions of this file to 0600, see chmod(1).

       Mailx supports different authentication methods for both IMAP and POP3.   If  Kerberos  is
       used at your location, you can try to activate GSSAPI-based authentication by

           set imap-auth=gssapi

       The advantage of this method is that mailx does not need to know your password at all, nor
       needs to send sensitive data over the network.  Otherwise, the options

           set imap-auth=cram-md5
           set pop3-use-apop

       for IMAP and POP3, respectively, offer authentication  methods  that  avoid  to  send  the
       password  in  clear text over the network, which is especially important if SSL/TLS cannot
       be used.  If the server does not offer any of these authentication  methods,  conventional
       user/password  based  authentication  must  be  used.   It is sometimes helpful to set the
       verbose option when authentication problems occur.  Mailx will display all  data  sent  to
       the  server in clear text on the screen with this option, including passwords.  You should
       thus take care that no unauthorized person can look at your terminal when this  option  is
       set.

       If you regularly use the same workstation to access IMAP accounts, you can greatly enhance
       performance by enabling local caching of IMAP messages.  For any  message  that  has  been
       fully  or  partially  fetched  from  the server, a local copy is made and is used when the
       message is accessed again, so most data is transferred over the  network  once  only.   To
       enable the IMAP cache, select a local directory name and put

           set imap-cache=~/localdirectory

       in  the  startup  file.   All files within that directory can be overwritten or deleted by
       mailx at any time, so you should not use the directory to store other information.

       Once the cache contains some messages, it is not strictly  necessary  anymore  to  open  a
       connection  to  the IMAP server to access them.  When mailx is invoked with the -D option,
       or when the disconnected variable is set, only cached data is  used  for  any  folder  you
       open.   Messages  that have not yet been completely cached are not available then, but all
       other messages can be handled as usual.  Changes made to IMAP  mailboxes  in  disconnected
       mode  are committed to the IMAP server next time it is used in online mode.  Synchronizing
       the  local  status  with  the  status  on  the  server  is  thus  partially  within   your
       responsibility;  if  you  forget  to  initiate a connection to the server again before you
       leave your location, changes made on one workstation are not available on others.  Also if
       you alter IMAP mailboxes from a workstation while uncommitted changes are still pending on
       another, the latter data may become invalid.   The  same  might  also  happen  because  of
       internal  server  status changes.  You should thus carefully evaluate this feature in your
       environment before you rely on it.

       Many servers will close the connection after a short period of inactivity. Use one of

           set pop3-keepalive=30
           set imap-keepalive=240

       to send a keepalive message each 30 seconds for POP3, or each 4 minutes for IMAP.

       If you encounter problems connecting to a SSL/TLS server, try the  ssl-rand-egd  and  ssl-
       rand-file  variables  (see  the  OpenSSL FAQ for more information) or specify the protocol
       version with ssl-method.  Contact your  ISP  if  you  need  a  client  certificate  or  if
       verification  of the server certificate fails.  If the failed certificate is indeed valid,
       fetch its CA certificate by executing the shell command

           $ openssl s_client </dev/null -showcerts -connect \
                  server.myisp.example:imaps 2>&1 | tee log

       (see s_client(1)) and put it into the file specified with ssl-ca-file.  The data you  need
       is  located  at  the  end  of  the  certificate  chain  within  (and including) the `BEGIN
       CERTIFICATE' and `END CERTIFICATE' lines.  (Note that it is possible  to  fetch  a  forged
       certificate  by  this  method.  You can only completely rely on the authenticity of the CA
       certificate if you fetch it in a way that is trusted by other means, such as by personally
       receiving the certificate on storage media.)

   Creating a score file or message filter
       The  scoring  commands  are  best  separated from other configuration for clarity, and are
       mostly mailx specific.  It is thus recommended to put them in  a  separate  file  that  is
       sourced from your NAIL_EXTRA_RC as follows:

           source ~/.scores

       The .scores file could then look as follows:

           define list {
               score (subject "important discussion") +10
               score (subject "annoying discussion") -10
               score (from "nicefellow@goodnet") +15
               score (from "badguy@poornet") -5
               move (header x-spam-flag "+++++") +junk
           }
           set folder-hook-imap://user@host/public.list=list

       In  this scheme, you would see any mail from `nicefellow@goodnet', even if the surrounding
       discussion is annoying; but you normally would not see mail from `badguy@poornet',  unless
       he  participates  in the important discussion.  Messages that are marked with five or more
       plus characters in their `X-Spam-Flag'  field  (inserted  by  some  server-side  filtering
       software) are moved to the folder `junk' in the folder directory.

       Be  aware  that  all  criteria  in  ()  lead to substring matches, so you would also score
       messages from e.g. `notsobadguy@poornetmakers' negative here.  It is  possible  to  select
       addresses  exactly  using  "address"  message specifications, but these cannot be executed
       remotely and will thus cause all headers to be downloaded from IMAP servers while  looking
       for matches.

       When searching messages on an IMAP server, best performance is usually achieved by sending
       as many criteria as possible in one large  ()  specification,  because  each  single  such
       specification will result in a separate network operation.

   Activating the Bayesian filter
       The  Bayesian  junk  mail  filter works by examining the words contained in messages.  You
       decide yourself what a good and what a bad message is.  Thus the resulting filter is  your
       very  personal  one;  once it is correctly set up, it will filter only messages similar to
       those previously specified by you.

       To use the Bayesian filter, a location for the junk mail database must be defined first:

           set junkdb=~/.junkdb

       The junk mail database does not contain actual words extracted from messages,  but  hashed
       representations  of  them.   A foreign person who can read the database could only examine
       the frequency of previously known words in your mail.

       If you have sufficient disk space (several 10 MB) available, it is  recommended  that  you
       set  the  chained-junk-tokens option.  The filter will then also consider two-word tokens,
       improving its accuracy.

       A set of good messages and junk messages must now be available; it is also possible to use
       the  incoming  new  messages  for  this purpose, although it will of course take some time
       until the filter becomes useful then.  Do not underestimate the amount of statistical data
       needed;  some  hundred  messages  are typically necessary to get satisfactory results, and
       many thousand messages for best operation.  You have to pass the good messages to the good
       command,  and the junk messages to the junk command.  If you ever accidentally mark a good
       message as junk or vice-versa, call the ungood or unjunk command to correct this.

       Once a reasonable amount of statistics has been collected, new messages can be  classified
       automatically.   The  classify  command marks all messages that the filter considers to be
       junk, but it does not perform any action on them by default.  It is recommended  that  you
       move  these  messages into a separate folder just for the case that false positives occur,
       or to pass them to the junk command later again to further improve the junk mail database.
       To  automatically  move  incoming  junk messages every time the inbox is opened, put lines
       like the following into your .scores file (or whatever name you gave to the  file  in  the
       last example):

           define junkfilter {
               classify (smaller 20000) :n
               move :j +junk
           }
           set folder-hook-imap://user@host/INBOX=junkfilter

       If  you set the verbose option before running the classify command, mailx prints the words
       it uses for calculating the junk status along with their statistical probabilities.   This
       can  help  you  to find out why some messages are not classified as you would like them to
       be.  To see the statistical probability of a given word, use the probability command.

       If a junk message was not recognized as such, use the junk command to correct this.   Also
       if  you  encounter  a false positive (a good message that was wrongly classified as junk),
       pass it to the good command.

       Since the classify command must examine the  entire  text  of  all  new  messages  in  the
       respective folder, this will also cause all of them to be downloaded from the IMAP server.
       You should thus restrict the size of messages for automatic  filtering.   If  server-based
       filtering is also available, you might try if that works for you first.

   Reading HTML mail
       You need either the w3m or lynx utility or another command-line web browser that can write
       plain text to standard output.

           set pipe-text/html="w3m -dump -T text/html"

       or

           set pipe-text/html="lynx -dump -force_html /dev/stdin"

       will then cause HTML message parts to be converted into a more friendly form.

   Viewing PDF attachments
       Most PDF viewers do not accept input directly from a pipe.  It is thus necessary to  store
       the attachment in a temporary file, as with

           set pipe-application/pdf="cat >/tmp/mailx$$.pdf; \
                  acroread /tmp/mailx$$.pdf; rm /tmp/mailx$$.pdf"

       Note  that  security defects are discovered in PDF viewers from time to time.  Automatical
       command execution like this can compromise your system security, in particular if you stay
       not always informed about such issues.

   Signed and encrypted messages with S/MIME
       S/MIME  provides two central mechanisms: message signing and message encryption.  A signed
       message contains some data in addition to the regular text.   The  data  can  be  used  to
       verify  that  the message was sent using a valid certificate, that the sender's address in
       the message header matches that in the certificate, and that the message text has not been
       altered.  Signing a message does not change its regular text; it can be read regardless of
       whether the recipient's software is able to handle S/MIME.  It is thus usually possible to
       sign  all outgoing messages if so desired.—Encryption, in contrast, makes the message text
       invisible for all people except those who have access to the secret  decryption  key.   To
       encrypt  a  message,  the specific recipient's public encryption key must be known.  It is
       thus not possible to send encrypted mail to people unless their  key  has  been  retrieved
       from  either previous communication or public key directories.  A message should always be
       signed before it is encrypted.  Otherwise, it is still possible that the encrypted message
       text is altered.

       A  central  concept  to  S/MIME  is  that  of the certification authority (CA).  A CA is a
       trusted institution that issues certificates.  For each of these certificates, it  can  be
       verified  that it really originates from the CA, provided that the CA's own certificate is
       previously known.  A set  of  CA  certificates  is  usually  delivered  with  OpenSSL  and
       installed  on your system.  If you trust the source of your OpenSSL software installation,
       this offers reasonable security for S/MIME on the Internet.   In  general,  a  certificate
       cannot  be more secure than the method its CA certificate has been retrieved with, though.
       Thus if you download a CA certificate from the Internet, you can only trust  the  messages
       you verify using that certificate as much as you trust the download process.

       The  first  thing  you  need for participating in S/MIME message exchange is your personal
       certificate, including a private key.  The certificate  contains  public  information,  in
       particular  your name and your email address, and the public key that is used by others to
       encrypt messages for you, and to verify signed messages they supposedly received from you.
       The certificate is included in each signed message you send.  The private key must be kept
       secret.  It is used to decrypt messages that were previously encrypted  with  your  public
       key, and to sign messages.

       For  personal  use,  it  is  recommended that you get a S/MIME certificate from one of the
       major CAs on the Internet using your WWW browser.  (Many CAs offer such  certificates  for
       free.)   You will usually receive a combined certificate and private key in PKCS#12 format
       which mailx does not directly accept if S/MIME support is built using OpenSSL.  To convert
       it to PEM format, use the following shell command:

           $ openssl pkcs12 -in cert.p12 -out cert.pem -clcerts \
               -nodes

       If  you  omit  the  -nodes  parameter,  you can specifiy an additional PEM pass phrase for
       protecting the private key.  Mailx will then ask you for that pass  phrase  each  time  it
       signs or decrypts a message.  You can then use

           set smime-sign-cert-myname@myisp.example=cert.pem

       to make this private key and certificate known to mailx.

       If  S/MIME  support  is  built using NSS, the PKCS#12 file must be installed using Mozilla
       (provided that nss-config-dir is set appropriately, see above), and no further  action  is
       necessary  unless multiple user certificates for the same email address are installed.  In
       this case, the smime-sign-nickname variable has to be set appropriately.

       You can now sign outgoing messages.  Just use

           set smime-sign

       to do so.

       From each signed message you send, the recipient can fetch your certificate and use it  to
       send  encrypted mail back to you.  Accordingly if somebody sends you a signed message, you
       can do the same.  First use the verify command to check the validity of  the  certificate.
       After that, retrieve the certificate and tell mailx that it should use it for encryption:

           certsave filename
           set smime-encrypt-user@host=filename

       If  S/MIME  support  is  built  using  NSS,  the saved certificate must be installed using
       Mozilla.  The value of the  smime-encrypt-user@host  is  ignored  then,  but  if  multiple
       certificates  for  the recipient are available, the smime-nickname-user@host variable must
       be set.

       You should carefully consider if you prefer to store encrypted messages in decrypted form.
       If  you  do, anybody who has access to your mail folders can read them, but if you do not,
       you might be unable to read them yourself later if you happen to lose  your  private  key.
       The  decrypt  command  saves  messages  in  decrypted form, while the save, copy, and move
       commands leave them encrypted.

       Note that neither S/MIME signing nor encryption  applies  to  message  subjects  or  other
       header  fields.   Thus  they may not contain sensitive information for encrypted messages,
       and cannot be trusted even if the message content has been verified.  When sending  signed
       messages,  it  is  recommended  to  repeat any important header information in the message
       text.

   Using CRLs with S/MIME or SSL/TLS
       Certification authorities (CAs) issue certificate revocation lists  (CRLs)  on  a  regular
       basis.   These  lists  contain  the serial numbers of certificates that have been declared
       invalid after they have been issued.  Such usually happens because the private key for the
       certificate  has  been  compromised,  because  the  owner  of the certificate has left the
       organization that is mentioned in the  certificate,  etc.   To  seriously  use  S/MIME  or
       SSL/TLS  verification,  an  up-to-date  CRL  is  required  for  each trusted CA.  There is
       otherwise no method to distinguish between  valid  and  invalidated  certificates.   Mailx
       currently  offers  no  mechanism  to fetch CRLs, or to access them on the Internet, so you
       have to retrieve them by some external mechanism.

       If S/MIME and SSL/TLS support are built using OpenSSL, mailx accepts CRLs  in  PEM  format
       only; CRLs in DER format must be converted, e.g. with the shell command

           $ openssl crl -inform DER -in crl.der -out crl.pem

       To tell mailx about the CRLs, a directory that contains all CRL files (and no other files)
       must be created.  The smime-crl-dir or ssl-crl-dir variables, respectively, must  then  be
       set  to  point to that directory.  After that, mailx requires a CRL to be present for each
       CA that is used to verify a certificate.

       If S/MIME and SSL/TLS support are built  using  NSS,  CRLs  can  be  imported  in  Mozilla
       applications (provided that nss-config-dir is set appropriately).

   Sending mail from scripts
       If  you  want  to  send  mail  from scripts, you must be aware that mailx reads the user's
       configuration files by default.  So unless your script  is  only  intended  for  your  own
       personal use (as e.g. a cron job), you need to circumvent this by invoking mailx like

           MAILRC=/dev/null mailx -n

       You  then  need  to create a configuration for mailx for your script.  This can be done by
       either pointing the MAILRC variable to a custom configuration  file,  or  by  passing  the
       configuration  in  environment variables.  Since many of the configuration options are not
       valid shell variables, the env command is useful in this situation.  An  invocation  could
       thus look like

           env MAILRC=/dev/null from=scriptreply@domain smtp=host \
                 smtp-auth-user=login smtp-auth-password=secret \
                 smtp-auth=login mailx -n -s "subject" \
                 -a attachment_file recipient@domain <content_file

SEE ALSO

       fmt(1),  newaliases(1),  openssl(1),  pg(1),  more(1),  vacation(1),  ssl(3),  aliases(5),
       locale(7), mailaddr(7), sendmail(8)

NOTES

       Variables in the environment passed to mailx cannot be unset.

       The character set conversion relies on the iconv(3) function.  Its  functionality  differs
       widely  between  the  various  system  environments mailx runs on.  If the message `Cannot
       convert from a to b' appears, either some characters within the message header or text are
       not  appropriate  for  the  currently  selected  terminal  character  set,  or  the needed
       conversion is not supported by the system.  In the first case, it is necessary to  set  an
       appropriate  LC_CTYPE locale (e.g. en_US) or the ttycharset variable.  In the second case,
       the sendcharsets and ttycharset variables must  be  set  to  the  same  value  to  inhibit
       character  set  conversion.   If  iconv()  is  not available at all, the value assigned to
       sendcharsets must match the character set that is used on the terminal.

       Mailx expects input text to be in Unix format, with lines separated by  newline  (^J,  \n)
       characters  only.   Non-Unix  text  files  that use carriage return (^M, \r) characters in
       addition will be treated as  binary  data;  to  send  such  files  as  text,  strip  these
       characters e. g. by

              tr -d '\015' <input | mailx . . .

       or fix the tools that generate them.

       Limitations  with  IMAP  mailboxes  are:  It  is  not possible to edit messages, but it is
       possible to append them.  Thus to edit a message, create a local  copy  of  it,  edit  it,
       append  it,  and  delete  the  original.   The  line  count for the header display is only
       appropriate if the entire message has been downloaded from the  server.   The  marking  of
       messages as `new' is performed by the IMAP server; use of the exit command instead of quit
       will not cause it to be reset, and if the autoinc/newmail variables  are  unset,  messages
       that arrived during a session will not be in state `new' anymore when the folder is opened
       again.  Also if commands queued in disconnected mode are committed, the IMAP  server  will
       delete the `new' flag for all messages in the changed folder, and new messages will appear
       as unread when it is selected for viewing later.  The `flagged', `answered',  and  `draft'
       attributes  are  usually  permanent,  but some IMAP servers are known to drop them without
       notification.  Message numbers may change with  IMAP  every  time  before  the  prompt  is
       printed  if  mailx is notified by the server that messages have been deleted by some other
       client or process.  In this case, `Expunged n messages' is printed,  and  message  numbers
       may have changed.

       Limitations with POP3 mailboxes are: It is not possible to edit messages, they can only be
       copied and deleted.  The line count for the header display  is  only  appropriate  if  the
       entire  message  has  been  downloaded  from the server.  The status field of a message is
       maintained by the server between connections; some servers do not update it  at  all,  and
       with a server that does, the `exit' command will not cause the message status to be reset.
       The `newmail' command and the `newmail' variable have no effect.  It is  not  possible  to
       rename or to remove POP3 mailboxes.

       If  a  RUBOUT  (interrupt)  is typed while an IMAP or POP3 operation is in progress, mailx
       will wait until the operation can be safely aborted, and will then return to  the  command
       loop and print the prompt again.  When a second RUBOUT is typed while mailx is waiting for
       the operation to complete, the operation itself will be canceled.  In this case, data that
       has not been fetched yet will have to be fetched before the next command can be performed.
       If the canceled operation was using an SSL/TLS encrypted channel,  an  error  in  the  SSL
       transport will very likely result, and the connection is no longer usable.

       As  mailx  is  a  mail  user  agent, it provides only basic SMTP services.  If it fails to
       contact its upstream SMTP server, it will  not  make  further  attempts  to  transfer  the
       message at a later time, and it does not leave other information about this condition than
       an error message on the terminal and a `dead.letter' file.  This is usually not a  problem
       if  the SMTP server is located in the same local network as the computer on which mailx is
       run.  However, care should be taken when using a remote server of  an  ISP;  it  might  be
       better to set up a local SMTP server then which just acts as a proxy.

       Mailx  immediately  contacts the SMTP server (or /usr/lib/sendmail) even when operating in
       disconnected mode.  It would not make much sense for mailx to defer  outgoing  mail  since
       SMTP  servers usually provide much more elaborated delay handling than mailx could perform
       as a client.  Thus the recommended setup for sending  mail  in  disconnected  mode  is  to
       configure  a  local  SMTP  server  such that it sends outgoing mail as soon as an external
       network connection is available again, i.e. to advise it to do that from a network startup
       script.

       The  junk  mail  filter follows the concepts developed by Paul Graham in his articles, ``A
       Plan for Spam'', August 2002, <http://www.paulgraham.com/spam.html>, and ``Better Bayesian
       Filtering'',  January  2003,  <http://www.paulgraham.com/better.html>.  Chained tokens are
       due to a paper by Jonathan A. Zdziarski, ``Advanced Language Classification using  Chained
       Tokens'', February 2004, <http://www.nuclearelephant.com/papers/chained.html>.

       A mail command appeared in Version 1 AT&T Unix.  Berkeley Mail was written in 1978 by Kurt
       Shoens.  This man page is derived from from The Mail Reference Manual  originally  written
       by  Kurt  Shoens.   Heirloom  Mailx  enhancements  are maintained and documented by Gunnar
       Ritter.

       Portions of this text are reprinted and  reproduced  in  electronic  form  from  IEEE  Std
       1003.1,  2003  Edition,  Standard  for Information Technology — Operating System Interface
       (POSIX), The Open Group  Base  Specifications  Issue  6,  Copyright  ©  2001-2003  by  the
       Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of
       any discrepancy between this version and the original IEEE and The  Open  Group  Standard,
       the  original  IEEE  and  The  Open  Group  Standard is the referee document. The original
       Standard   can   be   obtained   online   at   http://www.opengroup.org/unix/online.html .
       Redistribution of this material is permitted so long as this notice remains intact.