![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rlogin.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / foreign / src / rlogin|
Return to rlogin.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / foreign / src / rlogin |
1.1 root 1: /*
2: * Copyright (c) 1983, 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1983, 1990 The Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)rlogin.c 5.32.1.1 (Berkeley) 10/21/90";
28: #endif /* not lint */
29:
30: /*
31: * $Source: mit/rlogin/RCS/rlogin.c,v $
32: * $Header: mit/rlogin/RCS/rlogin.c,v 5.2 89/07/26 12:11:21 kfall
33: * Exp Locker: kfall $
34: */
35:
36: /*
37: * rlogin - remote login
38: */
39: #include <sys/param.h>
40: #include <sys/file.h>
41: #include <sys/socket.h>
42: #include <sys/signal.h>
43: #include <sys/time.h>
44: #include <sys/resource.h>
45: #include <sys/wait.h>
46:
47: #include <netinet/in.h>
48: #include <netinet/in_systm.h>
49: #include <netinet/ip.h>
50: #include <netdb.h>
51:
52: #include <sgtty.h>
53: #include <setjmp.h>
54: #include <varargs.h>
55: #include <errno.h>
56: #include <pwd.h>
57: #include <stdio.h>
58: #include <unistd.h>
59: #include <string.h>
60:
61: #ifdef KERBEROS
62: #include <kerberosIV/des.h>
63: #include <kerberosIV/krb.h>
64:
65: CREDENTIALS cred;
66: Key_schedule schedule;
67: int use_kerberos = 1, encrypt;
68: char dst_realm_buf[REALM_SZ], *dest_realm = NULL;
69: extern char *krb_realmofhost();
70: #endif
71:
72: #ifndef TIOCPKT_WINDOW
73: #define TIOCPKT_WINDOW 0x80
74: #endif
75:
76: /* concession to Sun */
77: #ifndef SIGUSR1
78: #define SIGUSR1 30
79: #endif
80:
81: extern int errno;
82: int eight, litout, rem;
83:
84: int noescape;
85: u_char escapechar = '~';
86:
87: char *speeds[] = {
88: "0", "50", "75", "110", "134", "150", "200", "300", "600", "1200",
89: "1800", "2400", "4800", "9600", "19200", "38400"
90: };
91:
92: #ifdef sun
93: struct winsize {
94: unsigned short ws_row, ws_col;
95: unsigned short ws_xpixel, ws_ypixel;
96: };
97: #endif
98: struct winsize winsize;
99:
100: #ifndef sun
101: #define get_window_size(fd, wp) ioctl(fd, TIOCGWINSZ, wp)
102: #endif
103:
104: void exit();
105:
106: main(argc, argv)
107: int argc;
108: char **argv;
109: {
110: extern char *optarg;
111: extern int optind;
112: struct passwd *pw;
113: struct servent *sp;
114: struct sgttyb ttyb;
115: long omask;
116: int argoff, ch, dflag, one, uid;
117: char *host, *p, *user, term[1024];
118: void lostpeer();
119: u_char getescape();
120: char *getenv();
121:
122: argoff = dflag = 0;
123: one = 1;
124: host = user = NULL;
125:
126: if (p = rindex(argv[0], '/'))
127: ++p;
128: else
129: p = argv[0];
130:
131: if (strcmp(p, "rlogin"))
132: host = p;
133:
134: /* handle "rlogin host flags" */
135: if (!host && argc > 2 && argv[1][0] != '-') {
136: host = argv[1];
137: argoff = 1;
138: }
139:
140: #ifdef KERBEROS
141: #define OPTIONS "8EKLde:k:l:x"
142: #else
143: #define OPTIONS "8EKLde:l:"
144: #endif
145: while ((ch = getopt(argc - argoff, argv + argoff, OPTIONS)) != EOF)
146: switch(ch) {
147: case '8':
148: eight = 1;
149: break;
150: case 'E':
151: noescape = 1;
152: break;
153: case 'K':
154: #ifdef KERBEROS
155: use_kerberos = 0;
156: #endif
157: break;
158: case 'L':
159: litout = 1;
160: break;
161: case 'd':
162: dflag = 1;
163: break;
164: case 'e':
165: escapechar = getescape(optarg);
166: break;
167: #ifdef KERBEROS
168: case 'k':
169: dest_realm = dst_realm_buf;
170: (void)strncpy(dest_realm, optarg, REALM_SZ);
171: break;
172: #endif
173: case 'l':
174: user = optarg;
175: break;
176: case '?':
177: default:
178: usage();
179: }
180: optind += argoff;
181: argc -= optind;
182: argv += optind;
183:
184: /* if haven't gotten a host yet, do so */
185: if (!host && !(host = *argv++))
186: usage();
187:
188: if (*argv)
189: usage();
190:
191: if (!(pw = getpwuid(uid = getuid()))) {
192: (void)fprintf(stderr, "rlogin: unknown user id.\n");
193: exit(1);
194: }
195: if (!user)
196: user = pw->pw_name;
197:
198: sp = NULL;
199: #ifdef KERBEROS
200: if (use_kerberos) {
201: sp = getservbyname((encrypt ? "eklogin" : "klogin"), "tcp");
202: if (sp == NULL) {
203: use_kerberos = 0;
204: warning("can't get entry for %s/tcp service",
205: encrypt ? "eklogin" : "klogin");
206: }
207: }
208: #endif
209: if (sp == NULL)
210: sp = getservbyname("login", "tcp");
211: if (sp == NULL) {
212: (void)fprintf(stderr, "rlogin: login/tcp: unknown service.\n");
213: exit(1);
214: }
215:
216: (void)strcpy(term, (p = getenv("TERM")) ? p : "network");
217: if (ioctl(0, TIOCGETP, &ttyb) == 0) {
218: (void)strcat(term, "/");
219: (void)strcat(term, speeds[ttyb.sg_ospeed]);
220: }
221:
222: (void)get_window_size(0, &winsize);
223:
224: (void)signal(SIGPIPE, lostpeer);
225: /* will use SIGUSR1 for window size hack, so hold it off */
226: omask = sigblock(sigmask(SIGURG) | sigmask(SIGUSR1));
227:
228: #ifdef KERBEROS
229: try_connect:
230: if (use_kerberos) {
231: rem = KSUCCESS;
232: errno = 0;
233: if (dest_realm == NULL)
234: dest_realm = krb_realmofhost(host);
235:
236: rem = krcmd(&host, sp->s_port, user, term, 0,
237: dest_realm);
238: if (rem < 0) {
239: use_kerberos = 0;
240: sp = getservbyname("login", "tcp");
241: if (sp == NULL) {
242: (void)fprintf(stderr,
243: "rlogin: unknown service login/tcp.\n");
244: exit(1);
245: }
246: if (errno == ECONNREFUSED)
247: warning("remote host doesn't support Kerberos");
248: if (errno == ENOENT)
249: warning("can't provide Kerberos auth data");
250: goto try_connect;
251: }
252: } else {
253: rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0);
254: }
255: #else
256: rem = rcmd(&host, sp->s_port, pw->pw_name, user, term, 0);
257: #endif /* KERBEROS */
258:
259: if (rem < 0)
260: exit(1);
261:
262: if (dflag &&
263: setsockopt(rem, SOL_SOCKET, SO_DEBUG, &one, sizeof(one)) < 0)
264: (void)fprintf(stderr, "rlogin: setsockopt: %s.\n",
265: strerror(errno));
266: one = IPTOS_LOWDELAY;
267: if (setsockopt(rem, IPPROTO_IP, IP_TOS, (char *)&one, sizeof(int)) < 0)
268: perror("rlogin: setsockopt TOS (ignored)");
269:
270: (void)setuid(uid);
271: doit(omask);
272: /*NOTREACHED*/
273: }
274:
275: int child, defflags, deflflags, tabflag;
276: char deferase, defkill;
277: struct tchars deftc;
278: struct ltchars defltc;
279: struct tchars notc = { -1, -1, -1, -1, -1, -1 };
280: struct ltchars noltc = { -1, -1, -1, -1, -1, -1 };
281:
282: doit(omask)
283: long omask;
284: {
285: struct sgttyb sb;
286: void catch_child(), copytochild(), exit(), writeroob();
287:
288: (void)ioctl(0, TIOCGETP, (char *)&sb);
289: defflags = sb.sg_flags;
290: tabflag = defflags & TBDELAY;
291: defflags &= ECHO | CRMOD;
292: deferase = sb.sg_erase;
293: defkill = sb.sg_kill;
294: (void)ioctl(0, TIOCLGET, (char *)&deflflags);
295: (void)ioctl(0, TIOCGETC, (char *)&deftc);
296: notc.t_startc = deftc.t_startc;
297: notc.t_stopc = deftc.t_stopc;
298: (void)ioctl(0, TIOCGLTC, (char *)&defltc);
299: (void)signal(SIGINT, SIG_IGN);
300: setsignal(SIGHUP, exit);
301: setsignal(SIGQUIT, exit);
302: child = fork();
303: if (child == -1) {
304: (void)fprintf(stderr, "rlogin: fork: %s.\n", strerror(errno));
305: done(1);
306: }
307: if (child == 0) {
308: mode(1);
309: if (reader(omask) == 0) {
310: msg("connection closed.");
311: exit(0);
312: }
313: sleep(1);
314: msg("\007connection closed.");
315: exit(1);
316: }
317:
318: /*
319: * We may still own the socket, and may have a pending SIGURG (or might
320: * receive one soon) that we really want to send to the reader. Set a
321: * trap that simply copies such signals to the child.
322: */
323: (void)signal(SIGURG, copytochild);
324: (void)signal(SIGUSR1, writeroob);
325: (void)sigsetmask(omask);
326: (void)signal(SIGCHLD, catch_child);
327: writer();
328: msg("closed connection.");
329: done(0);
330: }
331:
332: /* trap a signal, unless it is being ignored. */
333: setsignal(sig, act)
334: int sig;
335: void (*act)();
336: {
337: int omask = sigblock(sigmask(sig));
338:
339: if (signal(sig, act) == SIG_IGN)
340: (void)signal(sig, SIG_IGN);
341: (void)sigsetmask(omask);
342: }
343:
344: done(status)
345: int status;
346: {
347: int w;
348:
349: mode(0);
350: if (child > 0) {
351: /* make sure catch_child does not snap it up */
352: (void)signal(SIGCHLD, SIG_DFL);
353: if (kill(child, SIGKILL) >= 0)
354: while ((w = wait((union wait *)0)) > 0 && w != child);
355: }
356: exit(status);
357: }
358:
359: int dosigwinch;
360:
361: /*
362: * This is called when the reader process gets the out-of-band (urgent)
363: * request to turn on the window-changing protocol.
364: */
365: void
366: writeroob()
367: {
368: void sigwinch();
369:
370: if (dosigwinch == 0) {
371: sendwindow();
372: (void)signal(SIGWINCH, sigwinch);
373: }
374: dosigwinch = 1;
375: }
376:
377: void
378: catch_child()
379: {
380: union wait status;
381: int pid;
382:
383: for (;;) {
384: pid = wait3(&status, WNOHANG|WUNTRACED, (struct rusage *)0);
385: if (pid == 0)
386: return;
387: /* if the child (reader) dies, just quit */
388: if (pid < 0 || pid == child && !WIFSTOPPED(status))
389: done((int)(status.w_termsig | status.w_retcode));
390: }
391: /* NOTREACHED */
392: }
393:
394: /*
395: * writer: write to remote: 0 -> line.
396: * ~. terminate
397: * ~^Z suspend rlogin process.
398: * ~<delayed-suspend char> suspend rlogin process, but leave reader alone.
399: */
400: writer()
401: {
402: register int bol, local, n;
403: char c;
404:
405: bol = 1; /* beginning of line */
406: local = 0;
407: for (;;) {
408: n = read(STDIN_FILENO, &c, 1);
409: if (n <= 0) {
410: if (n < 0 && errno == EINTR)
411: continue;
412: break;
413: }
414: /*
415: * If we're at the beginning of the line and recognize a
416: * command character, then we echo locally. Otherwise,
417: * characters are echo'd remotely. If the command character
418: * is doubled, this acts as a force and local echo is
419: * suppressed.
420: */
421: if (bol) {
422: bol = 0;
423: if (!noescape && c == escapechar) {
424: local = 1;
425: continue;
426: }
427: } else if (local) {
428: local = 0;
429: if (c == '.' || c == deftc.t_eofc) {
430: echo(c);
431: break;
432: }
433: if (c == defltc.t_suspc || c == defltc.t_dsuspc) {
434: bol = 1;
435: echo(c);
436: stop(c);
437: continue;
438: }
439: if (c != escapechar)
440: (void)write(rem, &escapechar, 1);
441: }
442:
443: if (write(rem, &c, 1) == 0) {
444: msg("line gone");
445: break;
446: }
447: bol = c == defkill || c == deftc.t_eofc ||
448: c == deftc.t_intrc || c == defltc.t_suspc ||
449: c == '\r' || c == '\n';
450: }
451: }
452:
453: echo(c)
454: register char c;
455: {
456: register char *p;
457: char buf[8];
458:
459: p = buf;
460: c &= 0177;
461: *p++ = escapechar;
462: if (c < ' ') {
463: *p++ = '^';
464: *p++ = c + '@';
465: } else if (c == 0177) {
466: *p++ = '^';
467: *p++ = '?';
468: } else
469: *p++ = c;
470: *p++ = '\r';
471: *p++ = '\n';
472: (void)write(STDOUT_FILENO, buf, p - buf);
473: }
474:
475: stop(cmdc)
476: char cmdc;
477: {
478: mode(0);
479: (void)signal(SIGCHLD, SIG_IGN);
480: (void)kill(cmdc == defltc.t_suspc ? 0 : getpid(), SIGTSTP);
481: (void)signal(SIGCHLD, catch_child);
482: mode(1);
483: sigwinch(); /* check for size changes */
484: }
485:
486: void
487: sigwinch()
488: {
489: struct winsize ws;
490:
491: if (dosigwinch && get_window_size(0, &ws) == 0 &&
492: bcmp(&ws, &winsize, sizeof(ws))) {
493: winsize = ws;
494: sendwindow();
495: }
496: }
497:
498: /*
499: * Send the window size to the server via the magic escape
500: */
501: sendwindow()
502: {
503: struct winsize *wp;
504: char obuf[4 + sizeof (struct winsize)];
505:
506: wp = (struct winsize *)(obuf+4);
507: obuf[0] = 0377;
508: obuf[1] = 0377;
509: obuf[2] = 's';
510: obuf[3] = 's';
511: wp->ws_row = htons(winsize.ws_row);
512: wp->ws_col = htons(winsize.ws_col);
513: wp->ws_xpixel = htons(winsize.ws_xpixel);
514: wp->ws_ypixel = htons(winsize.ws_ypixel);
515:
516: (void)write(rem, obuf, sizeof(obuf));
517: }
518:
519: /*
520: * reader: read from remote: line -> 1
521: */
522: #define READING 1
523: #define WRITING 2
524:
525: jmp_buf rcvtop;
526: int ppid, rcvcnt, rcvstate;
527: char rcvbuf[8 * 1024];
528:
529: void
530: oob()
531: {
532: struct sgttyb sb;
533: int atmark, n, out, rcvd;
534: char waste[BUFSIZ], mark;
535:
536: out = O_RDWR;
537: rcvd = 0;
538: while (recv(rem, &mark, 1, MSG_OOB) < 0)
539: switch (errno) {
540: case EWOULDBLOCK:
541: /*
542: * Urgent data not here yet. It may not be possible
543: * to send it yet if we are blocked for output and
544: * our input buffer is full.
545: */
546: if (rcvcnt < sizeof(rcvbuf)) {
547: n = read(rem, rcvbuf + rcvcnt,
548: sizeof(rcvbuf) - rcvcnt);
549: if (n <= 0)
550: return;
551: rcvd += n;
552: } else {
553: n = read(rem, waste, sizeof(waste));
554: if (n <= 0)
555: return;
556: }
557: continue;
558: default:
559: return;
560: }
561: if (mark & TIOCPKT_WINDOW) {
562: /* Let server know about window size changes */
563: (void)kill(ppid, SIGUSR1);
564: }
565: if (!eight && (mark & TIOCPKT_NOSTOP)) {
566: (void)ioctl(0, TIOCGETP, (char *)&sb);
567: sb.sg_flags &= ~CBREAK;
568: sb.sg_flags |= RAW;
569: (void)ioctl(0, TIOCSETN, (char *)&sb);
570: notc.t_stopc = -1;
571: notc.t_startc = -1;
572: (void)ioctl(0, TIOCSETC, (char *)¬c);
573: }
574: if (!eight && (mark & TIOCPKT_DOSTOP)) {
575: (void)ioctl(0, TIOCGETP, (char *)&sb);
576: sb.sg_flags &= ~RAW;
577: sb.sg_flags |= CBREAK;
578: (void)ioctl(0, TIOCSETN, (char *)&sb);
579: notc.t_stopc = deftc.t_stopc;
580: notc.t_startc = deftc.t_startc;
581: (void)ioctl(0, TIOCSETC, (char *)¬c);
582: }
583: if (mark & TIOCPKT_FLUSHWRITE) {
584: (void)ioctl(1, TIOCFLUSH, (char *)&out);
585: for (;;) {
586: if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
587: (void)fprintf(stderr, "rlogin: ioctl: %s.\n",
588: strerror(errno));
589: break;
590: }
591: if (atmark)
592: break;
593: n = read(rem, waste, sizeof (waste));
594: if (n <= 0)
595: break;
596: }
597: /*
598: * Don't want any pending data to be output, so clear the recv
599: * buffer. If we were hanging on a write when interrupted,
600: * don't want it to restart. If we were reading, restart
601: * anyway.
602: */
603: rcvcnt = 0;
604: longjmp(rcvtop, 1);
605: }
606:
607: /* oob does not do FLUSHREAD (alas!) */
608:
609: /*
610: * If we filled the receive buffer while a read was pending, longjmp
611: * to the top to restart appropriately. Don't abort a pending write,
612: * however, or we won't know how much was written.
613: */
614: if (rcvd && rcvstate == READING)
615: longjmp(rcvtop, 1);
616: }
617:
618: /* reader: read from remote: line -> 1 */
619: reader(omask)
620: int omask;
621: {
622: void oob();
623:
624: #if !defined(BSD) || BSD < 43
625: int pid = -getpid();
626: #else
627: int pid = getpid();
628: #endif
629: int n, remaining;
630: char *bufp = rcvbuf;
631:
632: (void)signal(SIGTTOU, SIG_IGN);
633: (void)signal(SIGURG, oob);
634: ppid = getppid();
635: (void)fcntl(rem, F_SETOWN, pid);
636: (void)setjmp(rcvtop);
637: (void)sigsetmask(omask);
638: for (;;) {
639: while ((remaining = rcvcnt - (bufp - rcvbuf)) > 0) {
640: rcvstate = WRITING;
641: n = write(STDOUT_FILENO, bufp, remaining);
642: if (n < 0) {
643: if (errno != EINTR)
644: return(-1);
645: continue;
646: }
647: bufp += n;
648: }
649: bufp = rcvbuf;
650: rcvcnt = 0;
651: rcvstate = READING;
652:
653: rcvcnt = read(rem, rcvbuf, sizeof (rcvbuf));
654: if (rcvcnt == 0)
655: return (0);
656: if (rcvcnt < 0) {
657: if (errno == EINTR)
658: continue;
659: (void)fprintf(stderr, "rlogin: read: %s.\n",
660: strerror(errno));
661: return(-1);
662: }
663: }
664: }
665:
666: mode(f)
667: {
668: struct ltchars *ltc;
669: struct sgttyb sb;
670: struct tchars *tc;
671: int lflags;
672:
673: (void)ioctl(0, TIOCGETP, (char *)&sb);
674: (void)ioctl(0, TIOCLGET, (char *)&lflags);
675: switch(f) {
676: case 0:
677: sb.sg_flags &= ~(CBREAK|RAW|TBDELAY);
678: sb.sg_flags |= defflags|tabflag;
679: tc = &deftc;
680: ltc = &defltc;
681: sb.sg_kill = defkill;
682: sb.sg_erase = deferase;
683: lflags = deflflags;
684: break;
685: case 1:
686: sb.sg_flags |= (eight ? RAW : CBREAK);
687: sb.sg_flags &= ~defflags;
688: /* preserve tab delays, but turn off XTABS */
689: if ((sb.sg_flags & TBDELAY) == XTABS)
690: sb.sg_flags &= ~TBDELAY;
691: tc = ¬c;
692: ltc = &noltc;
693: sb.sg_kill = sb.sg_erase = -1;
694: if (litout)
695: lflags |= LLITOUT;
696: break;
697: default:
698: return;
699: }
700: (void)ioctl(0, TIOCSLTC, (char *)ltc);
701: (void)ioctl(0, TIOCSETC, (char *)tc);
702: (void)ioctl(0, TIOCSETN, (char *)&sb);
703: (void)ioctl(0, TIOCLSET, (char *)&lflags);
704: }
705:
706: void
707: lostpeer()
708: {
709: (void)signal(SIGPIPE, SIG_IGN);
710: msg("\007connection closed.");
711: done(1);
712: }
713:
714: /* copy SIGURGs to the child process. */
715: void
716: copytochild()
717: {
718: (void)kill(child, SIGURG);
719: }
720:
721: msg(str)
722: char *str;
723: {
724: (void)fprintf(stderr, "rlogin: %s\r\n", str);
725: }
726:
727: #ifdef KERBEROS
728: /* VARARGS */
729: warning(va_alist)
730: va_dcl
731: {
732: va_list ap;
733: char *fmt;
734:
735: (void)fprintf(stderr, "rlogin: warning, using standard rlogin: ");
736: va_start(ap);
737: fmt = va_arg(ap, char *);
738: vfprintf(stderr, fmt, ap);
739: va_end(ap);
740: (void)fprintf(stderr, ".\n");
741: }
742: #endif
743:
744: usage()
745: {
746: (void)fprintf(stderr,
747: "usage: rlogin [ -%s]%s[-e char] [ -l username ] host\n",
748: #ifdef KERBEROS
749: "8EL", " [-k realm] ");
750: #else
751: "8EL", " ");
752: #endif
753: exit(1);
754: }
755:
756: /*
757: * The following routine provides compatibility (such as it is) between 4.2BSD
758: * Suns and others. Suns have only a `ttysize', so we convert it to a winsize.
759: */
760: #ifdef sun
761: get_window_size(fd, wp)
762: int fd;
763: struct winsize *wp;
764: {
765: struct ttysize ts;
766: int error;
767:
768: if ((error = ioctl(0, TIOCGSIZE, &ts)) != 0)
769: return(error);
770: wp->ws_row = ts.ts_lines;
771: wp->ws_col = ts.ts_cols;
772: wp->ws_xpixel = 0;
773: wp->ws_ypixel = 0;
774: return(0);
775: }
776: #endif
777:
778: u_char
779: getescape(p)
780: register char *p;
781: {
782: long val;
783: int len;
784:
785: if ((len = strlen(p)) == 1) /* use any single char, including '\' */
786: return((u_char)*p);
787: /* otherwise, \nnn */
788: if (*p == '\\' && len >= 2 && len <= 4) {
789: val = strtol(++p, (char **)NULL, 8);
790: for (;;) {
791: if (!*++p)
792: return((u_char)val);
793: if (*p < '0' || *p > '8')
794: break;
795: }
796: }
797: msg("illegal option value -- e");
798: usage();
799: /* NOTREACHED */
800: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.