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 */ 629