1 /* $NetBSD: rlogin.c,v 1.48 2021/08/03 23:21:07 chs Exp $ */
2
3 /*
4 * Copyright (c) 1983, 1990, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 #ifndef lint
34 __COPYRIGHT("@(#) Copyright (c) 1983, 1990, 1993\
35 The Regents of the University of California. All rights reserved.");
36 #endif /* not lint */
37
38 #ifndef lint
39 #if 0
40 static char sccsid[] = "@(#)rlogin.c 8.4 (Berkeley) 4/29/95";
41 #else
42 __RCSID("$NetBSD: rlogin.c,v 1.48 2021/08/03 23:21:07 chs Exp $");
43 #endif
44 #endif /* not lint */
45
46 /*
47 * rlogin - remote login
48 */
49 #include <sys/param.h>
50 #include <sys/ioctl.h>
51 #include <sys/socket.h>
52 #include <sys/time.h>
53 #include <sys/resource.h>
54 #include <sys/wait.h>
55
56 #include <netinet/in.h>
57 #include <netinet/in_systm.h>
58 #include <netinet/ip.h>
59 #include <netinet/tcp.h>
60
61 #include <err.h>
62 #include <errno.h>
63 #include <fcntl.h>
64 #include <netdb.h>
65 #include <pwd.h>
66 #include <setjmp.h>
67 #include <signal.h>
68 #include <stdarg.h>
69 #include <stdio.h>
70 #include <stdlib.h>
71 #include <string.h>
72 #include <termios.h>
73 #include <unistd.h>
74
75 #include "getport.h"
76
77 #ifndef TIOCPKT_WINDOW
78 #define TIOCPKT_WINDOW 0x80
79 #endif
80
81 /* concession to Sun */
82 #ifndef SIGUSR1
83 #define SIGUSR1 30
84 #endif
85
86 #ifndef CCEQ
87 #define CCEQ(val, c) (c == val ? val != _POSIX_VDISABLE : 0)
88 #endif
89
90 static int eight, rem;
91 static struct termios deftty;
92
93 static int noescape;
94 static u_char escapechar = '~';
95
96 #ifdef OLDSUN
97 struct winsize {
98 unsigned short ws_row, ws_col;
99 unsigned short ws_xpixel, ws_ypixel;
100 };
101 #else
102 #define get_window_size(fd, wp) ioctl(fd, TIOCGWINSZ, wp)
103 #endif
104 static struct winsize winsize;
105
106 static void catch_child(int);
107 static void copytochild(int);
108 __dead static void doit(sigset_t *);
109 __dead static void done(int);
110 static void echo(int);
111 static u_int getescape(char *);
112 __dead static void lostpeer(int);
113 static void mode(int);
114 static void msg(const char *);
115 static void oob(int);
116 static int reader(sigset_t *);
117 static void sendwindow(void);
118 static void setsignal(int);
119 static void sigwinch(int);
120 static void stop(int);
121 __dead static void usage(void);
122 static void writer(void);
123 static void writeroob(int);
124
125 #ifdef OLDSUN
126 static int get_window_size(int, struct winsize *);
127 #endif
128
129 int
main(int argc,char * argv[])130 main(int argc, char *argv[])
131 {
132 struct passwd *pw;
133 struct servent *sp;
134 struct termios tty;
135 sigset_t imask, omask;
136 uid_t uid;
137 int argoff, ch, dflag, nflag, one;
138 int i, len, len2;
139 int family = AF_UNSPEC;
140 char *host, *p, *user, *name, term[1024] = "network";
141 speed_t ospeed;
142 struct sigaction sa;
143 char *service = NULL;
144 struct rlimit rlim;
145
146 argoff = dflag = nflag = 0;
147 one = 1;
148 host = user = NULL;
149 sp = NULL;
150
151 if (strcmp(getprogname(), "rlogin") != 0) {
152 host = strdup(getprogname());
153 if (host == NULL)
154 err(1, NULL);
155 }
156
157 /* handle "rlogin host flags" */
158 if (!host && argc > 2 && argv[1][0] != '-') {
159 host = argv[1];
160 argoff = 1;
161 }
162
163 #define OPTIONS "468dEe:l:np:"
164 while ((ch = getopt(argc - argoff, argv + argoff, OPTIONS)) != -1)
165 switch(ch) {
166 case '4':
167 family = AF_INET;
168 break;
169 case '6':
170 family = AF_INET6;
171 break;
172 case '8':
173 eight = 1;
174 break;
175 case 'd':
176 dflag = 1;
177 break;
178 case 'E':
179 noescape = 1;
180 break;
181 case 'e':
182 noescape = 0;
183 escapechar = getescape(optarg);
184 break;
185 case 'l':
186 user = optarg;
187 break;
188 case 'n':
189 nflag = 1;
190 break;
191 case 'p':
192 sp = getport(service = optarg, "tcp");
193 break;
194 case '?':
195 default:
196 usage();
197 }
198 optind += argoff;
199 argc -= optind;
200 argv += optind;
201
202 /* if haven't gotten a host yet, do so */
203 if (!host && !(host = *argv++))
204 usage();
205
206 if (*argv)
207 usage();
208
209 if (!(pw = getpwuid(uid = getuid())))
210 errx(1, "unknown user id.");
211 /* Accept user1@host format, though "-l user2" overrides user1 */
212 p = strchr(host, '@');
213 if (p) {
214 *p = '\0';
215 if (!user && p > host)
216 user = host;
217 host = p + 1;
218 if (*host == '\0')
219 usage();
220 }
221 if ((name = strdup(pw->pw_name)) == NULL)
222 err(1, "malloc");
223 if (!user)
224 user = name;
225
226 if (sp == NULL)
227 sp = getservbyname("login", "tcp");
228 if (sp == NULL)
229 errx(1, "login/tcp: unknown service.");
230
231 if ((p = getenv("TERM")) != NULL)
232 (void)strlcpy(term, p, sizeof(term));
233 len = strlen(term);
234 if (len < (int)(sizeof(term) - 1) && tcgetattr(0, &tty) == 0) {
235 /* start at 2 to include the / */
236 for (ospeed = i = cfgetospeed(&tty), len2 = 2; i > 9; len2++)
237 i /= 10;
238
239 if (len + len2 < (int)sizeof(term))
240 (void)snprintf(term + len, len2 + 1, "/%d", ospeed);
241 }
242
243 (void)get_window_size(0, &winsize);
244
245 sigemptyset(&sa.sa_mask);
246 sa.sa_flags = SA_RESTART;
247 sa.sa_handler = lostpeer;
248 (void)sigaction(SIGPIPE, &sa, NULL);
249 /* will use SIGUSR1 for window size hack, so hold it off */
250 sigemptyset(&imask);
251 sigaddset(&imask, SIGURG);
252 sigaddset(&imask, SIGUSR1);
253 (void)sigprocmask(SIG_SETMASK, &imask, &omask);
254 /*
255 * We set SIGURG and SIGUSR1 below so that an
256 * incoming signal will be held pending rather than being
257 * discarded. Note that these routines will be ready to get
258 * a signal by the time that they are unblocked below.
259 */
260 sa.sa_handler = copytochild;
261 (void)sigaction(SIGURG, &sa, NULL);
262 sa.sa_handler = writeroob;
263 (void)sigaction(SIGUSR1, &sa, NULL);
264
265 /* don't dump core */
266 rlim.rlim_cur = rlim.rlim_max = 0;
267 if (setrlimit(RLIMIT_CORE, &rlim) < 0)
268 warn("setrlimit");
269
270 rem = rcmd_af(&host, sp->s_port, name, user, term, 0, family);
271 if (rem < 0)
272 exit(1);
273
274 if (dflag &&
275 setsockopt(rem, SOL_SOCKET, SO_DEBUG, &one, sizeof(one)) < 0)
276 warn("setsockopt DEBUG (ignored)");
277 if (nflag &&
278 setsockopt(rem, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
279 warn("setsockopt NODELAY (ignored)");
280
281 {
282 struct sockaddr_storage ss;
283 socklen_t sslen = sizeof(ss);
284 if (getsockname(rem, (struct sockaddr *)&ss, &sslen) == 0
285 && ((struct sockaddr *)&ss)->sa_family == AF_INET) {
286 one = IPTOS_LOWDELAY;
287 if (setsockopt(rem, IPPROTO_IP, IP_TOS, (char *)&one,
288 sizeof(int)) < 0)
289 warn("setsockopt TOS (ignored)");
290 }
291 }
292
293 (void)setuid(uid);
294 doit(&omask);
295 /*NOTREACHED*/
296 return (0);
297 }
298
299 static pid_t child;
300
301 static void
doit(sigset_t * smask)302 doit(sigset_t *smask)
303 {
304 struct sigaction sa;
305
306 sigemptyset(&sa.sa_mask);
307 sa.sa_flags = SA_RESTART;
308 sa.sa_handler = SIG_IGN;
309 (void)sigaction(SIGINT, &sa, NULL);
310 setsignal(SIGHUP);
311 setsignal(SIGQUIT);
312 mode(1);
313 child = fork();
314 if (child == -1) {
315 warn("fork");
316 done(1);
317 }
318 if (child == 0) {
319 mode(1);
320 if (reader(smask) == 0) {
321 msg("connection closed.");
322 exit(0);
323 }
324 sleep(1);
325 msg("\aconnection closed.");
326 exit(1);
327 }
328
329 /*
330 * We may still own the socket, and may have a pending SIGURG (or might
331 * receive one soon) that we really want to send to the reader. When
332 * one of these comes in, the trap copytochild simply copies such
333 * signals to the child. We can now unblock SIGURG and SIGUSR1
334 * that were set above.
335 */
336 (void)sigprocmask(SIG_SETMASK, smask, NULL);
337 sa.sa_handler = catch_child;
338 (void)sigaction(SIGCHLD, &sa, NULL);
339 writer();
340 msg("closed connection.");
341 done(0);
342 }
343
344 /* trap a signal, unless it is being ignored. */
345 static void
setsignal(int sig)346 setsignal(int sig)
347 {
348 struct sigaction isa, osa;
349 sigset_t isigs, osigs;
350
351 sigemptyset(&isigs);
352 sigaddset(&isigs, sig);
353 sigprocmask(SIG_BLOCK, &isigs, &osigs);
354
355 sigemptyset(&isa.sa_mask);
356 isa.sa_handler = exit;
357 isa.sa_flags = SA_RESTART;
358 (void)sigaction(sig, &isa, &osa);
359 if (osa.sa_handler == SIG_IGN)
360 (void)sigaction(sig, &osa, NULL);
361
362 (void)sigprocmask(SIG_SETMASK, &osigs, NULL);
363 }
364
365 static void
done(int status)366 done(int status)
367 {
368 pid_t w;
369 int wstatus;
370 struct sigaction sa;
371
372 mode(0);
373 if (child > 0) {
374 /* make sure catch_child does not snap it up */
375 sigemptyset(&sa.sa_mask);
376 sa.sa_handler = SIG_DFL;
377 sa.sa_flags = 0;
378 (void)sigaction(SIGCHLD, &sa, NULL);
379 if (kill(child, SIGKILL) >= 0)
380 while ((w = wait(&wstatus)) > 0 && w != child)
381 continue;
382 }
383 exit(status);
384 }
385
386 static int dosigwinch;
387
388 /*
389 * This is called when the reader process gets the out-of-band (urgent)
390 * request to turn on the window-changing protocol.
391 */
392 static void
writeroob(int signo)393 writeroob(int signo)
394 {
395 struct sigaction sa;
396
397 if (dosigwinch == 0) {
398 sendwindow();
399 sigemptyset(&sa.sa_mask);
400 sa.sa_handler = sigwinch;
401 sa.sa_flags = SA_RESTART;
402 (void)sigaction(SIGWINCH, &sa, NULL);
403 }
404 dosigwinch = 1;
405 }
406
407 static void
catch_child(int signo)408 catch_child(int signo)
409 {
410 int status;
411 pid_t pid;
412
413 for (;;) {
414 pid = waitpid(-1, &status, WNOHANG|WUNTRACED);
415 if (pid == 0)
416 return;
417 /* if the child (reader) dies, just quit */
418 if (pid < 0 || (pid == child && !WIFSTOPPED(status)))
419 done(WEXITSTATUS(status) | WTERMSIG(status));
420 }
421 /* NOTREACHED */
422 }
423
424 /*
425 * writer: write to remote: 0 -> line.
426 * ~. terminate
427 * ~^Z suspend rlogin process.
428 * ~<delayed-suspend char> suspend rlogin process, but leave reader alone.
429 */
430 static void
writer(void)431 writer(void)
432 {
433 int bol, local;
434 ssize_t n;
435 char c;
436
437 bol = 1; /* beginning of line */
438 local = 0;
439 for (;;) {
440 n = read(STDIN_FILENO, &c, 1);
441 if (n <= 0) {
442 if (n < 0 && errno == EINTR)
443 continue;
444 break;
445 }
446 /*
447 * If we're at the beginning of the line and recognize a
448 * command character, then we echo locally. Otherwise,
449 * characters are echo'd remotely. If the command character
450 * is doubled, this acts as a force and local echo is
451 * suppressed.
452 */
453 if (bol) {
454 bol = 0;
455 if (!noescape && c == escapechar) {
456 local = 1;
457 continue;
458 }
459 } else if (local) {
460 local = 0;
461 if (c == '.' || CCEQ(deftty.c_cc[VEOF], c)) {
462 echo((int)c);
463 break;
464 }
465 if (CCEQ(deftty.c_cc[VSUSP], c)) {
466 bol = 1;
467 echo((int)c);
468 stop(1);
469 continue;
470 }
471 if (CCEQ(deftty.c_cc[VDSUSP], c)) {
472 bol = 1;
473 echo((int)c);
474 stop(0);
475 continue;
476 }
477 if (c != escapechar) {
478 (void)write(rem, &escapechar, 1);
479 }
480 }
481
482 if (write(rem, &c, 1) == 0) {
483 msg("line gone");
484 break;
485 }
486
487 bol = CCEQ(deftty.c_cc[VKILL], c) ||
488 CCEQ(deftty.c_cc[VEOF], c) ||
489 CCEQ(deftty.c_cc[VINTR], c) ||
490 CCEQ(deftty.c_cc[VSUSP], c) ||
491 c == '\r' || c == '\n';
492 }
493 }
494
495 static void
echo(int i)496 echo(int i)
497 {
498 char c = (char)i;
499 char *p;
500 char buf[8];
501
502 p = buf;
503 c &= 0177;
504 *p++ = escapechar;
505 if (c < ' ') {
506 *p++ = '^';
507 *p++ = c + '@';
508 } else if (c == 0177) {
509 *p++ = '^';
510 *p++ = '?';
511 } else
512 *p++ = c;
513 *p++ = '\r';
514 *p++ = '\n';
515 (void)write(STDOUT_FILENO, buf, p - buf);
516 }
517
518 static void
stop(int all)519 stop(int all)
520 {
521 struct sigaction sa;
522
523 mode(0);
524 sigemptyset(&sa.sa_mask);
525 sa.sa_handler = SIG_IGN;
526 sa.sa_flags = SA_RESTART;
527 (void)sigaction(SIGCHLD, &sa, NULL);
528 (void)kill(all ? 0 : getpid(), SIGTSTP);
529 sa.sa_handler = catch_child;
530 (void)sigaction(SIGCHLD, &sa, NULL);
531 mode(1);
532 sigwinch(0); /* check for size changes */
533 }
534
535 static void
sigwinch(int signo)536 sigwinch(int signo)
537 {
538 struct winsize ws;
539
540 if (dosigwinch && get_window_size(0, &ws) == 0 &&
541 memcmp(&ws, &winsize, sizeof(ws))) {
542 winsize = ws;
543 sendwindow();
544 }
545 }
546
547 /*
548 * Send the window size to the server via the magic escape
549 */
550 static void
sendwindow(void)551 sendwindow(void)
552 {
553 struct winsize *wp;
554 char obuf[4 + sizeof (struct winsize)];
555
556 wp = (struct winsize *)(obuf+4);
557 obuf[0] = 0377;
558 obuf[1] = 0377;
559 obuf[2] = 's';
560 obuf[3] = 's';
561 wp->ws_row = htons(winsize.ws_row);
562 wp->ws_col = htons(winsize.ws_col);
563 wp->ws_xpixel = htons(winsize.ws_xpixel);
564 wp->ws_ypixel = htons(winsize.ws_ypixel);
565
566 (void)write(rem, obuf, sizeof(obuf));
567 }
568
569 /*
570 * reader: read from remote: line -> 1
571 */
572 #define READING 1
573 #define WRITING 2
574
575 static jmp_buf rcvtop;
576 static pid_t ppid;
577 static ssize_t rcvcnt, rcvstate;
578 static char rcvbuf[8 * 1024];
579
580 static void
oob(int signo)581 oob(int signo)
582 {
583 struct termios tty;
584 int atmark;
585 ssize_t n, rcvd;
586 char waste[BUFSIZ], mark;
587
588 rcvd = 0;
589 while (recv(rem, &mark, 1, MSG_OOB) == -1) {
590 switch (errno) {
591 case EWOULDBLOCK:
592 /*
593 * Urgent data not here yet. It may not be possible
594 * to send it yet if we are blocked for output and
595 * our input buffer is full.
596 */
597 if (rcvcnt < (ssize_t)sizeof(rcvbuf)) {
598 n = read(rem, rcvbuf + rcvcnt,
599 sizeof(rcvbuf) - rcvcnt);
600 if (n <= 0)
601 return;
602 rcvd += n;
603 } else {
604 n = read(rem, waste, sizeof(waste));
605 if (n <= 0)
606 return;
607 }
608 continue;
609 default:
610 return;
611 }
612 }
613 if (mark & TIOCPKT_WINDOW) {
614 /* Let server know about window size changes */
615 (void)kill(ppid, SIGUSR1);
616 }
617 if (!eight && (mark & TIOCPKT_NOSTOP)) {
618 (void)tcgetattr(0, &tty);
619 tty.c_iflag &= ~IXON;
620 (void)tcsetattr(0, TCSANOW, &tty);
621 }
622 if (!eight && (mark & TIOCPKT_DOSTOP)) {
623 (void)tcgetattr(0, &tty);
624 tty.c_iflag |= (deftty.c_iflag & IXON);
625 (void)tcsetattr(0, TCSANOW, &tty);
626 }
627 if (mark & TIOCPKT_FLUSHWRITE) {
628 (void)tcflush(1, TCIOFLUSH);
629 for (;;) {
630 if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
631 warn("ioctl SIOCATMARK (ignored)");
632 break;
633 }
634 if (atmark)
635 break;
636 n = read(rem, waste, sizeof (waste));
637 if (n <= 0)
638 break;
639 }
640 /*
641 * Don't want any pending data to be output, so clear the recv
642 * buffer. If we were hanging on a write when interrupted,
643 * don't want it to restart. If we were reading, restart
644 * anyway.
645 */
646 rcvcnt = 0;
647 longjmp(rcvtop, 1);
648 }
649
650 /* oob does not do FLUSHREAD (alas!) */
651
652 /*
653 * If we filled the receive buffer while a read was pending, longjmp
654 * to the top to restart appropriately. Don't abort a pending write,
655 * however, or we won't know how much was written.
656 */
657 if (rcvd && rcvstate == READING)
658 longjmp(rcvtop, 1);
659 }
660
661 /* reader: read from remote: line -> 1 */
662 static int
reader(sigset_t * smask)663 reader(sigset_t *smask)
664 {
665 pid_t pid;
666 ssize_t n, remaining;
667 char *bufp;
668 struct sigaction sa;
669
670 pid = getpid(); /* modern systems use positives for pid */
671 sigemptyset(&sa.sa_mask);
672 sa.sa_flags = SA_RESTART;
673 sa.sa_handler = SIG_IGN;
674 (void)sigaction(SIGTTOU, &sa, NULL);
675 sa.sa_handler = oob;
676 (void)sigaction(SIGURG, &sa, NULL);
677 ppid = getppid();
678 (void)fcntl(rem, F_SETOWN, pid);
679 (void)setjmp(rcvtop);
680 (void)sigprocmask(SIG_SETMASK, smask, NULL);
681 bufp = rcvbuf;
682 for (;;) {
683 while ((remaining = rcvcnt - (bufp - rcvbuf)) > 0) {
684 rcvstate = WRITING;
685 n = write(STDOUT_FILENO, bufp, remaining);
686 if (n < 0) {
687 if (errno != EINTR)
688 return (-1);
689 continue;
690 }
691 bufp += n;
692 }
693 bufp = rcvbuf;
694 rcvcnt = 0;
695 rcvstate = READING;
696
697 rcvcnt = read(rem, rcvbuf, sizeof (rcvbuf));
698 if (rcvcnt == 0)
699 return (0);
700 if (rcvcnt < 0) {
701 if (errno == EINTR)
702 continue;
703 warn("read");
704 return (-1);
705 }
706 }
707 }
708
709 static void
mode(int f)710 mode(int f)
711 {
712 struct termios tty;
713
714 switch (f) {
715 case 0:
716 (void)tcsetattr(0, TCSANOW, &deftty);
717 break;
718 case 1:
719 (void)tcgetattr(0, &deftty);
720 tty = deftty;
721 /* This is loosely derived from sys/compat/tty_compat.c. */
722 tty.c_lflag &= ~(ECHO|ICANON|ISIG|IEXTEN);
723 tty.c_iflag &= ~ICRNL;
724 tty.c_oflag &= ~OPOST;
725 tty.c_cc[VMIN] = 1;
726 tty.c_cc[VTIME] = 0;
727 if (eight) {
728 tty.c_iflag &= IXOFF;
729 tty.c_cflag &= ~(CSIZE|PARENB);
730 tty.c_cflag |= CS8;
731 }
732 (void)tcsetattr(0, TCSANOW, &tty);
733 break;
734
735 default:
736 return;
737 }
738 }
739
740 static void
lostpeer(int signo)741 lostpeer(int signo)
742 {
743 struct sigaction sa;
744 sa.sa_flags = SA_RESTART;
745 sa.sa_handler = SIG_IGN;
746 sigemptyset(&sa.sa_mask);
747 (void)sigaction(SIGPIPE, &sa, NULL);
748 msg("\aconnection closed.");
749 done(1);
750 }
751
752 /* copy SIGURGs to the child process. */
753 static void
copytochild(int signo)754 copytochild(int signo)
755 {
756
757 (void)kill(child, SIGURG);
758 }
759
760 static void
msg(const char * str)761 msg(const char *str)
762 {
763
764 (void)fprintf(stderr, "rlogin: %s\r\n", str);
765 }
766
767 static void
usage(void)768 usage(void)
769 {
770 (void)fprintf(stderr,
771 "Usage: %s [-468dEn] [-e char] [-l username] [-p port] "
772 "[username@]host\n", getprogname());
773 exit(1);
774 }
775
776 /*
777 * The following routine provides compatibility (such as it is) between older
778 * Suns and others. Suns have only a `ttysize', so we convert it to a winsize.
779 */
780 #ifdef OLDSUN
781 static int
get_window_size(int fd,struct winsize * wp)782 get_window_size(int fd, struct winsize *wp)
783 {
784 struct ttysize ts;
785 int error;
786
787 if ((error = ioctl(0, TIOCGSIZE, &ts)) != 0)
788 return (error);
789 wp->ws_row = ts.ts_lines;
790 wp->ws_col = ts.ts_cols;
791 wp->ws_xpixel = 0;
792 wp->ws_ypixel = 0;
793 return (0);
794 }
795 #endif
796
797 static u_int
getescape(char * p)798 getescape(char *p)
799 {
800 long val;
801 size_t len;
802
803 if ((len = strlen(p)) == 1) /* use any single char, including '\' */
804 return ((u_int)*p);
805 /* otherwise, \nnn */
806 if (*p == '\\' && len >= 2 && len <= 4) {
807 val = strtol(++p, NULL, 8);
808 for (;;) {
809 if (!*++p)
810 return ((u_int)val);
811 if (*p < '0' || *p > '8')
812 break;
813 }
814 }
815 msg("illegal option value -- e");
816 usage();
817 /* NOTREACHED */
818 return (0);
819 }
820