f05fb1058ffc60e5b77bec81be6f6d75b1e0e647
[dragonfly.git] / usr.bin / telnet / sys_bsd.c
1 /*
2  * Copyright (c) 1988, 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#)sys_bsd.c        8.4 (Berkeley) 5/30/95
34  * $FreeBSD: src/usr.bin/telnet/sys_bsd.c,v 1.5.6.1 2002/04/13 11:07:13 markm Exp $
35  * $DragonFly: src/usr.bin/telnet/sys_bsd.c,v 1.3 2005/02/28 16:55:39 joerg Exp $
36  */
37
38 #include <sys/cdefs.h>
39 #include <stdlib.h>
40 #include <err.h>
41
42 /*
43  * The following routines try to encapsulate what is system dependent
44  * (at least between 4.x and dos) which is used in telnet.c.
45  */
46
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <sys/time.h>
50 #include <errno.h>
51 #include <fcntl.h>
52 #include <signal.h>
53 #include <unistd.h>
54 #include <arpa/telnet.h>
55
56 #include "ring.h"
57 #include "fdset.h"
58 #include "defines.h"
59 #include "externs.h"
60 #include "types.h"
61
62 int
63         tout,                   /* Output file descriptor */
64         tin,                    /* Input file descriptor */
65         net;
66
67 #ifndef USE_TERMIO
68 struct  tchars otc = { 0 }, ntc = { 0 };
69 struct  ltchars oltc = { 0 }, nltc = { 0 };
70 struct  sgttyb ottyb = { 0 }, nttyb = { 0 };
71 int     olmode = 0;
72 # define cfgetispeed(ptr)       (ptr)->sg_ispeed
73 # define cfgetospeed(ptr)       (ptr)->sg_ospeed
74 # define old_tc ottyb
75
76 #else   /* USE_TERMIO */
77 struct  termio old_tc = { 0, 0, 0, 0, {}, 0, 0 };
78
79 # ifndef        TCSANOW
80 #  ifdef TCSETS
81 #   define      TCSANOW         TCSETS
82 #   define      TCSADRAIN       TCSETSW
83 #   define      tcgetattr(f, t) ioctl(f, TCGETS, (char *)t)
84 #  else
85 #   ifdef TCSETA
86 #    define     TCSANOW         TCSETA
87 #    define     TCSADRAIN       TCSETAW
88 #    define     tcgetattr(f, t) ioctl(f, TCGETA, (char *)t)
89 #   else
90 #    define     TCSANOW         TIOCSETA
91 #    define     TCSADRAIN       TIOCSETAW
92 #    define     tcgetattr(f, t) ioctl(f, TIOCGETA, (char *)t)
93 #   endif
94 #  endif
95 #  define       tcsetattr(f, a, t) ioctl(f, a, (char *)t)
96 #  define       cfgetospeed(ptr)        ((ptr)->c_cflag&CBAUD)
97 #  ifdef CIBAUD
98 #   define      cfgetispeed(ptr)        (((ptr)->c_cflag&CIBAUD) >> IBSHIFT)
99 #  else
100 #   define      cfgetispeed(ptr)        cfgetospeed(ptr)
101 #  endif
102 # endif /* TCSANOW */
103 # ifdef sysV88
104 # define TIOCFLUSH TC_PX_DRAIN
105 # endif
106 #endif  /* USE_TERMIO */
107
108 static fd_set *ibitsp, *obitsp, *xbitsp;
109 int fdsn;
110
111 #ifdef  SIGINT
112 static SIG_FUNC_RET intr(int);
113 #endif  /* SIGINT */
114 #ifdef  SIGQUIT
115 static SIG_FUNC_RET intr2(int);
116 #endif  /* SIGQUIT */
117 #ifdef  SIGTSTP
118 static SIG_FUNC_RET susp(int);
119 #endif  /* SIGTSTP */
120 #ifdef  SIGINFO
121 static SIG_FUNC_RET ayt(int);
122 #endif
123
124 void
125 init_sys(void)
126 {
127     tout = fileno(stdout);
128     tin = fileno(stdin);
129     errno = 0;
130 }
131
132 int
133 TerminalWrite(char *buf, int n)
134 {
135     return write(tout, buf, n);
136 }
137
138 int
139 TerminalRead(char *buf, int n)
140 {
141     return read(tin, buf, n);
142 }
143
144 /*
145  *
146  */
147
148 int
149 TerminalAutoFlush(void)
150 {
151 #if     defined(LNOFLSH)
152     int flush;
153
154     ioctl(0, TIOCLGET, (char *)&flush);
155     return !(flush&LNOFLSH);    /* if LNOFLSH, no autoflush */
156 #else   /* LNOFLSH */
157     return 1;
158 #endif  /* LNOFLSH */
159 }
160
161 #ifdef  KLUDGELINEMODE
162 extern int kludgelinemode;
163 #endif
164 /*
165  * TerminalSpecialChars()
166  *
167  * Look at an input character to see if it is a special character
168  * and decide what to do.
169  *
170  * Output:
171  *
172  *      0       Don't add this character.
173  *      1       Do add this character
174  */
175
176 int
177 TerminalSpecialChars(int c)
178 {
179     if (c == termIntChar) {
180         intp();
181         return 0;
182     } else if (c == termQuitChar) {
183 #ifdef  KLUDGELINEMODE
184         if (kludgelinemode)
185             sendbrk();
186         else
187 #endif
188             sendabort();
189         return 0;
190     } else if (c == termEofChar) {
191         if (my_want_state_is_will(TELOPT_LINEMODE)) {
192             sendeof();
193             return 0;
194         }
195         return 1;
196     } else if (c == termSuspChar) {
197         sendsusp();
198         return(0);
199     } else if (c == termFlushChar) {
200         xmitAO();               /* Transmit Abort Output */
201         return 0;
202     } else if (!MODE_LOCAL_CHARS(globalmode)) {
203         if (c == termKillChar) {
204             xmitEL();
205             return 0;
206         } else if (c == termEraseChar) {
207             xmitEC();           /* Transmit Erase Character */
208             return 0;
209         }
210     }
211     return 1;
212 }
213
214
215 /*
216  * Flush output to the terminal
217  */
218
219 void
220 TerminalFlushOutput(void)
221 {
222 #ifdef  TIOCFLUSH
223     (void) ioctl(fileno(stdout), TIOCFLUSH, (char *) 0);
224 #else
225     (void) ioctl(fileno(stdout), TCFLSH, (char *) 0);
226 #endif
227 }
228
229 void
230 TerminalSaveState(void)
231 {
232 #ifndef USE_TERMIO
233     ioctl(0, TIOCGETP, (char *)&ottyb);
234     ioctl(0, TIOCGETC, (char *)&otc);
235     ioctl(0, TIOCGLTC, (char *)&oltc);
236     ioctl(0, TIOCLGET, (char *)&olmode);
237
238     ntc = otc;
239     nltc = oltc;
240     nttyb = ottyb;
241
242 #else   /* USE_TERMIO */
243     tcgetattr(0, &old_tc);
244
245     new_tc = old_tc;
246
247 #ifndef VDISCARD
248     termFlushChar = CONTROL('O');
249 #endif
250 #ifndef VWERASE
251     termWerasChar = CONTROL('W');
252 #endif
253 #ifndef VREPRINT
254     termRprntChar = CONTROL('R');
255 #endif
256 #ifndef VLNEXT
257     termLiteralNextChar = CONTROL('V');
258 #endif
259 #ifndef VSTART
260     termStartChar = CONTROL('Q');
261 #endif
262 #ifndef VSTOP
263     termStopChar = CONTROL('S');
264 #endif
265 #ifndef VSTATUS
266     termAytChar = CONTROL('T');
267 #endif
268 #endif  /* USE_TERMIO */
269 }
270
271 cc_t *
272 tcval(int func)
273 {
274     switch(func) {
275     case SLC_IP:        return(&termIntChar);
276     case SLC_ABORT:     return(&termQuitChar);
277     case SLC_EOF:       return(&termEofChar);
278     case SLC_EC:        return(&termEraseChar);
279     case SLC_EL:        return(&termKillChar);
280     case SLC_XON:       return(&termStartChar);
281     case SLC_XOFF:      return(&termStopChar);
282     case SLC_FORW1:     return(&termForw1Char);
283 #ifdef  USE_TERMIO
284     case SLC_FORW2:     return(&termForw2Char);
285 # ifdef VDISCARD
286     case SLC_AO:        return(&termFlushChar);
287 # endif
288 # ifdef VSUSP
289     case SLC_SUSP:      return(&termSuspChar);
290 # endif
291 # ifdef VWERASE
292     case SLC_EW:        return(&termWerasChar);
293 # endif
294 # ifdef VREPRINT
295     case SLC_RP:        return(&termRprntChar);
296 # endif
297 # ifdef VLNEXT
298     case SLC_LNEXT:     return(&termLiteralNextChar);
299 # endif
300 # ifdef VSTATUS
301     case SLC_AYT:       return(&termAytChar);
302 # endif
303 #endif
304
305     case SLC_SYNCH:
306     case SLC_BRK:
307     case SLC_EOR:
308     default:
309         return(NULL);
310     }
311 }
312
313 void
314 TerminalDefaultChars(void)
315 {
316 #ifndef USE_TERMIO
317     ntc = otc;
318     nltc = oltc;
319     nttyb.sg_kill = ottyb.sg_kill;
320     nttyb.sg_erase = ottyb.sg_erase;
321 #else   /* USE_TERMIO */
322     memcpy(new_tc.c_cc, old_tc.c_cc, sizeof(old_tc.c_cc));
323 # ifndef        VDISCARD
324     termFlushChar = CONTROL('O');
325 # endif
326 # ifndef        VWERASE
327     termWerasChar = CONTROL('W');
328 # endif
329 # ifndef        VREPRINT
330     termRprntChar = CONTROL('R');
331 # endif
332 # ifndef        VLNEXT
333     termLiteralNextChar = CONTROL('V');
334 # endif
335 # ifndef        VSTART
336     termStartChar = CONTROL('Q');
337 # endif
338 # ifndef        VSTOP
339     termStopChar = CONTROL('S');
340 # endif
341 # ifndef        VSTATUS
342     termAytChar = CONTROL('T');
343 # endif
344 #endif  /* USE_TERMIO */
345 }
346
347 /*
348  * TerminalNewMode - set up terminal to a specific mode.
349  *      MODE_ECHO: do local terminal echo
350  *      MODE_FLOW: do local flow control
351  *      MODE_TRAPSIG: do local mapping to TELNET IAC sequences
352  *      MODE_EDIT: do local line editing
353  *
354  *      Command mode:
355  *              MODE_ECHO|MODE_EDIT|MODE_FLOW|MODE_TRAPSIG
356  *              local echo
357  *              local editing
358  *              local xon/xoff
359  *              local signal mapping
360  *
361  *      Linemode:
362  *              local/no editing
363  *      Both Linemode and Single Character mode:
364  *              local/remote echo
365  *              local/no xon/xoff
366  *              local/no signal mapping
367  */
368
369 void
370 TerminalNewMode(int f)
371 {
372     static int prevmode = 0;
373 #ifndef USE_TERMIO
374     struct tchars tc;
375     struct ltchars ltc;
376     struct sgttyb sb;
377     int lmode;
378 #else   /* USE_TERMIO */
379     struct termio tmp_tc;
380 #endif  /* USE_TERMIO */
381     int onoff;
382     int old;
383     cc_t esc;
384
385     globalmode = f&~MODE_FORCE;
386     if (prevmode == f)
387         return;
388
389     /*
390      * Write any outstanding data before switching modes
391      * ttyflush() returns 0 only when there is no more data
392      * left to write out, it returns -1 if it couldn't do
393      * anything at all, otherwise it returns 1 + the number
394      * of characters left to write.
395 #ifndef USE_TERMIO
396      * We would really like ask the kernel to wait for the output
397      * to drain, like we can do with the TCSADRAIN, but we don't have
398      * that option.  The only ioctl that waits for the output to
399      * drain, TIOCSETP, also flushes the input queue, which is NOT
400      * what we want (TIOCSETP is like TCSADFLUSH).
401 #endif
402      */
403     old = ttyflush(SYNCHing|flushout);
404     if (old < 0 || old > 1) {
405 #ifdef  USE_TERMIO
406         tcgetattr(tin, &tmp_tc);
407 #endif  /* USE_TERMIO */
408         do {
409             /*
410              * Wait for data to drain, then flush again.
411              */
412 #ifdef  USE_TERMIO
413             tcsetattr(tin, TCSADRAIN, &tmp_tc);
414 #endif  /* USE_TERMIO */
415             old = ttyflush(SYNCHing|flushout);
416         } while (old < 0 || old > 1);
417     }
418
419     old = prevmode;
420     prevmode = f&~MODE_FORCE;
421 #ifndef USE_TERMIO
422     sb = nttyb;
423     tc = ntc;
424     ltc = nltc;
425     lmode = olmode;
426 #else
427     tmp_tc = new_tc;
428 #endif
429
430     if (f&MODE_ECHO) {
431 #ifndef USE_TERMIO
432         sb.sg_flags |= ECHO;
433 #else
434         tmp_tc.c_lflag |= ECHO;
435         tmp_tc.c_oflag |= ONLCR;
436         if (crlf)
437                 tmp_tc.c_iflag |= ICRNL;
438 #endif
439     } else {
440 #ifndef USE_TERMIO
441         sb.sg_flags &= ~ECHO;
442 #else
443         tmp_tc.c_lflag &= ~ECHO;
444         tmp_tc.c_oflag &= ~ONLCR;
445 #endif
446     }
447
448     if ((f&MODE_FLOW) == 0) {
449 #ifndef USE_TERMIO
450         tc.t_startc = _POSIX_VDISABLE;
451         tc.t_stopc = _POSIX_VDISABLE;
452 #else
453         tmp_tc.c_iflag &= ~(IXOFF|IXON);        /* Leave the IXANY bit alone */
454     } else {
455         if (restartany < 0) {
456                 tmp_tc.c_iflag |= IXOFF|IXON;   /* Leave the IXANY bit alone */
457         } else if (restartany > 0) {
458                 tmp_tc.c_iflag |= IXOFF|IXON|IXANY;
459         } else {
460                 tmp_tc.c_iflag |= IXOFF|IXON;
461                 tmp_tc.c_iflag &= ~IXANY;
462         }
463 #endif
464     }
465
466     if ((f&MODE_TRAPSIG) == 0) {
467 #ifndef USE_TERMIO
468         tc.t_intrc = _POSIX_VDISABLE;
469         tc.t_quitc = _POSIX_VDISABLE;
470         tc.t_eofc = _POSIX_VDISABLE;
471         ltc.t_suspc = _POSIX_VDISABLE;
472         ltc.t_dsuspc = _POSIX_VDISABLE;
473 #else
474         tmp_tc.c_lflag &= ~ISIG;
475 #endif
476         localchars = 0;
477     } else {
478 #ifdef  USE_TERMIO
479         tmp_tc.c_lflag |= ISIG;
480 #endif
481         localchars = 1;
482     }
483
484     if (f&MODE_EDIT) {
485 #ifndef USE_TERMIO
486         sb.sg_flags &= ~CBREAK;
487         sb.sg_flags |= CRMOD;
488 #else
489         tmp_tc.c_lflag |= ICANON;
490 #endif
491     } else {
492 #ifndef USE_TERMIO
493         sb.sg_flags |= CBREAK;
494         if (f&MODE_ECHO)
495             sb.sg_flags |= CRMOD;
496         else
497             sb.sg_flags &= ~CRMOD;
498 #else
499         tmp_tc.c_lflag &= ~ICANON;
500         tmp_tc.c_iflag &= ~ICRNL;
501         tmp_tc.c_cc[VMIN] = 1;
502         tmp_tc.c_cc[VTIME] = 0;
503 #endif
504     }
505
506     if ((f&(MODE_EDIT|MODE_TRAPSIG)) == 0) {
507 #ifndef USE_TERMIO
508         ltc.t_lnextc = _POSIX_VDISABLE;
509 #else
510 # ifdef VLNEXT
511         tmp_tc.c_cc[VLNEXT] = (cc_t)(_POSIX_VDISABLE);
512 # endif
513 #endif
514     }
515
516     if (f&MODE_SOFT_TAB) {
517 #ifndef USE_TERMIO
518         sb.sg_flags |= XTABS;
519 #else
520 # ifdef OXTABS
521         tmp_tc.c_oflag |= OXTABS;
522 # endif
523 # ifdef TABDLY
524         tmp_tc.c_oflag &= ~TABDLY;
525         tmp_tc.c_oflag |= TAB3;
526 # endif
527 #endif
528     } else {
529 #ifndef USE_TERMIO
530         sb.sg_flags &= ~XTABS;
531 #else
532 # ifdef OXTABS
533         tmp_tc.c_oflag &= ~OXTABS;
534 # endif
535 # ifdef TABDLY
536         tmp_tc.c_oflag &= ~TABDLY;
537 # endif
538 #endif
539     }
540
541     if (f&MODE_LIT_ECHO) {
542 #ifndef USE_TERMIO
543         lmode &= ~LCTLECH;
544 #else
545 # ifdef ECHOCTL
546         tmp_tc.c_lflag &= ~ECHOCTL;
547 # endif
548 #endif
549     } else {
550 #ifndef USE_TERMIO
551         lmode |= LCTLECH;
552 #else
553 # ifdef ECHOCTL
554         tmp_tc.c_lflag |= ECHOCTL;
555 # endif
556 #endif
557     }
558
559     if (f == -1) {
560         onoff = 0;
561     } else {
562 #ifndef USE_TERMIO
563         if (f & MODE_OUTBIN)
564                 lmode |= LLITOUT;
565         else
566                 lmode &= ~LLITOUT;
567
568         if (f & MODE_INBIN)
569                 lmode |= LPASS8;
570         else
571                 lmode &= ~LPASS8;
572 #else
573         if (f & MODE_INBIN)
574                 tmp_tc.c_iflag &= ~ISTRIP;
575         else
576                 tmp_tc.c_iflag |= ISTRIP;
577         if (f & MODE_OUTBIN) {
578                 tmp_tc.c_cflag &= ~(CSIZE|PARENB);
579                 tmp_tc.c_cflag |= CS8;
580                 tmp_tc.c_oflag &= ~OPOST;
581         } else {
582                 tmp_tc.c_cflag &= ~(CSIZE|PARENB);
583                 tmp_tc.c_cflag |= old_tc.c_cflag & (CSIZE|PARENB);
584                 tmp_tc.c_oflag |= OPOST;
585         }
586 #endif
587         onoff = 1;
588     }
589
590     if (f != -1) {
591 #ifdef  SIGINT
592         (void) signal(SIGINT, intr);
593 #endif
594 #ifdef  SIGQUIT
595         (void) signal(SIGQUIT, intr2);
596 #endif
597 #ifdef  SIGTSTP
598         (void) signal(SIGTSTP, susp);
599 #endif  /* SIGTSTP */
600 #ifdef  SIGINFO
601         (void) signal(SIGINFO, ayt);
602 #endif
603 #if     defined(USE_TERMIO) && defined(NOKERNINFO)
604         tmp_tc.c_lflag |= NOKERNINFO;
605 #endif
606         /*
607          * We don't want to process ^Y here.  It's just another
608          * character that we'll pass on to the back end.  It has
609          * to process it because it will be processed when the
610          * user attempts to read it, not when we send it.
611          */
612 #ifndef USE_TERMIO
613         ltc.t_dsuspc = _POSIX_VDISABLE;
614 #else
615 # ifdef VDSUSP
616         tmp_tc.c_cc[VDSUSP] = (cc_t)(_POSIX_VDISABLE);
617 # endif
618 #endif
619 #ifdef  USE_TERMIO
620         /*
621          * If the VEOL character is already set, then use VEOL2,
622          * otherwise use VEOL.
623          */
624         esc = (rlogin != _POSIX_VDISABLE) ? rlogin : escape;
625         if ((tmp_tc.c_cc[VEOL] != esc)
626 # ifdef VEOL2
627             && (tmp_tc.c_cc[VEOL2] != esc)
628 # endif
629             ) {
630                 if (tmp_tc.c_cc[VEOL] == (cc_t)(_POSIX_VDISABLE))
631                     tmp_tc.c_cc[VEOL] = esc;
632 # ifdef VEOL2
633                 else if (tmp_tc.c_cc[VEOL2] == (cc_t)(_POSIX_VDISABLE))
634                     tmp_tc.c_cc[VEOL2] = esc;
635 # endif
636         }
637 #else
638         if (tc.t_brkc == (cc_t)(_POSIX_VDISABLE))
639                 tc.t_brkc = esc;
640 #endif
641     } else {
642 #ifdef  SIGINFO
643         (void) signal(SIGINFO, (void (*)(int))ayt_status);
644 #endif
645 #ifdef  SIGINT
646         (void) signal(SIGINT, SIG_DFL);
647 #endif
648 #ifdef  SIGQUIT
649         (void) signal(SIGQUIT, SIG_DFL);
650 #endif
651 #ifdef  SIGTSTP
652         (void) signal(SIGTSTP, SIG_DFL);
653 # ifndef SOLARIS
654         (void) sigsetmask(sigblock(0) & ~(1<<(SIGTSTP-1)));
655 # else
656         (void) sigrelse(SIGTSTP);
657 # endif
658 #endif  /* SIGTSTP */
659 #ifndef USE_TERMIO
660         ltc = oltc;
661         tc = otc;
662         sb = ottyb;
663         lmode = olmode;
664 #else
665         tmp_tc = old_tc;
666 #endif
667     }
668 #ifndef USE_TERMIO
669     ioctl(tin, TIOCLSET, (char *)&lmode);
670     ioctl(tin, TIOCSLTC, (char *)&ltc);
671     ioctl(tin, TIOCSETC, (char *)&tc);
672     ioctl(tin, TIOCSETN, (char *)&sb);
673 #else
674     if (tcsetattr(tin, TCSADRAIN, &tmp_tc) < 0)
675         tcsetattr(tin, TCSANOW, &tmp_tc);
676 #endif
677
678     ioctl(tin, FIONBIO, (char *)&onoff);
679     ioctl(tout, FIONBIO, (char *)&onoff);
680
681 }
682
683 /*
684  * Try to guess whether speeds are "encoded" (4.2BSD) or just numeric (4.4BSD).
685  */
686 #if B4800 != 4800
687 #define DECODE_BAUD
688 #endif
689
690 #ifdef  DECODE_BAUD
691 #ifndef B7200
692 #define B7200   B4800
693 #endif
694
695 #ifndef B14400
696 #define B14400  B9600
697 #endif
698
699 #ifndef B19200
700 # define B19200 B14400
701 #endif
702
703 #ifndef B28800
704 #define B28800  B19200
705 #endif
706
707 #ifndef B38400
708 # define B38400 B28800
709 #endif
710
711 #ifndef B57600
712 #define B57600  B38400
713 #endif
714
715 #ifndef B76800
716 #define B76800  B57600
717 #endif
718
719 #ifndef B115200
720 #define B115200 B76800
721 #endif
722
723 #ifndef B230400
724 #define B230400 B115200
725 #endif
726
727
728 /*
729  * This code assumes that the values B0, B50, B75...
730  * are in ascending order.  They do not have to be
731  * contiguous.
732  */
733 struct termspeeds {
734         long speed;
735         long value;
736 } termspeeds[] = {
737         { 0,      B0 },      { 50,    B50 },    { 75,     B75 },
738         { 110,    B110 },    { 134,   B134 },   { 150,    B150 },
739         { 200,    B200 },    { 300,   B300 },   { 600,    B600 },
740         { 1200,   B1200 },   { 1800,  B1800 },  { 2400,   B2400 },
741         { 4800,   B4800 },   { 7200,  B7200 },  { 9600,   B9600 },
742         { 14400,  B14400 },  { 19200, B19200 }, { 28800,  B28800 },
743         { 38400,  B38400 },  { 57600, B57600 }, { 115200, B115200 },
744         { 230400, B230400 }, { -1,    B230400 }
745 };
746 #endif  /* DECODE_BAUD */
747
748 void
749 TerminalSpeeds(long *ispeed, long *ospeed)
750 {
751 #ifdef  DECODE_BAUD
752     struct termspeeds *tp;
753 #endif  /* DECODE_BAUD */
754     long in, out;
755
756     out = cfgetospeed(&old_tc);
757     in = cfgetispeed(&old_tc);
758     if (in == 0)
759         in = out;
760
761 #ifdef  DECODE_BAUD
762     tp = termspeeds;
763     while ((tp->speed != -1) && (tp->value < in))
764         tp++;
765     *ispeed = tp->speed;
766
767     tp = termspeeds;
768     while ((tp->speed != -1) && (tp->value < out))
769         tp++;
770     *ospeed = tp->speed;
771 #else   /* DECODE_BAUD */
772         *ispeed = in;
773         *ospeed = out;
774 #endif  /* DECODE_BAUD */
775 }
776
777 int
778 TerminalWindowSize(long *rows, long *cols)
779 {
780 #ifdef  TIOCGWINSZ
781     struct winsize ws;
782
783     if (ioctl(fileno(stdin), TIOCGWINSZ, (char *)&ws) >= 0) {
784         *rows = ws.ws_row;
785         *cols = ws.ws_col;
786         return 1;
787     }
788 #endif  /* TIOCGWINSZ */
789     return 0;
790 }
791
792 int
793 NetClose(int fd)
794 {
795     return close(fd);
796 }
797
798 static void
799 NetNonblockingIO(int fd, int onoff)
800 {
801     ioctl(fd, FIONBIO, (char *)&onoff);
802 }
803
804 \f
805 /*
806  * Various signal handling routines.
807  */
808
809 /* ARGSUSED */
810 static SIG_FUNC_RET
811 deadpeer(int sig __unused)
812 {
813         setcommandmode();
814         longjmp(peerdied, -1);
815 }
816
817 /* ARGSUSED */
818 SIG_FUNC_RET
819 intr(int sig __unused)
820 {
821     if (localchars) {
822         intp();
823         return;
824     }
825     setcommandmode();
826     longjmp(toplevel, -1);
827 }
828
829 /* ARGSUSED */
830 SIG_FUNC_RET
831 intr2(int sig __unused)
832 {
833     if (localchars) {
834 #ifdef  KLUDGELINEMODE
835         if (kludgelinemode)
836             sendbrk();
837         else
838 #endif
839             sendabort();
840         return;
841     }
842 }
843
844 #ifdef  SIGTSTP
845 /* ARGSUSED */
846 SIG_FUNC_RET
847 susp(int sig __unused)
848 {
849     if ((rlogin != _POSIX_VDISABLE) && rlogin_susp())
850         return;
851     if (localchars)
852         sendsusp();
853 }
854 #endif
855
856 #ifdef  SIGWINCH
857 /* ARGSUSED */
858 static SIG_FUNC_RET
859 sendwin(int sig __unused)
860 {
861     if (connected) {
862         sendnaws();
863     }
864 }
865 #endif
866
867 #ifdef  SIGINFO
868 /* ARGSUSED */
869 SIG_FUNC_RET
870 ayt(int sig __unused)
871 {
872     if (connected)
873         sendayt();
874     else
875         ayt_status();
876 }
877 #endif
878
879 \f
880 void
881 sys_telnet_init(void)
882 {
883     (void) signal(SIGINT, intr);
884     (void) signal(SIGQUIT, intr2);
885     (void) signal(SIGPIPE, deadpeer);
886 #ifdef  SIGWINCH
887     (void) signal(SIGWINCH, sendwin);
888 #endif
889 #ifdef  SIGTSTP
890     (void) signal(SIGTSTP, susp);
891 #endif
892 #ifdef  SIGINFO
893     (void) signal(SIGINFO, ayt);
894 #endif
895
896     setconnmode(0);
897
898     NetNonblockingIO(net, 1);
899
900 #if     defined(SO_OOBINLINE)
901     if (SetSockOpt(net, SOL_SOCKET, SO_OOBINLINE, 1) == -1) {
902         perror("SetSockOpt");
903     }
904 #endif  /* defined(SO_OOBINLINE) */
905 }
906
907 /*
908  * Process rings -
909  *
910  *      This routine tries to fill up/empty our various rings.
911  *
912  *      The parameter specifies whether this is a poll operation,
913  *      or a block-until-something-happens operation.
914  *
915  *      The return value is 1 if something happened, 0 if not.
916  */
917
918 int
919 process_rings(int netin, int netout, int netex, int ttyin, int ttyout, int poll)
920 {
921     int c;
922     int returnValue = 0;
923     static struct timeval TimeValue = { 0, 0 };
924     int maxfd = -1;
925     int tmp;
926
927     if ((netout || netin || netex) && net > maxfd)
928         maxfd = net;
929     
930     if (ttyout && tout > maxfd)
931         maxfd = tout;
932     if (ttyin && tin > maxfd)
933         maxfd = tin;
934     tmp = howmany(maxfd+1, NFDBITS) * sizeof(fd_mask);
935     if (tmp > fdsn) {
936         if (ibitsp)
937             free(ibitsp);
938         if (obitsp)
939             free(obitsp);
940         if (xbitsp)
941             free(xbitsp);
942         
943         fdsn = tmp;
944         if ((ibitsp = (fd_set *)malloc(fdsn)) == NULL)
945             err(1, "malloc");
946         if ((obitsp = (fd_set *)malloc(fdsn)) == NULL)
947             err(1, "malloc");
948         if ((xbitsp = (fd_set *)malloc(fdsn)) == NULL)
949             err(1, "malloc");
950         memset(ibitsp, 0, fdsn);
951         memset(obitsp, 0, fdsn);
952         memset(xbitsp, 0, fdsn);
953     }
954     
955     if (netout)
956         FD_SET(net, obitsp);
957     if (ttyout)
958         FD_SET(tout, obitsp);
959     if (ttyin)
960         FD_SET(tin, ibitsp);
961     if (netin)
962         FD_SET(net, ibitsp);
963     if (netex)
964         FD_SET(net, xbitsp);
965     if ((c = select(maxfd + 1, ibitsp, obitsp, xbitsp,
966              (poll == 0)? NULL : &TimeValue)) < 0) {
967         if (c == -1) {
968                     /*
969                      * we can get EINTR if we are in line mode,
970                      * and the user does an escape (TSTP), or
971                      * some other signal generator.
972                      */
973             if (errno == EINTR) {
974                 return 0;
975             }
976                     /* I don't like this, does it ever happen? */
977             printf("sleep(5) from telnet, after select: %s\r\n", strerror(errno));
978             sleep(5);
979         }
980         return 0;
981     }
982
983     /*
984      * Any urgent data?
985      */
986     if (FD_ISSET(net, xbitsp)) {
987         FD_CLR(net, xbitsp);
988         SYNCHing = 1;
989         (void) ttyflush(1);     /* flush already enqueued data */
990     }
991
992     /*
993      * Something to read from the network...
994      */
995     if (FD_ISSET(net, ibitsp)) {
996         int canread;
997
998         FD_CLR(net, ibitsp);
999         canread = ring_empty_consecutive(&netiring);
1000 #if     !defined(SO_OOBINLINE)
1001             /*
1002              * In 4.2 (and some early 4.3) systems, the
1003              * OOB indication and data handling in the kernel
1004              * is such that if two separate TCP Urgent requests
1005              * come in, one byte of TCP data will be overlaid.
1006              * This is fatal for Telnet, but we try to live
1007              * with it.
1008              *
1009              * In addition, in 4.2 (and...), a special protocol
1010              * is needed to pick up the TCP Urgent data in
1011              * the correct sequence.
1012              *
1013              * What we do is:  if we think we are in urgent
1014              * mode, we look to see if we are "at the mark".
1015              * If we are, we do an OOB receive.  If we run
1016              * this twice, we will do the OOB receive twice,
1017              * but the second will fail, since the second
1018              * time we were "at the mark", but there wasn't
1019              * any data there (the kernel doesn't reset
1020              * "at the mark" until we do a normal read).
1021              * Once we've read the OOB data, we go ahead
1022              * and do normal reads.
1023              *
1024              * There is also another problem, which is that
1025              * since the OOB byte we read doesn't put us
1026              * out of OOB state, and since that byte is most
1027              * likely the TELNET DM (data mark), we would
1028              * stay in the TELNET SYNCH (SYNCHing) state.
1029              * So, clocks to the rescue.  If we've "just"
1030              * received a DM, then we test for the
1031              * presence of OOB data when the receive OOB
1032              * fails (and AFTER we did the normal mode read
1033              * to clear "at the mark").
1034              */
1035         if (SYNCHing) {
1036             int atmark;
1037             static int bogus_oob = 0, first = 1;
1038
1039             ioctl(net, SIOCATMARK, (char *)&atmark);
1040             if (atmark) {
1041                 c = recv(net, netiring.supply, canread, MSG_OOB);
1042                 if ((c == -1) && (errno == EINVAL)) {
1043                     c = recv(net, netiring.supply, canread, 0);
1044                     if (clocks.didnetreceive < clocks.gotDM) {
1045                         SYNCHing = stilloob(net);
1046                     }
1047                 } else if (first && c > 0) {
1048                     /*
1049                      * Bogosity check.  Systems based on 4.2BSD
1050                      * do not return an error if you do a second
1051                      * recv(MSG_OOB).  So, we do one.  If it
1052                      * succeeds and returns exactly the same
1053                      * data, then assume that we are running
1054                      * on a broken system and set the bogus_oob
1055                      * flag.  (If the data was different, then
1056                      * we probably got some valid new data, so
1057                      * increment the count...)
1058                      */
1059                     int i;
1060                     i = recv(net, netiring.supply + c, canread - c, MSG_OOB);
1061                     if (i == c &&
1062                         memcmp(netiring.supply, netiring.supply + c, i) == 0) {
1063                         bogus_oob = 1;
1064                         first = 0;
1065                     } else if (i < 0) {
1066                         bogus_oob = 0;
1067                         first = 0;
1068                     } else
1069                         c += i;
1070                 }
1071                 if (bogus_oob && c > 0) {
1072                     int i;
1073                     /*
1074                      * Bogosity.  We have to do the read
1075                      * to clear the atmark to get out of
1076                      * an infinate loop.
1077                      */
1078                     i = read(net, netiring.supply + c, canread - c);
1079                     if (i > 0)
1080                         c += i;
1081                 }
1082             } else {
1083                 c = recv(net, netiring.supply, canread, 0);
1084             }
1085         } else {
1086             c = recv(net, netiring.supply, canread, 0);
1087         }
1088         settimer(didnetreceive);
1089 #else   /* !defined(SO_OOBINLINE) */
1090         c = recv(net, (char *)netiring.supply, canread, 0);
1091 #endif  /* !defined(SO_OOBINLINE) */
1092         if (c < 0 && errno == EWOULDBLOCK) {
1093             c = 0;
1094         } else if (c <= 0) {
1095             return -1;
1096         }
1097         if (netdata) {
1098             Dump('<', netiring.supply, c);
1099         }
1100         if (c)
1101             ring_supplied(&netiring, c);
1102         returnValue = 1;
1103     }
1104
1105     /*
1106      * Something to read from the tty...
1107      */
1108     if (FD_ISSET(tin, ibitsp)) {
1109         FD_CLR(tin, ibitsp);
1110         c = TerminalRead(ttyiring.supply, ring_empty_consecutive(&ttyiring));
1111         if (c < 0 && errno == EIO)
1112             c = 0;
1113         if (c < 0 && errno == EWOULDBLOCK) {
1114             c = 0;
1115         } else {
1116             /* EOF detection for line mode!!!! */
1117             if ((c == 0) && MODE_LOCAL_CHARS(globalmode) && isatty(tin)) {
1118                         /* must be an EOF... */
1119                 *ttyiring.supply = termEofChar;
1120                 c = 1;
1121             }
1122             if (c <= 0) {
1123                 return -1;
1124             }
1125             if (termdata) {
1126                 Dump('<', ttyiring.supply, c);
1127             }
1128             ring_supplied(&ttyiring, c);
1129         }
1130         returnValue = 1;                /* did something useful */
1131     }
1132
1133     if (FD_ISSET(net, obitsp)) {
1134         FD_CLR(net, obitsp);
1135         returnValue |= netflush();
1136     }
1137     if (FD_ISSET(tout, obitsp)) {
1138         FD_CLR(tout, obitsp);
1139         returnValue |= (ttyflush(SYNCHing|flushout) > 0);
1140     }
1141
1142     return returnValue;
1143 }