/* * 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 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* * * postio - RS-232 serial interface for PostScript printers * * A simple program that manages input and output for PostScript printers. Much * has been added and changed from early versions of the program, but the basic * philosophy is still the same. Don't send real data until we're certain we've * connected to a PostScript printer that's in the idle state and try to hold * the connection until the job is completely done. It's more work than you * might expect is necessary, but should provide a reasonably reliable spooler * interface that can return error indications to the caller via the program's * exit status. * * I've added code that will let you split the program into separate read/write * processes. Although it's not the default it should be useful if you have a * file that will be returning useful data from the printer. The two process * stuff was laid down on top of the single process code and both methods still * work. The implementation isn't as good as it could be, but didn't require * many changes to the original program (despite the fact that there are now * many differences). * * By default the program still runs as a single process. The -R2 option forces * separate read and write processes after the intial connection is made. If you * want that as the default initialize splitme (below) to TRUE. In addition the * -t option that's used to force stuff not recognized as status reports to * stdout also tries to run as two processes (by setting splitme to TRUE). It * will only work if the required code (ie. resetline() in ifdef.c) has been * implemented for your Unix system. I've only tested the System V code. * * Code needed to support interactive mode has also been added, although again * it's not as efficient as it could be. It depends on the system dependent * procedures resetline() and setupstdin() (file ifdef.c) and for now is only * guaranteed to work on System V. Can be requested using the -i option. * * Quiet mode (-q option) is also new, but was needed for some printers * connected to RADIAN. If you're running in quiet mode no status requests will * be sent to the printer while files are being transmitted (ie. in send()). * * The program expects to receive printer status lines that look like, * * %%[ status: idle; source: serial 25 ]%% * %%[ status: waiting; source: serial 25 ]%% * %%[ status: initializing; source: serial 25 ]%% * %%[ status: busy; source: serial 25 ]%% * %%[ status: printing; source: serial 25 ]%% * %%[ status: PrinterError: out of paper; source: serial 25 ]%% * %%[ status: PrinterError: no paper tray; source: serial 25 ]%% * * although this list isn't complete. Sending a '\024' (control T) character * forces the return of a status report. PostScript errors detected on the * printer result in the immediate transmission of special error messages that * look like, * * %%[ Error: undefined; OffendingCommand: xxx ]%% * %%[ Flushing: rest of job (to end-of-file) will be ignored ]%% * * although we only use the Error and Flushing keywords. Finally conditions, * like being out of paper, result in other messages being sent back from the * printer over the communications line. Typical PrinterError messages look * like, * * %%[ PrinterError: out of paper; source: serial 25 ]%% * %%[ PrinterError: paper jam; source: serial 25 ]%% * * although we only use the PrinterError keyword rather than trying to recognize * all possible printer errors. * * The implications of using one process and only flow controlling data going to * the printer are obvious. Job transmission should be reliable, but there can * be data loss in stuff sent back from the printer. Usually that only caused * problems with jobs designed to run on the printer and return useful data * back over the communications line. If that's the kind of job you're sending * call postio with the -t option. That should force the program to split into * separate read and write processes and everything not bracketed by "%%[ " * and " ]%%" strings goes to stdout. In otherwords the data you're expecting * should be separated from the status stuff that goes to the log file (or * stderr). The -R2 option does almost the same thing (ie. separate read and * write processes), but everything that comes back from the printer goes to * the log file (stderr by default) and you'll have to separate your data from * any printer messages. * * A typical command line might be, * * postio -l /dev/tty01 -b 9600 -L log file1 file2 * * where -l selects the line, -b sets the baud rate, and -L selects the printer * log file. Since there's no default line, at least not right now, you'll * always need to use the -l option, and if you don't choose a log file stderr * will be used. If you have a program that will be returning data the command * line might look like, * * postio -t -l/dev/tty01 -b9600 -Llog file >results * * Status stuff goes to file log while the data you're expecting back from the * printer gets put in file results. * */ #include <stdio.h> #include <unistd.h> #include <stdarg.h> #include <stdlib.h> #include <ctype.h> #include <fcntl.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> #include <errno.h> #include <string.h> #include <sys/ioccom.h> #include <sys/ioctl.h> #include <sys/bpp_io.h> #include <sys/ecppsys.h> #include "ifdef.h" /* conditional compilation stuff */ #include "gen.h" /* general purpose definitions */ #include "postio.h" /* some special definitions */ static char **argv; /* global so everyone can use them */ static int argc; static char *prog_name = ""; /* really just for error messages */ static int x_stat = 0; /* program exit status */ static int debug = OFF; /* debug flag */ static int ignore = OFF; /* what's done for FATAL errors */ static Baud baudtable[] = BAUDTABLE; /* converts strings to termio values */ static int quiet = FALSE; /* no status queries in send if TRUE */ char *postbegin = POSTBEGIN; /* preceeds all the input files */ static int useslowsend = FALSE; /* not recommended! */ static int splitme = FALSE; /* into READ & WRITE procs if TRUE */ static int whatami = READWRITE; /* a READ or WRITE process - or both */ static int otherpid = -1; /* who gets signals if greater than 1 */ static int joinsig = SIGTRAP; /* reader gets when writing is done */ static int writedone = FALSE; /* and then sets this to TRUE */ static char sbuf[MESGSIZE]; /* for parsing the message */ static char *mesgptr = NULL; /* printer msg starts here in mesg[] */ static Status status[] = STATUS; /* for converting status strings */ static int nostatus = NOSTATUS; /* default getstatus() return value */ static int tostdout = FALSE; /* non-status stuff goes to stdout? */ static int currentstate = NOTCONNECTED; /* START, SEND, or DONE */ char *line = NULL; /* printer is on this tty line */ short baudrate = BAUDRATE; /* and running at this baud rate */ int stopbits = 1; /* number of stop bits */ int interactive = FALSE; /* interactive mode */ char *block = NULL; /* input file buffer */ int blocksize = BLOCKSIZE; /* and its size in bytes */ int head = 0; /* block[head] is the next character */ int tail = 0; /* one past the last byte in block[] */ int canread = TRUE; /* allow reads */ int canwrite = TRUE; /* and writes if TRUE */ char mesg[MESGSIZE]; /* exactly what came back on ttyi */ char *endmesg = NULL; /* end for readline() in mesg[] */ int ttyi = 0; /* input */ int ttyo = 2; /* and output file descriptors */ FILE *fp_log = stderr; /* log file for stuff from printer */ static void init_signals(void); static void interrupt(int); static void options(void); static void initialize(void); static void initialize_parallel(void); static void start(void); static void split(void); static void arguments(void); static void send(int, char *); static void done(void); static void cleanup(void); static void clearline(void); void logit(char *, ...); static void quit(int sig); static void Rest(int t); static int parsemesg(void); static int sendsignal(int); static int writeblock(void); static int Write(int, char *, int); static short getbaud(char *); static char *find(char *, char *); void error(int, char *, ...); int getstatus(int); int readblock(int); /* from parallel.c for parallel interfaces */ extern int is_a_parallel_bpp(int); extern int bpp_state(int); extern int is_a_prnio(int); extern int prnio_state(int); extern int parallel_comm(int, int()); /* arg is bpp_state */ /* from ifdef.c for serial interfaces */ extern void setupline(void); extern void setupstdin(int); extern void slowsend(int); extern int resetline(void); extern int readline(void); /* * A simple program that manages input and output for PostScript printers. * Can run as a single process or as separate read/write processes. What's * done depends on the value assigned to splitme when split() is called. */ int nop(int fd) { return(0); } int main(int agc, char *agv[]) { argc = agc; argv = agv; prog_name = argv[0]; /* really just for error messages */ /* is this a serial or parallel port? */ init_signals(); /* sets up interrupt handling */ options(); /* get command line options */ setbuf(stderr, NULL); /* unbuffer io for stderr */ if (line) { close(1); open(line, O_RDWR); } if (is_a_prnio(1)) { initialize_parallel(); x_stat = parallel_comm(1, prnio_state); } else if (is_a_parallel_bpp(1) || (get_ecpp_status(1) == ECPP_CENTRONICS)) { initialize_parallel(); x_stat = parallel_comm(1, bpp_state); } else if (isatty(1)) { initialize(); /* must be done after options() */ start(); /* make sure the printer is ready */ split(); /* into read/write processes - maybe */ arguments(); /* then send each input file */ done(); /* wait until the printer is finished */ cleanup(); /* make sure the write process stops */ } else { initialize_parallel(); x_stat = parallel_comm(1, nop); } return (x_stat); /* everything probably went OK */ } /* * Makes sure we handle interrupts. The proper way to kill the program, if * necessary, is to do a kill -15. That forces a call to interrupt(), which in * turn tries to reset the printer and then exits with a non-zero status. If the * program is running as two processes, sending SIGTERM to either the parent or * child should clean things up. */ static void init_signals(void) { if (signal(SIGINT, interrupt) == SIG_IGN) { signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN); signal(SIGHUP, SIG_IGN); } else { signal(SIGHUP, interrupt); signal(SIGQUIT, interrupt); } signal(SIGTERM, interrupt); } /* * Reads and processes the command line options. The -R2, -t, and -i options all * force separate read and write processes by eventually setting splitme to TRUE * (check initialize()). The -S option is not recommended and should only be * used as a last resort! */ static void options(void) { int ch; /* return value from getopt() */ char *optnames = "b:il:qs:tB:L:P:R:SDI"; extern char *optarg; /* used by getopt() */ extern int optind; while ((ch = getopt(argc, argv, optnames)) != EOF) { switch (ch) { case 'b': /* baud rate string */ baudrate = getbaud(optarg); break; case 'i': /* interactive mode */ interactive = TRUE; break; case 'l': /* printer line */ line = optarg; break; case 'q': /* no status queries - for RADIAN? */ quiet = TRUE; break; case 's': /* use 2 stop bits - for UNISON? */ if ((stopbits = atoi(optarg)) < 1 || stopbits > 2) stopbits = 1; break; case 't': /* non-status stuff goes to stdout */ tostdout = TRUE; break; case 'B': /* set the job buffer size */ if ((blocksize = atoi(optarg)) <= 0) blocksize = BLOCKSIZE; break; case 'L': /* printer log file */ if ((fp_log = fopen(optarg, "w")) == NULL) { fp_log = stderr; error(NON_FATAL, "can't open log file %s", optarg); } /* End if */ break; case 'P': /* initial PostScript code */ postbegin = optarg; break; case 'R': /* run as one or two processes */ if (atoi(optarg) == 2) splitme = TRUE; else splitme = FALSE; break; case 'S': /* slow and kludged up vers. of send */ useslowsend = TRUE; break; case 'D': /* debug flag */ debug = ON; break; case 'I': /* ignore FATAL errors */ ignore = ON; break; case '?': /* don't understand the option */ error(FATAL, ""); break; default: /* don't know what to do for ch */ error(FATAL, "missing case for option %c\n", ch); break; } /* End switch */ } /* End while */ argc -= optind; /* get ready for non-option args */ argv += optind; } /* * Called from options() to convert a baud rate string into an appropriate * termio value. *rate is looked up in baudtable[] and if it's found, the * corresponding value is returned to the caller. */ static short getbaud(char *rate) /* string representing the baud rate */ { int i; /* for looking through baudtable[] */ for (i = 0; baudtable[i].rate != NULL; i++) if (strcmp(rate, baudtable[i].rate) == 0) return (baudtable[i].val); error(FATAL, "don't recognize baud rate %s", rate); /*NOTREACHED*/ return (0); } /* * Initialization, a few checks, and a call to setupline() (file ifdef.c) to * open and configure the communications line. Settings for interactive mode * always take precedence. The setupstdin() call with an argument of 0 saves * the current terminal settings if interactive mode has been requested - * otherwise nothing's done. Unbuffering stdout (via the setbuf() call) isn't * really needed on System V since it's flushed whenever terminal input is * requested. It's more efficient if we buffer the stdout (on System V) but * safer (for other versions of Unix) if we include the setbuf() call. */ static void initialize(void) { whatami = READWRITE; /* always run start() as one process */ canread = canwrite = TRUE; if (line == NULL) /* kludge for lp - they use -t option */ tostdout = FALSE; if (tostdout == TRUE) /* force separate read/write procs */ splitme = TRUE; if (interactive == TRUE) { /* interactive mode settings win */ quiet = FALSE; tostdout = FALSE; splitme = TRUE; blocksize = 1; postbegin = NULL; useslowsend = FALSE; nostatus = INTERACTIVE; setbuf(stdout, NULL); } if (useslowsend == TRUE) { /* last resort only - not recommended */ quiet = FALSE; splitme = FALSE; if (blocksize > 1024) /* don't send too much all at once */ blocksize = 1024; } if (line == NULL && (interactive == TRUE || tostdout == TRUE)) error(FATAL, "a printer line must be supplied - use the -l option"); if ((block = malloc(blocksize)) == NULL) error(FATAL, "no memory"); endmesg = mesg + sizeof mesg - 2; /* one byte from last pos. in mesg */ setupline(); /* configure the communications line */ setupstdin(0); /* save current stdin term settings */ } static void initialize_parallel(void) { if ((block = malloc(blocksize)) == NULL) error(FATAL, "no memory"); } /* * Tries to put the printer in the IDLE state before anything important is sent. * Run as a single process no matter what has been assigned to splitme. Separate * read and write processes, if requested, will be created after we're done * here. */ static void start(void) { int longwait = 0; logit("printer startup\n"); currentstate = START; clearline(); for (;;) switch (getstatus(1)) { case IDLE: case INTERACTIVE: if (postbegin != NULL && *postbegin != '\0') Write(ttyo, postbegin, strlen(postbegin)); clearline(); return; case BUSY: Write(ttyo, "\003", 1); Rest(1); break; /* 03/24/95 - bob golden * The HP LJ3 starts in waiting mode and needs the EOF to move * from waiting to idle. To see what would happen, code was added * to send the INTR on waiting and later changed to INTR/EOF. * The INTR by itself had no effect. The INTR/EOF put the * the printer in a busy status loop from which the only * recovery was to reset the printer. Until further testing * testing is done, do not send an INTR to a HPLJ3 in waiting * state. WAITING moved to a separate case to eliminate the * INTR write. */ case WAITING: Write(ttyo, "\004", 1); Rest(1); break; /* 03/24/95 - bob golden * The HP LJ3 seems to process INTR at later times. All the * longwaits are increaased to reduce the number of INTRs sent. */ case ERROR: case FLUSHING: Write(ttyo, "\004", 1); if (longwait++ == 5) { Write(ttyo, "\003", 1); Rest(5); longwait = 0; } Rest(1); break; case PRINTERERROR: Rest(15); break; case DISCONNECT: error(FATAL, "Disconnected - printer may be offline"); break; /* 03/24/95 - bob golden * The ENDJOB case has been removed. The HP LJ3 echoes all EOFs * sent so the ENDJOB has no real meaning. */ case UNKNOWN: clearline(); break; default: Rest(1); break; } /* End switch */ } /* End of start */ /* * * If splitme is TRUE we fork a process, make the parent handle reading, and let * the child take care of writing. resetline() (file ifdef.c) contains all the * system dependent code needed to reset the communications line for separate * read and write processes. For now it's expected to return TRUE or FALSE and * that value controls whether we try the fork. I've only tested the two process * stuff for System V. Other versions of resetline() may just be dummy * procedures that always return FALSE. If the fork() failed previous versions * continued as a single process, although the implementation wasn't quite * right, but I've now decided to quit. The main reason is a Datakit channel * may be configured to flow control data in both directions, and if we run * postio over that channel as a single process we likely will end up in * deadlock. */ static void split(void) { int pid; if (splitme == TRUE) if (resetline() == TRUE) { pid = getpid(); signal(joinsig, interrupt); if ((otherpid = fork()) == -1) error(FATAL, "can't fork"); else if (otherpid == 0) { whatami = WRITE; nostatus = WRITEPROCESS; otherpid = pid; setupstdin(1); } else whatami = READ; } else if (interactive == TRUE || tostdout == TRUE) error(FATAL, "can't create two process - check resetline()"); else error(NON_FATAL, "running as a single process - check resetline()"); canread = (whatami & READ) ? TRUE : FALSE; canwrite = (whatami & WRITE) ? TRUE : FALSE; } /* * Makes sure all the non-option command line arguments are processed. If there * aren't any arguments left when we get here we'll send stdin. Input files are * only read and sent to the printer if canwrite is TRUE. Checking it here means * we won't have to do it in send(). If interactive mode is TRUE we'll stay here * forever sending stdin when we run out of files - exit with a break. Actually * the loop is bogus and used at most once when we're in interactive mode * because stdin is in a pseudo raw mode and the read() in readblock() should * never see the end of file. */ static void arguments(void) { int fd_in; /* next input file */ if (canwrite == TRUE) do /* loop is for interactive mode */ if (argc < 1) send(fileno(stdin), "pipe.end"); else { while (argc > 0) { if ((fd_in = open(*argv, O_RDONLY)) == -1) error(FATAL, "can't open %s", *argv); send(fd_in, *argv); close(fd_in); argc--; argv++; } } while (interactive == TRUE); } /* * Sends file *name to the printer. There's nothing left here that depends on * sending and receiving status reports, although it can be reassuring to know * the printer is responding and processing our job. Only the writer gets here * in the two process implementation, and in that case split() has reset * nostatus to WRITEPROCESS and that's what getstatus() always returns. For * now we accept the IDLE state and ENDOFJOB as legitimate and ignore the * INITIALIZING state. * * fd_in next input file * name it's pathname */ static void send(int fd_in, char *name) { if (interactive == FALSE) logit("sending file %s\n", name); currentstate = SEND; if (useslowsend == TRUE) { slowsend(fd_in); return; } while (readblock(fd_in)) switch (getstatus(0)) { case IDLE: case BUSY: case WAITING: case PRINTING: case ENDOFJOB: case PRINTERERROR: case UNKNOWN: case NOSTATUS: case WRITEPROCESS: case INTERACTIVE: writeblock(); break; case ERROR: fprintf(stderr, "%s", mesg); /* for csw */ error(USER_FATAL, "PostScript Error"); break; case FLUSHING: error(USER_FATAL, "Flushing Job"); break; case DISCONNECT: error(FATAL, "Disconnected - printer may be offline"); break; } } /* * Tries to stay connected to the printer until we're reasonably sure the job is * complete. It's the only way we can recover error messages or data generated * by the PostScript program and returned over the communication line. Actually * doing it correctly for all possible PostScript jobs is more difficult that it * might seem. For example if we've sent several jobs, each with their own EOF * mark, then waiting for ENDOFJOB won't guarantee all the jobs have completed. * Even waiting for IDLE isn't good enough. Checking for the WAITING state after * all the files have been sent and then sending an EOF may be the best * approach, but even that won't work all the time - we could miss it or might * not get there. Even sending our own special PostScript job after all the * input files has it's own different set of problems, but probably could work * (perhaps by printing a fake status message or just not timing out). Anyway * it's probably not worth the trouble so for now we'll quit if writedone is * TRUE and we get ENDOFJOB or IDLE. * * If we're running separate read and write processes the reader gets here after * after split() while the writer goes to send() and only gets here after all * the input files have been transmitted. When they're both here the writer * sends the reader signal joinsig and that forces writedone to TRUE in the * reader. At that point the reader can begin looking for an indication of the * end of the job. The writer hangs around until the reader kills it (usually * in cleanup()) sending occasional status requests. */ static void done(void) { int sleeptime = 15; /* for 'out of paper' etc. */ int longwait = 0; if (canwrite == TRUE) logit("waiting for end of job\n"); currentstate = DONE; writedone = (whatami == READWRITE) ? TRUE : FALSE; for (;;) { switch (getstatus(1)) { case WRITEPROCESS: if (writedone == FALSE) { sendsignal(joinsig); Write(ttyo, "\004", 1); writedone = TRUE; sleeptime = 1; } Rest(sleeptime++); break; /* 03/24/95 - bob golden * For the HP LJ3 INTR sent while in the waiting state have * either had no effect or put the printer into a unrecoverable * loop. Further testing may reveal this to not be the case * but for now, remove the send INTR. */ case WAITING: Write(ttyo, "\004", 1); Rest(1); sleeptime = 15; break; /* 03/24/95 - bob golden * ENDOFJOB case removed here. The HP LJ 3 echoes all EOFs sent so * the ENDOFJOB case is meaningless. */ case IDLE: if (writedone == TRUE) { logit("job complete\n"); return; } break; /* 03/24/95 - bob golden * During print data transmission, the HP LJ3 stays in * status busy. So give it a rest. * */ case BUSY: case PRINTING: Rest(1); sleeptime = 15; break; case INTERACTIVE: Write(ttyo, "\004", 1); sleeptime = 15; break; case PRINTERERROR: Rest(sleeptime++); break; case ERROR: Write(ttyo, "\004", 1); fprintf(stderr, "%s", mesg); /* for csw */ error(USER_FATAL, "PostScript Error"); return; case FLUSHING: Write(ttyo, "\004", 1); error(USER_FATAL, "Flushing Job"); return; case DISCONNECT: error(FATAL, "Disconnected - printer may be offline"); return; /* 03/24/95 - bob golden * These cases are ignored without a EOF being sent */ case ENDOFJOB: case NOSTATUS: Rest(1); break; default: Write(ttyo, "\004", 1); Rest(1); break; } if (sleeptime > 60) sleeptime = 60; } } /* * Only needed if we're running separate read and write processes. Makes sure * the write process is killed after the read process has successfully finished * with all the jobs. sendsignal() returns a -1 if there's nobody to signal so * things work when we're running a single process. */ static void cleanup(void) { int w; while (sendsignal(SIGKILL) != -1 && (w = wait((int *)0)) != otherpid && w != -1); if ( currentstate != NOTCONNECTED ) Write(ttyo, "\004", 1); } /* * Fills the input buffer with the next block, provided we're all done with the * last one. Blocks from fd_in are stored in array block[]. head is the index * of the next byte in block[] that's supposed to go to the printer. tail points * one past the last byte in the current block. head is adjusted in writeblock() * after each successful write, while head and tail are reset here each time * a new block is read. Returns the number of bytes left in the current block. * Read errors cause the program to abort. The fake status message that's put * out in quiet mode is only so you can look at the log file and know * something's happening - take it out if you want. */ int readblock(int fd_in) { static long blocknum = 1; if (head >= tail) { /* done with the last block */ if ((tail = read(fd_in, block, blocksize)) == -1) error(FATAL, "error reading input file"); if (quiet == TRUE && tail > 0) /* put out a fake message? */ logit("%%%%[ status: busy; block: %d ]%%%%\n", blocknum++); head = 0; } return (tail - head); } /* * Called from send() when it's OK to send the next block to the printer. head * is adjusted after the write, and the number of bytes that were successfully * written is returned to the caller. */ static int writeblock(void) { int count; /* bytes successfully written */ if ((count = write(ttyo, &block[head], tail - head)) == -1) error(FATAL, "error writing to %s", line); else if (count == 0) error(FATAL, "printer appears to be offline"); head += count; return (count); } /* * Looks for things coming back from the printer on the communications line, * parses complete lines retrieved by readline(), and returns an integer * representation of the current printer status to the caller. If nothing was * available a status request (control T) is sent to the printer and nostatus * is returned to the caller (provided quiet isn't TRUE). Interactive mode * either never returns from readline() or returns FALSE. */ int getstatus(int t) /* sleep time after sending '\024' */ { int state = nostatus; /* the current state */ static int laststate = NOSTATUS; /* last state recognized */ if (canread == TRUE && readline() == TRUE) { state = parsemesg(); if (state != laststate || mesgptr != mesg || debug == ON) logit("%s", mesg); if (tostdout == TRUE && currentstate != START) { *mesgptr = '\0'; fprintf(stdout, "%s", mesg); } return (laststate = state); } if ((quiet == FALSE || currentstate != SEND) && interactive == FALSE) { if (Write(ttyo, "\024", 1) != 1) error(FATAL, "printer appears to be offline"); if (t > 0) Rest(t); } return (nostatus); } /* * * Parsing the lines that readline() stores in mesg[] is messy, and what's done * here isn't completely correct nor as fast as it could be. The general format * of lines that come back from the printer (assuming no data loss) is: * * str%%[ key: val; key: val; key: val ]%%\n * * where str can be most anything not containing a newline and printer reports * (eg. status or error messages) are bracketed by "%%[ " and " ]%%" strings and * end with a newline. Usually we'll have the string or printer report but not * both. For most jobs the leading string will be empty, but could be anything * generated on a printer and returned over the communications line using the * PostScript print operator. I'll assume PostScript jobs are well behaved and * never bracket their messages with "%%[ " and " ]%%" strings that delimit * status or error messages. * * Printer reports consist of one or more key/val pairs, and what we're * interested in (status or error indications) may not be the first pair in the * list. In addition we'll sometimes want the value associated with a keyword * (eg. when key = status) and other times we'll want the keyword (eg. when * key = Error or Flushing). The last pair isn't terminated by a semicolon and * a value string often contains many space separated words and it can even * include colons in meaningful places. I've also decided to continue * converting things to lower case before doing the lookup in status[]. The * isupper() test is for Berkeley systems. */ static int parsemesg(void) { char *e; /* end of printer message in mesg[] */ char *key, *val; /* keyword/value strings in sbuf[] */ char *p; /* for converting to lower case etc. */ int i; /* where *key was found in status[] */ if (*(mesgptr = find("%%[ ", mesg)) != '\0' && *(e = find(" ]%%", mesgptr+4)) != '\0') { strcpy(sbuf, mesgptr+4); /* don't change mesg[] */ sbuf[e-mesgptr-4] = '\0'; /* ignore the trailing " ]%%" */ for (key = strtok(sbuf, " :"); key != NULL; key = strtok(NULL, " :")) { if ((val = strtok(NULL, ";")) != NULL && strcmp(key, "status") == 0) key = val; for (; *key == ' '; key++); /* skip leading space */ for (p = key; *p; p++) /* conv to lower case */ if (*p == ':' || *p == ',') { *p = '\0'; break; } else if (isupper(*p)) *p = tolower(*p); for (i = 0; status[i].state != NULL; i++) if (strcmp(status[i].state, key) == 0) return (status[i].val); } } else if (strcmp(mesg, "CONVERSATION ENDED.\n") == 0) return (DISCONNECT); return (nostatus); } /* * Looks for *str1 in string *str2. Returns a pointer to the start of the * substring if it's found or to the end of string str2 otherwise. */ static char * find(char *str1, char *str2) { char *s1, *s2; /* can't change str1 or str2 too fast */ for (; *str2 != '\0'; str2++) { for (s1 = str1, s2 = str2; *s1 != '\0' && *s1 == *s2; s1++, s2++); if (*s1 == '\0') break; } return (str2); } /* * Reads characters from the input line until nothing's left. Don't do * anything if we're currently running separate read and write processes. */ static void clearline(void) { if (whatami == READWRITE) while (readline() != FALSE); } /* * Sends signal sig to the other process if we're running as separate read and * write processes. Returns the result of the kill if there's someone else to * signal or -1 if we're running alone. * */ static int sendsignal(int sig) { if (whatami != READWRITE && otherpid > 1) return (kill(otherpid, sig)); return (-1); } /* * Caught a signal - all except joinsig cause the program to quit. joinsig is * the signal sent by the writer to the reader after all the jobs have been * transmitted. Used to tell the read process when it can start looking for * the end of the job. */ static void interrupt(int sig) { signal(sig, SIG_IGN); if (sig != joinsig) { x_stat |= FATAL; if (canread == TRUE) if (interactive == FALSE) error(NON_FATAL, "signal %d abort", sig); else error(NON_FATAL, "quitting"); quit(sig); } writedone = TRUE; signal(joinsig, interrupt); } /* * Simple routine that's used to write a message to the log file. */ void logit(char *mesg, ...) { va_list ap; va_start(ap, mesg); vfprintf(fp_log, mesg, ap); va_end(ap); fflush(fp_log); } /* * Called when we've run into some kind of program error. First *mesg is * printed. If kind is FATAL and we're not ignoring errors the program * will be terminated. If mesg is NULL or *mesg is the NULL string nothing * will be printed. */ void error(int kind, char *mesg, ...) { va_list ap; if (mesg != NULL && *mesg != '\0') { fprintf(fp_log, "%s: ", prog_name); va_start(ap, mesg); vfprintf(fp_log, mesg, ap); va_end(ap); putc('\n', fp_log); } x_stat |= kind; if (kind != NON_FATAL && ignore == OFF) quit(SIGTERM); } /* * * Makes sure everything is properly cleaned up if there's a signal or FATAL * error that should cause the program to terminate. The sleep by the write * process is to help give the reset sequence a chance to reach the printer * before we break the connection - primarily for printers connected to Datakit. * There's a very slight chance the reset sequence that's sent to the printer * could get us stuck here. Simplest solution is don't bother to send it - * everything works without it. Flushing ttyo would be better, but means yet * another system dependent procedure in ifdef.c! I'll leave things be for now. */ static void quit(int sig) { int w; signal(sig, SIG_IGN); ignore = ON; while (sendsignal(sig) != -1 && (w = wait((int *)0)) != otherpid && w != -1); setupstdin(2); if (currentstate != NOTCONNECTED) Write(ttyo, "\003\004", 2); alarm(0); /* prevents sleep() loop on V9 systems */ Rest(2); exit(x_stat); } /* * Used to replace sleep() calls. Only needed if we're running the program as * a read and write process and don't want to have the read process sleep. Most * sleeps are in the code because of the non-blocking read used by the single * process implementation. Probably should be a macro. */ static void Rest(int t) { if (t > 0 && canwrite == TRUE) sleep(t); } /* * Used to replace some of the read() calls. Only needed if we're running * separate read and write processes. Should only be used to replace read calls * on ttyi. Always returns 0 to the caller if the process doesn't have its * READ flag set. Probably should be a macro. */ #ifdef NEVER static int Read(int fd, char *buf, int n) { int count; if (canread == TRUE) { if ((count = read(fd, buf, n)) == -1 && errno == EINTR) count = 0; } else count = 0; return (count); } #endif /* NEVER */ /* * * Used to replace some of the write() calls. Again only needed if we're running * separate read and write processes. Should only be used to replace write calls * on ttyo. Always returns n to the caller if the process doesn't have its WRITE * flag set. Should also probably be a macro. * */ static int Write(int fd, char *buf, int n) { int count; if (canwrite == TRUE) { if ((count = write(fd, buf, n)) == -1 && errno == EINTR) count = n; } else count = n; return (count); }
