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