![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to postio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / post.src / postio|
Return to postio.c CVS log | Up to [Research Unix] / researchv10no / cmd / post.src / postio |
1.1 root 1: /*
2: *
3: * postio - RS-232 serial interface for PostScript printers
4: *
5: * A simple program that manages input and output for PostScript printers. Much
6: * has been added and changed from early versions of the program, but the basic
7: * philosophy is still the same. Don't send real data until we're certain we've
8: * connected to a PostScript printer that's in the idle state and try to hold the
9: * connection until the job is completely done. It's more work than you might
10: * expect is necessary, but should provide a reasonably reliable spooler interface
11: * that can return error indications to the caller via the program's exit status.
12: *
13: * I've added code that will let you split the program into separate read/write
14: * processes. Although it's not the default it should be useful if you have a file
15: * that will be returning useful data from the printer. The two process stuff was
16: * laid down on top of the single process code and both methods still work. The
17: * implementation isn't as good as it could be, but didn't require many changes
18: * to the original program (despite the fact that there are now many differences).
19: *
20: * By default the program still runs as a single process. The -R2 option forces
21: * separate read and write processes after the intial connection is made. If you
22: * want that as the default initialize splitme (below) to TRUE. In addition the
23: * -t option that's used to force stuff not recognized as status reports to stdout
24: * also tries to run as two processes (by setting splitme to TRUE). It will only
25: * work if the required code (ie. resetline() in ifdef.c) has been implemented
26: * for your Unix system. I've only tested the System V code.
27: *
28: * Code needed to support interactive mode has also been added, although again it's
29: * not as efficient as it could be. It depends on the system dependent procedures
30: * resetline() and setupstdin() (file ifdef.c) and for now is only guaranteed to
31: * work on System V. Can be requested using the -i option.
32: *
33: * Quiet mode (-q option) is also new, but was needed for some printers connected
34: * to RADIAN. If you're running in quiet mode no status requests will be sent to
35: * the printer while files are being transmitted (ie. in send()).
36: *
37: * The program expects to receive printer status lines that look like,
38: *
39: * %%[ status: idle; source: serial 25 ]%%
40: * %%[ status: waiting; source: serial 25 ]%%
41: * %%[ status: initializing; source: serial 25 ]%%
42: * %%[ status: busy; source: serial 25 ]%%
43: * %%[ status: printing; source: serial 25 ]%%
44: * %%[ status: PrinterError: out of paper; source: serial 25 ]%%
45: * %%[ status: PrinterError: no paper tray; source: serial 25 ]%%
46: *
47: * although this list isn't complete. Sending a '\024' (control T) character forces
48: * the return of a status report. PostScript errors detected on the printer result
49: * in the immediate transmission of special error messages that look like,
50: *
51: * %%[ Error: undefined; OffendingCommand: xxx ]%%
52: * %%[ Flushing: rest of job (to end-of-file) will be ignored ]%%
53: *
54: * although we only use the Error and Flushing keywords. Finally conditions, like
55: * being out of paper, result in other messages being sent back from the printer
56: * over the communications line. Typical PrinterError messages look like,
57: *
58: * %%[ PrinterError: out of paper; source: serial 25 ]%%
59: * %%[ PrinterError: paper jam; source: serial 25 ]%%
60: *
61: * although we only use the PrinterError keyword rather than trying to recognize
62: * all possible printer errors.
63: *
64: * The implications of using one process and only flow controlling data going to
65: * the printer are obvious. Job transmission should be reliable, but there can be
66: * data loss in stuff sent back from the printer. Usually that only caused problems
67: * with jobs designed to run on the printer and return useful data back over the
68: * communications line. If that's the kind of job you're sending call postio with
69: * the -t option. That should force the program to split into separate read and
70: * write processes and everything not bracketed by "%%[ " and " ]%%" strings goes
71: * to stdout. In otherwords the data you're expecting should be separated from the
72: * status stuff that goes to the log file (or stderr). The -R2 option does almost
73: * the same thing (ie. separate read and write processes), but everything that
74: * comes back from the printer goes to the log file (stderr by default) and you'll
75: * have to separate your data from any printer messages.
76: *
77: * A typical command line might be,
78: *
79: * postio -l /dev/tty01 -b 9600 -L log file1 file2
80: *
81: * where -l selects the line, -b sets the baud rate, and -L selects the printer
82: * log file. Since there's no default line, at least not right now, you'll always
83: * need to use the -l option, and if you don't choose a log file stderr will be
84: * used. If you have a program that will be returning data the command line might
85: * look like,
86: *
87: * postio -t -l/dev/tty01 -b9600 -Llog file >results
88: *
89: * Status stuff goes to file log while the data you're expecting back from the
90: * printer gets put in file results.
91: *
92: */
93:
94: #include <stdio.h>
95: #include <ctype.h>
96: #include <fcntl.h>
97: #include <signal.h>
98: #include <sys/types.h>
99: #include <errno.h>
100:
101: #include "ifdef.h" /* conditional compilation stuff */
102: #include "gen.h" /* general purpose definitions */
103: #include "postio.h" /* some special definitions */
104:
105: char **argv; /* global so everyone can use them */
106: int argc;
107:
108: char *prog_name = ""; /* really just for error messages */
109: int x_stat = 0; /* program exit status */
110: int debug = OFF; /* debug flag */
111: int ignore = OFF; /* what's done for FATAL errors */
112:
113: char *line = NULL; /* printer is on this tty line */
114: short baudrate = BAUDRATE; /* and running at this baud rate */
115: Baud baudtable[] = BAUDTABLE; /* converts strings to termio values */
116:
117: int stopbits = 1; /* number of stop bits */
118: int tostdout = FALSE; /* non-status stuff goes to stdout? */
119: int quiet = FALSE; /* no status queries in send() if TRUE */
120: int interactive = FALSE; /* interactive mode */
121: char *postbegin = POSTBEGIN; /* preceeds all the input files */
122: int useslowsend = FALSE; /* not recommended! */
123: int sendctrlC = TRUE; /* interrupt with ctrl-C when BUSY */
124: int window_size = -1; /* for Datakit - use -w */
125:
126: char *block = NULL; /* input file buffer */
127: int blocksize = BLOCKSIZE; /* and its size in bytes */
128: int head = 0; /* block[head] is the next character */
129: int tail = 0; /* one past the last byte in block[] */
130:
131: int splitme = FALSE; /* into READ and WRITE processes if TRUE */
132: int whatami = READWRITE; /* a READ or WRITE process - or both */
133: int canread = TRUE; /* allow reads */
134: int canwrite = TRUE; /* and writes if TRUE */
135: int otherpid = -1; /* who gets signals if greater than 1 */
136: int joinsig = SIGTRAP; /* reader gets this when writing is done */
137: int writedone = FALSE; /* and then sets this to TRUE */
138:
139: char mesg[MESGSIZE]; /* exactly what came back on ttyi */
140: char sbuf[MESGSIZE]; /* for parsing the message */
141: int next = 0; /* next character goes in mesg[next] */
142: char *mesgptr = NULL; /* printer message starts here in mesg[] */
143: char *endmesg = NULL; /* as far as readline() can go in mesg[] */
144:
145: Status status[] = STATUS; /* for converting status strings */
146: int nostatus = NOSTATUS; /* default getstatus() return value */
147:
148: int currentstate = NOTCONNECTED; /* what's happening START, SEND, or DONE */
149:
150: int ttyi = 0; /* input */
151: int ttyo = 2; /* and output file descriptors */
152:
153: FILE *fp_log = stderr; /* log file for stuff from the printer */
154:
155: /*****************************************************************************/
156:
157: main(agc, agv)
158:
159: int agc;
160: char *agv[];
161:
162: {
163:
164: /*
165: *
166: * A simple program that manages input and output for PostScript printers. Can run
167: * as a single process or as separate read/write processes. What's done depends on
168: * the value assigned to splitme when split() is called.
169: *
170: */
171:
172: argc = agc; /* other routines may want them */
173: argv = agv;
174:
175: prog_name = argv[0]; /* really just for error messages */
176:
177: init_signals(); /* sets up interrupt handling */
178: options(); /* get command line options */
179: initialize(); /* must be done after options() */
180: start(); /* make sure the printer is ready */
181: split(); /* into read/write processes - maybe */
182: arguments(); /* then send each input file */
183: done(); /* wait until the printer is finished */
184: cleanup(); /* make sure the write process stops */
185:
186: exit(x_stat); /* everything probably went OK */
187:
188: } /* End of main */
189:
190: /*****************************************************************************/
191:
192: init_signals()
193:
194: {
195:
196: void interrupt(); /* handles them if we catch signals */
197:
198: /*
199: *
200: * Makes sure we handle interrupts. The proper way to kill the program, if
201: * necessary, is to do a kill -15. That forces a call to interrupt(), which in
202: * turn tries to reset the printer and then exits with a non-zero status. If the
203: * program is running as two processes, sending SIGTERM to either the parent or
204: * child should clean things up.
205: *
206: */
207:
208: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
209: signal(SIGINT, SIG_IGN);
210: signal(SIGQUIT, SIG_IGN);
211: signal(SIGHUP, SIG_IGN);
212: } else {
213: signal(SIGHUP, interrupt);
214: signal(SIGQUIT, interrupt);
215: } /* End else */
216:
217: signal(SIGTERM, interrupt);
218:
219: } /* End of init_sig */
220:
221: /*****************************************************************************/
222:
223: options()
224:
225: {
226:
227: int ch; /* return value from getopt() */
228: char *optnames = "b:cil:qs:tw:B:L:P:R:SDI";
229:
230: extern char *optarg; /* used by getopt() */
231: extern int optind;
232:
233: /*
234: *
235: * Reads and processes the command line options. The -R2, -t, and -i options all
236: * force separate read and write processes by eventually setting splitme to TRUE
237: * (check initialize()). The -S option is not recommended and should only be used
238: * as a last resort!
239: *
240: */
241:
242: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
243: switch ( ch ) {
244: case 'b': /* baud rate string */
245: baudrate = getbaud(optarg);
246: break;
247:
248: case 'c': /* no ctrl-C's */
249: sendctrlC = FALSE;
250: break;
251:
252: case 'i': /* interactive mode */
253: interactive = TRUE;
254: break;
255:
256: case 'l': /* printer line */
257: line = optarg;
258: break;
259:
260: case 'q': /* no status queries - for RADIAN? */
261: quiet = TRUE;
262: break;
263:
264: case 's': /* use 2 stop bits - for UNISON? */
265: if ( (stopbits = atoi(optarg)) < 1 || stopbits > 2 )
266: stopbits = 1;
267: break;
268:
269: case 't': /* non-status stuff goes to stdout */
270: tostdout = TRUE;
271: break;
272:
273: case 'w': /* Datakit window size */
274: window_size = atoi(optarg);
275: break;
276:
277: case 'B': /* set the job buffer size */
278: if ( (blocksize = atoi(optarg)) <= 0 )
279: blocksize = BLOCKSIZE;
280: break;
281:
282: case 'L': /* printer log file */
283: if ( (fp_log = fopen(optarg, "w")) == NULL ) {
284: fp_log = stderr;
285: error(NON_FATAL, "can't open log file %s", optarg);
286: } /* End if */
287: break;
288:
289: case 'P': /* initial PostScript code */
290: postbegin = optarg;
291: break;
292:
293: case 'R': /* run as one or two processes */
294: if ( atoi(optarg) == 2 )
295: splitme = TRUE;
296: else splitme = FALSE;
297: break;
298:
299: case 'S': /* slow and kludged up version of send */
300: useslowsend = TRUE;
301: break;
302:
303: case 'D': /* debug flag */
304: debug = ON;
305: break;
306:
307: case 'I': /* ignore FATAL errors */
308: ignore = ON;
309: break;
310:
311: case '?': /* don't understand the option */
312: error(FATAL, "");
313: break;
314:
315: default: /* don't know what to do for ch */
316: error(FATAL, "missing case for option %c\n", ch);
317: break;
318: } /* End switch */
319: } /* End while */
320:
321: argc -= optind; /* get ready for non-option args */
322: argv += optind;
323:
324: } /* End of options */
325:
326: /*****************************************************************************/
327:
328: getbaud(rate)
329:
330: char *rate; /* string representing the baud rate */
331:
332: {
333:
334: int i; /* for looking through baudtable[] */
335:
336: /*
337: *
338: * Called from options() to convert a baud rate string into an appropriate termio
339: * value. *rate is looked up in baudtable[] and if it's found, the corresponding
340: * value is returned to the caller.
341: *
342: */
343:
344: for ( i = 0; baudtable[i].rate != NULL; i++ )
345: if ( strcmp(rate, baudtable[i].rate) == 0 )
346: return(baudtable[i].val);
347:
348: error(FATAL, "don't recognize baud rate %s", rate);
349:
350: } /* End of getbaud */
351:
352: /*****************************************************************************/
353:
354: initialize()
355:
356: {
357:
358: /*
359: *
360: * Initialization, a few checks, and a call to setupline() (file ifdef.c) to open
361: * and configure the communications line. Settings for interactive mode always
362: * take precedence. The setupstdin() call with an argument of 0 saves the current
363: * terminal settings if interactive mode has been requested - otherwise nothing's
364: * done. Unbuffering stdout (via the setbuf() call) isn't really needed on System V
365: * since it's flushed whenever terminal input is requested. It's more efficient if
366: * we buffer the stdout (on System V) but safer (for other versions of Unix) if we
367: * include the setbuf() call.
368: *
369: */
370:
371: whatami = READWRITE; /* always run start() as one process */
372: canread = canwrite = TRUE;
373:
374: if ( tostdout == TRUE ) /* force separate read/write processes */
375: splitme = TRUE;
376:
377: if ( interactive == TRUE ) { /* interactive mode settings always win */
378: quiet = FALSE;
379: tostdout = FALSE;
380: splitme = TRUE;
381: blocksize = 1;
382: postbegin = NULL;
383: useslowsend = FALSE;
384: nostatus = INTERACTIVE;
385: setbuf(stdout, NULL);
386: } /* End if */
387:
388: if ( useslowsend == TRUE ) { /* last resort only - not recommended */
389: quiet = FALSE;
390: splitme = FALSE;
391: if ( blocksize > 1024 ) /* don't send too much all at once */
392: blocksize = 1024;
393: } /* End if */
394:
395: if ( tostdout == TRUE && fp_log == stderr )
396: fp_log = NULL;
397:
398: if ( line == NULL && (interactive == TRUE || tostdout == TRUE) )
399: error(FATAL, "a printer line must be supplied - use the -l option");
400:
401: if ( (block = malloc(blocksize)) == NULL )
402: error(FATAL, "no memory");
403:
404: endmesg = mesg + sizeof mesg - 2; /* one byte from last position in mesg */
405:
406: setupline(); /* configure the communications line */
407: setupstdin(0); /* save current stdin terminal settings */
408:
409: } /* End of initialize */
410:
411: /*****************************************************************************/
412:
413: start()
414:
415: {
416:
417: /*
418: *
419: * Tries to put the printer in the IDLE state before anything important is sent.
420: * Run as a single process no matter what has been assigned to splitme. Separate
421: * read and write processes, if requested, will be created after we're done here.
422: *
423: */
424:
425: logit("printer startup\n");
426:
427: currentstate = START;
428: clearline();
429:
430: while ( 1 )
431: switch ( getstatus(1) ) {
432: case IDLE:
433: case INTERACTIVE:
434: if ( postbegin != NULL && *postbegin != '\0' )
435: Write(ttyo, postbegin, strlen(postbegin));
436: clearline();
437: return;
438:
439: case BUSY:
440: if ( sendctrlC == TRUE ) {
441: Write(ttyo, "\003", 1);
442: Rest(1);
443: } /* End if */
444: break;
445:
446: case WAITING:
447: case ERROR:
448: case FLUSHING:
449: Write(ttyo, "\004", 1);
450: Rest(1);
451: break;
452:
453: case PRINTERERROR:
454: Rest(15);
455: break;
456:
457: case DISCONNECT:
458: error(FATAL, "Disconnected - printer may be offline");
459: break;
460:
461: case ENDOFJOB:
462: case UNKNOWN:
463: clearline();
464: break;
465:
466: default:
467: Rest(1);
468: break;
469: } /* End switch */
470:
471: } /* End of start */
472:
473: /*****************************************************************************/
474:
475: split()
476:
477: {
478:
479: int pid;
480: void interrupt();
481:
482: /*
483: *
484: * If splitme is TRUE we fork a process, make the parent handle reading, and let
485: * the child take care of writing. resetline() (file ifdef.c) contains all the
486: * system dependent code needed to reset the communications line for separate
487: * read and write processes. For now it's expected to return TRUE or FALSE and
488: * that value controls whether we try the fork. I've only tested the two process
489: * stuff for System V. Other versions of resetline() may just be dummy procedures
490: * that always return FALSE. If the fork() failed previous versions continued as
491: * a single process, although the implementation wasn't quite right, but I've now
492: * decided to quit. The main reason is a Datakit channel may be configured to
493: * flow control data in both directions, and if we run postio over that channel
494: * as a single process we likely will end up in deadlock.
495: *
496: */
497:
498: if ( splitme == TRUE )
499: if ( resetline() == TRUE ) {
500: pid = getpid();
501: signal(joinsig, interrupt);
502: if ( (otherpid = fork()) == -1 )
503: error(FATAL, "can't fork");
504: else if ( otherpid == 0 ) {
505: whatami = WRITE;
506: nostatus = WRITEPROCESS;
507: otherpid = pid;
508: setupstdin(1);
509: } else whatami = READ;
510: } else if ( interactive == TRUE || tostdout == TRUE )
511: error(FATAL, "can't create two process - check resetline()");
512: else error(NON_FATAL, "running as a single process - check resetline()");
513:
514: canread = (whatami & READ) ? TRUE : FALSE;
515: canwrite = (whatami & WRITE) ? TRUE : FALSE;
516:
517: } /* End of split */
518:
519: /*****************************************************************************/
520:
521: arguments()
522:
523: {
524:
525: int fd_in; /* next input file */
526:
527: /*
528: *
529: * Makes sure all the non-option command line arguments are processed. If there
530: * aren't any arguments left when we get here we'll send stdin. Input files are
531: * only read and sent to the printer if canwrite is TRUE. Checking it here means
532: * we won't have to do it in send(). If interactive mode is TRUE we'll stay here
533: * forever sending stdin when we run out of files - exit with a break. Actually
534: * the loop is bogus and used at most once when we're in interactive mode because
535: * stdin is in a pseudo raw mode and the read() in readblock() should never see
536: * the end of file.
537: *
538: */
539:
540: if ( canwrite == TRUE )
541: do /* loop is for interactive mode */
542: if ( argc < 1 )
543: send(fileno(stdin), "pipe.end");
544: else {
545: while ( argc > 0 ) {
546: if ( (fd_in = open(*argv, O_RDONLY)) == -1 )
547: error(FATAL, "can't open %s", *argv);
548: send(fd_in, *argv);
549: close(fd_in);
550: argc--;
551: argv++;
552: } /* End while */
553: } /* End else */
554: while ( interactive == TRUE );
555:
556: } /* End of arguments */
557:
558: /*****************************************************************************/
559:
560: send(fd_in, name)
561:
562: int fd_in; /* next input file */
563: char *name; /* and it's pathname */
564:
565: {
566:
567: /*
568: *
569: * Sends file *name to the printer. There's nothing left here that depends on
570: * sending and receiving status reports, although it can be reassuring to know
571: * the printer is responding and processing our job. Only the writer gets here
572: * in the two process implementation, and in that case split() has reset nostatus
573: * to WRITEPROCESS and that's what getstatus() always returns. For now we accept
574: * the IDLE state and ENDOFJOB as legitimate and ignore the INITIALIZING state.
575: *
576: */
577:
578: if ( interactive == FALSE )
579: logit("sending file %s\n", name);
580:
581: currentstate = SEND;
582:
583: if ( useslowsend == TRUE ) {
584: slowsend(fd_in);
585: return;
586: } /* End if */
587:
588: while ( readblock(fd_in) )
589: switch ( getstatus(0) ) {
590: case IDLE:
591: case BUSY:
592: case WAITING:
593: case PRINTING:
594: case ENDOFJOB:
595: case PRINTERERROR:
596: case UNKNOWN:
597: case NOSTATUS:
598: case WRITEPROCESS:
599: case INTERACTIVE:
600: writeblock();
601: break;
602:
603: case ERROR:
604: fprintf(stderr, "%s", mesg); /* for csw */
605: error(USER_FATAL, "PostScript Error");
606: break;
607:
608: case FLUSHING:
609: error(USER_FATAL, "Flushing Job");
610: break;
611:
612: case DISCONNECT:
613: error(FATAL, "Disconnected - printer may be offline");
614: break;
615: } /* End switch */
616:
617: } /* End of send */
618:
619: /*****************************************************************************/
620:
621: done()
622:
623: {
624:
625: int sleeptime = 15; /* for 'out of paper' etc. */
626:
627: /*
628: *
629: * Tries to stay connected to the printer until we're reasonably sure the job is
630: * complete. It's the only way we can recover error messages or data generated by
631: * the PostScript program and returned over the communication line. Actually doing
632: * it correctly for all possible PostScript jobs is more difficult that it might
633: * seem. For example if we've sent several jobs, each with their own EOF mark, then
634: * waiting for ENDOFJOB won't guarantee all the jobs have completed. Even waiting
635: * for IDLE isn't good enough. Checking for the WAITING state after all the files
636: * have been sent and then sending an EOF may be the best approach, but even that
637: * won't work all the time - we could miss it or might not get there. Even sending
638: * our own special PostScript job after all the input files has it's own different
639: * set of problems, but probably could work (perhaps by printing a fake status
640: * message or just not timing out). Anyway it's probably not worth the trouble so
641: * for now we'll quit if writedone is TRUE and we get ENDOFJOB or IDLE.
642: *
643: * If we're running separate read and write processes the reader gets here after
644: * after split() while the writer goes to send() and only gets here after all the
645: * input files have been transmitted. When they're both here the writer sends the
646: * reader signal joinsig and that forces writedone to TRUE in the reader. At that
647: * point the reader can begin looking for an indication of the end of the job.
648: * The writer hangs around until the reader kills it (usually in cleanup()) sending
649: * occasional status requests.
650: *
651: */
652:
653: if ( canwrite == TRUE )
654: logit("waiting for end of job\n");
655:
656: currentstate = DONE;
657: writedone = (whatami == READWRITE) ? TRUE : FALSE;
658:
659: while ( 1 ) {
660: switch ( getstatus(1) ) {
661:
662: case WRITEPROCESS:
663: if ( writedone == FALSE ) {
664: sendsignal(joinsig);
665: Write(ttyo, "\004", 1);
666: writedone = TRUE;
667: sleeptime = 1;
668: } /* End if */
669: Rest(sleeptime++);
670: break;
671:
672: case WAITING:
673: Write(ttyo, "\004", 1);
674: Rest(1);
675: sleeptime = 15;
676: break;
677:
678: case IDLE:
679: case ENDOFJOB:
680: if ( writedone == TRUE ) {
681: logit("job complete\n");
682: return;
683: } /* End if */
684: break;
685:
686: case BUSY:
687: case PRINTING:
688: case INTERACTIVE:
689: sleeptime = 15;
690: break;
691:
692: case PRINTERERROR:
693: Rest(sleeptime++);
694: break;
695:
696: case ERROR:
697: fprintf(stderr, "%s", mesg); /* for csw */
698: error(USER_FATAL, "PostScript Error");
699: return;
700:
701: case FLUSHING:
702: error(USER_FATAL, "Flushing Job");
703: return;
704:
705: case DISCONNECT:
706: error(FATAL, "Disconnected - printer may be offline");
707: return;
708:
709: default:
710: Rest(1);
711: break;
712: } /* End switch */
713:
714: if ( sleeptime > 60 )
715: sleeptime = 60;
716: } /* End while */
717:
718: } /* End of done */
719:
720: /*****************************************************************************/
721:
722: cleanup()
723:
724: {
725:
726: int w;
727:
728: /*
729: *
730: * Only needed if we're running separate read and write processes. Makes sure the
731: * write process is killed after the read process has successfully finished with
732: * all the jobs. sendsignal() returns a -1 if there's nobody to signal so things
733: * work when we're running a single process.
734: *
735: */
736:
737: while ( sendsignal(SIGKILL) != -1 && (w = wait((int *)0)) != otherpid && w != -1 ) ;
738:
739: } /* End of cleanup */
740:
741: /*****************************************************************************/
742:
743: readblock(fd_in)
744:
745: int fd_in; /* current input file */
746:
747: {
748:
749: static long blocknum = 1;
750:
751: /*
752: *
753: * Fills the input buffer with the next block, provided we're all done with the
754: * last one. Blocks from fd_in are stored in array block[]. head is the index
755: * of the next byte in block[] that's supposed to go to the printer. tail points
756: * one past the last byte in the current block. head is adjusted in writeblock()
757: * after each successful write, while head and tail are reset here each time
758: * a new block is read. Returns the number of bytes left in the current block.
759: * Read errors cause the program to abort. The fake status message that's put out
760: * in quiet mode is only so you can look at the log file and know something's
761: * happening - take it out if you want.
762: *
763: */
764:
765: if ( head >= tail ) { /* done with the last block */
766: if ( (tail = read(fd_in, block, blocksize)) == -1 )
767: error(FATAL, "error reading input file");
768: if ( quiet == TRUE && tail > 0 ) /* put out a fake message? */
769: logit("%%%%[ status: busy; block: %d ]%%%%\n", blocknum++);
770: head = 0;
771: } /* End if */
772:
773: return(tail - head);
774:
775: } /* End of readblock */
776:
777: /*****************************************************************************/
778:
779: writeblock()
780:
781: {
782:
783: int count; /* bytes successfully written */
784:
785: /*
786: *
787: * Called from send() when it's OK to send the next block to the printer. head
788: * is adjusted after the write, and the number of bytes that were successfully
789: * written is returned to the caller.
790: *
791: */
792:
793: if ( (count = write(ttyo, &block[head], tail - head)) == -1 )
794: error(FATAL, "error writing to %s", line);
795: else if ( count == 0 )
796: error(FATAL, "printer appears to be offline");
797:
798: head += count;
799: return(count);
800:
801: } /* End of writeblock */
802:
803: /*****************************************************************************/
804:
805: getstatus(t)
806:
807: int t; /* sleep time after sending '\024' */
808:
809: {
810:
811: int gotline = FALSE; /* value returned by readline() */
812: int state = nostatus; /* representation of the current state */
813: int mesgch; /* to restore mesg[] when tostdout == TRUE */
814:
815: static int laststate = NOSTATUS; /* last state recognized */
816:
817: /*
818: *
819: * Looks for things coming back from the printer on the communications line, parses
820: * complete lines retrieved by readline(), and returns an integer representation
821: * of the current printer status to the caller. If nothing was available a status
822: * request (control T) is sent to the printer and nostatus is returned to the
823: * caller (provided quiet isn't TRUE). Interactive mode either never returns from
824: * readline() or returns FALSE.
825: *
826: */
827:
828: if ( canread == TRUE && (gotline = readline()) == TRUE ) {
829: state = parsemesg();
830: if ( state != laststate || state == UNKNOWN || mesgptr != mesg || debug == ON )
831: logit("%s", mesg);
832:
833: if ( tostdout == TRUE && currentstate != START ) {
834: mesgch = *mesgptr;
835: *mesgptr = '\0';
836: fprintf(stdout, "%s", mesg);
837: fflush(stdout);
838: *mesgptr = mesgch; /* for ERROR in send() and done() */
839: } /* End if */
840: return(laststate = state);
841: } /* End if */
842:
843: if ( (quiet == FALSE || currentstate != SEND) &&
844: (tostdout == FALSE || currentstate == START) && interactive == FALSE ) {
845: if ( Write(ttyo, "\024", 1) != 1 )
846: error(FATAL, "printer appears to be offline");
847: if ( t > 0 ) Rest(t);
848: } /* End if */
849:
850: return(nostatus);
851:
852: } /* End of getstatus */
853:
854: /*****************************************************************************/
855:
856: parsemesg()
857:
858: {
859:
860: char *e; /* end of printer message in mesg[] */
861: char *key, *val; /* keyword/value strings in sbuf[] */
862: char *p; /* for converting to lower case etc. */
863: int i; /* where *key was found in status[] */
864:
865: /*
866: *
867: * Parsing the lines that readline() stores in mesg[] is messy, and what's done
868: * here isn't completely correct nor as fast as it could be. The general format
869: * of lines that come back from the printer (assuming no data loss) is:
870: *
871: * str%%[ key: val; key: val; key: val ]%%\n
872: *
873: * where str can be most anything not containing a newline and printer reports
874: * (eg. status or error messages) are bracketed by "%%[ " and " ]%%" strings and
875: * end with a newline. Usually we'll have the string or printer report but not
876: * both. For most jobs the leading string will be empty, but could be anything
877: * generated on a printer and returned over the communications line using the
878: * PostScript print operator. I'll assume PostScript jobs are well behaved and
879: * never bracket their messages with "%%[ " and " ]%%" strings that delimit status
880: * or error messages.
881: *
882: * Printer reports consist of one or more key/val pairs, and what we're interested
883: * in (status or error indications) may not be the first pair in the list. In
884: * addition we'll sometimes want the value associated with a keyword (eg. when
885: * key = status) and other times we'll want the keyword (eg. when key = Error or
886: * Flushing). The last pair isn't terminated by a semicolon and a value string
887: * often contains many space separated words and it can even include colons in
888: * meaningful places. I've also decided to continue converting things to lower
889: * case before doing the lookup in status[]. The isupper() test is for Berkeley
890: * systems.
891: *
892: */
893:
894: if ( *(mesgptr = find("%%[ ", mesg)) != '\0' && *(e = find(" ]%%", mesgptr+4)) != '\0' ) {
895: strcpy(sbuf, mesgptr+4); /* don't change mesg[] */
896: sbuf[e-mesgptr-4] = '\0'; /* ignore the trailing " ]%%" */
897:
898: for ( key = strtok(sbuf, " :"); key != NULL; key = strtok(NULL, " :") ) {
899: if ( (val = strtok(NULL, ";")) != NULL && strcmp(key, "status") == 0 )
900: key = val;
901:
902: for ( ; *key == ' '; key++ ) ; /* skip any leading spaces */
903: for ( p = key; *p; p++ ) /* convert to lower case */
904: if ( *p == ':' ) {
905: *p = '\0';
906: break;
907: } else if ( isupper(*p) ) *p = tolower(*p);
908:
909: for ( i = 0; status[i].state != NULL; i++ )
910: if ( strcmp(status[i].state, key) == 0 )
911: return(status[i].val);
912: } /* End for */
913: } else if ( strcmp(mesg, "CONVERSATION ENDED.\n") == 0 )
914: return(DISCONNECT);
915:
916: return(mesgptr == '\0' ? nostatus : UNKNOWN);
917:
918: } /* End of parsemesg */
919:
920: /*****************************************************************************/
921:
922: char *find(str1, str2)
923:
924: char *str1; /* look for this string */
925: char *str2; /* in this one */
926:
927: {
928:
929: char *s1, *s2; /* can't change str1 or str2 too fast */
930:
931: /*
932: *
933: * Looks for *str1 in string *str2. Returns a pointer to the start of the substring
934: * if it's found or to the end of string str2 otherwise.
935: *
936: */
937:
938: for ( ; *str2 != '\0'; str2++ ) {
939: for ( s1 = str1, s2 = str2; *s1 != '\0' && *s1 == *s2; s1++, s2++ ) ;
940: if ( *s1 == '\0' )
941: break;
942: } /* End for */
943:
944: return(str2);
945:
946: } /* End of find */
947:
948: /*****************************************************************************/
949:
950: clearline()
951:
952: {
953:
954: /*
955: *
956: * Reads characters from the input line until nothing's left. Don't do anything if
957: * we're currently running separate read and write processes.
958: *
959: */
960:
961: if ( whatami == READWRITE )
962: while ( readline() != FALSE ) ;
963:
964: } /* End of clearline */
965:
966: /*****************************************************************************/
967:
968: sendsignal(sig)
969:
970: int sig; /* this goes to the other process */
971:
972: {
973:
974: /*
975: *
976: * Sends signal sig to the other process if we're running as separate read and
977: * write processes. Returns the result of the kill if there's someone else to
978: * signal or -1 if we're running alone.
979: *
980: */
981:
982: if ( whatami != READWRITE && otherpid > 1 )
983: return(kill(otherpid, sig));
984:
985: return(-1);
986:
987: } /* End of sendsignal */
988:
989: /*****************************************************************************/
990:
991: void interrupt(sig)
992:
993: int sig; /* signal that we caught */
994:
995: {
996:
997: /*
998: *
999: * Caught a signal - all except joinsig cause the program to quit. joinsig is the
1000: * signal sent by the writer to the reader after all the jobs have been transmitted.
1001: * Used to tell the read process when it can start looking for the end of the job.
1002: *
1003: */
1004:
1005: signal(sig, SIG_IGN);
1006:
1007: if ( sig != joinsig ) {
1008: x_stat |= FATAL;
1009: if ( canread == TRUE )
1010: if ( interactive == FALSE )
1011: error(NON_FATAL, "signal %d abort", sig);
1012: else error(NON_FATAL, "quitting");
1013: quit(sig);
1014: } /* End if */
1015:
1016: writedone = TRUE;
1017: signal(joinsig, interrupt);
1018:
1019: } /* End of interrupt */
1020:
1021: /*****************************************************************************/
1022:
1023: logit(mesg, a1, a2, a3)
1024:
1025: char *mesg; /* control string */
1026: unsigned a1, a2, a3; /* and possible arguments */
1027:
1028: {
1029:
1030: /*
1031: *
1032: * Simple routine that's used to write a message to the log file.
1033: *
1034: */
1035:
1036: if ( mesg != NULL && fp_log != NULL ) {
1037: fprintf(fp_log, mesg, a1, a2, a3);
1038: fflush(fp_log);
1039: } /* End if */
1040:
1041: } /* End of logit */
1042:
1043: /*****************************************************************************/
1044:
1045: error(kind, mesg, a1, a2, a3)
1046:
1047: int kind; /* FATAL or NON_FATAL error */
1048: char *mesg; /* error message control string */
1049: unsigned a1, a2, a3; /* control string arguments */
1050:
1051: {
1052:
1053: FILE *fp_err;
1054:
1055: /*
1056: *
1057: * Called when we've run into some kind of program error. First *mesg is printed
1058: * using the control string arguments a?. If kind is FATAL and we're not ignoring
1059: * errors the program will be terminated. If mesg is NULL or *mesg is the NULL
1060: * string nothing will be printed.
1061: *
1062: */
1063:
1064: fp_err = (fp_log != NULL) ? fp_log : stderr;
1065:
1066: if ( mesg != NULL && *mesg != '\0' ) {
1067: fprintf(fp_err, "%s: ", prog_name);
1068: fprintf(fp_err, mesg, a1, a2, a3);
1069: putc('\n', fp_err);
1070: } /* End if */
1071:
1072: x_stat |= kind;
1073:
1074: if ( kind != NON_FATAL && ignore == OFF )
1075: quit(SIGTERM);
1076:
1077: } /* End of error */
1078:
1079: /*****************************************************************************/
1080:
1081: quit(sig)
1082:
1083: int sig;
1084:
1085: {
1086:
1087: int w;
1088:
1089: /*
1090: *
1091: * Makes sure everything is properly cleaned up if there's a signal or FATAL error
1092: * that should cause the program to terminate. The sleep by the write process is
1093: * to help give the reset sequence a chance to reach the printer before we break
1094: * the connection - primarily for printers connected to Datakit. There's a very
1095: * slight chance the reset sequence that's sent to the printer could get us stuck
1096: * here. Simplest solution is don't bother to send it - everything works without it.
1097: * Flushing ttyo would be better, but means yet another system dependent procedure
1098: * in ifdef.c! I'll leave things be for now.
1099: *
1100: * Obscure problem on PS-810 turbos says wait a bit after sending an interrupt.
1101: * Seem to remember the printer getting into a bad state immediately after the
1102: * top was opened when the toner light was on. A sleep after sending the ctrl-C
1103: * seemed to fix things.
1104: *
1105: */
1106:
1107: signal(sig, SIG_IGN);
1108: ignore = ON;
1109:
1110: while ( sendsignal(sig) != -1 && (w = wait((int *)0)) != otherpid && w != -1 ) ;
1111:
1112: setupstdin(2);
1113:
1114: if ( currentstate != NOTCONNECTED ) {
1115: if ( sendctrlC == TRUE ) {
1116: Write(ttyo, "\003", 1);
1117: Rest(1); /* PS-810 turbo problem?? */
1118: } /* End if */
1119: Write(ttyo, "\004", 1);
1120: } /* End if */
1121:
1122: alarm(0); /* prevents sleep() loop on V9 systems */
1123: Rest(2);
1124:
1125: exit(x_stat);
1126:
1127: } /* End of quit */
1128:
1129: /*****************************************************************************/
1130:
1131: Rest(t)
1132:
1133: int t;
1134:
1135: {
1136:
1137: /*
1138: *
1139: * Used to replace sleep() calls. Only needed if we're running the program as
1140: * a read and write process and don't want to have the read process sleep. Most
1141: * sleeps are in the code because of the non-blocking read used by the single
1142: * process implementation. Probably should be a macro.
1143: *
1144: */
1145:
1146: if ( t > 0 && canwrite == TRUE )
1147: sleep(t);
1148:
1149: } /* End of Rest */
1150:
1151: /*****************************************************************************/
1152:
1153: Read(fd, buf, n)
1154:
1155: int fd;
1156: char *buf;
1157: int n;
1158:
1159: {
1160:
1161: int count;
1162:
1163: /*
1164: *
1165: * Used to replace some of the read() calls. Only needed if we're running separate
1166: * read and write processes. Should only be used to replace read calls on ttyi.
1167: * Always returns 0 to the caller if the process doesn't have its READ flag set.
1168: * Probably should be a macro.
1169: *
1170: */
1171:
1172: if ( canread == TRUE ) {
1173: if ( (count = read(fd, buf, n)) == -1 && errno == EINTR )
1174: count = 0;
1175: } else count = 0;
1176:
1177: return(count);
1178:
1179: } /* End of Read */
1180:
1181: /*****************************************************************************/
1182:
1183: Write(fd, buf, n)
1184:
1185: int fd;
1186: char *buf;
1187: int n;
1188:
1189: {
1190:
1191: int count;
1192:
1193: /*
1194: *
1195: * Used to replace some of the write() calls. Again only needed if we're running
1196: * separate read and write processes. Should only be used to replace write calls
1197: * on ttyo. Always returns n to the caller if the process doesn't have its WRITE
1198: * flag set. Should also probably be a macro.
1199: *
1200: */
1201:
1202: if ( canwrite == TRUE ) {
1203: if ( (count = write(fd, buf, n)) == -1 && errno == EINTR )
1204: count = n;
1205: } else count = n;
1206:
1207: return(count);
1208:
1209: } /* End of Write */
1210:
1211: /*****************************************************************************/
1212:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.