telnetd: Fix a bug (really use the return value of tty_istrapsig()).
[dragonfly.git] / 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  * @(#)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 */