![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ifdef.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / postio|
Return to ifdef.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / postio |
1.1 root 1: /*
2: *
3: * Conditionally compiled routines for setting up and reading the line. Things
4: * were getting out of hand with all the ifdefs, and even though this defeats
5: * part of the purpose of conditional complilation directives, I think it's easier
6: * to follow this way. Thanks to Alan Buckwalter for the System V DKHOST code.
7: *
8: * postio now can be run as separate read and write processes, but requires that
9: * you write a procedure called resetline() and perhaps modify readline() some.
10: * I've already tested the code on System V and it seems to work. Ninth Edition
11: * and BSD code may be missing.
12: *
13: * By request I've changed the way some of the setupline() procedures (eg. in the
14: * System V implementation) handle things when no line has been given. If line is
15: * NULL the new setupline() procedures try to continue, assuming whoever called
16: * postio connected stdout to the printer. Things will only work if we can read
17: * and write stdout!
18: *
19: */
20:
21: #include <stdio.h>
22: #include <ctype.h>
23: #include <fcntl.h>
24: #include <signal.h>
25: #include <sys/types.h>
26: #include <errno.h>
27:
28: #include "ifdef.h" /* conditional header file inclusion */
29: #include "gen.h" /* general purpose definitions */
30:
31: FILE *fp_ttyi, *fp_ttyo;
32: char *ptr = mesg;
33:
34: /*****************************************************************************/
35:
36: #ifdef SYSV
37: setupline()
38:
39: {
40:
41: struct termio termio;
42:
43: /*
44: *
45: * Line initialization for SYSV. For now if no line is given (ie. line == NULL )
46: * we continue on as before using stdout as ttyi and ttyo. Doesn't work when we're
47: * running in interactive mode or forcing stuff that comes back from the printer
48: * to stdout. Both cases are now caught by a test that's been added to routine
49: * initialize(). The change is primarily for the version of lp that's available
50: * with SVR3.2.
51: *
52: */
53:
54: #ifdef DKHOST
55: if ( line != NULL && *line != '/' ) {
56: if ( strncmp(line, "DK:", 3) == 0 )
57: line += 3;
58: dkhost_connect();
59: #ifdef DKSTREAMS
60: if ( ioctl(ttyi, I_PUSH, "dknetty") == -1 )
61: error(FATAL, "ioctl error - dknetty");
62: if ( ioctl(ttyi, I_PUSH, "ldterm") == -1 )
63: error(FATAL, "ioctl error - ldterm");
64: #endif
65: } else
66: #endif
67:
68: if ( line == NULL )
69: ttyi = fileno(stdout);
70: else if ( (ttyi = open(line, O_RDWR)) == -1 )
71: error(FATAL, "can't open %s", line);
72:
73: if ( (ttyo = dup(ttyi)) == -1 )
74: error(FATAL, "can't dup file descriptor for %s", line);
75:
76: if ( stopbits == 1 )
77: stopbits = 0;
78: else stopbits = CSTOPB;
79:
80: if ( fcntl(ttyi, F_SETFL, O_NDELAY) == -1 )
81: error(FATAL, "fcntl error - F_SETFL");
82:
83: if ( ioctl(ttyi, TCGETA, &termio) == -1 )
84: error(FATAL, "ioctl error - TCGETA");
85:
86: termio.c_iflag = IXON | IGNCR;
87: termio.c_oflag = 0;
88: termio.c_cflag = HUPCL | CREAD | CS8 | stopbits | baudrate;
89: termio.c_lflag = 0;
90: termio.c_cc[VMIN] = termio.c_cc[VTIME] = 0;
91:
92: if ( ioctl(ttyi, TCSETA, &termio) == -1 )
93: error(FATAL, "ioctl error - TCSETA");
94:
95: if ( ioctl(ttyi, TCFLSH, 2) == -1 )
96: error(FATAL, "ioctl error - TCFLSH");
97:
98: fp_ttyi = fdopen(ttyi, "r");
99:
100: } /* End of setupline */
101:
102: /*****************************************************************************/
103:
104: resetline()
105:
106: {
107:
108: int flags; /* for turning O_NDELAY off */
109: struct termio termio; /* so we can reset flow control */
110:
111: /*
112: *
113: * Only used if we're running the program as separate read and write processes.
114: * Called from split() after the initial connection has been made and returns
115: * TRUE if two processes should work. Don't know if the O_NDELAY stuff is really
116: * needed, but setting c_cc[VMIN] to 1 definitely is. If we leave it be (as a 0)
117: * the read in readline() won't block!
118: *
119: */
120:
121: if ( (flags = fcntl(ttyi, F_GETFL, 0)) == -1 )
122: error(FATAL, "fcntl error - F_GETFL");
123:
124: flags &= ~O_NDELAY;
125:
126: if ( fcntl(ttyi, F_SETFL, flags) == -1 )
127: error(FATAL, "fcntl error - F_SETFL");
128:
129: if ( ioctl(ttyi, TCGETA, &termio) == -1 )
130: error(FATAL, "ioctl error - TCGETA");
131:
132: termio.c_iflag &= ~IXANY;
133: termio.c_iflag |= IXON | IXOFF;
134: termio.c_cc[VMIN] = 1;
135: termio.c_cc[VTIME] = 0;
136:
137: if ( ioctl(ttyi, TCSETA, &termio) == -1 )
138: error(FATAL, "ioctl error - TCSETA");
139:
140: return(TRUE);
141:
142: } /* End of resetline */
143:
144: /*****************************************************************************/
145:
146: setupstdin(mode)
147:
148: int mode; /* what to do with stdin settings */
149:
150: {
151:
152: struct termio termio;
153:
154: static int saved = FALSE;
155: static struct termio oldtermio;
156:
157: /*
158: *
159: * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
160: * stdin. Expect something like raw mode with no echo will be set up. Explicit
161: * code to ensure blocking reads probably isn't needed because blocksize is set
162: * to 1 when we're in interactive mode, but I've included it anyway.
163: *
164: */
165:
166: if ( interactive == TRUE )
167: switch ( mode ) {
168: case 0:
169: if ( isatty(0) != 1 )
170: error(FATAL, "stdin not a terminal - can't run interactive mode");
171: if ( ioctl(0, TCGETA, &oldtermio) == -1 )
172: error(FATAL, "can't save terminal settings");
173: saved = TRUE;
174: break;
175:
176: case 1:
177: termio = oldtermio;
178: termio.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL);
179: termio.c_cc[VMIN] = 1;
180: termio.c_cc[VTIME] = 0;
181: ioctl(0, TCSETA, &termio);
182: break;
183:
184: case 2:
185: if ( saved == TRUE )
186: ioctl(0, TCSETA, &oldtermio);
187: break;
188: } /* End switch */
189:
190: } /* End of setupstdin */
191:
192: /*****************************************************************************/
193:
194: readline()
195:
196: {
197:
198: int n; /* read() return value */
199: int ch; /* for interactive mode */
200:
201: static int tries = 0; /* consecutive times read returned 0 */
202:
203: /*
204: *
205: * Reads characters coming back from the printer on ttyi up to a newline (or EOF)
206: * or until no more characters are available. Characters are put in mesg[], the
207: * string is terminated with '\0' when we're done with a line and TRUE is returned
208: * to the caller. If complete line wasn't available FALSE is returned. Interactive
209: * mode should loop here forever, except during start(), echoing characters to
210: * stdout. If it happens to leave FALSE should be returned. The non-blocking read
211: * gets us out until split() is called.
212: *
213: * Some users (apparently just on 3B2 DKHOST systems) have had problems with the
214: * two process implementation that's forced me to kludge things up some. When a
215: * printer (on those systems) is turned off while postio is transmitting files
216: * the write process hangs in writeblock() (postio.c) - it's typically in the
217: * middle of a write() call, while the read() call (below) continually returns 0.
218: * In the original code readline() returned FALSE when read() returned 0 and we
219: * get into a loop that never ends - because the write process is hung. In the
220: * one process implementation having read return 0 is legitimate because the line
221: * is opened for no delay, but with two processes the read() blocks and a return
222: * value of 0 should never occur. From my point of view the real problem is that
223: * the write() call hangs on 3B2 DKHOST systems and apparently doesn't anywhere
224: * else. If the write returned anything less than or equal to 0 writeblock() would
225: * shut things down. The kludge I've implemented counts the number of consecutive
226: * times read() returns a 0 and if it exceeds a limit (100) the read process will
227: * shut things down. In fact one return of 0 from read() when we're in the two
228: * process mode is undoubtedly sufficient and no counting should be necessary!!!
229: * Moving the check to getstatus() should also work and is probably where things
230: * belong.
231: *
232: */
233:
234: if ( interactive == FALSE ) {
235: while ( (n = read(ttyi, ptr, 1)) != 0 ) {
236: if ( n < 0 )
237: if ( errno == EINTR )
238: continue;
239: else error(FATAL, "error reading %s", line);
240: tries = 0;
241: if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg ) {
242: *(ptr+1) = '\0';
243: if ( *ptr == '\004' )
244: strcpy(ptr, "%%[ status: endofjob ]%%\n");
245: ptr = mesg;
246: return(TRUE);
247: } /* End if */
248: ptr++;
249: } /* End while */
250: if ( canread == TRUE && canwrite == FALSE ) /* read process kludge */
251: if ( ++tries > 100 )
252: error(FATAL, "printer appears to be offline - shutting down");
253: return(FALSE);
254: } /* End if */
255:
256: if ( canwrite == TRUE ) /* don't block during start() */
257: return(FALSE);
258:
259: while ( (ch = getc(fp_ttyi)) != EOF )
260: putc(ch, stdout);
261: return(FALSE);
262:
263: } /* End of readline */
264: #endif
265:
266: /*****************************************************************************/
267:
268: #ifdef V9
269: #include <ipc.h>
270:
271: char tbuf[256]; /* temporary input buffer */
272: char *nptr = tbuf; /* next character comes from here */
273: char *eptr = tbuf; /* one past the last character in tbuf */
274:
275: setupline()
276:
277: {
278:
279: struct sgttyb sgtty;
280: struct ttydevb ttydev; /* for setting up the line */
281: static struct tchars tchar = { '\377', /* interrupt */
282: '\377', /* quit */
283: '\021', /* start output */
284: '\023', /* stop output */
285: '\377', /* end-of-file */
286: '\377' /* input delimiter */
287: };
288:
289: /*
290: *
291: * Line initialization for V9.
292: *
293: */
294:
295: if ( line == NULL ) {
296: ttyi = ttyo = 1;
297: return;
298: } /* End if */
299: alarm(120); /* watch for hanging opens */
300: if ( line[0] == '/' ) {
301: if ( (ttyi = open(line, O_RDWR)) == -1 )
302: error(FATAL, "can't open %s", line);
303: } else if ((ttyi = ipcopen(ipcpath(line, "dk", 0), "")) < 0) {
304: sleep(5); /* wait for Datakit to hangup */
305: if ((ttyi = ipcopen(ipcpath(line, "dk", 0), "")) < 0) {
306: fprintf(stderr, "%s", errstr);
307: error(FATAL, "can't ipcopen %s", line);
308: }
309: }
310: alarm(0);
311:
312: if ( (ttyo = dup(ttyi)) == -1 )
313: error(FATAL, "can't dup file descriptor for %s", line);
314:
315: if ( ioctl(ttyi, FIOPUSHLD, &tty_ld) == -1 )
316: error(FATAL, "ioctl error - FIOPUSHLD");
317:
318: if ( ioctl(ttyi, TIOCGDEV, &ttydev) == -1 )
319: error(FATAL, "ioctl error - TIOCGDEV");
320:
321: if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
322: error(FATAL, "ioctl error - TIOCGETP");
323:
324: sgtty.sg_flags &= ~ECHO;
325: sgtty.sg_flags &= ~CRMOD;
326: sgtty.sg_flags |= CBREAK;
327: ttydev.ispeed = baudrate;
328: ttydev.ospeed = baudrate;
329:
330: if ( ioctl(ttyi, TIOCSDEV, &ttydev) == -1 )
331: error(FATAL, "ioctl error - TIOCSDEV");
332:
333: if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
334: error(FATAL, "ioctl error - TIOCSETP");
335:
336: if ( ioctl(ttyi, TIOCSETC, &tchar) == -1 )
337: error(FATAL, "ioctl error - TIOCSETC");
338:
339: fp_ttyi = fdopen(ttyi, "r");
340:
341: } /* End of setupline */
342:
343: /*****************************************************************************/
344:
345: resetline()
346:
347: {
348:
349: struct sgttyb sgtty;
350:
351: /*
352: *
353: * Only used if we're running the program as separate read and write processes.
354: * Called from split() after the initial connection has been made and returns
355: * TRUE if two processes should work. Haven't tested or even compiled the stuff
356: * for separate read and write processes on Ninth Edition systems - no guarantees
357: * even though we return TRUE!
358: *
359: */
360:
361: if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
362: error(FATAL, "ioctl error - TIOCGETP");
363:
364: sgtty.sg_flags |= TANDEM;
365:
366: if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
367: error(FATAL, "ioctl error - TIOCSETP");
368:
369: return(TRUE);
370:
371: } /* End of resetline */
372:
373: /*****************************************************************************/
374:
375: setupstdin(mode)
376:
377: int mode; /* what to do with stdin settings */
378:
379: {
380:
381: struct sgttyb sgtty;
382:
383: static int saved = FALSE;
384: static struct sgttyb oldsgtty;
385:
386: /*
387: *
388: * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
389: * stdin. Expect something like raw mode with no echo will be set up. Need to make
390: * sure interrupt and quit still work - they're the only good way to exit when
391: * we're running interactive mode. I haven't tested or even compiled this code
392: * so there are no guarantees.
393: *
394: */
395:
396: if ( interactive == TRUE )
397: switch ( mode ) {
398: case 0:
399: if ( ioctl(0, TIOCGETP, &oldsgtty) == -1 )
400: error(FATAL, "can't save terminal settings");
401: saved = TRUE;
402: break;
403:
404: case 1:
405: sgtty = oldsgtty;
406: sgtty.sg_flags &= ~ECHO;
407: sgtty.sg_flags |= CBREAK;
408: ioctl(0, TIOCSETP, &sgtty);
409: break;
410:
411: case 2:
412: if ( saved == TRUE )
413: ioctl(0, TIOCSETP, &oldsgtty);
414: break;
415: } /* End switch */
416:
417: } /* End of setupstdin */
418:
419: /*****************************************************************************/
420:
421: readline()
422:
423: {
424:
425: int n; /* read() return value */
426: int ch; /* for interactive mode */
427:
428: /*
429: *
430: * Reads characters coming back from the printer on ttyi up to a newline (or EOF)
431: * and transfers each line to the mesg[] array. Everything available on ttyi is
432: * initially stored in tbuf[] and a line at a time is transferred from there to
433: * mesg[]. The string in mesg[] is terminated with a '\0' and TRUE is returned to
434: * the caller when we find a newline, EOF, or reach the end of the mesg[] array.
435: * If nothing is available on ttyi we return FALSE if a single process is being
436: * used for reads and writes, while in the two process implementation we force a
437: * one character read. Interactive mode loops here forever, except during start(),
438: * echoing everything that comes back on ttyi to stdout. The performance of a
439: * simple getc/putc loop for interactive mode was unacceptable when run under mux
440: * and has been replaced by more complicated code. When layers wasn't involved
441: * the getc/putc loop worked well.
442: *
443: */
444:
445: if ( interactive == FALSE ) {
446: while ( 1 ) {
447: while ( nptr < eptr ) { /* grab characters from tbuf */
448: *ptr = *nptr++;
449: if ( *ptr == '\r' ) continue;
450: if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg ) {
451: *(ptr+1) = '\0';
452: if ( *ptr == '\004' )
453: strcpy(ptr, "%%[ status: endofjob ]%%\n");
454: ptr = mesg;
455: return(TRUE);
456: } /* End if */
457: ++ptr;
458: } /* End for */
459:
460: nptr = eptr = tbuf;
461: if ( ioctl(ttyi, FIONREAD, &n) < 0 )
462: if ( errno == EINTR )
463: continue;
464: else error(FATAL, "ioctl error - FIONREAD");
465: if ( n <= 0 )
466: if ( canwrite == TRUE )
467: return(FALSE);
468: n = ((n < 1) ? 1 : ((n < sizeof(tbuf)) ? n : sizeof(tbuf)));
469: if ( (n = read(ttyi, tbuf, n)) < 0 )
470: if ( errno == EINTR )
471: continue;
472: else error(FATAL, "error reading line %s", line);
473: else eptr = nptr + n;
474: } /* End while */
475: } /* End if */
476:
477: if ( canwrite == TRUE ) /* don't block during start() */
478: return(FALSE);
479:
480: while ( 1 ) { /* only interactive mode gets here */
481: if ( ioctl(ttyi, FIONREAD, &n) < 0 )
482: error(FATAL, "ioctl error - FIONREAD");
483: n = ((n < 1) ? 1 : ((n < sizeof(tbuf)) ? n : sizeof(tbuf)));
484: if ( (n = read(ttyi, tbuf, n)) < 0 )
485: error(FATAL, "error reading line %s", line);
486: else if ( n == 0 ) /* should not happen */
487: error(FATAL, "end of file in interactive mode");
488: if ( write(1, tbuf, n) != n )
489: error(FATAL, "error writing to stdout");
490: } /* End while */
491:
492: return(FALSE);
493:
494: } /* End of readline */
495: #endif
496:
497: /*****************************************************************************/
498:
499: #ifdef BSD4_2
500: setupline()
501:
502: {
503:
504: struct sgttyb sgtty;
505: static struct tchars tchar = { '\377', /* interrupt */
506: '\377', /* quit */
507: '\021', /* start output */
508: '\023', /* stop output */
509: '\377', /* end-of-file */
510: '\377' /* input delimiter */
511: };
512: long lmodes;
513: int disc = NTTYDISC;
514:
515: /*
516: *
517: * Line initialization for BSD4_2. As in the System V code, if no line is given
518: * (ie. line == NULL) we continue on as before using stdout as ttyi and ttyo.
519: *
520: */
521:
522: if ( line == NULL )
523: ttyi = fileno(stdout);
524: else if ( (ttyi = open(line, O_RDWR)) == -1 )
525: error(FATAL, "can't open %s", line);
526:
527: if ( (ttyo = dup(ttyi)) == -1 )
528: error(FATAL, "can't dup file descriptor for %s", line);
529:
530: if (ioctl(ttyi, TIOCSETD, &disc) == -1 )
531: error(FATAL, "ioctl error - TIOCSETD");
532:
533: if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
534: error(FATAL, "ioctl error - TIOCGETP");
535:
536: if ( ioctl(ttyi, TIOCLGET, &lmodes) == -1 )
537: error(FATAL, "ioctl error - TIOCLGET");
538:
539: sgtty.sg_flags &= ~ECHO;
540: sgtty.sg_flags &= ~CRMOD;
541: sgtty.sg_flags |= CBREAK;
542: sgtty.sg_ispeed = baudrate;
543: sgtty.sg_ospeed = baudrate;
544: lmodes |= LDECCTQ;
545:
546: if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
547: error(FATAL, "ioctl error - TIOCSETP");
548:
549: if ( ioctl(ttyi, TIOCSETC, &tchar) == -1 )
550: error(FATAL, "ioctl error - TIOCSETC");
551:
552: if ( ioctl(ttyi, TIOCLSET, &lmodes) == -1 )
553: error(FATAL, "ioctl error - TIOCLSET");
554:
555: fp_ttyi = fdopen(ttyi, "r");
556:
557: } /* End of setupline */
558:
559: /*****************************************************************************/
560:
561: resetline()
562:
563: {
564:
565: struct sgttyb sgtty;
566:
567: /*
568: *
569: * Only used if we're running the program as separate read and write processes.
570: * Called from split() after the initial connection has been made and returns
571: * TRUE if two processes should work. Haven't tested or even compiled the stuff
572: * for separate read and write processes on Berkeley systems - no guarantees
573: * even though we return TRUE!
574: *
575: */
576:
577: if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
578: error(FATAL, "ioctl error - TIOCGETP");
579:
580: sgtty.sg_flags |= TANDEM;
581:
582: if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
583: error(FATAL, "ioctl error - TIOCSETP");
584:
585: return(TRUE);
586:
587: } /* End of resetline */
588:
589: /*****************************************************************************/
590:
591: setupstdin(mode)
592:
593: int mode; /* what to do with stdin settings */
594:
595: {
596:
597: struct sgttyb sgtty;
598:
599: static int saved = FALSE;
600: static struct sgttyb oldsgtty;
601:
602: /*
603: *
604: * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
605: * stdin. Expect something like raw mode with no echo will be set up. Need to make
606: * sure interrupt and quit still work - they're the only good way to exit when
607: * we're running interactive mode. I haven't tested or even compiled this code
608: * so there are no guarantees.
609: *
610: */
611:
612: if ( interactive == TRUE )
613: switch ( mode ) {
614: case 0:
615: if ( isatty(0) != 1 )
616: error(FATAL, "stdin not a terminal - can't run interactive mode");
617: if ( ioctl(0, TIOCGETP, &oldsgtty) == -1 )
618: error(FATAL, "can't save terminal settings");
619: saved = TRUE;
620: break;
621:
622: case 1:
623: sgtty = oldsgtty;
624: sgtty.sg_flags &= ~ECHO;
625: sgtty.sg_flags |= CBREAK;
626: ioctl(0, TIOCSETP, &sgtty);
627: break;
628:
629: case 2:
630: if ( saved == TRUE )
631: ioctl(0, TIOCSETP, &oldsgtty);
632: break;
633: } /* End switch */
634:
635: } /* End of setupstdin */
636:
637: /*****************************************************************************/
638:
639: readline()
640:
641: {
642:
643: int n; /* read() return value */
644: int ch; /* for interactive mode */
645:
646: /*
647: *
648: * Reads characters coming back from the printer on ttyo up to a newline (or EOF)
649: * or until no more characters are available. Characters are put in mesg[], the
650: * string is terminated with '\0' when we're done with a line and TRUE is returned
651: * to the caller. If complete line wasn't available FALSE is returned. Interactive
652: * mode should loop here forever, except during start(), echoing characters to
653: * stdout. If it happens to leave FALSE should be returned. Probably should read
654: * everything available on ttyi into a temporary buffer and work from there rather
655: * than reading one character at a time.
656: *
657: */
658:
659: if ( interactive == FALSE ) {
660: while ( 1 ) {
661: if ( ioctl(ttyi, FIONREAD, &n) < 0 )
662: if ( errno == EINTR )
663: continue;
664: else error(FATAL, "ioctl error - FIONREAD");
665: if ( n <= 0 )
666: if ( canwrite == TRUE )
667: return(FALSE);
668: else n = 1;
669: for ( ; n > 0; n-- ) {
670: /*if ( read(ttyi, ptr, 1) < 0 )*/
671: if ( (*ptr = getc(fp_ttyi)) == EOF )
672: if ( errno == EINTR )
673: continue;
674: else error(FATAL, "error reading %s", line);
675: if ( *ptr == '\r' ) continue;
676: if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg ) {
677: *(ptr+1) = '\0';
678: if ( *ptr == '\004' )
679: strcpy(ptr, "%%[ status: endofjob ]%%\n");
680: ptr = mesg;
681: return(TRUE);
682: } /* End if */
683: ++ptr;
684: } /* End for */
685: } /* End while */
686: } /* End if */
687:
688: if ( canwrite == TRUE ) /* don't block during start() */
689: return(FALSE);
690:
691: while ( (ch = getc(fp_ttyi)) != EOF )
692: putc(ch, stdout);
693: return(FALSE);
694:
695: } /* End of readline */
696:
697: /*****************************************************************************/
698:
699: /* @(#)strspn.c 1.2 */
700: /*LINTLIBRARY*/
701: /*
702: * Return the number of characters in the maximum leading segment
703: * of string which consists solely of characters from charset.
704: */
705: int
706: strspn(string, charset)
707: char *string;
708: register char *charset;
709: {
710: register char *p, *q;
711:
712: for(q=string; *q != '\0'; ++q) {
713: for(p=charset; *p != '\0' && *p != *q; ++p)
714: ;
715: if(*p == '\0')
716: break;
717: }
718: return(q-string);
719: }
720:
721: /* @(#)strpbrk.c 1.2 */
722: /*LINTLIBRARY*/
723: /*
724: * Return ptr to first occurance of any character from `brkset'
725: * in the character string `string'; NULL if none exists.
726: */
727:
728: char *
729: strpbrk(string, brkset)
730: register char *string, *brkset;
731: {
732: register char *p;
733:
734: do {
735: for(p=brkset; *p != '\0' && *p != *string; ++p)
736: ;
737: if(*p != '\0')
738: return(string);
739: }
740: while(*string++);
741: return((char*)0);
742: }
743:
744: /* @(#)strtok.c 1.2 */
745: /* 3.0 SID # 1.2 */
746: /*LINTLIBRARY*/
747: /*
748: * uses strpbrk and strspn to break string into tokens on
749: * sequentially subsequent calls. returns NULL when no
750: * non-separator characters remain.
751: * `subsequent' calls are calls with first argument NULL.
752: */
753:
754:
755: extern int strspn();
756: extern char *strpbrk();
757:
758: char *
759: strtok(string, sepset)
760: char *string, *sepset;
761: {
762: register char *p, *q, *r;
763: static char *savept;
764:
765: /*first or subsequent call*/
766: p = (string == (char*)0)? savept: string;
767:
768: if(p == 0) /* return if no tokens remaining */
769: return((char*)0);
770:
771: q = p + strspn(p, sepset); /* skip leading separators */
772:
773: if(*q == '\0') /* return if no tokens remaining */
774: return((char*)0);
775:
776: if((r = strpbrk(q, sepset)) == (char*)0) /* move past token */
777: savept = 0; /* indicate this is last token */
778: else {
779: *r = '\0';
780: savept = ++r;
781: }
782: return(q);
783: }
784: #endif
785:
786: /*****************************************************************************/
787:
788: #ifdef DKHOST
789:
790: #ifndef DKSTREAMS
791: short dkrmode[3] = {DKR_TIME, 0, 0};
792: #endif
793:
794: dkhost_connect()
795:
796: {
797:
798: int ofd; /* for saving and restoring stderr */
799: int dfd;
800: int retrytime = 5;
801:
802: /*
803: *
804: * Tries to connect to a Datakit destination. The extra stuff I've added to save
805: * and later restore stderr is primarily for our spooling setup at Murray Hill.
806: * postio is usually called with stderr directed to a file that will be returned
807: * to the user when the job finishes printing. Problems encountered by dkdial(),
808: * like busy messages, go to stderr but don't belong in the user's mail. They'll
809: * be temporarily directed to the log file. After we've connected stderr will be
810: * restored.
811: *
812: */
813:
814: if ( *line == '\0' )
815: error(FATAL, "incomplete Datakit line");
816:
817: if ( fp_log != NULL && fp_log != stderr ) { /* redirect dkdial errors */
818: ofd = dup(2);
819: close(2);
820: dup(fileno(fp_log));
821: } /* End if */
822:
823: while ( (dfd = ttyi = dkdial(line)) < 0 ) {
824: if ( retrytime < 0 )
825: error(FATAL, "can't connect to %s", line);
826: sleep(retrytime++);
827: if ( retrytime > 60 )
828: retrytime = 60;
829: } /* End while */
830:
831: if ( fp_log != NULL && fp_log != stderr ) { /* restore stderr */
832: close(2);
833: dup(ofd);
834: close(ofd);
835: } /* End if */
836:
837: #ifndef DKSTREAMS
838: if ( ioctl(ttyi, DIOCRMODE, dkrmode) == -1 )
839: error(FATAL, "ioctl error - DIOCRMODE");
840:
841: line = dtnamer(dkminor(ttyi));
842:
843: if ( (ttyi = open(line, O_RDWR)) == -1 )
844: error(FATAL, "can't open %s", line);
845:
846: close(dfd);
847: #endif
848:
849: } /* End of dkhost_connect */
850: #endif
851:
852: /*****************************************************************************/
853:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.