xref: /illumos-gate/usr/src/cmd/lp/model/lp.cat.c (revision bbf21555)

/*
 * 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 2009 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 <stdio.h>
#include <stdlib.h>
#include <termio.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>
#include <sys/times.h>
#include <string.h>
#include <limits.h>
#include <sys/prnio.h>

#include "lp.h"

#include <locale.h>

/*
 *	Begin Sun Additions for Parallel ports
 */

#include <string.h>
#include <stdarg.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioccom.h>
#include <sys/ioctl.h>

#include <sys/bpp_io.h>
#include <sys/ecppsys.h>
#include <stropts.h>

/*
 * the parameter structure for the parallel port
 */
struct ppc_params_t {
	int		flags;		/* same as above */
	int		state;		/* status of the printer interface */
	int		strobe_w;	/* strobe width, in uS */
	int		data_setup;	/* data setup time, in uS */
	int		ack_timeout;	/* ACK timeout, in secs */
	int		error_timeout;	/* PAPER OUT, etc... timeout, in secs */
	int		busy_timeout;	/* BUSY timeout, in seconds */
};



static void printer_info(char *fmt, ...);

/*	These are the routines avaliable to others for use 	*/
int is_a_parallel_bpp(int);
int bpp_state(int);
int parallel_comm(int, int());
int get_ecpp_status(int fd);
int is_a_prnio(int);
int prnio_state(int);

#define	PRINTER_ERROR_PAPER_OUT		1
#define	PRINTER_ERROR_OFFLINE		2
#define	PRINTER_ERROR_BUSY		3
#define	PRINTER_ERROR_ERROR		4
#define	PRINTER_ERROR_CABLE_POWER	5
#define	PRINTER_ERROR_UNKNOWN		6
#define	PRINTER_ERROR_TIMEOUT		7
#define	PRINTER_IO_ERROR		129


/*
 *	for BPP PARALLEL interfaces
 */

int
is_a_parallel_bpp(int fd)
{
	if (ioctl(fd, BPPIOC_TESTIO) == 0 || errno == EIO)
		return (1);
	return (0);
}


#if defined(DEBUG) && defined(NOTDEF)
char *
BppState(int state)
{
	static char buf[BUFSIZ];

	memset(buf, 0, sizeof (buf));
	sprintf(buf, "State (0x%.4x) - (%s%s%s%s)\n", state,
	    ((state & BPP_SLCT_ERR) ?  "offline " : ""),
	    ((state & BPP_BUSY_ERR) ?  "busy " : ""),
	    ((state & BPP_PE_ERR) ?  "paper " : ""),
	    ((state & BPP_ERR_ERR) ?  "error " : ""));

	return (buf);
}
#endif

int
bpp_state(int fd)
{
	if (ioctl(fd, BPPIOC_TESTIO)) {
		struct bpp_error_status  bpp_stat;
		int state;

		if (ioctl(fd, BPPIOC_GETERR, &bpp_stat) < 0)
			exit(PRINTER_IO_ERROR);
		state = bpp_stat.pin_status;

#if defined(DEBUG) && defined(NOTDEF)
		logit("%s", BppState(state));
#endif

		if (state == (BPP_PE_ERR | BPP_ERR_ERR | BPP_SLCT_ERR)) {
			/* paper is out */
			return (PRINTER_ERROR_PAPER_OUT);
		} else if (state & BPP_BUSY_ERR) {
			/* printer is busy */
			return (PRINTER_ERROR_BUSY);
		} else if (state & BPP_SLCT_ERR) {
			/* printer is offline */
			return (PRINTER_ERROR_OFFLINE);
		} else if (state & BPP_ERR_ERR) {
			/* printer is errored */
			return (PRINTER_ERROR_ERROR);
		} else if (state == BPP_PE_ERR) {
			/* printer is off/unplugged */
			return (PRINTER_ERROR_CABLE_POWER);
		} else if (state) {
			return (PRINTER_ERROR_UNKNOWN);
		} else
			return (0);
	}
	return (0);
}

/*
 * For ecpp parallel port
 */

int
get_ecpp_status(int fd)
{
	int state;
	struct ecpp_transfer_parms transfer_parms;


	if (ioctl(fd, ECPPIOC_GETPARMS, &transfer_parms) == -1) {
		return (-1);
	}

	state = transfer_parms.mode;
	/*
	 * We don't know what all printers will return in
	 * nibble mode, therefore if we support nibble mode we will
	 * force the printer to be in CENTRONICS mode.
	 */
	if (state != ECPP_CENTRONICS) {
		transfer_parms.mode = ECPP_CENTRONICS;
		if (ioctl(fd, ECPPIOC_SETPARMS, &transfer_parms) == -1) {
			return (-1);
		} else {
			state = ECPP_CENTRONICS;
		}
	}


	return (state);
}

/*
 * For prnio(4I) - generic printer interface
 */
int
is_a_prnio(int fd)
{
	uint_t	cap;

	/* check if device supports prnio */
	if (ioctl(fd, PRNIOC_GET_IFCAP, &cap) == -1) {
		return (0);
	}
	/* we will use 1284 status if available */
	if ((cap & PRN_1284_STATUS) == 0) {
		/* some devices may only support 1284 status in unidir. mode */
		if (cap & PRN_BIDI) {
			cap &= ~PRN_BIDI;
			(void) ioctl(fd, PRNIOC_SET_IFCAP, &cap);
		}
	}
	return (1);
}

int
prnio_state(int fd)
{
	uint_t	status;
	uchar_t	pins;

	if ((ioctl(fd, PRNIOC_GET_STATUS, &status) == 0) &&
	    (status & PRN_READY)) {
		return (0);
	}

	if (ioctl(fd, PRNIOC_GET_1284_STATUS, &pins) != 0) {
		return (PRINTER_ERROR_UNKNOWN);
	}

	if ((pins & ~PRN_1284_BUSY) == PRN_1284_PE) {
		/* paper is out */
		return (PRINTER_ERROR_PAPER_OUT);
	} else if (pins == (PRN_1284_PE | PRN_1284_SELECT |
	    PRN_1284_NOFAULT | PRN_1284_BUSY)) {
		/* printer is off/unplugged */
		return (PRINTER_ERROR_CABLE_POWER);
	} else if ((pins & PRN_1284_SELECT) == 0) {
		/* printer is offline */
		return (PRINTER_ERROR_OFFLINE);
	} else if ((pins & PRN_1284_NOFAULT) == 0) {
		/* printer is errored */
		return (PRINTER_ERROR_ERROR);
	} else if (pins & PRN_1284_PE) {
		/* paper is out */
		return (PRINTER_ERROR_PAPER_OUT);
	} else if (pins ^ (PRN_1284_SELECT | PRN_1284_NOFAULT)) {
		return (PRINTER_ERROR_UNKNOWN);
	}

	return (0);
}

/*
 *	Common routines
 */

/*ARGSUSED0*/
static void
ByeByeParallel(int sig)
{
	/* try to shove out the EOT */
	(void) write(1, "\004", 1);
	exit(0);
}


/*ARGSUSED0*/
static void
printer_info(char *fmt, ...)
{
	char mesg[BUFSIZ];
	va_list ap;

	va_start(ap, fmt);
	vsprintf(mesg, fmt, ap);
	va_end(ap);
/*
 *	fprintf(stderr,
 *		"%%%%[ PrinterError: %s; source: parallel ]%%%%\n",
 *		mesg);
 */
	fprintf(stderr, "%s\n", mesg);
	fflush(stderr);
	fsync(2);

}

static void
printer_error(int error)
{
	switch (error) {
	case -1:
		printer_info("ioctl(): %s", strerror(errno));
		break;
	case PRINTER_ERROR_PAPER_OUT:
		printer_info("out of paper");
		break;
	case PRINTER_ERROR_OFFLINE:
		printer_info("offline");
		break;
	case PRINTER_ERROR_BUSY:
		printer_info("busy");
		break;
	case PRINTER_ERROR_ERROR:
		printer_info("printer error");
		break;
	case PRINTER_ERROR_CABLE_POWER:
		printer_info("printer powered off or disconnected");
		break;
	case PRINTER_ERROR_UNKNOWN:
		printer_info("unknown error");
		break;
	case PRINTER_ERROR_TIMEOUT:
		printer_info("communications timeout");
		break;
	default:
		printer_info("get_status() failed");
	}
}


static void
wait_state(int fd, int get_state())
{
	int state;
	int was_faulted = 0;

	while (state = get_state(fd)) {
		was_faulted = 1;
		printer_error(state);
		sleep(15);
	}

	if (was_faulted) {
		fprintf(stderr, "printer ok\n");
		fflush(stderr);
		fsync(2);
	}
}

/*
 *  end of Sun Additions for parallel port
 */
#define	IDENTICAL(A, B)	(A.st_dev == B.st_dev && A.st_ino == B.st_ino)
#define	ISBLK(A)	((A.st_mode & S_IFMT) == S_IFBLK)
#define	ISCHR(A)	((A.st_mode & S_IFMT) == S_IFCHR)

#define	E_SUCCESS	0
#define	E_BAD_INPUT	1
#define	E_BAD_OUTPUT	2
#define	E_BAD_TERM	3
#define	E_IDENTICAL	4
#define	E_WRITE_FAILED	5
#define	E_TIMEOUT	6
#define	E_HANGUP	7
#define	E_INTERRUPT	8

#define	SAFETY_FACTOR	2.0
#define	R(F)		(int)((F) + .5)
#define	DELAY(N, D)	R(SAFETY_FACTOR * ((N) / (double)(D)))

char			buffer[BUFSIZ];

void			sighup(),
			sigint(),
			sigquit(),
			sigpipe(),
			sigalrm(),
			sigterm();

#if	defined(baudrate)
#undef	baudrate
#endif

int baudrate();


int
nop(int fd)
{
	return (0);
}

int bpp_state(int);


/*
 * main()
 */

int
main(int argc, char *argv[])
{
	int	nin, nout, effective_rate, max_delay = 0, n;
	int	report_rate;
	short	print_rate;
	struct stat	in, out;
	struct tms	tms;
	long	epoch_start, epoch_end;
	char	*TERM;
	int	(*func)(int fd);

	/*
	 * The Spooler can hit us with SIGTERM for three reasons:
	 *
	 *	- the user's job has been canceled
	 *	- the printer has been disabled while we were printing
	 *	- the Spooler heard that the printer has a fault,
	 *	  and the fault recovery is wait or beginning
	 *
	 * We should exit cleanly for the first two cases,
	 * but we have to be careful with the last. If it was THIS
	 * PROGRAM that told the Spooler about the fault, we must
	 * exit consistently.
	 *
	 * The method of avoiding any problem is to turn off the
	 * trapping of SIGTERM before telling the Spooler about
	 * the fault.
	 *
	 * Faults that we can detect:
	 *	- hangup (drop of carrier)
	 *	- interrupt (printer sent a break or quit character)
	 *	- SIGPIPE (output port is a FIFO, and was closed early)
	 *	- failed or incomplete write()
	 *	- excess delay in write() (handled with SIGALRM later)
	 *
	 * Pseudo-faults (errors in use):
	 *	- No input/output, or strange input/output
	 *	- Input/output identical
	 *	- No TERM defined or trouble reading Terminfo database
	 */
	signal(SIGTERM, sigterm);
	signal(SIGHUP, sighup);
	signal(SIGINT, sigint);
	signal(SIGQUIT, sigint);
	signal(SIGPIPE, sigpipe);


	if (argc > 1 && STREQU(argv[1], "-r")) {
		report_rate = 1;
		argc--;
		argv++;
	} else
		report_rate = 0;

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

	/*
	 * Stat the standard output to be sure it is defined.
	 */
	if (fstat(1, &out) < 0) {
		signal(SIGTERM, SIG_IGN);
		fprintf(stderr, gettext("Can't stat output "
		    "(%s);\nincorrect use of lp.cat!\n"), PERROR);
		exit(E_BAD_OUTPUT);
	}

	/*
	 * Stat the standard input to be sure it is defined.
	 */
	if (fstat(0, &in) < 0) {
		signal(SIGTERM, SIG_IGN);
		fprintf(stderr, gettext("Can't stat input "
		    "(%s);\nincorrect use of lp.cat!\n"), PERROR);
		exit(E_BAD_INPUT);
	}

	/*
	 * If the standard output is not a character special file or a
	 * block special file, make sure it is not identical to the
	 * standard input.
	 *
	 * If we are an ecpp parallel port in centronics mode treat
	 * ourselves as a bpp compatible device.
	 */

	if (is_a_prnio(1)) {
		func = prnio_state;
	} else if (is_a_parallel_bpp(1) ||
	    (get_ecpp_status(1) == ECPP_CENTRONICS)) {
		func = bpp_state;
	} else if (isatty(1)) {
		/* serial connection (probably) - continue as usual */
		func = nop;
	} else {
		func = nop;
	}

	if (!ISCHR(out) && !ISBLK(out) && IDENTICAL(out, in)) {
		signal(SIGTERM, SIG_IGN);
		fprintf(stderr, gettext("Input and output are identical; "
		    "incorrect use of lp.cat!\n"));
		exit(E_IDENTICAL);
	}

	/*
	 * The effective data transfer rate is the lesser
	 * of the transmission rate and print rate. If an
	 * argument was passed to us, it should be a data
	 * rate and it may be lower still.
	 * Based on the effective data transfer rate,
	 * we can predict the maximum delay we should experience.
	 * But there are other factors that could introduce
	 * delay, so let's be generous; after all, we'd rather
	 * err in favor of waiting too long to detect a fault
	 * than err too often on false alarms.
	 */

	if (!(TERM = getenv("TERM")) || !*TERM) {
		signal(SIGTERM, SIG_IGN);
		fprintf(stderr, gettext("No TERM variable defined! "
		    "Trouble with the Spooler!\n"));
		exit(E_BAD_TERM);
	}
	if (!STREQU(TERM, NAME_UNKNOWN) &&
	    tidbit(TERM, "cps", &print_rate) == -1) {
		signal(SIGTERM, SIG_IGN);
		fprintf(stderr, gettext("Trouble identifying printer "
		    "type \"%s\"; check the Terminfo database.\n"), TERM);
		exit(E_BAD_TERM);
	}
	if (STREQU(TERM, NAME_UNKNOWN))
		print_rate = -1;

	effective_rate = baudrate() / 10; /* okay for most bauds */
	if (print_rate != -1 && print_rate < effective_rate)
		effective_rate = print_rate;
	if (argc > 1 && (n = atoi(argv[1])) >= 0 && n < effective_rate)
		effective_rate = n;	  /* 0 means infinite delay */
	if (effective_rate)
		max_delay = DELAY(BUFSIZ, effective_rate);

	/*
	 * We'll use the "alarm()" system call to keep us from
	 * waiting too long to write to a printer in trouble.
	 */
	if (max_delay)
		signal(SIGALRM, sigalrm);

	/*
	 * While not end of standard input, copy blocks to
	 * standard output.
	 */
	while ((nin = read(0, buffer, BUFSIZ)) > 0) {
		char *ptr = buffer;

		/*
		 * We should be safe from incomplete writes to a full
		 * pipe, as long as the size of the buffer we write is
		 * a even divisor of the pipe buffer limit. As long as
		 * we read from files or pipes (not communication devices)
		 * this should be true for all but the last buffer. The
		 * last will be smaller, and won't straddle the pipe max
		 * limit (think about it).
		 */
#if	PIPE_BUF < BUFSIZ || (PIPE_MAX % BUFSIZ)
		this_wont_compile;
#endif
		if (report_rate)
			epoch_start = times(&tms);
		do {
			wait_state(1, func);

			if (max_delay)
				alarm(max_delay);
			nout = write(1, ptr, nin);
			alarm(0);
			if (nout < 0) {
				fprintf(stderr, gettext("Write failed "
				    "(%s);\nperhaps the printer has gone "
				    "off-line.\n"), PERROR);
				fflush(stderr);
				if (errno != EINTR)
				/* I/O error on device, get lpcshed to retry */
					exit(PRINTER_IO_ERROR);
				else /* wait for printer to come back online */
					sleep(15);
			} else {
				nin -= nout;
				ptr += nout;
			}
		} while (nin > 0);

		if (max_delay)
			alarm(0);
		else if (report_rate) {
			epoch_end = times(&tms);
			if (epoch_end - epoch_start > 0)
				fprintf(stderr, "%d CPS\n",
				    R((100 * BUFSIZ) /
				    (double)(epoch_end - epoch_start)));
		}

	}

	return (E_SUCCESS);
}

/*
 * sighup() - CATCH A HANGUP (LOSS OF CARRIER)
 */
void
sighup()
{
	signal(SIGTERM, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
	fprintf(stderr, gettext(HANGUP_FAULT_LPCAT));
	exit(E_HANGUP);
}

/*
 * sigint() - CATCH AN INTERRUPT
 */
void
sigint()
{
	signal(SIGTERM, SIG_IGN);
	signal(SIGINT, SIG_IGN);
	fprintf(stderr, gettext(INTERRUPT_FAULT));
	exit(E_INTERRUPT);
}

/*
 * sigpipe() - CATCH EARLY CLOSE OF PIPE
 */
void
sigpipe()
{
	signal(SIGTERM, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);
	fprintf(stderr, gettext(PIPE_FAULT));
	exit(E_INTERRUPT);
}

/*
 * sigalrm() - CATCH AN ALARM
 */
void
sigalrm()
{
	signal(SIGTERM, SIG_IGN);
	fprintf(stderr, gettext("Excessive write delay; "
	    "perhaps the printer has gone off-line.\n"));
	exit(E_TIMEOUT);
}

/*
 * sigterm() - CATCH A TERMINATION SIGNAL
 */
void
sigterm()
{
	signal(SIGTERM, SIG_IGN);
	/*
	 * try to flush the output queue in the case of ecpp port.
	 * ignore the return code as this may not be the ecpp.
	 */
	ioctl(1, I_FLUSH, FLUSHW);
	exit(E_SUCCESS);
}

/*
 * baudrate() - RETURN BAUD RATE OF OUTPUT LINE
 */

static int baud_convert[] = {
	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
	1800, 2400, 4800, 9600, 19200, 38400, 57600,
	76800, 115200, 153600, 230400, 307200, 460800, 921600,
	1000000, 1152000, 1500000, 2000000, 2500000, 3000000,
	3500000, 4000000
};

int
baudrate()
{
	struct termio		tm;
	struct termios		tms;
	int			speed;

	if (ioctl(1, TCGETS, &tms) < 0) {
		if (ioctl(1, TCGETA, &tm) < 0) {
			return (1200);
		} else {
			speed = tm.c_cflag&CBAUD;
		}
	} else {
		speed = cfgetospeed(&tms);
	}

	return (speed ? baud_convert[speed] : 1200);
}