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