/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

# include       <stdarg.h>
# include       "lpsched.h"

typedef struct fault    FLT;

struct fault
{
    FLT *       next;
    int         type;
    int         i1;
    char *      s1;
    RSTATUS *   r1;
    MESG *      ident;
};

static void free_flt ( FLT * );
static void do_flt_acts ( MESG * );

static FLT      Fault_Head = { NULL, 0, 0, NULL, NULL, NULL };
static FLT *    Fault_List = &Fault_Head;

void
add_flt_act(MESG * md, ...)
{
    va_list     arg;
    FLT         *f;

    va_start (arg, md);

    f = (FLT *)Malloc(sizeof(FLT));

    (void) memset((char *)f, 0, sizeof(FLT));

    f->type = (int)va_arg(arg, int);
    f->ident = md;

    if (md->on_discon == NULL)
        if (mon_discon(md, do_flt_acts))
            mallocfail();

    switch(f->type)
    {
        case FLT_FILES:
        f->s1 = Strdup((char *)va_arg(arg, char *));
        f->i1 = (int)va_arg(arg, int);
        break;

        case FLT_CHANGE:
        f->r1 = (RSTATUS *)va_arg(arg, RSTATUS *);
        break;
    }

    va_end(arg);

    f->next = Fault_List->next;
    Fault_List->next = f;
}


void
del_flt_act(MESG *md, ...)
{
    va_list     arg;
    int         type;
    FLT         *fp;
    FLT         *f;

    va_start(arg, md);

    type = (int)va_arg(arg, int);

    for (f = Fault_List; f->next; f = f->next)
        if (f->next->type == type && f->next->ident == md)
        {
            fp = f->next;
            f->next = f->next->next;
            free_flt(fp);
            break;
        }

    va_end(arg);
}

static void
do_flt_acts(MESG *md)
{
    FLT         *f;
    FLT         *fp;
    char        *file;
    char        id[15];
#ifdef LP_USE_PAPI_ATTR
    struct stat tmpBuf;
    char        attrFile[BUFSIZ];
#endif

    for (f = Fault_List; f && f->next; f = f->next)
        if (f->next->ident == md)
        {
            fp = f->next;
            f->next = f->next->next;

            switch (fp->type)
            {
                case FLT_FILES:
                /* remove files created with alloc_files */

                while(fp->i1--)
                {
                    (void) snprintf(id, sizeof (id), "%s-%d", fp->s1, fp->i1);
                    file = makepath(Lp_Temp, id, (char *)0);
                    (void) Unlink(file);
                    Free(file);
                }

#ifdef LP_USE_PAPI_ATTR
                /*
                 * check if the PAPI attribute file exists, if it does delete it
                 */
                (void) snprintf(attrFile, sizeof (attrFile),
                                "%s-%s", fp->s1, LP_PAPIATTRNAME);
                file = makepath(Lp_Temp, attrFile, (char *)0);
                if ((file != NULL) && (stat(file, &tmpBuf) == 0))
                {
                        (void) Unlink(file);
                }
                Free(file);
#endif
                break;


                case FLT_CHANGE:
                /* clear RS_CHANGE bit, write request file, and schedule */
                fp->r1->request->outcome &= ~RS_CHANGING;
                putrequest(fp->r1->req_file, fp->r1->request);
                if (NEEDS_FILTERING(fp->r1))
                    schedule(/* LP_FILTER */ EV_SLOWF, fp->r1);
                else
                    schedule(/* LP_PRINTER */ EV_INTERF, fp->r1->printer);
                break;
            }
            free_flt(fp);
        }
}

static void
free_flt(FLT *f)
{
    if (f->s1)
        Free(f->s1);
    Free((char *)f);
}