lp/cmd/lpforms.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

#include <locale.h>
#include "stdio.h"
#include "errno.h"
#include "string.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "stdlib.h"

#include "lp.h"
#include "access.h"
#include "form.h"
#include "msgs.h"

#define WHO_AM_I    I_AM_LPFORMS
#include "oam.h"

#define OPT_LIST    "f:F:xlLA:u:W:Q:P:d"

#define TMPDIR      "/usr/tmp"

typedef int     (*Action)();

#if defined(__STDC__)

static int  add_form ( char * , FILE * , FALERT * , char * );
static int  add_alert ( char * , FILE * , FALERT * , char * );
static int  delete_form ( char * );
static int  list_form ( char * );
static int  list_alert ( char * );
static int  list_both ( char * );
static int  any_alert ( char * , FILE * , FALERT * );
static int  quiet_alert ( char * );
static int  notify_spooler ( int , int , char * );
static int  onerror ( int , int , int );

static Action   set_action ( int (*)() , char * );

#else

static int  add_form();
static int  add_alert();
static int  delete_form();
static int  list_form();
static int  list_alert();
static int  list_both();
static int  any_alert();
static int  quiet_alert();
static int  notify_spooler();
static int  onerror();

static Action   set_action();

#endif

/**
 ** usage()
 **/

void            usage ()
{
    (void) printf (gettext(
"usage:\n"
"\n"
"  (add or change form)\n"
"    lpforms -f form-name [options]\n"
"   [-F path-name | - | -P paper [-d] | -d ]    (form definition)\n"
"      -F path-name         (initialize from file)\n"
"      -                (initialize from stdin)\n"
"      -P paper [-d]        (initialize with paper (as default))\n"
"      -d               (create form with paper of same name)\n"
"   [-u allow:user-list | deny:user-list]   (who's allowed to use)\n"
"   [-A mail | write | shell-command]  (alert definition)\n"
"   [-Q threshold]          (# needed for alert)\n"
"   [-W interval]           (minutes between alerts)\n"
"\n"
"  (list form)\n"
"    lpforms -f form-name -l\n"
"    lpforms -f form-name -L (verbose for -P forms)\n"
"\n"
"  (delete form)\n"
"    lpforms -f form-name -x\n"
"\n"
"  (define alert for forms with no alert yet)\n"
"    lpforms -f any -A {mail | write | shell-command}\n"
"\n"
"  (define alert for all forms)\n"
"    lpforms -f all -A {mail | write | shell-command}\n"
"\n"
"  (examine alerting)\n"
"    lpforms -f form-name -A list\n"
"\n"
"  (stop alerting)\n"
"    lpforms -f form-name -A quiet      (temporarily)\n"
"    lpforms -f form-name -A none       (for good)"
"\n"
));

    return;
}

static char *P = NULL;
static int d = 0;
static int L = 0;
/**
 ** main()
 **/

int
main(int argc, char *argv[])
{
    extern int      optind;
    extern int      opterr;
    extern int      optopt;

    extern char *       optarg;

    int         c;
    int         cnt = 0;

    char *          form        = 0;
    char *          u       = 0;
    char *          cp;
    char *          rest;
    char            stroptsw[]  = "-X";

    Action          action      = 0;

    FILE            *input      = 0;

    FORM            fbuf;

    FALERT          alert       = { (char *)0, -1, -1 };

    struct stat     statbuf;


    (void) setlocale (LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    if (!is_user_admin()) {
        LP_ERRMSG (ERROR, E_LP_NOTADM);
        exit (1);
    }

    opterr = 0;

    while ((c = getopt(argc, argv, OPT_LIST)) != -1) {

        /*
         * These options take values; "getopt()" passes values
         * that begin with a dash without checking if they're
         * options. If a value is missing, we want to complain
         * about it.
         */
        switch (c) {
        case 'W':
        case 'Q':
            /*
             * These options take numeric values, which might
             * be negative. Negative values are handled later,
             * but here we just screen them.
             */
            (void)strtol (optarg, &rest, 10);
            if (!rest || (!*rest && rest != optarg))
                break;
            /*FALLTHROUGH*/
        case 'f':
        case 'F':
        case 'A':
        case 'u':
            if (!*optarg) {
                stroptsw[1] = c;
                LP_ERRMSG1 (ERROR, E_LP_NULLARG, stroptsw);
                exit (1);
            }
            if (*optarg == '-') {
                stroptsw[1] = c;
                LP_ERRMSG1 (ERROR, E_LP_OPTARG, stroptsw);
                exit (1);
            }
            break;
        }

        switch (c) {

        case 'f':
            if (form)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'f');
            form = optarg;
            if (!syn_name(form)) {
                LP_ERRMSG1 (ERROR, E_LP_NOTNAME, form);
                exit (1);
            } else if (!*form)
                form = NAME_ALL;
            break;

        case 'F':
            if (input)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'F');
            if (!(input = fopen(optarg, "r"))) {
                LP_ERRMSG1 (ERROR, E_FOR_OPEN, optarg);
                exit (1);
            }
            action = set_action(add_form, "-F");
            break;

        case 'A':
            if (STREQU(NAME_LIST, optarg))
                action = set_action(list_alert, "\"-A list\"");

            else if (STREQU(NAME_QUIET, optarg))
                action = set_action(quiet_alert, "\"-A quiet\"");

            else {
                if (STREQU(MAIL, optarg) || STREQU(WRITE, optarg))
                    alert.shcmd = makestr(optarg, " ", getname(), (char *)0);
                else
                    alert.shcmd = strdup(optarg);
                action = set_action(add_alert, "-A");
            }
            break;

        case 'Q':
            if (alert.Q != -1)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'Q');
            if (STREQU(NAME_ANY, optarg))
                alert.Q = 1;
            else {
                alert.Q = strtol(optarg, &rest, 10);
                if (alert.Q < 0) {
                    LP_ERRMSG1 (ERROR, E_LP_NEGARG, 'Q');
                    exit (1);
                }
                if (rest && *rest) {
                    LP_ERRMSG1 (ERROR, E_LP_GARBNMB, 'Q');
                    exit (1);
                }
                if (alert.Q == 0) {
                    LP_ERRMSG1 (ERROR, E_LP_ZEROARG, 'Q');
                    exit (1);
                }
            }
            action = set_action(add_alert, "-Q");
            break;

        case 'W':
            if (alert.W != -1)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'W');
            if (STREQU(NAME_ONCE, optarg))
                alert.W = 0;
            else {
                alert.W = strtol(optarg, &rest, 10);
                if (alert.W < 0) {
                    LP_ERRMSG1 (ERROR, E_LP_NEGARG, 'W');
                    exit (1);
                }
                if (rest && *rest) {
                    LP_ERRMSG1 (ERROR, E_LP_GARBNMB, 'W');
                    exit (1);
                }
            }
            action = set_action(add_alert, "-W");
            break;

        case 'u':
            if (u)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'u');
            u = strdup(optarg);
            action = set_action(add_form, "-u");
            break;

        case 'x':
            action = set_action(delete_form, "-x");
            break;

        case 'L':
            L = 1;
            action = set_action(list_form, "-L");
            break;
        case 'l':
            action = set_action(list_form, "-l");
            break;

        case 'd':
            d = 1;
            action = set_action(add_form, "-d");
            break;

        case 'P':
            if (P)
                LP_ERRMSG1 (WARNING, E_LP_2MANY, 'P');
            action = set_action(add_form, "-P");
            P = strdup(optarg);
            break;

        default:
            if (optopt == '?') {
                usage ();
                exit (0);
            }
            stroptsw[1] = optopt;
            if (strchr(OPT_LIST, optopt))
                LP_ERRMSG1 (ERROR, E_LP_OPTARG, stroptsw);
            else
                LP_ERRMSG1 (ERROR, E_LP_OPTION, stroptsw);
            exit (1);

        }
    }

    if (!form) {
        LP_ERRMSG (ERROR, E_FOR_FORMNAME);
        exit (1);
    }

    if (STREQU(NAME_ANY, form))
        action = set_action(any_alert, "\"-f any\"");

    if (optind < argc && STREQU(argv[optind], "-")) {
        action = set_action(add_form, "-");
        input = stdin;
        optind++;
    }
    if (optind < argc)
        LP_ERRMSG1 (WARNING, E_FOR_EXTRAARG, argv[optind]);

    if (!action) {
        LP_ERRMSG (ERROR, E_FOR_NOACT);
        exit (1);
    }

    if (action == any_alert && STREQU(alert.shcmd, NAME_NONE)) {
        LP_ERRMSG (WARNING, E_FOR_ANYDEL);
        exit (0);
    }

    /*
     * We must have a shell command for the alert if:
     *
     *  (1) we're adding a new form and the -W or -Q options
     *      have been given, or
     *
     *  (2) the -f any option was given.
     */
    if (
        (
            action == add_form
             && !alert.shcmd
             && (alert.Q != -1 || alert.W != -1)
             && !STREQU(NAME_ALL, form)
             && getform(form, &fbuf, (FALERT *)0, (FILE **)0) != 0
        )
         || action == any_alert && !alert.shcmd
    ) {
        LP_ERRMSG (ERROR, E_FOR_NOSHCMDERR);
        return (1);
    }

    if (P && (! STREQU(P,form))) {
        while (P && (cnt++ < 2)) {
            /*
             * two times should do it unless user has edited
             * files directly
             */
            if (getform(P, &fbuf, (FALERT *)0, (FILE **)0) != -1) {
                if (!fbuf.paper) {
                    LP_ERRMSG3(ERROR, E_FOR_ALSO_SEP_FORM,
                        form, P, P);
                    return (1);
                } else if (!STREQU(fbuf.paper, P))
                    P = Strdup(fbuf.paper);
                else
                    break;   /* we found a good paper */
            } else {
                int result;
                int saveD;

                saveD = d;
                d = 1;
                result = ((*action)(P, NULL, &alert, u));
                d = saveD;
                return (result ? result :
                    ((*action)(form, input, &alert, u)));
            }
        }
    }

    if (d && !P)
        P = Strdup(form);

    return ((*action)(form, input, &alert, u));
}

/**
 ** add_alert()
 ** add_form()
 **/

/*
 * "add_alert()" exists just to simplify the checking of mixed
 * options in "set_action()".
 */

static int
#if defined(__STDC__)
add_alert (
    char *          form,
    FILE *          input,
    FALERT *        p_new_alert,
    char *          u
)
#else
add_alert (form, input, new_alert, u)
    char *          form;
    FILE *          input;
    FALERT *        p_new_alert;
    char *          u;
#endif
{
    return (add_form(form, input, p_new_alert, u));
}

static int
#if defined(__STDC__)
add_form (
    char *          form,
    FILE *          input,
    FALERT *        p_new_alert,
    char *          u
)
#else
add_form (form, input, new_alert, u)
    char *          form;
    FILE *          input;
    FALERT *        p_new_alert;
    char *          u;
#endif
{
    int         fld;
    int         which_set[FO_MAX];
    int         new_form    = 0;
    int         nform;
    int         return_code;

    char *          all_list[]  = { NAME_ALL, 0 };
    char **         u_allow     = 0;
    char **         u_deny      = 0;

    FILE *          align_fp    = 0;

    FORM            fbuf;
    FORM            new_fbuf;

    FALERT          alert;


    /*
     * Read the input configuration (if any) and parse it into a form,
     * storing it in the form buffer "fbuf". Keep track of
     * which fields have been given, to avoid overwriting unchanged
     * fields later.
     */
    if (input) {
        for (fld = 0; fld < FO_MAX; fld++)
            which_set[fld] = 0;

        if (rdform(form, &new_fbuf, fileno(input), onerror,
                which_set) == -1) {
            LP_ERRMSG2 (ERROR, E_FOR_UNKNOWN, "(input)", PERROR);
            return (1);
        }
        for (fld = 0; fld < FO_MAX; fld++)
            if (which_set[fld])
                break;
        if (fld >= FO_MAX)
            LP_ERRMSG (WARNING, E_FOR_EMPTYFILE);

        /*
         * Read the alignment pattern (if any) into a temporary
         * file so that it can be used for (potentially) many
         * forms.
         */
        if (which_set[FO_ALIGN]) {

            size_t          n;

            char            buf[BUFSIZ];


            if ((align_fp = tmpfile()) == NULL) {
                LP_ERRMSG (ERROR, E_FOR_CTMPFILE);
                exit (1);
            }

            while ((n = fread(buf, 1, BUFSIZ, input)))
                fwrite (buf, 1, n, align_fp);
        }
    }

    /*
     * Parse the user allow/deny list (if any).
     */
    if (u) {

        char *          cp;
        char *          type;


        type = strtok(u, ":");
        cp = strtok((char *)0, ":");

        if (STREQU(type, NAME_ALLOW) && cp) {
            if (!(u_allow = getlist(cp, LP_WS, LP_SEP)))
                LP_ERRMSG1 (
                    WARNING,
                    E_LP_MISSING,
                    NAME_ALLOW
                );

        } else if (STREQU(type, NAME_DENY) && cp) {
            if (!(u_deny = getlist(cp, LP_WS, LP_SEP)))
                LP_ERRMSG1 (
                    WARNING,
                    E_LP_MISSING,
                    NAME_DENY
                );

        } else {
            LP_ERRMSG (ERROR, E_LP_UALLOWDENY);
            exit (1);
        }
    }

    /*
     * The following loop gets either a particular form or
     * all forms (one at a time). The value of "return_code"
     * controls the loop and is also the value to use in the
     * "return()" at the end.
     */
    nform = 0;
    return_code = -1;
    while (return_code == -1) {

        /*
         * If we are adding/changing a single form, set
         * the loop control to get us out.
         */
        if (!STREQU(NAME_ALL, form))
            return_code = 0;

        nform++;

        if (P) {
            memset ((char *)&fbuf, 0, sizeof(FORM));
            fbuf.name = strdup(form);
            fbuf.plen.val = DPLEN;
            fbuf.plen.sc = 0;
            fbuf.pwid.val = DPWIDTH;
            fbuf.pwid.sc = 0;
            fbuf.lpi.val = DLPITCH;
            fbuf.lpi.sc = 0;
            fbuf.cpi.val = DCPITCH;
            fbuf.cpi.sc = 0;
            fbuf.np = DNP;
            fbuf.chset = strdup(DCHSET);
            fbuf.mandatory = 0;
            fbuf.rcolor = strdup(DRCOLOR);
            fbuf.conttype = strdup(DCONTYP);
            fbuf.paper = P;
            fbuf.isDefault = d;
            alert.shcmd = 0;
            alert.W = alert.Q = -1;
            new_form = 1;

        } else if (getform(form, &fbuf, &alert, (FILE **)0) == -1)
            switch (errno) {

            case ENOENT:
                /*
                 * This is a problem only if it occurs
                 * immediately on trying to get ``all''.
                 */
                if (STREQU(NAME_ALL, form)) {
                    if (nform > 1)
                        return_code = 0;
                    else {
                        LP_ERRMSG (ERROR, E_FOR_NOFORMS);
                        return_code = 1;
                    }
                    continue;
                }

                /*
                 * We're adding a new form,
                 * so set up default values.
                 */
                memset ((char *)&fbuf, 0, sizeof(FORM));
                fbuf.name = strdup(form);
                fbuf.plen.val = DPLEN;
                fbuf.plen.sc = 0;
                fbuf.pwid.val = DPWIDTH;
                fbuf.pwid.sc = 0;
                fbuf.lpi.val = DLPITCH;
                fbuf.lpi.sc = 0;
                fbuf.cpi.val = DCPITCH;
                fbuf.cpi.sc = 0;
                fbuf.np = DNP;
                fbuf.chset = strdup(DCHSET);
                fbuf.mandatory = 0;
                fbuf.rcolor = strdup(DRCOLOR);
                fbuf.conttype = strdup(DCONTYP);
                alert.shcmd = 0;
                alert.W = alert.Q = -1;

                new_form = 1;
                break;

            default:
                /*
                 * Don't know if we'll have a good name
                 * in the "all" case on getting here, so
                 * punt on naming the form in the error
                 * message.
                 */
                LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
                return_code = 1;
                continue;
            }

        /*
         * Copy just those items that were given in the input.
         */
        if (!input && new_form && !P) {
            LP_ERRMSG1 (ERROR, E_LP_NOFORM, form);
            return (1);
        }
        if (input)
            for (fld = 0; fld < FO_MAX; fld++)
                if (which_set[fld]) switch(fld) {

                case FO_PLEN:
                    fbuf.plen = new_fbuf.plen;
                    break;

                case FO_PWID:
                    fbuf.pwid = new_fbuf.pwid;
                    break;

                case FO_CPI:
                    fbuf.cpi = new_fbuf.cpi;
                    break;

                case FO_LPI:
                    fbuf.lpi = new_fbuf.lpi;
                    break;

                case FO_NP:
                    fbuf.np = new_fbuf.np;
                    break;

                case FO_CHSET:
                    fbuf.chset = new_fbuf.chset;
                    fbuf.mandatory = new_fbuf.mandatory;
                    break;

                case FO_RCOLOR:
                    fbuf.rcolor = new_fbuf.rcolor;
                    break;

                case FO_CMT:
                    fbuf.comment = new_fbuf.comment;
                    break;

                case FO_ALIGN:
                    fbuf.conttype = new_fbuf.conttype;
                    rewind (align_fp);
                    break;

                case FO_PAPER:
                    fbuf.paper = new_fbuf.paper;
                    fbuf.isDefault = new_fbuf.isDefault;
                    break;

                }

        /*
         * Set just those alert elements that were given.
         * However, complain about those form(s) that don't have
         * a shell command yet, and none was given, yet -W or -Q
         * were given.
         */
        if (
            !alert.shcmd && !p_new_alert->shcmd
             && (p_new_alert->W != -1 || p_new_alert->Q != -1)
        )
            LP_ERRMSG1 (WARNING, E_FOR_NOSHCMDWARN, fbuf.name);
        else {
            if (p_new_alert->shcmd)
                alert.shcmd = p_new_alert->shcmd;
            if (p_new_alert->Q != -1)
                alert.Q = p_new_alert->Q;
            if (p_new_alert->W != -1)
                alert.W = p_new_alert->W;
        }

        /*
         * Create/update the form.
         */
#define P_FBUF  (new_form || input? &fbuf : (FORM *)0)
        if (putform(fbuf.name, P_FBUF, &alert, &align_fp) == -1) {
            LP_ERRMSG2 (ERROR, E_LP_PUTFORM, fbuf.name, PERROR);
            return_code = 1;
            continue;
        }

        /*
         * Allow/deny users.
         */
        if (new_form && allow_user_form(all_list, fbuf.name) == -1) {
            LP_ERRMSG1 (ERROR, E_LP_ACCESSINFO, PERROR);
            return_code = 1;
            continue;
        }
        if (u_allow && allow_user_form(u_allow, fbuf.name) == -1) {
            LP_ERRMSG1 (ERROR, E_LP_ACCESSINFO, PERROR);
            return_code = 1;
            continue;
        }
        if (u_deny && deny_user_form(u_deny, fbuf.name) == -1) {
            LP_ERRMSG1 (ERROR, E_LP_ACCESSINFO, PERROR);
            return_code = 1;
            continue;
        }

        notify_spooler (S_LOAD_FORM, R_LOAD_FORM, fbuf.name);

    }

    if (align_fp)
        close_lpfile (align_fp);

    return (return_code);
}

/**
 ** list_form()
 ** list_alert()
 ** list_both()
 **/

#if defined(__STDC__)

static int  list ( char * , void (*)() );
static void _list_form ( FORM * , FALERT * , FILE * );
static void _list_alert ( FORM * , FALERT * );
static void _list_both ( FORM * , FALERT * , FILE * );

#else

static int  list();
static void _list_form();
static void _list_alert();
static void _list_both();

#endif

static int
#if defined(__STDC__)
list_form (
    char            *form
)
#else
list_form (form)
    char            *form;
#endif
{
    return (list(form, _list_form));
}

static int
#if defined(__STDC__)
list_alert (
    char            *form
)
#else
list_alert (form)
    char            *form;
#endif
{
    return (list(form, _list_alert));
}

static int
#if defined(__STDC__)
list_both (
    char            *form
)
#else
list_both (form)
    char            *form;
#endif
{
    return (list(form, _list_both));
}

static int
#if defined(__STDC__)
list (
    char            *form,
    void            (*subaction)()
)
#else
list (form, subaction)
    char            *form;
    void            (*subaction)();
#endif
{
    FORM            fbuf;

    FALERT          alert;

    FILE *          align_fp;

    char            *nl;


    if (STREQU(NAME_ALL, form)) {

        nl = "";
        while (getform(form, &fbuf, &alert, &align_fp) == 0) {
            printf (gettext("%sForm name: %s\n"), nl, fbuf.name);
            (*subaction) (&fbuf, &alert, align_fp);
            nl = "\n";
        }

        switch (errno) {
        case ENOENT:
            return (0);
        default:
            /*
             * Don't know if we'll have a good name
             * in the "all" case on getting here, so
             * punt on naming the form in the error
             * message.
             */
            LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
            return (1);
        }

    } else {

        if (getform(form, &fbuf, &alert, &align_fp) == 0) {
            (*subaction) (&fbuf, &alert, align_fp);
            return (0);
        }

        switch (errno) {
        case ENOENT:
            LP_ERRMSG1 (ERROR, E_LP_NOFORM, form);
            return (1);
        default:
            LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
            return (1);
        }

    }
}

/**
 ** _list_form()
 **/

static void
#if defined(__STDC__)
_list_form (
    FORM *          pf,
    FALERT *        palert,
    FILE *          align_fp
)
#else
_list_form (pf, palert, align_fp)
    FORM *          pf;
    FALERT *        palert;
    FILE *          align_fp;
#endif
{
    size_t          n;

    char            buf[BUFSIZ];

    int         which_set[FO_MAX];
    int         fld,whichVal;


    whichVal = (pf->paper && (L == 0) ? 0 : 1);
    for (fld = 0; fld < FO_MAX; fld++)
        which_set[fld] = whichVal;
    if (!align_fp)
        which_set[FO_ALIGN] = 0;
    if (pf->paper)
        which_set[FO_PAPER] = 1;
    wrform (pf->name, pf, 1, onerror, which_set);
    if (align_fp)
        while ((n = fread(buf, 1, BUFSIZ, align_fp)))
            write (1, buf, n);
}

/**
 ** _list_alert()
 **/

static void
#if defined(__STDC__)
_list_alert (
    FORM *          ignore,
    FALERT *        palert
)
#else
_list_alert (ignore, palert)
    FORM *          ignore;
    FALERT *        palert;
#endif
{
    printalert (stdout, palert, 0);
}

/**
 ** _list_both()
 **/

static void
#if defined(__STDC__)
_list_both (
    FORM *          pf,
    FALERT *        palert,
    FILE *          align_fp
)
#else
_list_both (pf, palert, align_fp)
    FORM *          pf;
    FALERT *        palert;
    FILE *          align_fp;
#endif
{
    _list_alert (pf, palert);
    _list_form (pf, palert, align_fp);
}

/**
 ** any_alert()
 **/

static int
#if defined(__STDC__)
any_alert (
    char *          form,
    FILE *          ignore,
    FALERT *        p_new_alert
)
#else
any_alert (form, ignore, p_new_alert)
    char *          form;
    FILE *          ignore;
    FALERT *        p_new_alert;
#endif
{
    FORM            fbuf;

    FALERT          alert;


    while (getform(NAME_ALL, &fbuf, &alert, (FILE **)0) == 0)
        if (!alert.shcmd)
            if (putform(fbuf.name, (FORM *)0, p_new_alert, (FILE **)0) == -1) {
                LP_ERRMSG2 (ERROR, E_LP_PUTFORM, fbuf.name, PERROR);
                return (1);
            }

    return (0);
}

/**
 ** delete_form()
 ** quiet_alert()
 **/

#if defined(__STDC__)

static int  dq ( char * , int (*)() );
static int  _delete_form ( char * );
static int  _quiet_alert ( char * );

#else

static int  dq();
static int  _delete_form();
static int  _quiet_alert();

#endif

static int
#if defined(__STDC__)
delete_form (
    char            *form
)
#else
delete_form (form)
    char            *form;
#endif
{
    return (dq(form, _delete_form));
}

static int
#if defined(__STDC__)
quiet_alert (
    char *          form
)
#else
quiet_alert (form)
    char *          form;
#endif
{
    return (dq(form, _quiet_alert));
}

static int
#if defined(__STDC__)
dq (
    char            *form,
    int         (*subaction)()
)
#else
dq (form, subaction)
    char            *form;
    int         (*subaction)();
#endif
{
    FORM            fbuf;


    if (STREQU(NAME_ANY, form) || STREQU(NAME_NONE, form)) {
        LP_ERRMSG (ERROR, E_FOR_ANYNONE);
        exit (1);
    }

    if (STREQU(NAME_ALL, form)) {

        while (getform(form, &fbuf, (FALERT *)0, (FILE **)0) == 0)
            if ((*subaction)(fbuf.name) == 1)
                return (1);

        switch (errno) {
        case ENOENT:
            return (0);
        default:
            /*
             * Don't know if we'll have a good name
             * in the "all" case on getting here, so
             * punt on naming the form in the error
             * message.
             */
            LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
            return (1);
        }

    } else {

        if (getform(form, &fbuf, (FALERT *)0, (FILE **)0) == 0)
            return ((*subaction)(fbuf.name));

        switch (errno) {
        case ENOENT:
            LP_ERRMSG1 (ERROR, E_LP_NOFORM, form);
            return (1);
        default:
            LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
            return (1);
        }
    }
}

static int
#if defined(__STDC__)
_delete_form (
    char            *form
)
#else
_delete_form (form)
    char            *form;
#endif
{
    switch (notify_spooler(S_UNLOAD_FORM, R_UNLOAD_FORM, form)) {

    case -1:
        if (anyrequests()) {
            LP_ERRMSG (ERROR, E_FOR_MOPENREQX);
            return (1);
        }
        /*FALLTHROUGH*/

    case MNODEST:
        if (delform(form) == -1) {
            if (errno == ENOENT) {
                LP_ERRMSG1 (ERROR, E_LP_NOFORM, form);
                return (1);
            } else {
                LP_ERRMSG2 (
                    ERROR,
                        E_FOR_UNKNOWN,
                    form,
                    PERROR
                );
                return (1);
            }
        }
        break;

    case MOK:
        if (delform(form) == -1) {
                LP_ERRMSG (ERROR, E_FOR_DELSTRANGE);
            return (1);
        }
        break;
    }
    return (0);
}

static int
#if defined(__STDC__)
_quiet_alert (
    char *          form
)
#else
_quiet_alert (form)
    char *          form;
#endif
{
    char            *msgbuf;

    int         mtype;

    int         size;

    short           status;

    /*
     * If the attempt to open a message queue to the
     * Spooler fails, assume it isn't running and just
     * return--don't say anything, `cause the user may
     * know. Any other failure deserves an error message.
     */

    if (mopen() == -1)
        return (0);

    size = putmessage (NULL, S_QUIET_ALERT, form, QA_FORM);
    msgbuf = malloc(size);
    putmessage (msgbuf, S_QUIET_ALERT, form, QA_FORM);

    if (msend(msgbuf) == -1) {
        LP_ERRMSG (ERROR, E_LP_MSEND);
        mclose ();
        return (1);
    }

    if (mrecv(msgbuf, size) == -1) {
        LP_ERRMSG (ERROR, E_LP_MRECV);
        mclose ();
        return (1);
    }

    mtype = getmessage(msgbuf, R_QUIET_ALERT, &status);
    free (msgbuf);
    mclose ();
    if (mtype != R_QUIET_ALERT) {
        LP_ERRMSG (ERROR, E_LP_BADREPLY);
        return (1);
    }

    switch (status) {

    case MOK:
        break;

    case MNODEST:   /* not quite, but not a lie either */
    case MERRDEST:
        LP_ERRMSG1 (WARNING, E_LP_NOQUIET, form);
        break;

    case MNOPERM:   /* taken care of up front */
    default:
        LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, status);
        return (1);
        /*NOTREACHED*/
    }

    return (0);
}

/**
 ** set_action() - CHECK FOR AMBIGUOUS ACTIONS
 **/

static Action
#if defined(__STDC__)
set_action (
    Action          action,
    char *          option
)
#else
set_action (action, option)
    Action          action;
    char *          option;
#endif
{
    static Action       prev_action = 0;

    static char *       prev_option;


    if (
        action == list_form && prev_action == list_alert
         || action == list_alert && prev_action == list_form
    )
        action = list_both;

    else if (
        action == add_form && prev_action == add_alert
         || action == add_alert && prev_action == add_form
    )
        action = add_form;

    else if (
        action == any_alert && prev_action == add_alert
         || action == add_alert && prev_action == any_alert
    )
        action = any_alert;

    else if (prev_action && prev_action != action) {
        LP_ERRMSG2 (ERROR, E_LP_AMBIG, option, prev_option);
        exit (1);
    }

OK: prev_action = action;
    prev_option = option;
    return (action);
}

/**
 ** notify_spooler() - NOTIFY SPOOLER OF ACTION ON FORMS DB
 **/

static int
#if defined(__STDC__)
notify_spooler (
    int         sendmsg,
    int         replymsg,
    char *          form
)
#else
notify_spooler (sendmsg, replymsg, form)
    int         sendmsg;
    int         replymsg;
    char *          form;
#endif
{
    char *          msgbuf;

    int         mtype;
    int         size;

    short           status;

    /*
     * If the attempt to open a message queue to the
     * Spooler fails, assume it isn't running and just
     * return--don't say anything, `cause the user may
     * know. Any other failure deserves an error message.
     */

    if (mopen() == -1)
        return (-1);

    size = putmessage((char *)0, sendmsg, form);
    msgbuf = malloc(size);
    putmessage (msgbuf, sendmsg, form);

    if (msend(msgbuf) == -1) {
        LP_ERRMSG (ERROR, E_LP_MSEND);
        mclose ();
        exit (1);
    }
    if (mrecv(msgbuf, size) == -1) {
        LP_ERRMSG (ERROR, E_LP_MRECV);
        mclose ();
        exit (1);
    }
    mclose ();

    mtype = getmessage(msgbuf, replymsg, &status);
    free (msgbuf);
    if (mtype != replymsg) {
        LP_ERRMSG (ERROR, E_LP_BADREPLY);
        exit (1);
    }

    if (status == MOK)
        return (MOK);

    if (sendmsg == S_LOAD_FORM)
        switch (status) {
        case MNOSPACE:
            LP_ERRMSG (ERROR, E_FOR_NOSPACE);
            break;
        case MNOPERM:
            LP_ERRMSG (ERROR, E_LP_NOTADM);
            break;

        /*
         * The following two error conditions should have
         * already been trapped, so treat them as bad status
         * should they occur.
         */
        case MNODEST:
        case MERRDEST:
        default:
            LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, status);
            break;
        }

    if (sendmsg == S_UNLOAD_FORM)
        switch (status) {
        case MBUSY:
            LP_ERRMSG1 (ERROR, E_FOR_FORMBUSY, form);
            break;
        case MNODEST:
            return (MNODEST);
        case MNOPERM:
            LP_ERRMSG (ERROR, E_LP_NOTADM);
            break;
        default:
            LP_ERRMSG (ERROR, E_LP_BADSTATUS);
            break;
        }

    exit (1);
}

/**
 ** onerror()
 **/

static int
#if defined(__STDC__)
onerror (
    int         Errno,
    int         lp_errno,
    int         linenum
)
#else
onerror (Errno, lp_errno, linenum)
    int         Errno;
    int         lp_errno;
    int         linenum;
#endif
{
    static int      nerrors = 0;


    if (Errno == EBADF) {
        switch (lp_errno) {
        case LP_EBADSDN:
            LP_ERRMSG1 (WARNING, E_FOR_BADSCALE, linenum);
            break;
        case LP_EBADINT:
            LP_ERRMSG1 (WARNING, E_FOR_BADINT, linenum);
            break;
        case LP_EBADNAME:
            LP_ERRMSG1 (WARNING, E_FOR_NOTNAME, linenum);
            break;
        case LP_EBADARG:
            LP_ERRMSG1 (WARNING, E_FOR_BADCHSETQUALIFIER, linenum);
            break;
        case LP_ETRAILIN:
            LP_ERRMSG1 (WARNING, E_FOR_TRAILIN, linenum);
            break;
        case LP_EBADCTYPE:
            LP_ERRMSG1 (WARNING, E_FOR_NOTCTYPE, linenum);
            break;
        case LP_EBADHDR:
            LP_ERRMSG1 (WARNING, E_FOR_BADHDR, linenum);
            break;
        }
        if (nerrors++ >= 5) {
            LP_ERRMSG (ERROR, E_LP_GARBAGE);
            return (-1);
        }
        return (0);
    } else {
        LP_ERRMSG2 (ERROR, E_FOR_UNKNOWN, "(stdin)", PERROR);
        return (-1);
    }
}