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