src/bin/network/telnetd/state.c

   1 /*
   2  * Copyright (c) 1989, 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 #if 0
  35 #ifndef lint
  36 static const char sccsid[] = "@(#)state.c       8.5 (Berkeley) 5/30/95";
  37 #endif
  38 #endif
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD: src/contrib/telnet/telnetd/state.c,v 1.14 2003/05/04 02:54:49 obrien Exp $");
  41
  42 #include <stdarg.h>
  43 #include "telnetd.h"
  44 #ifdef  AUTHENTICATION
  45 #include <libtelnet/auth.h>
  46 #endif
  47 #ifdef  ENCRYPTION
  48 #include <libtelnet/encrypt.h>
  49 #endif
  50
  51 unsigned char   doopt[] = { IAC, DO, '%', 'c', 0 };
  52 unsigned char   dont[] = { IAC, DONT, '%', 'c', 0 };
  53 unsigned char   will[] = { IAC, WILL, '%', 'c', 0 };
  54 unsigned char   wont[] = { IAC, WONT, '%', 'c', 0 };
  55 int     not42 = 1;
  56
  57 /*
  58  * Buffer for sub-options, and macros
  59  * for suboptions buffer manipulations
  60  */
  61 unsigned char subbuffer[512], *subpointer= subbuffer, *subend= subbuffer;
  62
  63 #define SB_CLEAR()      subpointer = subbuffer
  64 #define SB_TERM()       { subend = subpointer; SB_CLEAR(); }
  65 #define SB_ACCUM(c)     if (subpointer < (subbuffer+sizeof subbuffer)) { \
  66                                 *subpointer++ = (c); \
  67                         }
  68 #define SB_GET()        ((*subpointer++)&0xff)
  69 #define SB_EOF()        (subpointer >= subend)
  70 #define SB_LEN()        (subend - subpointer)
  71
  72 #ifdef  ENV_HACK
  73 unsigned char *subsave;
  74 #define SB_SAVE()       subsave = subpointer;
  75 #define SB_RESTORE()    subpointer = subsave;
  76 #endif
  77
  78
  79 /*
  80  * State for recv fsm
  81  */
  82 #define TS_DATA         0       /* base state */
  83 #define TS_IAC          1       /* look for double IAC's */
  84 #define TS_CR           2       /* CR-LF ->'s CR */
  85 #define TS_SB           3       /* throw away begin's... */
  86 #define TS_SE           4       /* ...end's (suboption negotiation) */
  87 #define TS_WILL         5       /* will option negotiation */
  88 #define TS_WONT         6       /* wont " */
  89 #define TS_DO           7       /* do " */
  90 #define TS_DONT         8       /* dont " */
  91
  92 static void doclientstat(void);
  93
  94 void
  95 telrcv(void)
  96 {
  97         int c;
  98         static int state = TS_DATA;
  99
 100         while (ncc > 0) {
 101                 if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
 102                         break;
 103                 c = *netip++ & 0377, ncc--;
 104 #ifdef  ENCRYPTION
 105                 if (decrypt_input)
 106                         c = (*decrypt_input)(c);
 107 #endif  /* ENCRYPTION */
 108                 switch (state) {
 109
 110                 case TS_CR:
 111                         state = TS_DATA;
 112                         /* Strip off \n or \0 after a \r */
 113                         if ((c == 0) || (c == '\n')) {
 114                                 break;
 115                         }
 116                         /* FALLTHROUGH */
 117
 118                 case TS_DATA:
 119                         if (c == IAC) {
 120                                 state = TS_IAC;
 121                                 break;
 122                         }
 123                         /*
 124                          * We now map \r\n ==> \r for pragmatic reasons.
 125                          * Many client implementations send \r\n when
 126                          * the user hits the CarriageReturn key.
 127                          *
 128                          * We USED to map \r\n ==> \n, since \r\n says
 129                          * that we want to be in column 1 of the next
 130                          * printable line, and \n is the standard
 131                          * unix way of saying that (\r is only good
 132                          * if CRMOD is set, which it normally is).
 133                          */
 134                         if ((c == '\r') && his_state_is_wont(TELOPT_BINARY)) {
 135                                 int nc = *netip;
 136 #ifdef  ENCRYPTION
 137                                 if (decrypt_input)
 138                                         nc = (*decrypt_input)(nc & 0xff);
 139 #endif  /* ENCRYPTION */
 140 #ifdef  LINEMODE
 141                                 /*
 142                                  * If we are operating in linemode,
 143                                  * convert to local end-of-line.
 144                                  */
 145                                 if (linemode && (ncc > 0) && (('\n' == nc) ||
 146                                          ((0 == nc) && tty_iscrnl())) ) {
 147                                         netip++; ncc--;
 148                                         c = '\n';
 149                                 } else
 150 #endif
 151                                 {
 152 #ifdef  ENCRYPTION
 153                                         if (decrypt_input)
 154                                                 (void)(*decrypt_input)(-1);
 155 #endif  /* ENCRYPTION */
 156                                         state = TS_CR;
 157                                 }
 158                         }
 159                         *pfrontp++ = c;
 160                         break;
 161
 162                 case TS_IAC:
 163 gotiac:                 switch (c) {
 164
 165                         /*
 166                          * Send the process on the pty side an
 167                          * interrupt.  Do this with a NULL or
 168                          * interrupt char; depending on the tty mode.
 169                          */
 170                         case IP:
 171                                 DIAG(TD_OPTIONS,
 172                                         printoption("td: recv IAC", c));
 173                                 interrupt();
 174                                 break;
 175
 176                         case BREAK:
 177                                 DIAG(TD_OPTIONS,
 178                                         printoption("td: recv IAC", c));
 179                                 sendbrk();
 180                                 break;
 181
 182                         /*
 183                          * Are You There?
 184                          */
 185                         case AYT:
 186                                 DIAG(TD_OPTIONS,
 187                                         printoption("td: recv IAC", c));
 188                                 recv_ayt();
 189                                 break;
 190
 191                         /*
 192                          * Abort Output
 193                          */
 194                         case AO:
 195                             {
 196                                 DIAG(TD_OPTIONS,
 197                                         printoption("td: recv IAC", c));
 198                                 ptyflush();     /* half-hearted */
 199                                 init_termbuf();
 200
 201                                 if (slctab[SLC_AO].sptr &&
 202                                     *slctab[SLC_AO].sptr != (cc_t)(_POSIX_VDISABLE)) {
 203                                     *pfrontp++ =
 204                                         (unsigned char)*slctab[SLC_AO].sptr;
 205                                 }
 206
 207                                 netclear();     /* clear buffer back */
 208                                 output_data("%c%c", IAC, DM);
 209                                 neturg = nfrontp-1; /* off by one XXX */
 210                                 DIAG(TD_OPTIONS,
 211                                         printoption("td: send IAC", DM));
 212                                 break;
 213                             }
 214
 215                         /*
 216                          * Erase Character and
 217                          * Erase Line
 218                          */
 219                         case EC:
 220                         case EL:
 221                             {
 222                                 cc_t ch;
 223
 224                                 DIAG(TD_OPTIONS,
 225                                         printoption("td: recv IAC", c));
 226                                 ptyflush();     /* half-hearted */
 227                                 init_termbuf();
 228                                 if (c == EC)
 229                                         ch = *slctab[SLC_EC].sptr;
 230                                 else
 231                                         ch = *slctab[SLC_EL].sptr;
 232                                 if (ch != (cc_t)(_POSIX_VDISABLE))
 233                                         *pfrontp++ = (unsigned char)ch;
 234                                 break;
 235                             }
 236
 237                         /*
 238                          * Check for urgent data...
 239                          */
 240                         case DM:
 241                                 DIAG(TD_OPTIONS,
 242                                         printoption("td: recv IAC", c));
 243                                 SYNCHing = stilloob(net);
 244                                 settimer(gotDM);
 245                                 break;
 246
 247
 248                         /*
 249                          * Begin option subnegotiation...
 250                          */
 251                         case SB:
 252                                 state = TS_SB;
 253                                 SB_CLEAR();
 254                                 continue;
 255
 256                         case WILL:
 257                                 state = TS_WILL;
 258                                 continue;
 259
 260                         case WONT:
 261                                 state = TS_WONT;
 262                                 continue;
 263
 264                         case DO:
 265                                 state = TS_DO;
 266                                 continue;
 267
 268                         case DONT:
 269                                 state = TS_DONT;
 270                                 continue;
 271                         case EOR:
 272                                 if (his_state_is_will(TELOPT_EOR))
 273                                         doeof();
 274                                 break;
 275
 276                         /*
 277                          * Handle RFC 10xx Telnet linemode option additions
 278                          * to command stream (EOF, SUSP, ABORT).
 279                          */
 280                         case xEOF:
 281                                 doeof();
 282                                 break;
 283
 284                         case SUSP:
 285                                 sendsusp();
 286                                 break;
 287
 288                         case ABORT:
 289                                 sendbrk();
 290                                 break;
 291
 292                         case IAC:
 293                                 *pfrontp++ = c;
 294                                 break;
 295                         }
 296                         state = TS_DATA;
 297                         break;
 298
 299                 case TS_SB:
 300                         if (c == IAC) {
 301                                 state = TS_SE;
 302                         } else {
 303                                 SB_ACCUM(c);
 304                         }
 305                         break;
 306
 307                 case TS_SE:
 308                         if (c != SE) {
 309                                 if (c != IAC) {
 310                                         /*
 311                                          * bad form of suboption negotiation.
 312                                          * handle it in such a way as to avoid
 313                                          * damage to local state.  Parse
 314                                          * suboption buffer found so far,
 315                                          * then treat remaining stream as
 316                                          * another command sequence.
 317                                          */
 318
 319                                         /* for DIAGNOSTICS */
 320                                         SB_ACCUM(IAC);
 321                                         SB_ACCUM(c);
 322                                         subpointer -= 2;
 323
 324                                         SB_TERM();
 325                                         suboption();
 326                                         state = TS_IAC;
 327                                         goto gotiac;
 328                                 }
 329                                 SB_ACCUM(c);
 330                                 state = TS_SB;
 331                         } else {
 332                                 /* for DIAGNOSTICS */
 333                                 SB_ACCUM(IAC);
 334                                 SB_ACCUM(SE);
 335                                 subpointer -= 2;
 336
 337                                 SB_TERM();
 338                                 suboption();    /* handle sub-option */
 339                                 state = TS_DATA;
 340                         }
 341                         break;
 342
 343                 case TS_WILL:
 344                         willoption(c);
 345                         state = TS_DATA;
 346                         continue;
 347
 348                 case TS_WONT:
 349                         wontoption(c);
 350                         state = TS_DATA;
 351                         continue;
 352
 353                 case TS_DO:
 354                         dooption(c);
 355                         state = TS_DATA;
 356                         continue;
 357
 358                 case TS_DONT:
 359                         dontoption(c);
 360                         state = TS_DATA;
 361                         continue;
 362
 363                 default:
 364                         syslog(LOG_ERR, "panic state=%d", state);
 365                         printf("telnetd: panic state=%d\n", state);
 366                         exit(1);
 367                 }
 368         }
 369 }  /* end of telrcv */
 370
 371 /*
 372  * The will/wont/do/dont state machines are based on Dave Borman's
 373  * Telnet option processing state machine.
 374  *
 375  * These correspond to the following states:
 376  *      my_state = the last negotiated state
 377  *      want_state = what I want the state to go to
 378  *      want_resp = how many requests I have sent
 379  * All state defaults are negative, and resp defaults to 0.
 380  *
 381  * When initiating a request to change state to new_state:
 382  *
 383  * if ((want_resp == 0 && new_state == my_state) || want_state == new_state) {
 384  *      do nothing;
 385  * } else {
 386  *      want_state = new_state;
 387  *      send new_state;
 388  *      want_resp++;
 389  * }
 390  *
 391  * When receiving new_state:
 392  *
 393  * if (want_resp) {
 394  *      want_resp--;
 395  *      if (want_resp && (new_state == my_state))
 396  *              want_resp--;
 397  * }
 398  * if ((want_resp == 0) && (new_state != want_state)) {
 399  *      if (ok_to_switch_to new_state)
 400  *              want_state = new_state;
 401  *      else
 402  *              want_resp++;
 403  *      send want_state;
 404  * }
 405  * my_state = new_state;
 406  *
 407  * Note that new_state is implied in these functions by the function itself.
 408  * will and do imply positive new_state, wont and dont imply negative.
 409  *
 410  * Finally, there is one catch.  If we send a negative response to a
 411  * positive request, my_state will be the positive while want_state will
 412  * remain negative.  my_state will revert to negative when the negative
 413  * acknowlegment arrives from the peer.  Thus, my_state generally tells
 414  * us not only the last negotiated state, but also tells us what the peer
 415  * wants to be doing as well.  It is important to understand this difference
 416  * as we may wish to be processing data streams based on our desired state
 417  * (want_state) or based on what the peer thinks the state is (my_state).
 418  *
 419  * This all works fine because if the peer sends a positive request, the data
 420  * that we receive prior to negative acknowlegment will probably be affected
 421  * by the positive state, and we can process it as such (if we can; if we
 422  * can't then it really doesn't matter).  If it is that important, then the
 423  * peer probably should be buffering until this option state negotiation
 424  * is complete.
 425  *
 426  */
 427 void
 428 send_do(int option, int init)
 429 {
 430         if (init) {
 431                 if ((do_dont_resp[option] == 0 && his_state_is_will(option)) ||
 432                     his_want_state_is_will(option))
 433                         return;
 434                 /*
 435                  * Special case for TELOPT_TM:  We send a DO, but pretend
 436                  * that we sent a DONT, so that we can send more DOs if
 437                  * we want to.
 438                  */
 439                 if (option == TELOPT_TM)
 440                         set_his_want_state_wont(option);
 441                 else
 442                         set_his_want_state_will(option);
 443                 do_dont_resp[option]++;
 444         }
 445         output_data((const char *)doopt, option);
 446
 447         DIAG(TD_OPTIONS, printoption("td: send do", option));
 448 }
 449
 450 void
 451 willoption(int option)
 452 {
 453         int changeok = 0;
 454         void (*func)(void) = 0;
 455
 456         /*
 457          * process input from peer.
 458          */
 459
 460         DIAG(TD_OPTIONS, printoption("td: recv will", option));
 461
 462         if (do_dont_resp[option]) {
 463                 do_dont_resp[option]--;
 464                 if (do_dont_resp[option] && his_state_is_will(option))
 465                         do_dont_resp[option]--;
 466         }
 467         if (do_dont_resp[option] == 0) {
 468             if (his_want_state_is_wont(option)) {
 469                 switch (option) {
 470
 471                 case TELOPT_BINARY:
 472                         init_termbuf();
 473                         tty_binaryin(1);
 474                         set_termbuf();
 475                         changeok++;
 476                         break;
 477
 478                 case TELOPT_ECHO:
 479                         /*
 480                          * See comments below for more info.
 481                          */
 482                         not42 = 0;      /* looks like a 4.2 system */
 483                         break;
 484
 485                 case TELOPT_TM:
 486 #if     defined(LINEMODE) && defined(KLUDGELINEMODE)
 487                         /*
 488                          * This telnetd implementation does not really
 489                          * support timing marks, it just uses them to
 490                          * support the kludge linemode stuff.  If we
 491                          * receive a will or wont TM in response to our
 492                          * do TM request that may have been sent to
 493                          * determine kludge linemode support, process
 494                          * it, otherwise TM should get a negative
 495                          * response back.
 496                          */
 497                         /*
 498                          * Handle the linemode kludge stuff.
 499                          * If we are not currently supporting any
 500                          * linemode at all, then we assume that this
 501                          * is the client telling us to use kludge
 502                          * linemode in response to our query.  Set the
 503                          * linemode type that is to be supported, note
 504                          * that the client wishes to use linemode, and
 505                          * eat the will TM as though it never arrived.
 506                          */
 507                         if (lmodetype < KLUDGE_LINEMODE) {
 508                                 lmodetype = KLUDGE_LINEMODE;
 509                                 clientstat(TELOPT_LINEMODE, WILL, 0);
 510                                 send_wont(TELOPT_SGA, 1);
 511                         } else if (lmodetype == NO_AUTOKLUDGE) {
 512                                 lmodetype = KLUDGE_OK;
 513                         }
 514 #endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
 515                         /*
 516                          * We never respond to a WILL TM, and
 517                          * we leave the state WONT.
 518                          */
 519                         return;
 520
 521                 case TELOPT_LFLOW:
 522                         /*
 523                          * If we are going to support flow control
 524                          * option, then don't worry peer that we can't
 525                          * change the flow control characters.
 526                          */
 527                         slctab[SLC_XON].defset.flag &= ~SLC_LEVELBITS;
 528                         slctab[SLC_XON].defset.flag |= SLC_DEFAULT;
 529                         slctab[SLC_XOFF].defset.flag &= ~SLC_LEVELBITS;
 530                         slctab[SLC_XOFF].defset.flag |= SLC_DEFAULT;
 531                 case TELOPT_TTYPE:
 532                 case TELOPT_SGA:
 533                 case TELOPT_NAWS:
 534                 case TELOPT_TSPEED:
 535                 case TELOPT_XDISPLOC:
 536                 case TELOPT_NEW_ENVIRON:
 537                 case TELOPT_OLD_ENVIRON:
 538                         changeok++;
 539                         break;
 540
 541 #ifdef  LINEMODE
 542                 case TELOPT_LINEMODE:
 543 # ifdef KLUDGELINEMODE
 544                         /*
 545                          * Note client's desire to use linemode.
 546                          */
 547                         lmodetype = REAL_LINEMODE;
 548 # endif /* KLUDGELINEMODE */
 549                         func = doclientstat;
 550                         changeok++;
 551                         break;
 552 #endif  /* LINEMODE */
 553
 554 #ifdef  AUTHENTICATION
 555                 case TELOPT_AUTHENTICATION:
 556                         func = auth_request;
 557                         changeok++;
 558                         break;
 559 #endif
 560
 561 #ifdef  ENCRYPTION
 562                 case TELOPT_ENCRYPT:
 563                         func = encrypt_send_support;
 564                         changeok++;
 565                         break;
 566 #endif  /* ENCRYPTION */
 567
 568                 default:
 569                         break;
 570                 }
 571                 if (changeok) {
 572                         set_his_want_state_will(option);
 573                         send_do(option, 0);
 574                 } else {
 575                         do_dont_resp[option]++;
 576                         send_dont(option, 0);
 577                 }
 578             } else {
 579                 /*
 580                  * Option processing that should happen when
 581                  * we receive conformation of a change in
 582                  * state that we had requested.
 583                  */
 584                 switch (option) {
 585                 case TELOPT_ECHO:
 586                         not42 = 0;      /* looks like a 4.2 system */
 587                         /*
 588                          * Egads, he responded "WILL ECHO".  Turn
 589                          * it off right now!
 590                          */
 591                         send_dont(option, 1);
 592                         /*
 593                          * "WILL ECHO".  Kludge upon kludge!
 594                          * A 4.2 client is now echoing user input at
 595                          * the tty.  This is probably undesireable and
 596                          * it should be stopped.  The client will
 597                          * respond WONT TM to the DO TM that we send to
 598                          * check for kludge linemode.  When the WONT TM
 599                          * arrives, linemode will be turned off and a
 600                          * change propogated to the pty.  This change
 601                          * will cause us to process the new pty state
 602                          * in localstat(), which will notice that
 603                          * linemode is off and send a WILL ECHO
 604                          * so that we are properly in character mode and
 605                          * all is well.
 606                          */
 607                         break;
 608 #ifdef  LINEMODE
 609                 case TELOPT_LINEMODE:
 610 # ifdef KLUDGELINEMODE
 611                         /*
 612                          * Note client's desire to use linemode.
 613                          */
 614                         lmodetype = REAL_LINEMODE;
 615 # endif /* KLUDGELINEMODE */
 616                         func = doclientstat;
 617                         break;
 618 #endif  /* LINEMODE */
 619
 620 #ifdef  AUTHENTICATION
 621                 case TELOPT_AUTHENTICATION:
 622                         func = auth_request;
 623                         break;
 624 #endif
 625
 626 #ifdef  ENCRYPTION
 627                 case TELOPT_ENCRYPT:
 628                         func = encrypt_send_support;
 629                         break;
 630 #endif  /* ENCRYPTION */
 631                 case TELOPT_LFLOW:
 632                         func = flowstat;
 633                         break;
 634                 }
 635             }
 636         }
 637         set_his_state_will(option);
 638         if (func)
 639                 (*func)();
 640 }  /* end of willoption */
 641
 642 void
 643 send_dont(int option, int init)
 644 {
 645         if (init) {
 646                 if ((do_dont_resp[option] == 0 && his_state_is_wont(option)) ||
 647                     his_want_state_is_wont(option))
 648                         return;
 649                 set_his_want_state_wont(option);
 650                 do_dont_resp[option]++;
 651         }
 652         output_data((const char *)dont, option);
 653
 654         DIAG(TD_OPTIONS, printoption("td: send dont", option));
 655 }
 656
 657 void
 658 wontoption(int option)
 659 {
 660         /*
 661          * Process client input.
 662          */
 663
 664         DIAG(TD_OPTIONS, printoption("td: recv wont", option));
 665
 666         if (do_dont_resp[option]) {
 667                 do_dont_resp[option]--;
 668                 if (do_dont_resp[option] && his_state_is_wont(option))
 669                         do_dont_resp[option]--;
 670         }
 671         if (do_dont_resp[option] == 0) {
 672             if (his_want_state_is_will(option)) {
 673                 /* it is always ok to change to negative state */
 674                 switch (option) {
 675                 case TELOPT_ECHO:
 676                         not42 = 1; /* doesn't seem to be a 4.2 system */
 677                         break;
 678
 679                 case TELOPT_BINARY:
 680                         init_termbuf();
 681                         tty_binaryin(0);
 682                         set_termbuf();
 683                         break;
 684
 685 #ifdef  LINEMODE
 686                 case TELOPT_LINEMODE:
 687 # ifdef KLUDGELINEMODE
 688                         /*
 689                          * If real linemode is supported, then client is
 690                          * asking to turn linemode off.
 691                          */
 692                         if (lmodetype != REAL_LINEMODE)
 693                                 break;
 694                         lmodetype = KLUDGE_LINEMODE;
 695 # endif /* KLUDGELINEMODE */
 696                         clientstat(TELOPT_LINEMODE, WONT, 0);
 697                         break;
 698 #endif  /* LINEMODE */
 699
 700                 case TELOPT_TM:
 701                         /*
 702                          * If we get a WONT TM, and had sent a DO TM,
 703                          * don't respond with a DONT TM, just leave it
 704                          * as is.  Short circut the state machine to
 705                          * achive this.
 706                          */
 707                         set_his_want_state_wont(TELOPT_TM);
 708                         return;
 709
 710                 case TELOPT_LFLOW:
 711                         /*
 712                          * If we are not going to support flow control
 713                          * option, then let peer know that we can't
 714                          * change the flow control characters.
 715                          */
 716                         slctab[SLC_XON].defset.flag &= ~SLC_LEVELBITS;
 717                         slctab[SLC_XON].defset.flag |= SLC_CANTCHANGE;
 718                         slctab[SLC_XOFF].defset.flag &= ~SLC_LEVELBITS;
 719                         slctab[SLC_XOFF].defset.flag |= SLC_CANTCHANGE;
 720                         break;
 721
 722 #ifdef  AUTHENTICATION
 723                 case TELOPT_AUTHENTICATION:
 724                         auth_finished(0, AUTH_REJECT);
 725                         break;
 726 #endif
 727
 728                 /*
 729                  * For options that we might spin waiting for
 730                  * sub-negotiation, if the client turns off the
 731                  * option rather than responding to the request,
 732                  * we have to treat it here as if we got a response
 733                  * to the sub-negotiation, (by updating the timers)
 734                  * so that we'll break out of the loop.
 735                  */
 736                 case TELOPT_TTYPE:
 737                         settimer(ttypesubopt);
 738                         break;
 739
 740                 case TELOPT_TSPEED:
 741                         settimer(tspeedsubopt);
 742                         break;
 743
 744                 case TELOPT_XDISPLOC:
 745                         settimer(xdisplocsubopt);
 746                         break;
 747
 748                 case TELOPT_OLD_ENVIRON:
 749                         settimer(oenvironsubopt);
 750                         break;
 751
 752                 case TELOPT_NEW_ENVIRON:
 753                         settimer(environsubopt);
 754                         break;
 755
 756                 default:
 757                         break;
 758                 }
 759                 set_his_want_state_wont(option);
 760                 if (his_state_is_will(option))
 761                         send_dont(option, 0);
 762             } else {
 763                 switch (option) {
 764                 case TELOPT_TM:
 765 #if     defined(LINEMODE) && defined(KLUDGELINEMODE)
 766                         if (lmodetype < NO_AUTOKLUDGE) {
 767                                 lmodetype = NO_LINEMODE;
 768                                 clientstat(TELOPT_LINEMODE, WONT, 0);
 769                                 send_will(TELOPT_SGA, 1);
 770                                 send_will(TELOPT_ECHO, 1);
 771                         }
 772 #endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
 773                         break;
 774
 775 #ifdef AUTHENTICATION
 776                 case TELOPT_AUTHENTICATION:
 777                         auth_finished(0, AUTH_REJECT);
 778                         break;
 779 #endif
 780                 default:
 781                         break;
 782                 }
 783             }
 784         }
 785         set_his_state_wont(option);
 786
 787 }  /* end of wontoption */
 788
 789 void
 790 send_will(int option, int init)
 791 {
 792         if (init) {
 793                 if ((will_wont_resp[option] == 0 && my_state_is_will(option))||
 794                     my_want_state_is_will(option))
 795                         return;
 796                 set_my_want_state_will(option);
 797                 will_wont_resp[option]++;
 798         }
 799         output_data((const char *)will, option);
 800
 801         DIAG(TD_OPTIONS, printoption("td: send will", option));
 802 }
 803
 804 #if     !defined(LINEMODE) || !defined(KLUDGELINEMODE)
 805 /*
 806  * When we get a DONT SGA, we will try once to turn it
 807  * back on.  If the other side responds DONT SGA, we
 808  * leave it at that.  This is so that when we talk to
 809  * clients that understand KLUDGELINEMODE but not LINEMODE,
 810  * we'll keep them in char-at-a-time mode.
 811  */
 812 int turn_on_sga = 0;
 813 #endif
 814
 815 void
 816 dooption(int option)
 817 {
 818         int changeok = 0;
 819
 820         /*
 821          * Process client input.
 822          */
 823
 824         DIAG(TD_OPTIONS, printoption("td: recv do", option));
 825
 826         if (will_wont_resp[option]) {
 827                 will_wont_resp[option]--;
 828                 if (will_wont_resp[option] && my_state_is_will(option))
 829                         will_wont_resp[option]--;
 830         }
 831         if ((will_wont_resp[option] == 0) && (my_want_state_is_wont(option))) {
 832                 switch (option) {
 833                 case TELOPT_ECHO:
 834 #ifdef  LINEMODE
 835 # ifdef KLUDGELINEMODE
 836                         if (lmodetype == NO_LINEMODE)
 837 # else
 838                         if (his_state_is_wont(TELOPT_LINEMODE))
 839 # endif
 840 #endif
 841                         {
 842                                 init_termbuf();
 843                                 tty_setecho(1);
 844                                 set_termbuf();
 845                         }
 846                         changeok++;
 847                         break;
 848
 849                 case TELOPT_BINARY:
 850                         init_termbuf();
 851                         tty_binaryout(1);
 852                         set_termbuf();
 853                         changeok++;
 854                         break;
 855
 856                 case TELOPT_SGA:
 857 #if     defined(LINEMODE) && defined(KLUDGELINEMODE)
 858                         /*
 859                          * If kludge linemode is in use, then we must
 860                          * process an incoming do SGA for linemode
 861                          * purposes.
 862                          */
 863                         if (lmodetype == KLUDGE_LINEMODE) {
 864                                 /*
 865                                  * Receipt of "do SGA" in kludge
 866                                  * linemode is the peer asking us to
 867                                  * turn off linemode.  Make note of
 868                                  * the request.
 869                                  */
 870                                 clientstat(TELOPT_LINEMODE, WONT, 0);
 871                                 /*
 872                                  * If linemode did not get turned off
 873                                  * then don't tell peer that we did.
 874                                  * Breaking here forces a wont SGA to
 875                                  * be returned.
 876                                  */
 877                                 if (linemode)
 878                                         break;
 879                         }
 880 #else
 881                         turn_on_sga = 0;
 882 #endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
 883                         changeok++;
 884                         break;
 885
 886                 case TELOPT_STATUS:
 887                         changeok++;
 888                         break;
 889
 890                 case TELOPT_TM:
 891                         /*
 892                          * Special case for TM.  We send a WILL, but
 893                          * pretend we sent a WONT.
 894                          */
 895                         send_will(option, 0);
 896                         set_my_want_state_wont(option);
 897                         set_my_state_wont(option);
 898                         return;
 899
 900                 case TELOPT_LOGOUT:
 901                         /*
 902                          * When we get a LOGOUT option, respond
 903                          * with a WILL LOGOUT, make sure that
 904                          * it gets written out to the network,
 905                          * and then just go away...
 906                          */
 907                         set_my_want_state_will(TELOPT_LOGOUT);
 908                         send_will(TELOPT_LOGOUT, 0);
 909                         set_my_state_will(TELOPT_LOGOUT);
 910                         (void)netflush();
 911                         cleanup(0);
 912                         /* NOT REACHED */
 913                         break;
 914
 915 #ifdef  ENCRYPTION
 916                 case TELOPT_ENCRYPT:
 917                         changeok++;
 918                         break;
 919 #endif  /* ENCRYPTION */
 920                 case TELOPT_LINEMODE:
 921                 case TELOPT_TTYPE:
 922                 case TELOPT_NAWS:
 923                 case TELOPT_TSPEED:
 924                 case TELOPT_LFLOW:
 925                 case TELOPT_XDISPLOC:
 926 #ifdef  TELOPT_ENVIRON
 927                 case TELOPT_NEW_ENVIRON:
 928 #endif
 929                 case TELOPT_OLD_ENVIRON:
 930                 default:
 931                         break;
 932                 }
 933                 if (changeok) {
 934                         set_my_want_state_will(option);
 935                         send_will(option, 0);
 936                 } else {
 937                         will_wont_resp[option]++;
 938                         send_wont(option, 0);
 939                 }
 940         }
 941         set_my_state_will(option);
 942
 943 }  /* end of dooption */
 944
 945 void
 946 send_wont(int option, int init)
 947 {
 948         if (init) {
 949                 if ((will_wont_resp[option] == 0 && my_state_is_wont(option)) ||
 950                     my_want_state_is_wont(option))
 951                         return;
 952                 set_my_want_state_wont(option);
 953                 will_wont_resp[option]++;
 954         }
 955         output_data((const char *)wont, option);
 956
 957         DIAG(TD_OPTIONS, printoption("td: send wont", option));
 958 }
 959
 960 void
 961 dontoption(int option)
 962 {
 963         /*
 964          * Process client input.
 965          */
 966
 967
 968         DIAG(TD_OPTIONS, printoption("td: recv dont", option));
 969
 970         if (will_wont_resp[option]) {
 971                 will_wont_resp[option]--;
 972                 if (will_wont_resp[option] && my_state_is_wont(option))
 973                         will_wont_resp[option]--;
 974         }
 975         if ((will_wont_resp[option] == 0) && (my_want_state_is_will(option))) {
 976                 switch (option) {
 977                 case TELOPT_BINARY:
 978                         init_termbuf();
 979                         tty_binaryout(0);
 980                         set_termbuf();
 981                         break;
 982
 983                 case TELOPT_ECHO:       /* we should stop echoing */
 984 #ifdef  LINEMODE
 985 # ifdef KLUDGELINEMODE
 986                         if ((lmodetype != REAL_LINEMODE) &&
 987                             (lmodetype != KLUDGE_LINEMODE))
 988 # else
 989                         if (his_state_is_wont(TELOPT_LINEMODE))
 990 # endif
 991 #endif
 992                         {
 993                                 init_termbuf();
 994                                 tty_setecho(0);
 995                                 set_termbuf();
 996                         }
 997                         break;
 998
 999                 case TELOPT_SGA:
1000 #if     defined(LINEMODE) && defined(KLUDGELINEMODE)
1001                         /*
1002                          * If kludge linemode is in use, then we
1003                          * must process an incoming do SGA for
1004                          * linemode purposes.
1005                          */
1006                         if ((lmodetype == KLUDGE_LINEMODE) ||
1007                             (lmodetype == KLUDGE_OK)) {
1008                                 /*
1009                                  * The client is asking us to turn
1010                                  * linemode on.
1011                                  */
1012                                 lmodetype = KLUDGE_LINEMODE;
1013                                 clientstat(TELOPT_LINEMODE, WILL, 0);
1014                                 /*
1015                                  * If we did not turn line mode on,
1016                                  * then what do we say?  Will SGA?
1017                                  * This violates design of telnet.
1018                                  * Gross.  Very Gross.
1019                                  */
1020                         }
1021                         break;
1022 #else
1023                         set_my_want_state_wont(option);
1024                         if (my_state_is_will(option))
1025                                 send_wont(option, 0);
1026                         set_my_state_wont(option);
1027                         if (turn_on_sga ^= 1)
1028                                 send_will(option, 1);
1029                         return;
1030 #endif  /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
1031
1032                 default:
1033                         break;
1034                 }
1035
1036                 set_my_want_state_wont(option);
1037                 if (my_state_is_will(option))
1038                         send_wont(option, 0);
1039         }
1040         set_my_state_wont(option);
1041
1042 }  /* end of dontoption */
1043
1044 #ifdef  ENV_HACK
1045 int env_ovar = -1;
1046 int env_ovalue = -1;
1047 #else   /* ENV_HACK */
1048 # define env_ovar OLD_ENV_VAR
1049 # define env_ovalue OLD_ENV_VALUE
1050 #endif  /* ENV_HACK */
1051
1052 /*
1053  * suboption()
1054  *
1055  *      Look at the sub-option buffer, and try to be helpful to the other
1056  * side.
1057  *
1058  *      Currently we recognize:
1059  *
1060  *      Terminal type is
1061  *      Linemode
1062  *      Window size
1063  *      Terminal speed
1064  */
1065 void
1066 suboption(void)
1067 {
1068     int subchar;
1069
1070     DIAG(TD_OPTIONS, {netflush(); printsub('<', subpointer, SB_LEN()+2);});
1071
1072     subchar = SB_GET();
1073     switch (subchar) {
1074     case TELOPT_TSPEED: {
1075         int xspeed, rspeed;
1076
1077         if (his_state_is_wont(TELOPT_TSPEED))   /* Ignore if option disabled */
1078                 break;
1079
1080         settimer(tspeedsubopt);
1081
1082         if (SB_EOF() || SB_GET() != TELQUAL_IS)
1083                 return;
1084
1085         xspeed = atoi((char *)subpointer);
1086
1087         while (SB_GET() != ',' && !SB_EOF());
1088         if (SB_EOF())
1089                 return;
1090
1091         rspeed = atoi((char *)subpointer);
1092         clientstat(TELOPT_TSPEED, xspeed, rspeed);
1093
1094         break;
1095
1096     }  /* end of case TELOPT_TSPEED */
1097
1098     case TELOPT_TTYPE: {                /* Yaaaay! */
1099         static char terminalname[41];
1100
1101         if (his_state_is_wont(TELOPT_TTYPE))    /* Ignore if option disabled */
1102                 break;
1103         settimer(ttypesubopt);
1104
1105         if (SB_EOF() || SB_GET() != TELQUAL_IS) {
1106             return;             /* ??? XXX but, this is the most robust */
1107         }
1108
1109         terminaltype = terminalname;
1110
1111         while ((terminaltype < (terminalname + sizeof terminalname-1)) &&
1112                                                                     !SB_EOF()) {
1113             int c;
1114
1115             c = SB_GET();
1116             if (isupper(c)) {
1117                 c = tolower(c);
1118             }
1119             *terminaltype++ = c;    /* accumulate name */
1120         }
1121         *terminaltype = 0;
1122         terminaltype = terminalname;
1123         break;
1124     }  /* end of case TELOPT_TTYPE */
1125
1126     case TELOPT_NAWS: {
1127         int xwinsize, ywinsize;
1128
1129         if (his_state_is_wont(TELOPT_NAWS))     /* Ignore if option disabled */
1130                 break;
1131
1132         if (SB_EOF())
1133                 return;
1134         xwinsize = SB_GET() << 8;
1135         if (SB_EOF())
1136                 return;
1137         xwinsize |= SB_GET();
1138         if (SB_EOF())
1139                 return;
1140         ywinsize = SB_GET() << 8;
1141         if (SB_EOF())
1142                 return;
1143         ywinsize |= SB_GET();
1144         clientstat(TELOPT_NAWS, xwinsize, ywinsize);
1145
1146         break;
1147
1148     }  /* end of case TELOPT_NAWS */
1149
1150 #ifdef  LINEMODE
1151     case TELOPT_LINEMODE: {
1152         int request;
1153
1154         if (his_state_is_wont(TELOPT_LINEMODE)) /* Ignore if option disabled */
1155                 break;
1156         /*
1157          * Process linemode suboptions.
1158          */
1159         if (SB_EOF())
1160             break;              /* garbage was sent */
1161         request = SB_GET();     /* get will/wont */
1162
1163         if (SB_EOF())
1164             break;              /* another garbage check */
1165
1166         if (request == LM_SLC) {  /* SLC is not preceeded by WILL or WONT */
1167                 /*
1168                  * Process suboption buffer of slc's
1169                  */
1170                 start_slc(1);
1171                 do_opt_slc(subpointer, subend - subpointer);
1172                 (void) end_slc(0);
1173                 break;
1174         } else if (request == LM_MODE) {
1175                 if (SB_EOF())
1176                     return;
1177                 useeditmode = SB_GET();  /* get mode flag */
1178                 clientstat(LM_MODE, 0, 0);
1179                 break;
1180         }
1181
1182         if (SB_EOF())
1183             break;
1184         switch (SB_GET()) {  /* what suboption? */
1185         case LM_FORWARDMASK:
1186                 /*
1187                  * According to spec, only server can send request for
1188                  * forwardmask, and client can only return a positive response.
1189                  * So don't worry about it.
1190                  */
1191
1192         default:
1193                 break;
1194         }
1195         break;
1196     }  /* end of case TELOPT_LINEMODE */
1197 #endif
1198     case TELOPT_STATUS: {
1199         int mode;
1200
1201         if (SB_EOF())
1202             break;
1203         mode = SB_GET();
1204         switch (mode) {
1205         case TELQUAL_SEND:
1206             if (my_state_is_will(TELOPT_STATUS))
1207                 send_status();
1208             break;
1209
1210         case TELQUAL_IS:
1211             break;
1212
1213         default:
1214             break;
1215         }
1216         break;
1217     }  /* end of case TELOPT_STATUS */
1218
1219     case TELOPT_XDISPLOC: {
1220         if (SB_EOF() || SB_GET() != TELQUAL_IS)
1221                 return;
1222         settimer(xdisplocsubopt);
1223         subpointer[SB_LEN()] = '\0';
1224         (void)setenv("DISPLAY", (char *)subpointer, 1);
1225         break;
1226     }  /* end of case TELOPT_XDISPLOC */
1227
1228 #ifdef  TELOPT_NEW_ENVIRON
1229     case TELOPT_NEW_ENVIRON:
1230 #endif
1231     case TELOPT_OLD_ENVIRON: {
1232         int c;
1233         char *cp, *varp, *valp;
1234
1235         if (SB_EOF())
1236                 return;
1237         c = SB_GET();
1238         if (c == TELQUAL_IS) {
1239                 if (subchar == TELOPT_OLD_ENVIRON)
1240                         settimer(oenvironsubopt);
1241                 else
1242                         settimer(environsubopt);
1243         } else if (c != TELQUAL_INFO) {
1244                 return;
1245         }
1246
1247 #ifdef  TELOPT_NEW_ENVIRON
1248         if (subchar == TELOPT_NEW_ENVIRON) {
1249             while (!SB_EOF()) {
1250                 c = SB_GET();
1251                 if ((c == NEW_ENV_VAR) || (c == ENV_USERVAR))
1252                         break;
1253             }
1254         } else
1255 #endif
1256         {
1257 #ifdef  ENV_HACK
1258             /*
1259              * We only want to do this if we haven't already decided
1260              * whether or not the other side has its VALUE and VAR
1261              * reversed.
1262              */
1263             if (env_ovar < 0) {
1264                 int last = -1;          /* invalid value */
1265                 int empty = 0;
1266                 int got_var = 0, got_value = 0, got_uservar = 0;
1267
1268                 /*
1269                  * The other side might have its VALUE and VAR values
1270                  * reversed.  To be interoperable, we need to determine
1271                  * which way it is.  If the first recognized character
1272                  * is a VAR or VALUE, then that will tell us what
1273                  * type of client it is.  If the fist recognized
1274                  * character is a USERVAR, then we continue scanning
1275                  * the suboption looking for two consecutive
1276                  * VAR or VALUE fields.  We should not get two
1277                  * consecutive VALUE fields, so finding two
1278                  * consecutive VALUE or VAR fields will tell us
1279                  * what the client is.
1280                  */
1281                 SB_SAVE();
1282                 while (!SB_EOF()) {
1283                         c = SB_GET();
1284                         switch(c) {
1285                         case OLD_ENV_VAR:
1286                                 if (last < 0 || last == OLD_ENV_VAR
1287                                     || (empty && (last == OLD_ENV_VALUE)))
1288                                         goto env_ovar_ok;
1289                                 got_var++;
1290                                 last = OLD_ENV_VAR;
1291                                 break;
1292                         case OLD_ENV_VALUE:
1293                                 if (last < 0 || last == OLD_ENV_VALUE
1294                                     || (empty && (last == OLD_ENV_VAR)))
1295                                         goto env_ovar_wrong;
1296                                 got_value++;
1297                                 last = OLD_ENV_VALUE;
1298                                 break;
1299                         case ENV_USERVAR:
1300                                 /* count strings of USERVAR as one */
1301                                 if (last != ENV_USERVAR)
1302                                         got_uservar++;
1303                                 if (empty) {
1304                                         if (last == OLD_ENV_VALUE)
1305                                                 goto env_ovar_ok;
1306                                         if (last == OLD_ENV_VAR)
1307                                                 goto env_ovar_wrong;
1308                                 }
1309                                 last = ENV_USERVAR;
1310                                 break;
1311                         case ENV_ESC:
1312                                 if (!SB_EOF())
1313                                         c = SB_GET();
1314                                 /* FALLTHROUGH */
1315                         default:
1316                                 empty = 0;
1317                                 continue;
1318                         }
1319                         empty = 1;
1320                 }
1321                 if (empty) {
1322                         if (last == OLD_ENV_VALUE)
1323                                 goto env_ovar_ok;
1324                         if (last == OLD_ENV_VAR)
1325                                 goto env_ovar_wrong;
1326                 }
1327                 /*
1328                  * Ok, the first thing was a USERVAR, and there
1329                  * are not two consecutive VAR or VALUE commands,
1330                  * and none of the VAR or VALUE commands are empty.
1331                  * If the client has sent us a well-formed option,
1332                  * then the number of VALUEs received should always
1333                  * be less than or equal to the number of VARs and
1334                  * USERVARs received.
1335                  *
1336                  * If we got exactly as many VALUEs as VARs and
1337                  * USERVARs, the client has the same definitions.
1338                  *
1339                  * If we got exactly as many VARs as VALUEs and
1340                  * USERVARS, the client has reversed definitions.
1341                  */
1342                 if (got_uservar + got_var == got_value) {
1343             env_ovar_ok:
1344                         env_ovar = OLD_ENV_VAR;
1345                         env_ovalue = OLD_ENV_VALUE;
1346                 } else if (got_uservar + got_value == got_var) {
1347             env_ovar_wrong:
1348                         env_ovar = OLD_ENV_VALUE;
1349                         env_ovalue = OLD_ENV_VAR;
1350                         DIAG(TD_OPTIONS,
1351                             output_data("ENVIRON VALUE and VAR are reversed!\r\n"));
1352
1353                 }
1354             }
1355             SB_RESTORE();
1356 #endif
1357
1358             while (!SB_EOF()) {
1359                 c = SB_GET();
1360                 if ((c == env_ovar) || (c == ENV_USERVAR))
1361                         break;
1362             }
1363         }
1364
1365         if (SB_EOF())
1366                 return;
1367
1368         cp = varp = (char *)subpointer;
1369         valp = 0;
1370
1371         while (!SB_EOF()) {
1372                 c = SB_GET();
1373                 if (subchar == TELOPT_OLD_ENVIRON) {
1374                         if (c == env_ovar)
1375                                 c = NEW_ENV_VAR;
1376                         else if (c == env_ovalue)
1377                                 c = NEW_ENV_VALUE;
1378                 }
1379                 switch (c) {
1380
1381                 case NEW_ENV_VALUE:
1382                         *cp = '\0';
1383                         cp = valp = (char *)subpointer;
1384                         break;
1385
1386                 case NEW_ENV_VAR:
1387                 case ENV_USERVAR:
1388                         *cp = '\0';
1389                         if (valp)
1390                                 (void)setenv(varp, valp, 1);
1391                         else
1392                                 unsetenv(varp);
1393                         cp = varp = (char *)subpointer;
1394                         valp = 0;
1395                         break;
1396
1397                 case ENV_ESC:
1398                         if (SB_EOF())
1399                                 break;
1400                         c = SB_GET();
1401                         /* FALLTHROUGH */
1402                 default:
1403                         *cp++ = c;
1404                         break;
1405                 }
1406         }
1407         *cp = '\0';
1408         if (valp)
1409                 (void)setenv(varp, valp, 1);
1410         else
1411                 unsetenv(varp);
1412         break;
1413     }  /* end of case TELOPT_NEW_ENVIRON */
1414 #ifdef  AUTHENTICATION
1415     case TELOPT_AUTHENTICATION:
1416         if (SB_EOF())
1417                 break;
1418         switch(SB_GET()) {
1419         case TELQUAL_SEND:
1420         case TELQUAL_REPLY:
1421                 /*
1422                  * These are sent by us and cannot be sent by
1423                  * the client.
1424                  */
1425                 break;
1426         case TELQUAL_IS:
1427                 auth_is(subpointer, SB_LEN());
1428                 break;
1429         case TELQUAL_NAME:
1430                 auth_name(subpointer, SB_LEN());
1431                 break;
1432         }
1433         break;
1434 #endif
1435 #ifdef  ENCRYPTION
1436     case TELOPT_ENCRYPT:
1437         if (SB_EOF())
1438                 break;
1439         switch(SB_GET()) {
1440         case ENCRYPT_SUPPORT:
1441                 encrypt_support(subpointer, SB_LEN());
1442                 break;
1443         case ENCRYPT_IS:
1444                 encrypt_is(subpointer, SB_LEN());
1445                 break;
1446         case ENCRYPT_REPLY:
1447                 encrypt_reply(subpointer, SB_LEN());
1448                 break;
1449         case ENCRYPT_START:
1450                 encrypt_start(subpointer, SB_LEN());
1451                 break;
1452         case ENCRYPT_END:
1453                 encrypt_end();
1454                 break;
1455         case ENCRYPT_REQSTART:
1456                 encrypt_request_start(subpointer, SB_LEN());
1457                 break;
1458         case ENCRYPT_REQEND:
1459                 /*
1460                  * We can always send an REQEND so that we cannot
1461                  * get stuck encrypting.  We should only get this
1462                  * if we have been able to get in the correct mode
1463                  * anyhow.
1464                  */
1465                 encrypt_request_end();
1466                 break;
1467         case ENCRYPT_ENC_KEYID:
1468                 encrypt_enc_keyid(subpointer, SB_LEN());
1469                 break;
1470         case ENCRYPT_DEC_KEYID:
1471                 encrypt_dec_keyid(subpointer, SB_LEN());
1472                 break;
1473         default:
1474                 break;
1475         }
1476         break;
1477 #endif  /* ENCRYPTION */
1478
1479     default:
1480         break;
1481     }  /* end of switch */
1482
1483 }  /* end of suboption */
1484
1485 static void
1486 doclientstat(void)
1487 {
1488         clientstat(TELOPT_LINEMODE, WILL, 0);
1489 }
1490
1491 #define ADD(c)   *ncp++ = c
1492 #define ADD_DATA(c) { *ncp++ = c; if (c == SE || c == IAC) *ncp++ = c; }
1493 void
1494 send_status(void)
1495 {
1496         unsigned char statusbuf[256];
1497         unsigned char *ncp;
1498         unsigned char i;
1499
1500         ncp = statusbuf;
1501
1502         netflush();     /* get rid of anything waiting to go out */
1503
1504         ADD(IAC);
1505         ADD(SB);
1506         ADD(TELOPT_STATUS);
1507         ADD(TELQUAL_IS);
1508
1509         /*
1510          * We check the want_state rather than the current state,
1511          * because if we received a DO/WILL for an option that we
1512          * don't support, and the other side didn't send a DONT/WONT
1513          * in response to our WONT/DONT, then the "state" will be
1514          * WILL/DO, and the "want_state" will be WONT/DONT.  We
1515          * need to go by the latter.
1516          */
1517         for (i = 0; i < (unsigned char)NTELOPTS; i++) {
1518                 if (my_want_state_is_will(i)) {
1519                         ADD(WILL);
1520                         ADD_DATA(i);
1521                         if (i == IAC)
1522                                 ADD(IAC);
1523                 }
1524                 if (his_want_state_is_will(i)) {
1525                         ADD(DO);
1526                         ADD_DATA(i);
1527                         if (i == IAC)
1528                                 ADD(IAC);
1529                 }
1530         }
1531
1532         if (his_want_state_is_will(TELOPT_LFLOW)) {
1533                 ADD(SB);
1534                 ADD(TELOPT_LFLOW);
1535                 if (flowmode) {
1536                         ADD(LFLOW_ON);
1537                 } else {
1538                         ADD(LFLOW_OFF);
1539                 }
1540                 ADD(SE);
1541
1542                 if (restartany >= 0) {
1543                         ADD(SB);
1544                         ADD(TELOPT_LFLOW);
1545                         if (restartany) {
1546                                 ADD(LFLOW_RESTART_ANY);
1547                         } else {
1548                                 ADD(LFLOW_RESTART_XON);
1549                         }
1550                         ADD(SE);
1551                 }
1552         }
1553
1554 #ifdef  LINEMODE
1555         if (his_want_state_is_will(TELOPT_LINEMODE)) {
1556                 unsigned char *cp, *cpe;
1557                 int len;
1558
1559                 ADD(SB);
1560                 ADD(TELOPT_LINEMODE);
1561                 ADD(LM_MODE);
1562                 ADD_DATA(editmode);
1563                 ADD(SE);
1564
1565                 ADD(SB);
1566                 ADD(TELOPT_LINEMODE);
1567                 ADD(LM_SLC);
1568                 start_slc(0);
1569                 send_slc();
1570                 len = end_slc(&cp);
1571                 for (cpe = cp + len; cp < cpe; cp++)
1572                         ADD_DATA(*cp);
1573                 ADD(SE);
1574         }
1575 #endif  /* LINEMODE */
1576
1577         ADD(IAC);
1578         ADD(SE);
1579
1580         output_datalen(statusbuf, ncp - statusbuf);
1581         netflush();     /* Send it on its way */
1582
1583         DIAG(TD_OPTIONS,
1584                 {printsub('>', statusbuf, ncp - statusbuf); netflush();});
1585 }
1586
1587 /*
1588  * This function appends data to nfrontp and advances nfrontp.
1589  * Returns the number of characters written altogether (the
1590  * buffer may have been flushed in the process).
1591  */
1592
1593 int
1594 output_data(const char *format, ...)
1595 {
1596         va_list args;
1597         int len;
1598         char *buf;
1599
1600         va_start(args, format);
1601         if ((len = vasprintf(&buf, format, args)) == -1)
1602                 return -1;
1603         output_datalen(buf, len);
1604         va_end(args);
1605         free(buf);
1606         return (len);
1607 }
1608
1609 void
1610 output_datalen(const char *buf, int len)
1611 {
1612         int remaining, copied;
1613
1614         remaining = BUFSIZ - (nfrontp - netobuf);
1615         while (len > 0) {
1616                 /* Free up enough space if the room is too low*/
1617                 if ((len > BUFSIZ ? BUFSIZ : len) > remaining) {
1618                         netflush();
1619                         remaining = BUFSIZ - (nfrontp - netobuf);
1620                 }
1621
1622                 /* Copy out as much as will fit */
1623                 copied = remaining > len ? len : remaining;
1624                 memmove(nfrontp, buf, copied);
1625                 nfrontp += copied;
1626                 len -= copied;
1627                 remaining -= copied;
1628                 buf += copied;
1629         }
1630         return;
1631 }