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