xref: /titanic_51/usr/src/cmd/lp/cmd/lpadmin/do_align.c (revision 437427fb0e9def2a846945f03aca7152a1438123)

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


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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#include <libintl.h>

#include "lp.h"
#include "msgs.h"
#include "printers.h"
#include "requests.h"
#include "form.h"

#define	WHO_AM_I	I_AM_LPADMIN
#include "oam.h"

#include "lpadmin.h"


extern void		mount_unmount();

extern short		printer_status;

extern char		*cur_pwheel,
			*disable_reason,
			*reject_reason;

extern FORM		formbuf;

static int		again();

static void		disable(),
			enable(),
			accept(),
			reject(),
			cancel(),
			sigpipe(),
			sigother();

static jmp_buf		cleanup_env,
			pipe_env;

/**
 ** do_align() - SET UP PRINTER TO PRINT ALIGNMENT PATTERNS
 **/

int			do_align (printer, form, pwheel)
	char			*printer,
				*form,
				*pwheel;
{
	short			status;

	char			*req_id		= 0,
				*file_prefix,
				*rfile,
				*fifo,
				buffer[MSGMAX];

	long			printer_chk;

	int			try;

	FILE			*align_fp,
				*fifo_fp;

	REQUEST			req;

	void			(*old_sighup)(),
				(*old_sigint)(),
				(*old_sigquit)(),
				(*old_sigterm)();


	/*
	 * Having reached this point means we've already fetched
	 * the form definition. Now get the alignment pattern.
	 */
	if (getform(form, (FORM *)0, (FALERT *)0, &align_fp) == -1) {
		LP_ERRMSG2 (ERROR, E_LP_GETFORM, form, PERROR);
		done (1);
	}
	if (!align_fp) {
		LP_ERRMSG1 (WARNING, E_ADM_NOALIGN, form);
		return (0);
	}

	/*
	 * Having reached this far also means we've already obtained
	 * the printer status from the Spooler. We'll be changing the
	 * status of the printer and queue and will have to restore
	 * the disable/reject reasons.
	 * NOTE: We can't restore the dates!
	 */


	/*
	 * Construct a request to print a ``file'' for copy. The
	 * equivalent "lp" command (with a filename) would be:
	 *
	 * lp -p printer -H immediate -f form -T type -S charset -c -P 1-N
	 *
	 * "type", "charset", and "N" are derived from the form def'n.
	 * This command would make us next to print ONCE THE FORM IS
	 * MOUNTED.
	 *
	 * NOTE: Don't bother with the -S charset if it isn't mandatory,
	 * so we won't get a rejection. Also, we use either the print
	 * wheel given in the -S option or, lacking that, the currently
	 * mounted print wheel. (The former WILL be mounted.) This also
	 * avoids a rejection by the Spooler.
	 */
	req.copies	= 1;
	req.destination	= printer;
/*	req.file_list	= 0;	This is done later. */
	req.form	= form;
	req.actions	= ACT_IMMEDIATE | ACT_FAST;
	req.alert	= 0;
	req.options	= "nobanner";
	req.priority	= 20;	/* it doesn't matter */
	sprintf ((req.pages = "1-999999")+2, "%d", formbuf.np);
	req.charset	= NAME_ANY;	/* Don't restrict the request */
	req.modes	= 0;
	req.title	= "Aligning Form";
	req.input_type	= formbuf.conttype;
	req.user	= getname();


	/*
	 * The following code is sensitive to interrupts: We must
	 * catch interrupts so to restore the printer to its original
	 * state, but if we get interrupted while receiving a message
	 * from the Spooler, we can't issue additional messages because
	 * the old responses still in the response queue will confuse us.
	 * Thus while sending/receiving a message we ignore signals.
	 */
	if (setjmp(cleanup_env) != 0)
		done (1);
	trap_signals (); /* make sure we've done this once */
	old_sighup = signal(SIGHUP, sigother);
	old_sigint = signal(SIGINT, sigother);
	old_sigquit = signal(SIGQUIT, sigother);
	old_sigterm = signal(SIGTERM, sigother);

	/*
	 * We'll try the following twice, first with the page list
	 * set as above. If the request gets refused because there's
	 * no filter to convert the content, we'll try again without
	 * the page list. I don't think the number-of-pages-in-a-form
	 * feature is likely to be used much, so why hassle the
	 * administrator?
#if	defined(WARN_OF_TOO_MANY_LINES)
	 * However, do warn him or her.
#endif
	 */

	try = 0;
Again:	try++;

	/*
	 * Have the Spooler allocate a request file and another file
	 * for our use. We'll delete the other file and recreate it
	 * as a FIFO. We can do this because "lpadmin" can only be run
	 * (successfully) by an administrator. This is the key to what
	 * we're doing! We are submitting a named pipe (FIFO) for
	 * printing, which gives us a connection to the printer
	 * through any filters needed!
	 */

	BEGIN_CRITICAL
		send_message (S_ALLOC_FILES, 2);
		if (mrecv(buffer, MSGMAX) != R_ALLOC_FILES) {
			LP_ERRMSG (ERROR, E_LP_MRECV);
			done (1);
		}
	END_CRITICAL
	(void)getmessage (buffer, R_ALLOC_FILES, &status, &file_prefix);

	switch (status) {
	case MOK:
		break;

	case MNOMEM:
		LP_ERRMSG (ERROR, E_LP_MNOMEM);
		done (1);
	}

	if (!(rfile = malloc((unsigned int)strlen(file_prefix) + 2 + 1))) {
		LP_ERRMSG (ERROR, E_LP_MALLOC);
		done (1);
	}

	sprintf (rfile, "%s-1", file_prefix);

	if (!(fifo = makepath(Lp_Temp, rfile, (char *)0))) {
		LP_ERRMSG (ERROR, E_LP_MALLOC);
		done (1);
	}
	req.file_list = 0;
	addlist (&req.file_list, fifo);

	if (
		Unlink(fifo) == -1
	     || Mknod(fifo, S_IFIFO | 0600, 0) == -1
	) {
		LP_ERRMSG1 (ERROR, E_ADM_NFIFO, PERROR);
		done (1);
	}

	/*
	 * In quick succession,
	 *
	 *	- mount the form,
	 *	- disable the printer,
	 *	- make the Spooler accept requests (if need be),
	 *	- submit the request,
	 *	- make the Spooler reject requests (if need be).
	 *
	 * We want to minimize the window when another request can
	 * be submitted ahead of ours. Though this window is small,
	 * it is a flaw in our design. Disabling the printer will
	 * help, because it will stop any request that is printing
	 * (if the form is already mounted) and will prevent any other
	 * request from printing. (We disable the printer AFTER trying
	 * to mount the form, because we don't disable a printer for a
	 * regular mount, and we'd like to make this mount APPEAR to
	 * be as similar as possible.)
	 */

	if (try == 1) {

		mount_unmount (S_MOUNT, printer, NB(form), NB(pwheel));
		/* This will die if the mount fails, leaving */
		/* the Spooler to clean up our files.        */

		if (!(printer_status & PS_DISABLED))
			disable (printer, CUZ_MOUNTING, 0);

		if (printer_status & PS_REJECTED)
			accept (printer);

		if (setjmp(cleanup_env) != 0) {
			if (printer_status & PS_DISABLED)
				disable (printer, disable_reason, 1);
			if (printer_status & PS_REJECTED)
				reject (printer, reject_reason);
			if (req_id && *req_id)
				cancel (req_id);
			done (1);
		}
	}

	sprintf (rfile, "%s-0", file_prefix);
	if (putrequest(rfile, &req) == -1) {
		LP_ERRMSG1 (ERROR, E_LP_PUTREQUEST, PERROR);
		goto Done;
	}
	BEGIN_CRITICAL
		send_message (S_PRINT_REQUEST, rfile);
		if (mrecv(buffer, MSGMAX) != R_PRINT_REQUEST) {
			LP_ERRMSG (ERROR, E_LP_MRECV);
			done (1);
		}
	END_CRITICAL
	(void)getmessage (buffer, R_PRINT_REQUEST, &status, &req_id, &printer_chk);

	switch (status) {

	case MNOFILTER:
		if (try == 1) {
			req.pages = 0;
			goto Again;
		}
		LP_ERRMSG (ERROR, E_ADM_NFILTER);
		goto Done;

	case MOK:
#if	defined(WARN_OF_TOO_MANY_LINES)
		if (!req.pages)
			LP_ERRMSG1 (WARNING, E_ADM_NPAGES, formbuf.np);
#endif
		break;

	case MERRDEST:
		accept (printer); /* someone snuck a reject in! */
		goto Again;

	case MNOMEM:
		LP_ERRMSG (ERROR, E_LP_MNOMEM);
		goto Done;

	case MNODEST:
		LP_ERRMSG1 (ERROR, E_LP_PGONE, printer);
		goto Done;

	case MNOOPEN:	/* not quite, but close */
		LP_ERRMSG (ERROR, E_ADM_ERRDEST);
		goto Done;

	case MDENYDEST:
		if (printer_chk) {
			char			reason[1024],
						*cp	= reason;

			if (printer_chk & PCK_TYPE)
				cp += sprintf(cp, "printer type, ");
			if (printer_chk & PCK_CHARSET)
				cp += sprintf(cp, "character set, ");
			if (printer_chk & PCK_CPI)
				cp += sprintf(cp, "character pitch, ");
			if (printer_chk & PCK_LPI)
				cp += sprintf(cp, "line pitch, ");
			if (printer_chk & PCK_WIDTH)
				cp += sprintf(cp, "page width, ");
			if (printer_chk & PCK_LENGTH)
				cp += sprintf(cp, "page length, ");
			if (printer_chk & PCK_BANNER)
				cp += sprintf(cp, "nobanner, ");
			cp[-2] = 0;
			LP_ERRMSG1 (ERROR, E_LP_PTRCHK, reason);
			goto Done;
		}
		/*fall through*/

	case MUNKNOWN:
	case MNOMEDIA:
	case MDENYMEDIA:
	case MNOMOUNT:
	case MNOSPACE:
	case MNOPERM:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, status);

Done:		if (!(printer_status & PS_DISABLED))
			enable (printer);
		if (printer_status & PS_REJECTED)
			reject (printer, reject_reason);
		done (1);
		/*NOTREACHED*/
	}

	if (printer_status & PS_REJECTED)
		reject (printer, reject_reason);

	/*
	 * Enable printing, to start the interface program going.
	 * Because of our precautions above, our request SHOULD be
	 * the one that prints!
 	 */
	enable (printer);

	/*
	 * Open the FIFO. One problem: This will hang until the
	 * interface program opens the other end!!
	 */
	if (!(fifo_fp = fopen(fifo, "w"))) {
		LP_ERRMSG1 (ERROR, E_ADM_NFIFO, PERROR);
		done (1);
	}

	/*
	 * Loop, dumping the ENTIRE alignment pattern to the FIFO
	 * each time. SIGPIPE probably means the printer faulted.
	 */
	if (setjmp(pipe_env) == 0) {
		/*
		 * Don't send a form feed after the last copy, since
		 * the interface program does that. To implement this,
		 * we send the form feed BEFORE the alignment pattern;
		 * this way we can simply not send it the first time.
		 */
		char *			ff		= 0;
		char *			ff_before	= 0;

		/*
		 * If we'll be inserting page breaks between alignment
		 * patterns, look up the control sequence for this.
		 *
		 * MORE: We currently don't have the smarts to figure out
		 * WHICH printer type the Spooler will pick; we would need
		 * to steal some of its code for that (see pickfilter.c)
		 * The best we do so far is use the alignment pattern's
		 * content type, if known.
		 */
		if (filebreak) {
			if (
				formbuf.conttype
			     && searchlist_with_terminfo(
					formbuf.conttype,
					T  /* having "filebreak" => OK */
				)
			)
				tidbit (formbuf.conttype, "ff", &ff);
			else
				tidbit (*T, "ff", &ff);
		}

		signal (SIGPIPE, sigpipe);
		do {
			register int		n;
			char			buf[BUFSIZ];

			if (ff_before && *ff_before)
				fputs (ff_before, fifo_fp);
			ff_before = ff;

			rewind (align_fp);
			while ((n = fread(buf, 1, BUFSIZ, align_fp)) > 0)
				fwrite (buf, 1, n, fifo_fp);

			fflush (fifo_fp);

		} while (again());
		fclose (align_fp);
		signal (SIGPIPE, SIG_DFL);

	} else {
		cancel (req_id);

#define P(X)	printf (X)

P("We were interrupted while printing the alignment pattern;\n");
P("check the printer. The form is mounted, so you will have to\n");
P("unmount it if you need to print more alignment patterns later.\n");
	}

	/*
	 * Disable the printer, if needed, and close the FIFO.
	 * Use the wait version of the disable, so our request isn't
	 * stopped, and do it before closing the FIFO, so another request
	 * can't start printing if it isn't supposed to.
	 */
	if (printer_status & PS_DISABLED)
		disable (printer, disable_reason, 1);
	fclose (fifo_fp);

	signal (SIGHUP, old_sighup);
	signal (SIGINT, old_sigint);
	signal (SIGQUIT, old_sigquit);
	signal (SIGTERM, old_sigterm);

	return (1);
}

/**
 ** accept() - MAKE PRINTER ACCEPT REQUESTS
 **/

static void		accept (printer)
	char			*printer;
{
	int			rc;

	BEGIN_CRITICAL
		send_message (S_ACCEPT_DEST, printer);
		rc = output(R_ACCEPT_DEST);
	END_CRITICAL

	switch (rc) {
	case MOK:
	case MERRDEST:	/* someone may have snuck in an accept */
		break;

	case MNODEST:	/* make up your mind, Spooler! */
	case MNOPERM:	/* taken care of up front */
	default:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, rc);
		done (1);
	}
	return;
}

/**
 ** reject() - MAKE PRINTER REJECT REQUESTS
 **/

static void		reject (printer, reason)
	char			*printer,
				*reason;
{
	int			rc;

	BEGIN_CRITICAL
		send_message (S_REJECT_DEST, printer, reason);
		rc = output(R_REJECT_DEST);
	END_CRITICAL

	switch (rc) {

	case MOK:
	case MERRDEST:	/* someone may have snuck in a reject */
		break;

	case MNODEST:	/* make up your mind, Spooler! */
	case MNOPERM:	/* taken care of up front */
	default:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, rc);
		done (1);
	}
	return;
}

/**
 ** enable() - ENABLE THE PRINTER
 **/

static void		enable (printer)
	char			*printer;
{
	int			rc;

	BEGIN_CRITICAL
		send_message (S_ENABLE_DEST, printer);
		rc = output(R_ENABLE_DEST);
	END_CRITICAL

	switch (rc) {
	case MOK:
	case MERRDEST:	/* someone may have snuck in an enable */
		break;

	case MNODEST:	/* make up your mind, Spooler! */
	case MNOPERM:	/* taken care of up front */
	default:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, rc);
		done (1);
	}
	return;
}

/**
 ** disable() - DISABLE THE PRINTER
 **/

static void		disable (printer, reason, when)
	char			*printer,
				*reason;
	int			when;
{
	int			rc;

	BEGIN_CRITICAL
		send_message (S_DISABLE_DEST, printer, reason, when);
		rc = output(R_DISABLE_DEST);
	END_CRITICAL

	switch (rc) {
	case MOK:
	case MERRDEST:	/* someone may have snuck in a disable */
		break;

	case MNODEST:	/* make up your mind, Spooler! */
	case MNOPERM:	/* taken care of up front */
	default:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, rc);
		done (1);
	}
	return;
}

/**
 ** cancel() - MAKE PRINTER ACCEPT REQUESTS
 **/

static void		cancel (req_id)
	char			*req_id;
{
	int			rc;

	BEGIN_CRITICAL
		send_message (S_CANCEL_REQUEST, req_id);
		rc = output(R_CANCEL_REQUEST);
	END_CRITICAL

	switch (rc) {
	case MOK:
	case MUNKNOWN:
	case M2LATE:
		break;

	case MNOPERM:
	default:
		LP_ERRMSG1 (ERROR, E_LP_BADSTATUS, rc);
		done (1);
	}
	return;
}

/**
 ** again()
 **/

static int		again ()
{
	char			answer[BUFSIZ];


	for (;;) {

		printf (
		gettext("Press return to print an alignment pattern [q to quit]: ")
		);

		if (!fgets(answer, sizeof (answer), stdin))
			return (0);

		answer[strlen(answer) -1] = '\0';

		if (
		        STREQU(answer, "q")
		     || STREQU(answer, "n")
		     || STREQU(answer, "no")
		)
			return (0);

		else if (
			!*answer
		     || STREQU(answer, "y")
		     || STREQU(answer, "yes")
		)
			return (1);

		printf (gettext("Sorry?\n"));
	}
}

/**
 ** sigpipe()
 ** sigother()
 **/

static void		sigpipe ()
{
	signal (SIGPIPE, SIG_IGN);
	longjmp (pipe_env, 1);
	/*NOTREACHED*/
}

static void		sigother (sig)
	int			sig;
{
	signal (sig, SIG_IGN);
	longjmp (cleanup_env, 1);
	/*NOTREACHED*/
}