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