/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2006 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        "dispatch.h"
#include <syslog.h>
#include <time.h>

char *showForms(PSTATUS *);

/*
 * untidbit_all() - CALL untidbit() FOR A LIST OF TYPES
 */

static void
untidbit_all (char **printer_types)
{
        char **                 pl;

        for (pl = printer_types; *pl; pl++)
                untidbit (*pl);
        return;
}

/*
 * s_load_printer()
 */

void
s_load_printer(char *m, MESG *md)
{
        char                    *printer;
        ushort                  status;
        register PRINTER        *pp;
        register PSTATUS        *pps;
        char **paperDenied;

        (void) getmessage(m, S_LOAD_PRINTER, &printer);
        syslog(LOG_DEBUG, "s_load_printer(%s)", (printer ? printer : "NULL"));

        if (!*printer)
                /* no printer */
                status = MNODEST;
        else if (!(pp = Getprinter(printer))) {
                /* Strange or missing printer? */
                switch (errno) {
                case EBADF:
                        status = MERRDEST;
                        break;
                case ENOENT:
                default:
                        status = MNODEST;
                        break;
                }
        } else if ((pps = search_pstatus(printer))) {
                /* Printer we know about already? */
                PRINTER *op = pps->printer;

                pps->printer = pp;

                /*
                 * Ensure that an old Terminfo type that's no longer
                 * needed gets freed, and that an existing type gets
                 * reloaded (in case it has been changed).
                 */
                untidbit_all (op->printer_types);
                untidbit_all (pp->printer_types);

                /*
                 * Does an alert get affected?
                 *      - Different command?
                 *      - Different wait interval?
                 */
                if (pps->alert->active)
                        if (!SAME(pp->fault_alert.shcmd,
                                  op->fault_alert.shcmd) ||
                            pp->fault_alert.W != op->fault_alert.W) {
                                /*
                                 * We can't use "cancel_alert()" here
                                 * because it will remove the message.
                                 * We'll do half of the cancel, then
                                 * check if we need to run the new alert,
                                 * and remove the message if not.
                                 */
                                pps->alert->active = 0;
                                terminate (pps->alert->exec);
                                if (pp->fault_alert.shcmd)
                                        alert(A_PRINTER, pps, (RSTATUS *)0,
                                                (char *)0);
                                else
                                        Unlink (pps->alert->msgfile);
                        }
                freeprinter (op);

                unload_list (&pps->users_allowed);
                unload_list (&pps->users_denied);
                unload_list (&pps->forms_allowed);
                unload_list (&pps->forms_denied);
                load_userprinter_access(pp->name, &pps->users_allowed,
                        &pps->users_denied);
                load_formprinter_access(pp->name, &pps->forms_allowed,
                        &pps->forms_denied);

                unload_list (&pps->paper_allowed);
                load_paperprinter_access(pp->name, &pps->paper_allowed,
                        &paperDenied);
                freelist(paperDenied);

                load_sdn (&pps->cpi, pp->cpi);
                load_sdn (&pps->lpi, pp->lpi);
                load_sdn (&pps->plen, pp->plen);
                load_sdn (&pps->pwid, pp->pwid);

                pps->last_dial_rc = 0;
                pps->nretry = 0;

                /*
                 * Evaluate all requests queued for this printer,
                 * to make sure they are still eligible. They will
                 * get moved to another printer, get (re)filtered,
                 * or get canceled.
                 */
                (void) queue_repel(pps, 0, (qchk_fnc_type)0);

                status = MOK;
        } else if (pp->remote) {
                /* don't really load a remote printer */
                status = MOK;
        } else if ((pps = new_pstatus(pp))) {
                pps->status = PS_DISABLED | PS_REJECTED;
                load_str (&pps->dis_reason, CUZ_NEW_PRINTER);
                load_str (&pps->rej_reason, CUZ_NEW_DEST);
                load_str (&pps->fault_reason, CUZ_PRINTING_OK);
                time (&pps->dis_date);
                time (&pps->rej_date);

                dump_pstatus ();

                status = MOK;
        } else {
                freeprinter (pp);
                status = MNOSPACE;
        }


        mputm (md, R_LOAD_PRINTER, status);
        return;
}

/*
 * s_unload_printer()
 */

static void
_unload_printer(PSTATUS *pps)
{
        int i;

        if (pps->alert->active)
                cancel_alert (A_PRINTER, pps);

        /*
         * Remove this printer from the classes it may be in.
         * This is likely to be redundant, i.e. upon deleting
         * a printer the caller is SUPPOSED TO check all the
         * classes; any that contain the printer will be changed
         * and we should receive a S_LOAD_CLASS message for each
         * to reload the class.
         *
         * HOWEVER, this leaves a (small) window where someone
         * can sneak a request in destined for the CLASS. If
         * we have deleted the printer but still have it in the
         * class, we may have trouble!
         */
        for (i = 0; CStatus != NULL && CStatus[i] != NULL; i++)
                (void) dellist(&(CStatus[i]->class->members),
                                pps->printer->name);

        free_pstatus(pps);
        /*
         * this is removed from the PStatus table by the caller
         *   list_remove((void ***)&PStatus, (void *)pps);
         */

        return;
}

void
s_unload_printer(char *m, MESG *md)
{
        char                    *printer;
        ushort                  status;
        register PSTATUS        *pps;

        (void) getmessage(m, S_UNLOAD_PRINTER, &printer);

        syslog(LOG_DEBUG, "s_unload_printer(%s)",
               (printer ? printer : "NULL"));

        if (!*printer || STREQU(printer, NAME_ALL))
                /* Unload ALL printers */
                if (!Request_List)
                        /*  If we have ANY requests queued, we can't do it. */
                        status = MBUSY;

                else {
                        int i;
                        for (i = 0; PStatus != NULL && PStatus[i] != NULL; i++)
                                _unload_printer (PStatus[i]);
                        free(PStatus);
                        PStatus = NULL;
                        status = MOK;
                }

        else if (!(pps = search_pstatus(printer)))
                /* Have we seen this printer before */
                status = MNODEST;
        else {
                /*
                 * Note: This routine WILL MOVE requests to another
                 * printer. It will not stop until it has gone through
                 * the entire list of requests, so all requests that
                 * can be moved will be moved. If any couldn't move,
                 * however, we don't unload the printer.
                 */
                if (queue_repel(pps, 1, (qchk_fnc_type)0))
                        status = MOK;
                else
                        status = MBUSY;

                if (status == MOK) {
                        _unload_printer (pps);
                        list_remove((void ***)&PStatus, (void *)pps);
                }
        }

        if (status == MOK)
                dump_pstatus ();

        mputm (md, R_UNLOAD_PRINTER, status);
        return;
}

/*
 * combineReasons()
 */

static char *
combineReasons(PSTATUS *pps, char *freeReason)
{
        char    *reason = NULL;

        if (pps->status & PS_FAULTED) {
                if ((pps->status & (PS_DISABLED | PS_LATER)) &&
                    (!STREQU(pps->dis_reason, CUZ_STOPPED)) &&
                    (addstring(&reason, "Fault reason: ") == 0) &&
                    (addstring(&reason, pps->fault_reason) == 0) &&
                    (addstring(&reason, "\n\tDisable reason: ") == 0) &&
                    (addstring(&reason, pps->dis_reason) == 0))
                        *freeReason = 1;

                else {
                        if (reason)
                                /* memory allocation failed part way through */
                                Free(reason);

                        reason = pps->fault_reason;
                        *freeReason = 0;
                }
        } else {
                reason = pps->dis_reason;
                *freeReason = 0;
        }
        return (reason);
}

static void
local_printer_status(MESG *md, PSTATUS *pps, short status)
{
        char    *reason = NULL;
        char    freeReason = 0;
        char    *formList = NULL;

        reason = combineReasons(pps, &freeReason);
        formList = showForms(pps);

        send(md, R_INQUIRE_PRINTER_STATUS, status, pps->printer->name,
                (formList ? formList : ""),
                (pps->pwheel_name ? pps->pwheel_name : ""),
                reason, pps->rej_reason, pps->status,
                (pps->request ? pps->request->secure->req_id : ""),
                pps->dis_date, pps->rej_date);

        if (formList)
                Free(formList);

        if (freeReason)
                Free(reason);
}

/*
 * s_inquire_printer_status()
 */

void
s_inquire_printer_status(char *m, MESG *md)
{
        char                    *printer;
        register PSTATUS        *pps;

        (void) getmessage(m, S_INQUIRE_PRINTER_STATUS, &printer);
        syslog(LOG_DEBUG, "s_inquire_printer_status(%s)", printer);

        if (!*printer || STREQU(printer, NAME_ALL)) {
                /* inquire about all printers */
                int i;

                for (i = 0; PStatus != NULL && PStatus[i] != NULL; i++) {
                        pps = PStatus[i];
                        if (PStatus[i + 1] != NULL)
                                local_printer_status(md, pps, MOKMORE);
                }
        } else
                /* inquire about a specific printer */
                pps = search_pstatus(printer);

        if (pps)
                local_printer_status(md, pps, MOK);
        else {
                mputm(md, R_INQUIRE_PRINTER_STATUS, MNODEST, "", "", "", "",
                        "", 0, "", 0L, 0L);
        }
}


/*
 * s_load_class()
 */

void
s_load_class(char *m, MESG *md)
{
        char                    *class;
        ushort                  status;
        register CLASS          *pc;
        register CLSTATUS       *pcs;

        (void) getmessage(m, S_LOAD_CLASS, &class);
        syslog(LOG_DEBUG, "s_load_class(%s)", (class ? class : "NULL"));

        if (!*class)
                /* no class defined */
                status = MNODEST;
        else if (!(pc = Getclass(class))) {
                /* Strange or missing class */
                switch (errno) {
                case EBADF:
                        status = MERRDEST;
                        break;
                case ENOENT:
                default:
                        status = MNODEST;
                        break;
                }

        } else if ((pcs = search_cstatus(class))) {
                /* Class we already know about */
                register RSTATUS        *prs;

                freeclass (pcs->class);
                pcs->class = pc;

                /*
                 * Here we go through the list of requests
                 * to see who gets affected.
                 */
                for (prs = Request_List; prs != NULL; prs = prs->next)
                        if (STREQU(prs->request->destination, class)) {
                                /*
                                * If not still eligible for this class...
                                */
                                switch (validate_request(prs, (char **)0, 1)) {
                                case MOK:
                                case MERRDEST:  /* rejecting (shouldn't happen) */
                                        break;
                                case MDENYDEST:
                                case MNOMOUNT:
                                case MNOMEDIA:
                                case MNOFILTER:
                                default:
                                        /*
                                        * ...then too bad!
                                        */
                                        cancel (prs, 1);
                                        break;
                                }
                        }

                status = MOK;
        } else if ((pcs = new_cstatus(pc))) {
                /* Room for new class? */
                pcs->status = CS_REJECTED;
                load_str (&pcs->rej_reason, CUZ_NEW_DEST);
                time (&pcs->rej_date);

                dump_cstatus ();

                status = MOK;
        } else {
                freeclass (pc);
                status = MNOSPACE;
        }


        mputm (md, R_LOAD_CLASS, status);
        return;
}

/*
 * s_unload_class()
 */

static void
_unload_class(CLSTATUS *pcs)
{
        freeclass (pcs->class);
        if (pcs->rej_reason != NULL)
                Free (pcs->rej_reason);
        Free(pcs);

        return;
}

void
s_unload_class(char *m, MESG *md)
{
        char                    *class;
        ushort                  status;
        RSTATUS                 *prs;
        register CLSTATUS       *pcs;

        (void) getmessage(m, S_UNLOAD_CLASS, &class);
        syslog(LOG_DEBUG, "s_unload_class(%s)", (class ? class : "NULL"));

        /*
         * Unload ALL classes?
         */
        if (!*class || STREQU(class, NAME_ALL)) {
                int i;
                /*
                 * If we have a request queued for a member of ANY
                 * class, we can't do it.
                 */
                status = MOK;
                for (i = 0; ((CStatus[i] != NULL) && (status == MOK)); i++) {
                        for (prs = Request_List; prs != NULL; prs = prs->next)
                                if (STREQU(prs->request->destination,
                                                CStatus[i]->class->name)) {
                                        status = MBUSY;
                                        break;
                                }
                }

                if (status == MOK) {
                        for (i = 0; CStatus != NULL && CStatus[i] != NULL; i++)
                                _unload_class (CStatus[i]);
                        free(CStatus);
                        CStatus = NULL;
                }

        /*
         * Have we seen this class before?
         */
        } else if (!(pcs = search_cstatus(class)))
                status = MNODEST;

        /*
         * Is there even one request queued for this class?
         * If not, we can safely remove it.
         */
        else {
                status = MOK;
                for (prs = Request_List; prs != NULL; prs = prs->next)
                        if (STREQU(prs->request->destination, class)) {
                                status = MBUSY;
                                break;
                        }

                if (status == MOK) {
                        _unload_class (pcs);
                        list_remove((void ***)&CStatus, (void *)pcs);
                }
        }

        if (status == MOK)
                dump_cstatus ();

        mputm (md, R_UNLOAD_CLASS, status);
        return;
}

/*
 * s_inquire_class()
 */

void
s_inquire_class(char *m, MESG *md)
{
        char                    *class;
        register CLSTATUS       *pcs;

        (void) getmessage(m, S_INQUIRE_CLASS, &class);
        syslog(LOG_DEBUG, "s_inquire_class(%s)", (class ? class : "NULL"));



        if (!*class || STREQU(class, NAME_ALL)) {
                /* inquire about ALL classes */
                int i;

                for (i = 0; CStatus != NULL && CStatus[i] != NULL; i++) {
                        pcs = CStatus[i];
                        if (CStatus[i + 1] != NULL)
                                send(md, R_INQUIRE_CLASS, MOKMORE,
                                        pcs->class->name, pcs->status,
                                        pcs->rej_reason, pcs->rej_date);
                }
        } else
                /* inquire about a single class */
                pcs = search_cstatus(class);

        if (pcs)
                send(md, R_INQUIRE_CLASS, MOK, pcs->class->name, pcs->status,
                        pcs->rej_reason, pcs->rej_date);
        else
                mputm (md, R_INQUIRE_CLASS, MNODEST, "", 0, "", 0L);

        return;
}

/*
 * s_paper_allowed()
 */

void
s_paper_allowed(char *m, MESG *md)
{
        char                    *printer;
        char                    *paperList = NULL;
        register PSTATUS        *pps, *ppsnext;

        (void) getmessage(m, S_PAPER_ALLOWED, &printer);
        syslog(LOG_DEBUG, "s_paper_allowed(%s)", (printer ? printer : "NULL"));


        if (!*printer || STREQU(printer, NAME_ALL)) {
                /* inquire about ALL printers */
                int i;

                for (i = 0; PStatus != NULL && PStatus[i] != NULL; i++) {
                        pps = PStatus[i];
                        if (PStatus[i + 1] != NULL) {
                                paperList = sprintlist(pps->paper_allowed);
                                send(md, R_PAPER_ALLOWED, MOKMORE,
                                        pps->printer->name,
                                        (paperList ? paperList : ""));
                                if (paperList)
                                        Free(paperList);
                        }
                }
        } else
                /* inquire about a specific printer */
                pps = search_pstatus(printer);

        if (pps) {
                paperList = sprintlist(pps->paper_allowed);
                send(md, R_PAPER_ALLOWED, MOK, pps->printer->name,
                        (paperList ? paperList : ""));
                if (paperList)
                        Free(paperList);

        } else {
                mputm(md, R_PAPER_ALLOWED, MNODEST, "", "");
        }
}