/*
 * 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, "", "");
	}
}