cmd/mailx/main.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2010 The Regents of the University of California an*
*                                                                      *
* Redistribution and use in source and binary forms, with or           *
* without modification, are permitted provided that the following      *
* conditions are met:                                                  *
*                                                                      *
*    1. Redistributions of source code must retain the above           *
*       copyright notice, this list of conditions and the              *
*       following disclaimer.                                          *
*                                                                      *
*    2. Redistributions in binary form must reproduce the above        *
*       copyright notice, this list of conditions and the              *
*       following disclaimer in the documentation and/or other         *
*       materials provided with the distribution.                      *
*                                                                      *
*    3. Neither the name of The Regents of the University of California*
*       names of its contributors may be used to endorse or            *
*       promote products derived from this software without            *
*       specific prior written permission.                             *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND               *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,          *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF             *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE             *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS    *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,             *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED      *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        *
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    *
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,      *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY       *
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE              *
* POSSIBILITY OF SUCH DAMAGE.                                          *
*                                                                      *
* Redistribution and use in source and binary forms, with or without   *
* modification, are permitted provided that the following conditions   *
* are met:                                                             *
* 1. Redistributions of source code must retain the above copyright    *
*    notice, this list of conditions and the following disclaimer.     *
* 2. Redistributions in binary form must reproduce the above copyright *
*    notice, this list of conditions and the following disclaimer in   *
*    the documentation and/or other materials provided with the        *
*    distribution.                                                     *
* 3. Neither the name of the University nor the names of its           *
*    contributors may be used to endorse or promote products derived   *
*    from this software without specific prior written permission.     *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"    *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED    *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A      *
* PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS    *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF     *
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND  *
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT   *
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *
* SUCH DAMAGE.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Mail -- a mail program
 *
 * Startup -- interface with user.
 */

#include "mailx.h"

#if _PACKAGE_ast

#include "stamp.h"

static const char usage[] =
"[-?" STAMP "]"
USAGE_LICENSE
"[+NAME?mailx - send and receive mail]"
"[+DESCRIPTION?\bmailx\b is a mail processing command. The options place"
"   \bmailx\b in either \asend\a or \areceive\a mode. Send mode composes"
"   and sends messages from text on the standard input. Receive mode"
"   provides both an interactive command language and non-interactive"
"   command line actions. Receive mode, on startup, reads commands and"
"   variable settings from the file \b$HOME/.mailrc\b, if it exists.]"
"[+?\bmailx\b provides commands for saving, deleting and responding to"
"   messages. Message composition supports editing, reviewing and"
"   other modifications as the message is entered.]"
"[+?Incoming mail is stored in one or more unspecified locations for each"
"   user, collectively called the system mailbox for that user. When"
"   \bmailx\b is invoked in \areceive\a mode, the system mailbox is"
"   searched by default.]"
"[+?For additional help run \bmailx\b with no options or operands,"
"   and then enter the \bhelp\b command at the interactive prompt.]"
"[A:articles?Treat mail folders as netnews article.]"
"[F:followup?Automatically include the previous message (followup) text"
"   when composing a reply.]"
"[H:headers?List all headers and exit.]"
"[I:interactive?Force interactive receive mode.]"
"[N!:list-headers?List a screen of headers on receive mode startup.]"
"[P:pipe?Coprocess receive mode from a pipe.]"
"[Q:query?List the status character and sender address for the \acount\a"
"   most recent messages, one line per message, and exit. See \b--status\b"
"   for message status characters details.]:[count]"
"[S:status?List the status character and sender address for all messages,"
"   one line per message, and exit. The message status characters are:]{"
"       [M?To be saved in \bmbox\b and marked for delete on exit.]"
"       [N?New message.]"
"       [P?Preserved and will not be deleted.]"
"       [R?Already read.]"
"       [U?Unread message from previous session.]"
"       [X?Possible spam.]"
"       [\b*\b?Saved to a folder and marked for delete on exit.]"
"}"
"[T:oldnews?Read/deleted netnews article names are appended to \afile\a]:[file]"
"[b:bcc?Prompt for the blind carbon copy recipient list when composing"
"   messages.]"
"[c:cc?Prompt for the carbon copy recipient list when composing messages.]"
"[d:debug?Enable implementation specific debug output.]"
"[e:check?Silently exit 0 if there is mail, 1 otherwise.]"
"[f:folder?Mail is read from \afolder\a instead of the default"
"   user mailbox.]:?[folder:=$HOME/mbox]"
"[i:ignore-interrupts?Ignore interrupts.]"
"[n!:master?Read commands from \b/etc/mailx.rc\b on receive mode startup.]"
"[o:set?Set \aname\a=\avalue\a options. The interactive mail command"
"   \bhelp set all\b lists details for each option.]:[name=value]"
"[r:address?Set the reply to header address to \aaddress\a.]:[address]"
"[s:subject?The non-interactive send mode subject text.]:[text]"
"[t:sendheaders?Check for headers in send mode message text.]"
"[u:user?Pretend to be this \buser\b in send mode. For debugging.]:[user]"
"[v:verbose?Enable implementation specific send mode verbose trace.]"
"\n"
"\n[ address ... ]\n"
"\n"
"[+SEE ALSO?\b/bin/mail\b(1), \bMail\b(1)]"
;

#undef  optarg
#define optarg      opt_info.arg
#undef  optnum
#define optnum      opt_info.num
#undef  optind
#define optind      opt_info.index

#undef  getopt
#define getopt(c,v,u)   optget(v,u)

#else

static const char usage[] = "AFHINPQ:ST:b:c:defino:r:s:tu:v";

#endif

/*
 * Interrupt printing of the headers.
 */
static void
hdrstop(int sig)
{
    note(0, "\nInterrupt");
    longjmp(state.jump.header, sig);
}

/*
 * Set command line options and append to
 * op list for resetopt() after the rc's.
 */
static struct list*
setopt(register struct list* op, char* s, char* v)
{
    int     n;
    struct argvec   vec;

    n = strlen(s) + 1;
    if (v)
        n += strlen(v) + 1;
    if (!(op->next = newof(0, struct list, 1, n)))
        note(PANIC, "Out of space");
    op = op->next;
    s = strcopy(op->name, s);
    if (v) {
        *s++ = '=';
        strcpy(s, v);
    }
    state.onstack++;
    initargs(&vec);
    getargs(&vec, op->name);
    if (endargs(&vec) > 0) {
        state.cmdline = 1;
        set(vec.argv);
        state.cmdline = 0;
    }
    sreset();
    state.onstack--;
    return op;
}

/*
 * Reset the setopt() options after the rc's.
 */
static void
resetopt(register struct list* op)
{
    register struct list*   np;
    struct argvec       vec;

    np = op->next;
    while (op = np) {
        initargs(&vec);
        getargs(&vec, op->name);
        if (endargs(&vec) > 0) {
            state.cmdline = 1;
            set(vec.argv);
            state.cmdline = 0;
        }
        sreset();
        np = op->next;
        free(op);
    }
}

int
main(int argc, char** argv)
{
    register int    i;
    int     sig;
    char*       ef;
    int     flags = 0;
    sig_t       prevint;
    struct header   head;
    struct list options;
    struct list*    op;
#if _PACKAGE_ast
    int     fatal = 0;
#endif

#if _PACKAGE_ast
    error_info.id = "mailx";
#endif

    /*
     * Set up a reasonable environment.
     * Figure out whether we are being run interactively,
     * and so forth.
     */
    memset(&head, 0, sizeof(head));
    (op = &options)->next = 0;
    if (!(state.path.buf = sfstropen()) || !(state.path.move = sfstropen()) || !(state.path.part = sfstropen()) || !(state.path.temp = sfstropen()))
        note(FATAL, "out of space");
    varinit();
    /*
     * Now, determine how we are being used.
     * We successively pick off - flags.
     * If there is anything left, it is the base of the list
     * of users to mail to.  Argp will be set to point to the
     * first of these users.
     */
    ef = 0;
    opterr = 0;
    for (;;) {
        switch (getopt(argc, argv, usage)) {
        case 0:
        case EOF:
            break;
        case 'A':
            op = setopt(op, "news", NiL);
            continue;
        case 'F':
            flags |= FOLLOWUP;
            continue;
        case 'H':
            /*
             * List all headers and exit.
             */
            op = setopt(op, "justheaders", NiL);
            state.var.quiet = state.on;
            continue;
        case 'I':
            /*
             * We're interactive
             */
            op = setopt(op, "interactive", NiL);
            continue;
        case 'N':
            /*
             * Avoid initial header printing.
             */
            op = setopt(op, "noheader", NiL);
            state.var.quiet = state.on;
            continue;
        case 'P':
            /*
             * Coprocess on pipe.
             */
            op = setopt(op, "coprocess", NiL);
            continue;
        case 'Q':
            /*
             * List all n most recent status and senders and exit.
             */
            op = setopt(op, "justfrom", optarg);
            state.var.quiet = state.on;
            continue;
        case 'S':
            /*
             * List all status and senders and exit.
             */
            op = setopt(op, "justfrom", "-1");
            state.var.quiet = state.on;
            continue;
        case 'T':
            /*
             * Next argument is temp file to write which
             * articles have been read/deleted for netnews.
             */
            op = setopt(op, "news", optarg);
            continue;
        case 'b':
            /*
             * Get Blind Carbon Copy Recipient list
             */
            extract(&head, GBCC|GMETOO, optarg);
            continue;
        case 'c':
            /*
             * Get Carbon Copy Recipient list
             */
            extract(&head, GCC|GMETOO, optarg);
            continue;
        case 'd':
            /*
             * Debug output.
             */
            op = setopt(op, "debug", NiL);
            continue;
        case 'e':
            /*
             * Silently exit 0 if mail, 1, otherwise.
             */
            op = setopt(op, "justcheck", NiL);
            state.var.quiet = state.on;
            continue;
        case 'f':
#if _PACKAGE_ast
            if (!(ef = opt_info.arg))
                ef = "&";
#else
            /*
             * User is specifying file to "edit" with Mail,
             * as opposed to reading system mailbox.
             * If no argument is given after -f, we read his
             * mbox file.
             *
             * getopt() can't handle optional arguments, so here
             * is an ugly hack to get around it.
             */
            if (argv[optind] && argv[optind][0] != '-')
                ef = argv[optind++];
            else
                ef = "&";
#endif
            continue;
        case 'i':
            /*
             * User wants to ignore interrupts.
             * Set the variable "ignore"
             */
            op = setopt(op, "ignore", NiL);
            continue;
        case 'n':
            /*
             * User doesn't want to source state.var.master
             */
            op = setopt(op, "nomaster", NiL);
            continue;
        case 'o':
            /*
             * Set option(s) by name.
             */
            op = setopt(op, optarg, NiL);
            continue;
        case 'r':
            /*
             * Set replyto.
             */
            {
                char*           s;
                int         n;

                static const char   h[] = "fixedheaders=Reply-To:\" \"";

                n = strlen(optarg);
                if (!(s = newof(0, char, n + sizeof(h) + 1, 0)))
                    note(PANIC, "Out of space");
                memcpy(s, h, sizeof(h) - 1);
                memcpy(s + sizeof(h) - 1, optarg, n);
                op = setopt(op, s, NiL);
            }
            continue;
        case 's':
            /*
             * Give a subject field for sending from
             * non terminal
             */
            if (head.h_subject = optarg)
                head.h_flags |= GSUB;
            continue;
        case 't':
            /*
             * Check for headers in message text.
             */
            op = setopt(op, "sendheaders", optarg);
            state.mode = SEND;
            continue;
        case 'u':
            /*
             * Next argument is person to pretend to be.
             */
            op = setopt(op, "user", optarg);
            continue;
        case 'v':
            /*
             * Send mailer verbose flag
             */
            op = setopt(op, "verbose", NiL);
            continue;
#if _PACKAGE_ast
        case '?':
            error(ERROR_USAGE|4, "%s", opt_info.arg);
            break;
        case ':':
            error(2, "%s", opt_info.arg);
            fatal = 1;
            break;
#else
        case '?':
            note(FATAL, "\
Usage: mail [-o [no]name[=value]] [-s subject] [-c cc] [-b bcc] to ...\n\
       mail [-o [no]name[=value]] [-f [folder]]");
            break;
#endif
        }
        break;
    }
#if _PACKAGE_ast
    if (fatal)
        error(ERROR_USAGE|4, "%s", optusage(NiL));
#endif
    for (i = optind; (argv[i]) && (*argv[i] != '-'); i++)
        extract(&head, GTO|GMETOO, argv[i]);
    if (argv[i])
        head.h_options = argv;
    if (!state.mode)
        state.mode = (head.h_flags & GTO) ? SEND : RECEIVE;
    /*
     * Check for inconsistent arguments.
     */
    if (state.mode == RECEIVE && (head.h_flags & GSTD)) {
        if (!state.var.sendheaders)
            note(FATAL|IDENTIFY, "You must specify direct recipients with -s, -c, or -b");
        state.mode = SEND;
    }
    if (state.mode == RECEIVE)
        state.var.receive = state.on;
    if (state.mode == SEND && ef)
        note(FATAL|IDENTIFY, "Cannot give -f and people to send to");
    if (state.var.justcheck && state.mode == SEND)
        exit(1);
    tempinit();
    state.input = stdin;
    /*
     * Up to this point salloc()==malloc() by default.
     * From now on salloc() space cleared by sreset().
     */
    state.onstack = 1;
    if (state.var.master)
        load(expand(state.var.master, 1));
    /*
     * Expand returns a savestr, but load only uses the file name
     * for fopen, so it's safe to do this.
     */
    load(expand(state.var.mailrc, 1));
    /*
     * Reset command line options so they take precedence over the rc's.
     */
    resetopt(&options);
    if (state.mode == SEND) {
        sendmail(&head, flags);
        /*
         * why wait?
         */
        exit(state.senderr);
    }
    /*
     * Ok, we are reading mail.
     * Decide whether we are editing a mailbox or reading
     * the system mailbox, and open up the right stuff.
     */
    if (!ef)
        ef = "%";
    if (setfolder(ef) < 0)
        exit(1);
    if (sig = setjmp(state.jump.header))
        resume(sig);
    else {
        if ((prevint = signal(SIGINT, SIG_IGN)) != SIG_IGN)
            signal(SIGINT, hdrstop);
        if (!state.var.quiet)
            note(0, "Mail version %s.  Type ? for help", state.version);
        announce();
        fflush(stdout);
        signal(SIGINT, prevint);
    }
    if (!state.var.justheaders) {
        commands();
        signal(SIGHUP, SIG_IGN);
        signal(SIGINT, SIG_IGN);
        signal(SIGQUIT, SIG_IGN);
        quit();
    }
    exit(0);
}