xref: /titanic_52/usr/src/cmd/lp/model/tsol_standard (revision f875b4ebb1dd9fdbeb043557cab38ab3bf7f6e01)

#
# 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 2007 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
#pragma ident	"%Z%%M%	%I%	%E% SMI"

###########
##
## Standard printer interface program.
###########

#####
#
# Until we get to the point below where the printer port
# and physical printer are initialized, we can't do much
# except exit if the Spooler/Scheduler cancels us.
#####
trap 'exit' 15

#####
#
# We can be clever about getting a hangup or interrupt, though, at least
# until the filter runs. Do this early, even though $LPTELL
# isn't defined, so that we're covered.
#####
catch_hangup () {
	if [ -n "${LPTELL}" ]
	then
		echo \
"The connection to the printer dropped; perhaps the printer went off-line?" \
		| ${LPTELL} ${printer}
	fi
	return 0
}
catch_interrupt () {
	if [ -n "${LPTELL}" ]
	then
		echo \
"Received an interrupt from the printer.  The reason is unknown,
although a common cause is that the baud rate is too high." \
		| ${LPTELL} ${printer}
	fi
	return 0
}
trap 'catch_hangup; exit_code=129 exit 129' 1
trap 'catch_interrupt; exit_code=129 exit 129' 2 3

#####
#
# Most of the time we don't want the standard error to be captured
# by the Spooler, mainly to avoid "Terminated" messages that the
# shell puts out when we get a SIGTERM. We'll save the standard
# error channel under another number, so we can use it when it
# should be captured.
#
# Open another channel to the printer port, for use when the
# regular standard output won't be directed there, such as in
# command substitution (`cmd`).
#####
exec 5>&2 2>/dev/null 3>&1

#####
#
# Set some globally used variables and functions.
#####

: ${TMPDIR:=/tmp}
: ${SPOOLDIR:=/usr/spool/lp}
: ${TERMINFO:=/usr/lib/terminfo}
: ${CHARSETDIR:=/usr/lib/charsets}

: ${LOCALPATH:=${SPOOLDIR}/bin}
PATH="/bin:/usr/bin:${LOCALPATH}"

MAX_COLS_SMALL_BANNER=40

#####
#
# On the 3.2 release of the 386unix product, the parallel port does
# not support any ioctl calls.  As a result, we cannot set the opost
# and onlcr attributes to have <NL>'s expanded to <CR><NL>.  This
# "filter" gets the job done for us.
#####
: ${FIX386BD:=${LOCALPATH}/386parallel}
if [ -n "${FIX386BD}" -a -x "${FIX386BD}" ]
then
	FIX386BD="| ${FIX386BD}"
else
	FIX386BD=""
fi

#####
# Use ${TMPPREFIX} as the prefix for all temporary files, so
# that cleanup is easy. The prefix may be up to 13 characters
# long, so you only have space for one more character to make
# a file name. If necessary, make a directory using this prefix
# for better management of unique temporary file names.
#####
TMPPREFIX=${TMPDIR}/`uname -n`$$

#####
# Before exiting, set ${exit_code} to the value with which to exit.
# Otherwise, the exit from this script will be 0.
#####
trap 'rm -fr ${TMPPREFIX}*; exit ${exit_code}' 0

#####
# ${LPTELL} is the name of a program that will send its
# standard input to the Spooler. It is used to forward
# the description of a printer fault to the Spooler,
# which uses it in an alert to the administrator.
#####
if [ ! -x "${LPTELL:=${LOCALPATH}/lp.tell}" ]
then
	fake_lptell () {
		header="no"
		while read line
		do
			if [ "no" = "${header}" ]
			then
				errmsg ERROR ${E_IP_UNKNOWN} \
		"unknown printer/interface failure" \
		"consult your system administrator;
		reasons for failure (if any) follow:"
				header=yes
			fi
			echo "${line}" >&2
		done
		return 1
	}
	LPTELL=fake_lptell
fi

#####
# ${DRAIN} is the name of a program that will wait
# long enough for data sent to the printer to print.
#####
if [ -x "${LOCALPATH}/drain.output" ]
then
	DRAIN="${LOCALPATH}/drain.output 5"	# wait only five seconds
else
	DRAIN=
fi

#####
# ${LPTSOLSEPARATOR} is the name of a program to put banner and trailer
# pages around the job.
#####
if [ -x ${LOCALPATH}/lp.tsol_separator ]
then
	LPTSOLSEPARATOR=${LOCALPATH}/lp.tsol_separator
else
	echo "${LOCALPATH}/lp.tsol_separator not found." >&2
	exit 1
fi

#####
# ${LPCAT} is the name of a program to use as a default
# filter. Minimally it should copy its standard input to
# the standard output, but it should also trap printer
# faults. The current LPCAT traps hangups (DCD dropping, SIGHUP),
# interrupts (SIGINT, SIGQUIT), broken pipe (SIGPIPE), and
# excess delays in sending data to the printer, interpreting all
# as printer faults.
#####
if [ ! -x "${LPCAT:=${LOCALPATH}/lp.cat}" ]
then
	LPCAT="cat"
fi

#####
# ${LPSET} is the name of a program that will set the
# character pitch, line pitch, page width, page length,
# and character set. It helps to have this in a single
# binary program so that (1) it's faster than calls
# to "tput"; and (2) it can access the new Terminfo
# capabilities for printers (on pre SVR3.2 machines, tput can't).
#####
if [ ! -x "${LPSET:=${LOCALPATH}/lp.set}" ]
then
	fake_lpset () {
		echo H V W L S >&2
		false
	}
	LPSET=fake_lpset
fi

internal_lpset () {
	#####
	#
	# The funny business with the "2>&1 1>&3" is to let us capture
	# the standard ERROR, not the standard OUTPUT as is the usual case
	# with foo=`cmd`. The standard output will go to the printer.
	#####
	[ -n "${stty1}" ] && stty ${stty1} 0<&1
	chk=`${LPSET} "$1" "$2" "$3" "$4" "$5" 2>&1 1>&3`
	[ -n "${stty2}" ] && stty ${stty2} 0<&1

	#####
	#
	# The standard error of the delivered ${LPSET} program
	# is a string of letters, H, V, W, L, S, which correspond
	# to cpi, lpi, width, length, and character set. A letter
	# is present only if the corresponding attribute could not
	# be set.
	#####
	for err in ${chk}
	do
		case ${err} in
		H )
			errmsg WARNING ${E_IP_BADCPI} \
		"can't select the character pitch \"${cpi}\"" \
		"check the valid pitches for the printer,
		or consult your system administrator;
		printing continues"
			;;
		V )
			errmsg WARNING ${E_IP_BADLPI} \
		"can't select the line pitch \"${lpi}\"" \
		"check the valid pitches for the printer,
		or consult your system administrator;
		printing continues"
			;;
		W )
			width=${cols}
			errmsg WARNING ${E_IP_BADWIDTH} \
		"can't select the page width \"${width}\"" \
		"check the valid widths for the printer,
		or consult your system administrator;
		printing continues"
			;;
		L )
			length=${lines}
			errmsg WARNING ${E_IP_BADLENGTH} \
		"can't select the page length \"${length}\"" \
		"check the valid lengths for the printer,
		or consult your system administrator;
		printing continues"
			;;
		S )
			errmsg WARNING ${E_IP_BADCHARSET} \
		"can't select the character set \"${CHARSET}\"" \
		"check the name given in the -S option,
		or consult your system administrator;
		printing continues"
			;;
		esac
	done
}


#####
# ${TPUT} is "tput" IF it works. We'll disable it if we get an
# ugly error message the first time we use it. See the TERM variable
# later in the script.
#
# NOTE: The check we use to see if "tput" works is to use an OLD
# Terminfo capability, like "lines". If it works with that it may
# still fail with some of the newer capabilities like "init" (SVR3.0)
# or "swidm" (SVR3.2), because the version of "tput" we have on your
# machine is older. Thus, on some of the code where ${TPUT} is used
# you'll see "2>/dev/null" being used to avoid ugly error messages.
#####
TPUT=tput

#####
# Error message formatter:
#
# Invoke as
#
#	errmsg severity message-number problem help
#
# where severity is "ERROR" or "WARNING", message-number is
# a unique identifier, problem is a short description of the
# problem, and help is a short suggestion for fixing the problem.
#####

LP_ERR_LABEL="UX:lp"

E_IP_ARGS=1
E_IP_OPTS=2
#E_IP_FILTER=3
E_IP_STTY=4
E_IP_UNKNOWN=5
E_IP_BADFILE=6
E_IP_BADCHARSET=7
E_IP_BADCPI=8
E_IP_BADLPI=9
E_IP_BADWIDTH=10
E_IP_BADLENGTH=11
E_IP_ERRORS=12		# (in slow.filter)

errmsg () {
	case $1 in
	ERROR )
		sev="  ERROR";
		;;
	WARNING )
		sev="WARNING";
		;;
	esac
#	tag=`expr "${LP_ERR_LABEL}" : "\(.*\):"``expr "${LP_ERR_LABEL}" : ".*:\(.*\)"`
	echo "${LP_ERR_LABEL}: ${sev}: $3
        TO FIX: $4" >&5
}


###########
##
## Check arguments
###########

parse () {
	echo "`expr \"$1\" : \"^[^=]*=\(.*\)\"`"
}

#####
#
# This program is invoked as
#
# ${SPOOLDIR}/.../printer request-id user title copies options files...
#
# The first three arguments are simply reprinted on the banner page,
# the fourth (copies) is used to control the number of copies to print,
# the fifth (options) is a blank separated list (in a single argument)
# of user or Spooler supplied options (without the -o prefix),
# and the last arguments are the files to print.
#####

if [ $# -lt 5 ]
then
	errmsg ERROR ${E_IP_ARGS} \
		"wrong number of arguments to interface program" \
		"consult your system administrator"
	exit 1
fi

printer=`basename $0`
request_id=$1
user_name=$2
title=$3
copies=$4
option_list=$5

shift 5
files="$*"

nobanner="no"
nofilebreak="no"
nolabels="no"
stty=

inlist=
for i in ${option_list}
do
	case "${inlist}${i}" in


	nobanner )
		nobanner="yes"
		;;

	nofilebreak )
		nofilebreak="yes"
		;;

	nolabels )
		nolabels="yes"
		;;

	#####
	#
	# If you want to add simple options (e.g. -o simple)
	# identify them here.
	#####
#	simple )
#		simple="yes"
#		;;


	cpi=pica )
		cpi=10
		;;
	cpi=elite )
		cpi=12
		;;
	cpi=* )
		cpi=`parse ${i}`
		;;

	lpi=* )
		lpi=`parse ${i}`
		;;

	length=* )
		length=`parse ${i}`
		;;

	width=* )
		width=`parse ${i}`
		;;

	#####
	#
	# If you want to add simple-value options (e.g. -o value=a)
	# identify them here.
	#####
#	value=* )
#		value=`parse ${i}`
#		;;


	#####
	#
	# If you want to add options that, like "stty",
	# take a list (e.g. -o lopt='a b c'), identify
	# them here and below (look for LOPT).
	#####
	stty=* | flist=* | lpd=* )
#LOPT	stty=* | flist=* | lpd=* | lopt=* )

		inlist=`expr "${inlist}${i}" : "^\([^=]*=\)"`
		case "${i}" in
		${inlist}\'*\' )
			item=`expr "${i}" : "^[^=]*='*\(.*\)'\$"`
			;;
		${inlist}\' )
			continue
			;;
		${inlist}\'* )
			item=`expr "${i}" : "^[^=]*='*\(.*\)\$"`
			;;
		${inlist}* )
			item=`expr "${i}" : "^[^=]*=\(.*\)\$"`
			;;
		*\' )
			item=`expr "${i}" : "^\(.*\)'\$"`
			;;
		* )
			item="${i}"
			;;
		esac

		#####
		#
		# We don't dare use "eval" because a clever user could
		# put something in an option value that we'd end up
		# exec'ing.
		#####
		case "${inlist}" in
		stty= )
			stty="${stty} ${item}"
			;;
		flist= )
			flist="${flist} ${item}"
			;;
		lpd= )
			lpd="${lpd} ${item}"
			;;
#LOPT		lopt= )
#LOPT			lopt="${lopt} ${item}"
#LOPT			;;
		esac

		case "${i}" in
		${inlist}\'*\' )
			inlist=
			;;
		${inlist}\'* )
			;;
		*\' | ${inlist}* )
			inlist=
			;;
		esac
		;;

	* )
		errmsg WARNING ${E_IP_OPTS} \
			"unrecognized \"-o ${i}\" option" \
			"check the option, resubmit if necessary
		printing continues"
		;;
	esac
done

#####
#
# Additional ``parameters'' are passed via Shell environment
# variables:
#
#	TERM	The printer type (used for Terminfo access)
#	CHARSET	The character set to choose
#	FILTER	The filter to run
#####

#####
# Set defaults for unset variables.
#####

: ${TERM:=unknown}
tput lines 1>/dev/null 2>&1 || TPUT=:

: ${CHARSET:=cs0}

if [ -z "${FILTER}" ]
then
	#####
	#
	# If no filter is being used, we have a little routine that
	# will push the data to the printer. It traps hangups (loss
	# of carrier) and checks for excessive delays in sending the
	# data to the printer. The lesser of the print rate of the printer
	# (obtained from Terminfo) or the baud rate is used to compute
	# the expected delay. If neither of these is correct, you
	# may be experiencing false alarms. If so, give the correct
	# rate, in characters per second, as a single argument.
	# An argument of 0 means don't check for delays.
	# Give an -r option to get a printout of actual delays.
	# (QUOTES ARE IMPORTANT!)
	#####
	case "$TERM" in
		PS )
			# make the "postscript" printers use postio to
			# talk to the printer and periodically get a
			# status from them
			FILTER="/usr/lib/lp/postscript/postio"
		;;
		PSR )
			# make the "reverse postscript" printers reverse the
			# output and the use postio to talk to the printer
			FILTER="/usr/lib/lp/postscript/postreverse | \
				/usr/lib/lp/postscript/postio"
		;;
		* )
			# we don't know the type, so just assume that the
			# input and output are the same
			if [ `basename "${LPCAT}"` = "lp.cat" ] ; then
				FILTER="${LPCAT} 0"	# infinite delays
				# FILTER="${LPCAT} 120"	# e.g. 120 CPS
				# FILTER="${LPCAT} -r 0 2>/tmp/delays"
				# FILTER=${LPCAT}
			fi
		;;
	esac
fi

###########
##
## Initialize the printer port
###########

#####
#
# SERIAL PORTS:
# Initialize everything.
#
# PARALLEL PORTS:
# Don't initialize baud rate.
#
# It's not obvious how to tell if a port is parallel or serial.
# However, by splitting the initialization into two steps and letting
# the serial-only part fail nicely, it'll work.
#
# Another point: The output must be a ``tty'' device. If not, don't
# bother with any of this.
#####
stty1= stty2=
tty 0<&1 1>/dev/null 2>&1 && {

	#####
	#
	# First set the default parameters,
	# then the requested parameters.
	#####

	stty \
		9600 \
			0<&1 2>/dev/null 1>&2
	stty \
		cs8 -cstopb -parenb -parodd \
		ixon -ixany \
		opost -olcuc onlcr -ocrnl -onocr -onlret -ofill \
		nl0 cr0 tab0 bs0 vt0 ff0 \
			0<&1 2>/dev/null 1>&2

	if [ -n "${stty}" ]
	then
		if stty ${stty} 0<&1 1>/dev/null 2>&5
		then
			:
		else
			errmsg ERROR ${E_IP_STTY} \
				"stty option list failed" \
				"check the \"-o stty\" option you used,
		or consult your system administrator"
			exit 1
		fi
	fi

	#####
	#
	# Here you may want to add other port initialization code.
	# Some examples:
	#
	# estty	# for printer needing hardware flow control (3B2/EPORTS)
	# fctty	# for printer needing hardware flow control (3B15,3B20)
	#####
	#estty 0<&1
	#fctty 0<&1


	##########
	#
	# Find out if we have to turn off opost before initializing the
	# printer and on after. Likewise, check clocal.
	#
	# Turning OFF opost (output postprocessing) keeps the UNIX system
	# from changing what we try to send to the printer. Turning ON
	# clocal keeps the UNIX system from dropping what we are trying to
	# send if the printer drops DTR. An example of the former is the
	# AT&T 479, which wants to send a linefeed (ASCII 10) when a page
	# width of 10 is set; with opost on, this COULD BE turned into a
	# carriage-return/linefeed pair. An example of the latter is the
	# AT&T 455, which momentarily drops DTR when it gets the
	# initialization string, is2; with clocal off, the UNIX system
	# stops sending the rest of the initialization sequence at that
	# point.
	#
	# THIS CODE MUST FOLLOW THE REST OF THE PORT INITIALIZATION CODE.
	##########
	cur_stty=`stty -a 0<&3`
	expr "${cur_stty}" : '.*-opost' 1>/dev/null 2>&1 \
		|| stty1="${stty1} -opost" stty2="${stty2} opost"
	expr "${cur_stty}" : '.*-clocal' 1>/dev/null 2>&1 \
		&& stty1="${stty1} clocal" stty2="${stty2} -clocal"
	expr "${cur_stty}" : '.* opost.*' 1>/dev/null 2>&1 \
		|| banner_filter=${FIX386BD}

}


###########
##
## Initialize the physical printer (Part I).
## Here we bring the printer to a sane state and set the page size.
###########

##########
#
# WARNING! The "echo" command will catch backslashes (\) and
# try to interpret the characters following it. Thus, using
# "echo" to print string values obtained from "tput" is dangerous.
##########

#####
# We're confident that most printers don't have backslashes
# in the control sequences for carriage return and form-feed.
# We're also confident that these don't contain newlines.
# We're also confident that most printers have a linefeed
# in the control sequence for doing a newline (move to beginning
# of next line), but we can't capture it like we do the
# carriage return or form-feed. Thus we set it unconditionally.
# We don't set form-feed if it isn't defined, however, because
# maybe the printer doesn't have a formfeed. If not set, we're
# out of luck.
#####

CR=`${TPUT} cr`
[ -z "${CR}" ] && CR="\r"

FF=`${TPUT} ff`

NL="${CR}\n"

lines=`${TPUT} lines`
[ -z "${lines}" -o 0 -ge "${lines}" ] && lines=66

cols=`${TPUT} cols`
[ -z "${cols}" -o 0 -ge "${cols}" ] && cols=132

#####
#
# Basic initialization. The ``else'' clause is equivalent,
# but covers cases where old Terminal Information Utilities are present.
#####
[ -n "${stty1}" ] && stty ${stty1} 0<&1

#
# "tput init" will return an "^M" in many cases to "stdout", i.e., printer!
# This creates problems for some PS printers
#
if [ "${TERM}" = "PS" -o "${TERM}" = "PSR" ]
then
	:
elif ${TPUT} init 2>/dev/null
then
	:
else
	pgm=`${TPUT} iprog`
	if [ -x "${pgm}" ]
	then
		eval ${pgm}
	fi

	${TPUT} is1
	${TPUT} is2

	tabset=
	if [ "8" != "`${TPUT} it`" ]
	then
		stty tab3 0<&1 1>/dev/null 2>&1

	elif `${TPUT} ht >/dev/null`
	then
		tabset="/usr/lib/tabset/${TERM}"
		if [ -r ${tabset} ]
		then
			cat -s ${tabset}
		fi
		stty tab3 0<&1 1>/dev/null 2>&1
	fi

	file=`${TPUT} if`
	if [ "${tabset}" != "${file}" -a -r "${file}" ]
	then
		cat -s "${file}"
	fi

	${TPUT} is3
	echo "${CR}\c"
fi
[ -n "${stty2}" ] && stty ${stty2} 0<&1

#####
#
# Set the page size and print spacing, but not the character set.
# We will be doing the character set later (after the header).
#####
internal_lpset "${cpi}" "${lpi}" "${width}" "${length}" ""

#####
#
# The banner page (and cancellation page) will
# use double width characters if they're available.
#####
WIDE_CS=`${TPUT} swidm 2>/dev/null` && NORM_CS=`${TPUT} rwidm 2>/dev/null`
PAD="#####${NL}"

#####
#
# Some printers need to have the banner page filtered.
#####
case "${TERM}" in

PS | PSR )
	banner_filter="/usr/lib/lp/postscript/postprint | /usr/lib/lp/postscript/postio"
	LPTELL_OPTS="-l"
	;;

esac
if [ -n "${banner_filter}" ]
then
	banner_filter="| ${banner_filter}"
fi

#####
#
# Now that the printer is ready for printing, we're able
# to record on paper a cancellation.
#####

cancel_banner () {
	echo "${PAD}${PAD}\c"
	echo "#####${WIDE_CS} Job ${request_id}${NORM_CS}${NL}\c"
	echo "#####${WIDE_CS} suspended or canceled${NORM_CS}${NL}\c"
	echo "${PAD}${PAD}\c"
}

canceled () {
	${TPUT} scs 0 2>/dev/null
	echo "${CR}\c"
	if [ "${width:-${cols}}" -lt "${MAX_COLS_SMALL_BANNER}" ]
	then
		WIDE_CS= NORM_CS=
	fi
	cancel_banner
	if [ -n "${FF}" ]
	then
		echo "${CR}${FF}\c"
	fi
}

trap 'eval canceled ${banner_filter}; exit_code=0 exit' 15


###########
##
## Print the banner page
###########

#####
#
# You may want to change the following code to get a custom banner.
#####

regular_banner () {
	echo "${CR}\c"
	echo "${PAD}${PAD}${PAD}${PAD}${PAD}\c"
	echo "#####${WIDE_CS}       User: ${user_name}${NORM_CS}${NL}\c"
	if [ -n "$ALIAS_USERNAME" ]
	then
		echo "${PAD}\c"
		echo "#####${WIDE_CS}      Alias: ${ALIAS_USERNAME}${NORM_CS}${NL}\c"
	fi
	if [ -n "${title}" ]
	then
		echo "${PAD}\c"
		echo "#####${WIDE_CS}      Title: ${title}${NORM_CS}${NL}\c"
	fi
	echo "${PAD}\c"
	echo "#####${WIDE_CS}    Printed: `LANG=C date '+%a %H:%M %h %d, %Y'`${NORM_CS}${NL}\c"
	echo "${PAD}\c"
	echo "#####${WIDE_CS} Job number: ${request_id}${NORM_CS}${NL}\c"
	echo "${PAD}${PAD}${PAD}${PAD}${PAD}\c"
	if [ -n "${FF}" ]
	then
		echo "${CR}${FF}\c"
	fi
}

small_banner () {
	echo "${CR}\c"
	echo "${PAD}\c"
	echo "#####  User: ${user_name}${NL}\c"
	if [ -n "${title}" ]
	then
		echo "##### Title: ${title}${NL}\c"
	fi
	echo "#####  Date: `LANG=C date '+%a %H:%M %h %d, %Y'`${NL}\c"
	echo "#####   Job: ${request_id}${NL}\c"
	echo "${PAD}\c"
	if [ -n "${FF}" ]
	then
		echo "${CR}${FF}\c"
	fi
}

if [ "${width:-${cols}}" -lt "${MAX_COLS_SMALL_BANNER}" ]
then
	banner=small_banner
else
	banner=regular_banner
fi

## Skip this for PS/PSR in TSOL, since lp.tsol_separator handles the banners
if [ "no" = "${nobanner}" -a "${TERM}" != "PSR" -a "${TERM}" != "PS" ]
then
	( eval "${banner} ${banner_filter}" 2>&1 1>&3 ) \
		| ${LPTELL} ${LPTELL_OPTS} ${printer}
fi

###########
##
## Surround the job by PostScript code to produce banner
## and trailerpages and page headers and footers.
##
###########

BANNER_EXIT_CODE=${TMPPREFIX}.banner.exit_code
echo 0 > ${BANNER_EXIT_CODE}
TSOLSEPARATOR_LOG=${TMPPREFIX}.banner.errmsg

tsol_bannerize () {
	TSOLSEPARATOR_OPTS="-e ${TSOLSEPARATOR_LOG}"

	if [ "yes" = "${nolabels}" ]
	then
		TSOLSEPARATOR_OPTS="${TSOLSEPARATOR_OPTS} -l"
	fi

	if [ "yes" = "${nobanner}" ]
	then
		TSOLSEPARATOR_OPTS="${TSOLSEPARATOR_OPTS} -t /dev/null -b /dev/null"
	fi

	if [ "${TERM}" = "PSR" ]
	then
		TSOLSEPARATOR_OPTS="${TSOLSEPARATOR_OPTS} -r"
	fi

	# Get rid of the #, TAB and NL characters in the title
	tsol_title=`echo $title`
	tsol_title=`echo $tsol_title | sed 's/#//g'`

	LC_TIME=C ${LPTSOLSEPARATOR} ${TSOLSEPARATOR_OPTS} "${printer}" \
	    "${request_id}" "${user_name}" "${tsol_title}" "${file}"
	echo $? > ${BANNER_EXIT_CODE}
	true
}

bannerize=tsol_bannerize

if [ "yes" = "${nobanner}" -a  "yes" = "${nolabels}" ]
then
	bannerize=cat
fi

if [ "${TERM}" != "PSR" -a "${TERM}" != "PS" ]
then
	bannerize=cat
fi


###########
##
## Initialize the physical printer (Part II)
## Here we select the character set.
## One could argue that this should be done before the banner is printed,
## but we don't, to keep the banner page looking consistent for the
## operator. You can move this code before the banner code if you
## disagree. If you do, combine it with the other call to "internal_lpset"
## to do everything in one shot.
###########
internal_lpset "" "" "" "" "${CHARSET}"

###########
##
## Print some copies of the file(s)
###########

#####
#
# The protocol between the interface program and the Spooler
# is fairly simple:
#
#	All standard error output is assumed to indicate a
#	fault WITH THE REQUEST. The output is mailed to the
#	user who submitted the print request and the print
#	request is finished.
#
#	If the interface program sets a zero exit code,
#	it is assumed that the file printed correctly.
#	If the interface program sets a non-zero exit code
#	less than 128, it is assumed that the file did not
#	print correctly, and the user will be notified.
#	In either case the print request is finished.
#
#	If the interface program sets an exit code greater
#	than 128, it is assumed that the file did not print
#	because of a printer fault. If an alert isn't already
#	active (see below) one will be activated. (Exit code
#	128 should not be used at all. The shell, which executes
#	this program, turns SIGTERM, used to kill this program
#	for a cancellation or disabling, into exit 128. The
#	Spooler thus interpretes 128 as SIGTERM.)
#
#	A message sent to the standard input of the ${LPTELL}
#	program is assumed to describe a fault WITH THE PRINTER.
#	The output is used in an alert (if alerts are defined).
#	If the fault recovery is "wait" or "begin", the printer
#	is disabled (killing the interface program if need be),
#	and the print request is left on the queue.
#	If the fault recovery is "continue", the interface program
#	is allowed to wait for the printer fault to be cleared so
#	it can resume printing.
#
# This interface program relies on filters to detect printer faults.
# In absence of a filter provided by the customer, it uses a simple
# filter (${LPCAT}) to detect the class of faults that cause DCD
# (``carrier'') drop. The protocol between the interface program and
# the filter:
#
#	The filter should exit with zero if printing was
#	successful and non-zero if printing failed because
#	of a printer fault. This interface program turns a
#	non-zero exit of the filter into an "exit 129" from
#	itself, thus telling the Spooler that a printer fault
#	(still) exists.
#
#	The filter should report printer faults via a message
#	to its standard error. This interface program takes all
#	standard error output from the filter and feeds it as
#	standard input to the ${LPTELL} program.
#
#	The filter should wait for a printer fault to clear,
#	and should resume printing when the fault clears.
#	Preferably it should resume at the top of the page
#	that was being printed when the fault occurred.
#	If it waits and finishes printing, it should exit
#	with a 0 exit code. If it can't wait, it should exit
#	with a non-zero exit code.
#
#	The interface program expects that ANY message on the
#	standard error from the filter indicates a printer fault.
#	Therefore, a filter should not put user (input) error
#	messages on the standard error, but on the standard output
#	(where the user can read them when he or she examines
#	the print-out).
#
#####

badfileyet=
i=1
while [ $i -le $copies ]
do
	for file in ${files}
	do
		if [ -r "${file}" ]
		then
			#####
			#
			# Here's where we set up the $LPTELL program to
			# capture fault messages, and...
			#
			# Here's where we print the file.
			#
			# We set up a pipeline to $LPTELL, but play a trick
			# to get the filter's standard ERROR piped instead of
			# its standard OUTPUT: Divert the standard error (#2) to
			# the standard output (#1) IN THE PIPELINE. The shell
			# will have changed #1 to be the pipe, not the
			# printer, so diverting #2 connects it to the pipe.
			# We then change the filter's #1 to a copy of the real
			# standard output (the printer port) made earlier,
			# so that is connected back to the printer again.
			#
			# We do all this inside a parenthesized expression
			# so that we can get the exit code; this is necessary
			# because the exit code of a pipeline is the exit
			# code of the right-most command, which isn't the
			# filter.
			#
			# These two tricks could be avoided by using a named
			# pipe to connect the standard error to $LPTELL. In
			# fact an early prototype of this script did just
			# that; however, the named pipe introduced a timing
			# problem. The processes that open a named pipe hang
			# until both ends of the pipe are opened. Cancelling
			# a request or disabling the printer often killed one
			# of the processes, causing the other process to hang
			# forever waiting for the other end of the pipe to
			# be opened.
			#####
			EXIT_CODE=${TMPPREFIX}e
			trap '' 1	# Let the filter handle a hangup
			trap '' 2 3	# and interrupts
			(
				#####
				# Put the 0<${file} before the "eval" to keep
				# clever users from giving a file name that
				# evaluates as something to execute.
				#####
				0<${file} $bannerize | eval ${FILTER} 2>&1 1>&3
				echo $? >${EXIT_CODE}
			) | ${LPTELL} ${LPTELL_OPTS} ${printer}

			# if lp.tsol_separator had an error, send its logged
			# error message to LPTELL.
			banner_exit_code=`cat ${BANNER_EXIT_CODE}`
			if [ -n "${banner_exit_code}" -a \
				0 -ne "${banner_exit_code}" -a \
				 -n "${LPTELL}" -a \
				-r "${TSOLSEPARATOR_LOG}" ]
			then
				cat ${TSOLSEPARATOR_LOG} | ${LPTELL} ${printer}
				echo 77 > ${EXIT_CODE}
			fi

			trap 'catch_hangup; exit_code=129 exit 129' 1
			trap 'catch_interrupt; exit_code=129 exit 129' 2 3
			exit_code=`cat ${EXIT_CODE}`

			if [ -n "${exit_code}" -a 0 -ne "${exit_code}" ]
			then
				trap '' 15  # Avoid dying from disable
				sleep 4	    # Give $LPTELL a chance to tell
				exit ${exit_code}
			fi

			if [ -n "${FF}" -a "no" = "${nofilebreak}" ]
			then
				echo "${CR}${FF}\c"
			fi

		else

			#####
			#
			# Don't complain about not being able to read
			# a file on second and subsequent copies, unless
			# we've not complained yet. This removes repeated
			# messages about the same file yet reduces the
			# chance that the user can remove a file and not
			# know that we had trouble finding it.
			#####
			if [ "${i}" -le 1 -o -z "${badfileyet}" ]
			then
				errmsg WARNING ${E_IP_BADFILE} \
					"cannot read file \"${file}\"" \
					"see if the file still exists and is readable,
		or consult your system administrator;
		printing continues"
				badfileyet=yes
			fi

		fi

	done
	i=`expr $i + 1`

done

# Skip this for TSOL, since lp.tsol_separator handles the banners
#
# if [ "no" = "${nobanner}" -a "${TERM}" = "PSR" ]
# then
# 	( eval "${banner} ${banner_filter}" 2>&1 1>&3 ) \
# 		| ${LPTELL} ${LPTELL_OPTS} ${printer}
# fi

if [ -n "${exit_code}" -a 0 -ne "${exit_code}" ]
then
	exit ${exit_code}
fi

#####
#
# Always ensure the complete job ends with a ``formfeed'', to
# let the next job start on a new page. (If someone wants to
# concatenate files, they can give them in one job.)
# So, if we haven't been putting out a ``formfeed'' between files,
# it means we haven't followed the last file with a formfeed,
# so we do it here.
#####
if [ -n "${FF}" -a "yes" = "${nofilebreak}" ]
then
	echo "${CR}${FF}\c"
fi

${DRAIN}

exit_code=0 exit 0