crypto/telnet/telnetd/termstat.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  * @(#)termstat.c       8.2 (Berkeley) 5/30/95
  34  * $FreeBSD: src/crypto/telnet/telnetd/termstat.c,v 1.4.2.4 2002/04/13 10:59:09 markm Exp $
  35  * $DragonFly: src/crypto/telnet/telnetd/termstat.c,v 1.2 2003/06/17 04:24:37 dillon Exp $
  36  */
  37
  38 #include "telnetd.h"
  39
  40 #ifdef  ENCRYPTION
  41 #include <libtelnet/encrypt.h>
  42 #endif
  43
  44 /*
  45  * local variables
  46  */
  47 int def_tspeed = -1, def_rspeed = -1;
  48 #ifdef  TIOCSWINSZ
  49 int def_row = 0, def_col = 0;
  50 #endif
  51 #ifdef  LINEMODE
  52 static int _terminit = 0;
  53 #endif  /* LINEMODE */
  54
  55 #ifdef  LINEMODE
  56 /*
  57  * localstat
  58  *
  59  * This function handles all management of linemode.
  60  *
  61  * Linemode allows the client to do the local editing of data
  62  * and send only complete lines to the server.  Linemode state is
  63  * based on the state of the pty driver.  If the pty is set for
  64  * external processing, then we can use linemode.  Further, if we
  65  * can use real linemode, then we can look at the edit control bits
  66  * in the pty to determine what editing the client should do.
  67  *
  68  * Linemode support uses the following state flags to keep track of
  69  * current and desired linemode state.
  70  *      alwayslinemode : true if -l was specified on the telnetd
  71  *      command line.  It means to have linemode on as much as
  72  *      possible.
  73  *
  74  *      lmodetype: signifies whether the client can
  75  *      handle real linemode, or if use of kludgeomatic linemode
  76  *      is preferred.  It will be set to one of the following:
  77  *              REAL_LINEMODE : use linemode option
  78  *              NO_KLUDGE : don't initiate kludge linemode.
  79  *              KLUDGE_LINEMODE : use kludge linemode
  80  *              NO_LINEMODE : client is ignorant of linemode
  81  *
  82  *      linemode, uselinemode : linemode is true if linemode
  83  *      is currently on, uselinemode is the state that we wish
  84  *      to be in.  If another function wishes to turn linemode
  85  *      on or off, it sets or clears uselinemode.
  86  *
  87  *      editmode, useeditmode : like linemode/uselinemode, but
  88  *      these contain the edit mode states (edit and trapsig).
  89  *
  90  * The state variables correspond to some of the state information
  91  * in the pty.
  92  *      linemode:
  93  *              In real linemode, this corresponds to whether the pty
  94  *              expects external processing of incoming data.
  95  *              In kludge linemode, this more closely corresponds to the
  96  *              whether normal processing is on or not.  (ICANON in
  97  *              system V, or COOKED mode in BSD.)
  98  *              If the -l option was specified (alwayslinemode), then
  99  *              an attempt is made to force external processing on at
 100  *              all times.
 101  *
 102  * The following heuristics are applied to determine linemode
 103  * handling within the server.
 104  *      1) Early on in starting up the server, an attempt is made
 105  *         to negotiate the linemode option.  If this succeeds
 106  *         then lmodetype is set to REAL_LINEMODE and all linemode
 107  *         processing occurs in the context of the linemode option.
 108  *      2) If the attempt to negotiate the linemode option failed,
 109  *         and the "-k" (don't initiate kludge linemode) isn't set,
 110  *         then we try to use kludge linemode.  We test for this
 111  *         capability by sending "do Timing Mark".  If a positive
 112  *         response comes back, then we assume that the client
 113  *         understands kludge linemode (ech!) and the
 114  *         lmodetype flag is set to KLUDGE_LINEMODE.
 115  *      3) Otherwise, linemode is not supported at all and
 116  *         lmodetype remains set to NO_LINEMODE (which happens
 117  *         to be 0 for convenience).
 118  *      4) At any time a command arrives that implies a higher
 119  *         state of linemode support in the client, we move to that
 120  *         linemode support.
 121  *
 122  * A short explanation of kludge linemode is in order here.
 123  *      1) The heuristic to determine support for kludge linemode
 124  *         is to send a do timing mark.  We assume that a client
 125  *         that supports timing marks also supports kludge linemode.
 126  *         A risky proposition at best.
 127  *      2) Further negotiation of linemode is done by changing the
 128  *         the server's state regarding SGA.  If server will SGA,
 129  *         then linemode is off, if server won't SGA, then linemode
 130  *         is on.
 131  */
 132 void
 133 localstat(void)
 134 {
 135         int need_will_echo = 0;
 136
 137         /*
 138          * Check for changes to flow control if client supports it.
 139          */
 140         flowstat();
 141
 142         /*
 143          * Check linemode on/off state
 144          */
 145         uselinemode = tty_linemode();
 146
 147         /*
 148          * If alwayslinemode is on, and pty is changing to turn it off, then
 149          * force linemode back on.
 150          */
 151         if (alwayslinemode && linemode && !uselinemode) {
 152                 uselinemode = 1;
 153                 tty_setlinemode(uselinemode);
 154         }
 155
 156         if (uselinemode) {
 157                 /*
 158                  * Check for state of BINARY options.
 159                  *
 160                  * We only need to do the binary dance if we are actually going
 161                  * to use linemode.  As this confuses some telnet clients
 162                  * that don't support linemode, and doesn't gain us
 163                  * anything, we don't do it unless we're doing linemode.
 164                  * -Crh (henrich@msu.edu)
 165                  */
 166
 167                 if (tty_isbinaryin()) {
 168                         if (his_want_state_is_wont(TELOPT_BINARY))
 169                                 send_do(TELOPT_BINARY, 1);
 170                 } else {
 171                         if (his_want_state_is_will(TELOPT_BINARY))
 172                                 send_dont(TELOPT_BINARY, 1);
 173                 }
 174
 175                 if (tty_isbinaryout()) {
 176                         if (my_want_state_is_wont(TELOPT_BINARY))
 177                                 send_will(TELOPT_BINARY, 1);
 178                 } else {
 179                         if (my_want_state_is_will(TELOPT_BINARY))
 180                                 send_wont(TELOPT_BINARY, 1);
 181                 }
 182         }
 183
 184 #ifdef  ENCRYPTION
 185         /*
 186          * If the terminal is not echoing, but editing is enabled,
 187          * something like password input is going to happen, so
 188          * if we the other side is not currently sending encrypted
 189          * data, ask the other side to start encrypting.
 190          */
 191         if (his_state_is_will(TELOPT_ENCRYPT)) {
 192                 static int enc_passwd = 0;
 193                 if (uselinemode && !tty_isecho() && tty_isediting()
 194                     && (enc_passwd == 0) && !decrypt_input) {
 195                         encrypt_send_request_start();
 196                         enc_passwd = 1;
 197                 } else if (enc_passwd) {
 198                         encrypt_send_request_end();
 199                         enc_passwd = 0;
 200                 }
 201         }
 202 #endif  /* ENCRYPTION */
 203
 204         /*
 205          * Do echo mode handling as soon as we know what the
 206          * linemode is going to be.
 207          * If the pty has echo turned off, then tell the client that
 208          * the server will echo.  If echo is on, then the server
 209          * will echo if in character mode, but in linemode the
 210          * client should do local echoing.  The state machine will
 211          * not send anything if it is unnecessary, so don't worry
 212          * about that here.
 213          *
 214          * If we need to send the WILL ECHO (because echo is off),
 215          * then delay that until after we have changed the MODE.
 216          * This way, when the user is turning off both editing
 217          * and echo, the client will get editing turned off first.
 218          * This keeps the client from going into encryption mode
 219          * and then right back out if it is doing auto-encryption
 220          * when passwords are being typed.
 221          */
 222         if (uselinemode) {
 223                 if (tty_isecho())
 224                         send_wont(TELOPT_ECHO, 1);
 225                 else
 226                         need_will_echo = 1;
 227 #ifdef  KLUDGELINEMODE
 228                 if (lmodetype == KLUDGE_OK)
 229                         lmodetype = KLUDGE_LINEMODE;
 230 #endif
 231         }
 232
 233         /*
 234          * If linemode is being turned off, send appropriate
 235          * command and then we're all done.
 236          */
 237          if (!uselinemode && linemode) {
 238 # ifdef KLUDGELINEMODE
 239                 if (lmodetype == REAL_LINEMODE) {
 240 # endif /* KLUDGELINEMODE */
 241                         send_dont(TELOPT_LINEMODE, 1);
 242 # ifdef KLUDGELINEMODE
 243                 } else if (lmodetype == KLUDGE_LINEMODE)
 244                         send_will(TELOPT_SGA, 1);
 245 # endif /* KLUDGELINEMODE */
 246                 send_will(TELOPT_ECHO, 1);
 247                 linemode = uselinemode;
 248                 goto done;
 249         }
 250
 251 # ifdef KLUDGELINEMODE
 252         /*
 253          * If using real linemode check edit modes for possible later use.
 254          * If we are in kludge linemode, do the SGA negotiation.
 255          */
 256         if (lmodetype == REAL_LINEMODE) {
 257 # endif /* KLUDGELINEMODE */
 258                 useeditmode = 0;
 259                 if (tty_isediting())
 260                         useeditmode |= MODE_EDIT;
 261                 if (tty_istrapsig())
 262                         useeditmode |= MODE_TRAPSIG;
 263                 if (tty_issofttab())
 264                         useeditmode |= MODE_SOFT_TAB;
 265                 if (tty_islitecho())
 266                         useeditmode |= MODE_LIT_ECHO;
 267 # ifdef KLUDGELINEMODE
 268         } else if (lmodetype == KLUDGE_LINEMODE) {
 269                 if (tty_isediting() && uselinemode)
 270                         send_wont(TELOPT_SGA, 1);
 271                 else
 272                         send_will(TELOPT_SGA, 1);
 273         }
 274 # endif /* KLUDGELINEMODE */
 275
 276         /*
 277          * Negotiate linemode on if pty state has changed to turn it on.
 278          * Send appropriate command and send along edit mode, then all done.
 279          */
 280         if (uselinemode && !linemode) {
 281 # ifdef KLUDGELINEMODE
 282                 if (lmodetype == KLUDGE_LINEMODE) {
 283                         send_wont(TELOPT_SGA, 1);
 284                 } else if (lmodetype == REAL_LINEMODE) {
 285 # endif /* KLUDGELINEMODE */
 286                         send_do(TELOPT_LINEMODE, 1);
 287                         /* send along edit modes */
 288                         output_data("%c%c%c%c%c%c%c", IAC, SB,
 289                                 TELOPT_LINEMODE, LM_MODE, useeditmode,
 290                                 IAC, SE);
 291                         editmode = useeditmode;
 292 # ifdef KLUDGELINEMODE
 293                 }
 294 # endif /* KLUDGELINEMODE */
 295                 linemode = uselinemode;
 296                 goto done;
 297         }
 298
 299 # ifdef KLUDGELINEMODE
 300         /*
 301          * None of what follows is of any value if not using
 302          * real linemode.
 303          */
 304         if (lmodetype < REAL_LINEMODE)
 305                 goto done;
 306 # endif /* KLUDGELINEMODE */
 307
 308         if (linemode && his_state_is_will(TELOPT_LINEMODE)) {
 309                 /*
 310                  * If edit mode changed, send edit mode.
 311                  */
 312                  if (useeditmode != editmode) {
 313                         /*
 314                          * Send along appropriate edit mode mask.
 315                          */
 316                         output_data("%c%c%c%c%c%c%c", IAC, SB,
 317                                 TELOPT_LINEMODE, LM_MODE, useeditmode,
 318                                 IAC, SE);
 319                         editmode = useeditmode;
 320                 }
 321
 322
 323                 /*
 324                  * Check for changes to special characters in use.
 325                  */
 326                 start_slc(0);
 327                 check_slc();
 328                 (void) end_slc(0);
 329         }
 330
 331 done:
 332         if (need_will_echo)
 333                 send_will(TELOPT_ECHO, 1);
 334         /*
 335          * Some things should be deferred until after the pty state has
 336          * been set by the local process.  Do those things that have been
 337          * deferred now.  This only happens once.
 338          */
 339         if (_terminit == 0) {
 340                 _terminit = 1;
 341                 defer_terminit();
 342         }
 343
 344         netflush();
 345         set_termbuf();
 346         return;
 347
 348 }  /* end of localstat */
 349 #endif  /* LINEMODE */
 350
 351 /*
 352  * flowstat
 353  *
 354  * Check for changes to flow control
 355  */
 356 void
 357 flowstat(void)
 358 {
 359         if (his_state_is_will(TELOPT_LFLOW)) {
 360                 if (tty_flowmode() != flowmode) {
 361                         flowmode = tty_flowmode();
 362                         output_data("%c%c%c%c%c%c",
 363                                         IAC, SB, TELOPT_LFLOW,
 364                                         flowmode ? LFLOW_ON : LFLOW_OFF,
 365                                         IAC, SE);
 366                 }
 367                 if (tty_restartany() != restartany) {
 368                         restartany = tty_restartany();
 369                         output_data("%c%c%c%c%c%c",
 370                                         IAC, SB, TELOPT_LFLOW,
 371                                         restartany ? LFLOW_RESTART_ANY
 372                                                    : LFLOW_RESTART_XON,
 373                                         IAC, SE);
 374                 }
 375         }
 376 }
 377
 378 /*
 379  * clientstat
 380  *
 381  * Process linemode related requests from the client.
 382  * Client can request a change to only one of linemode, editmode or slc's
 383  * at a time, and if using kludge linemode, then only linemode may be
 384  * affected.
 385  */
 386 void
 387 clientstat(int code, int parm1, int parm2)
 388 {
 389
 390         /*
 391          * Get a copy of terminal characteristics.
 392          */
 393         init_termbuf();
 394
 395         /*
 396          * Process request from client. code tells what it is.
 397          */
 398         switch (code) {
 399 #ifdef  LINEMODE
 400         case TELOPT_LINEMODE:
 401                 /*
 402                  * Don't do anything unless client is asking us to change
 403                  * modes.
 404                  */
 405                 uselinemode = (parm1 == WILL);
 406                 if (uselinemode != linemode) {
 407 # ifdef KLUDGELINEMODE
 408                         /*
 409                          * If using kludge linemode, make sure that
 410                          * we can do what the client asks.
 411                          * We can not turn off linemode if alwayslinemode
 412                          * and the ICANON bit is set.
 413                          */
 414                         if (lmodetype == KLUDGE_LINEMODE) {
 415                                 if (alwayslinemode && tty_isediting()) {
 416                                         uselinemode = 1;
 417                                 }
 418                         }
 419
 420                         /*
 421                          * Quit now if we can't do it.
 422                          */
 423                         if (uselinemode == linemode)
 424                                 return;
 425
 426                         /*
 427                          * If using real linemode and linemode is being
 428                          * turned on, send along the edit mode mask.
 429                          */
 430                         if (lmodetype == REAL_LINEMODE && uselinemode)
 431 # else  /* KLUDGELINEMODE */
 432                         if (uselinemode)
 433 # endif /* KLUDGELINEMODE */
 434                         {
 435                                 useeditmode = 0;
 436                                 if (tty_isediting())
 437                                         useeditmode |= MODE_EDIT;
 438                                 if (tty_istrapsig)
 439                                         useeditmode |= MODE_TRAPSIG;
 440                                 if (tty_issofttab())
 441                                         useeditmode |= MODE_SOFT_TAB;
 442                                 if (tty_islitecho())
 443                                         useeditmode |= MODE_LIT_ECHO;
 444                                 output_data("%c%c%c%c%c%c%c", IAC,
 445                                         SB, TELOPT_LINEMODE, LM_MODE,
 446                                                         useeditmode, IAC, SE);
 447                                 editmode = useeditmode;
 448                         }
 449
 450
 451                         tty_setlinemode(uselinemode);
 452
 453                         linemode = uselinemode;
 454
 455                         if (!linemode)
 456                                 send_will(TELOPT_ECHO, 1);
 457                 }
 458                 break;
 459
 460         case LM_MODE:
 461             {
 462                 int ack, changed;
 463
 464                 /*
 465                  * Client has sent along a mode mask.  If it agrees with
 466                  * what we are currently doing, ignore it; if not, it could
 467                  * be viewed as a request to change.  Note that the server
 468                  * will change to the modes in an ack if it is different from
 469                  * what we currently have, but we will not ack the ack.
 470                  */
 471                  useeditmode &= MODE_MASK;
 472                  ack = (useeditmode & MODE_ACK);
 473                  useeditmode &= ~MODE_ACK;
 474
 475                  if ((changed = (useeditmode ^ editmode))) {
 476                         /*
 477                          * This check is for a timing problem.  If the
 478                          * state of the tty has changed (due to the user
 479                          * application) we need to process that info
 480                          * before we write in the state contained in the
 481                          * ack!!!  This gets out the new MODE request,
 482                          * and when the ack to that command comes back
 483                          * we'll set it and be in the right mode.
 484                          */
 485                         if (ack)
 486                                 localstat();
 487                         if (changed & MODE_EDIT)
 488                                 tty_setedit(useeditmode & MODE_EDIT);
 489
 490                         if (changed & MODE_TRAPSIG)
 491                                 tty_setsig(useeditmode & MODE_TRAPSIG);
 492
 493                         if (changed & MODE_SOFT_TAB)
 494                                 tty_setsofttab(useeditmode & MODE_SOFT_TAB);
 495
 496                         if (changed & MODE_LIT_ECHO)
 497                                 tty_setlitecho(useeditmode & MODE_LIT_ECHO);
 498
 499                         set_termbuf();
 500
 501                         if (!ack) {
 502                                 output_data("%c%c%c%c%c%c%c", IAC,
 503                                         SB, TELOPT_LINEMODE, LM_MODE,
 504                                         useeditmode|MODE_ACK,
 505                                         IAC, SE);
 506                         }
 507
 508                         editmode = useeditmode;
 509                 }
 510
 511                 break;
 512
 513             }  /* end of case LM_MODE */
 514 #endif  /* LINEMODE */
 515
 516         case TELOPT_NAWS:
 517 #ifdef  TIOCSWINSZ
 518             {
 519                 struct winsize ws;
 520
 521                 def_col = parm1;
 522                 def_row = parm2;
 523 #ifdef  LINEMODE
 524                 /*
 525                  * Defer changing window size until after terminal is
 526                  * initialized.
 527                  */
 528                 if (terminit() == 0)
 529                         return;
 530 #endif  /* LINEMODE */
 531
 532                 /*
 533                  * Change window size as requested by client.
 534                  */
 535
 536                 ws.ws_col = parm1;
 537                 ws.ws_row = parm2;
 538                 (void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
 539             }
 540 #endif  /* TIOCSWINSZ */
 541
 542                 break;
 543
 544         case TELOPT_TSPEED:
 545             {
 546                 def_tspeed = parm1;
 547                 def_rspeed = parm2;
 548 #ifdef  LINEMODE
 549                 /*
 550                  * Defer changing the terminal speed.
 551                  */
 552                 if (terminit() == 0)
 553                         return;
 554 #endif  /* LINEMODE */
 555                 /*
 556                  * Change terminal speed as requested by client.
 557                  * We set the receive speed first, so that if we can't
 558                  * store separate receive and transmit speeds, the transmit
 559                  * speed will take precedence.
 560                  */
 561                 tty_rspeed(parm2);
 562                 tty_tspeed(parm1);
 563                 set_termbuf();
 564
 565                 break;
 566
 567             }  /* end of case TELOPT_TSPEED */
 568
 569         default:
 570                 /* What? */
 571                 break;
 572         }  /* end of switch */
 573
 574         netflush();
 575
 576 }  /* end of clientstat */
 577
 578 #ifdef  LINEMODE
 579 /*
 580  * defer_terminit
 581  *
 582  * Some things should not be done until after the login process has started
 583  * and all the pty modes are set to what they are supposed to be.  This
 584  * function is called when the pty state has been processed for the first time.
 585  * It calls other functions that do things that were deferred in each module.
 586  */
 587 void
 588 defer_terminit(void)
 589 {
 590
 591         /*
 592          * local stuff that got deferred.
 593          */
 594         if (def_tspeed != -1) {
 595                 clientstat(TELOPT_TSPEED, def_tspeed, def_rspeed);
 596                 def_tspeed = def_rspeed = 0;
 597         }
 598
 599 #ifdef  TIOCSWINSZ
 600         if (def_col || def_row) {
 601                 struct winsize ws;
 602
 603                 memset((char *)&ws, 0, sizeof(ws));
 604                 ws.ws_col = def_col;
 605                 ws.ws_row = def_row;
 606                 (void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
 607         }
 608 #endif
 609
 610         /*
 611          * The only other module that currently defers anything.
 612          */
 613         deferslc();
 614
 615 }  /* end of defer_terminit */
 616
 617 /*
 618  * terminit
 619  *
 620  * Returns true if the pty state has been processed yet.
 621  */
 622 int
 623 terminit(void)
 624 {
 625         return(_terminit);
 626
 627 }  /* end of terminit */
 628 #endif  /* LINEMODE */