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