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