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