![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to termstat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd|
Return to termstat.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd |
1.1 root 1: /*
2: * Copyright (c) 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)termstat.c 5.6 (Berkeley) 6/28/90";
22: #endif /* not lint */
23:
24: #include "telnetd.h"
25:
26: /*
27: * local variables
28: */
29: #ifdef LINEMODE
30: static int _terminit = 0;
31: static int def_tspeed = -1, def_rspeed = -1;
32: #ifdef TIOCSWINSZ
33: static int def_row = 0, def_col = 0;
34: #endif
35: #endif LINEMODE
36:
37: #if defined(CRAY2) && defined(UNICOS5)
38: int newmap = 1; /* nonzero if \n maps to ^M^J */
39: #endif
40:
41: #ifdef LINEMODE
42: /*
43: * localstat
44: *
45: * This function handles all management of linemode.
46: *
47: * Linemode allows the client to do the local editing of data
48: * and send only complete lines to the server. Linemode state is
49: * based on the state of the pty driver. If the pty is set for
50: * external processing, then we can use linemode. Further, if we
51: * can use real linemode, then we can look at the edit control bits
52: * in the pty to determine what editing the client should do.
53: *
54: * Linemode support uses the following state flags to keep track of
55: * current and desired linemode state.
56: * alwayslinemode : true if -l was specified on the telnetd
57: * command line. It means to have linemode on as much as
58: * possible.
59: *
60: * lmodetype: signifies whether the client can
61: * handle real linemode, or if use of kludgeomatic linemode
62: * is preferred. It will be set to one of the following:
63: * REAL_LINEMODE : use linemode option
64: * KLUDGE_LINEMODE : use kludge linemode
65: * NO_LINEMODE : client is ignorant of linemode
66: *
67: * linemode, uselinemode : linemode is true if linemode
68: * is currently on, uselinemode is the state that we wish
69: * to be in. If another function wishes to turn linemode
70: * on or off, it sets or clears uselinemode.
71: *
72: * editmode, useeditmode : like linemode/uselinemode, but
73: * these contain the edit mode states (edit and trapsig).
74: *
75: * The state variables correspond to some of the state information
76: * in the pty.
77: * linemode:
78: * In real linemode, this corresponds to whether the pty
79: * expects external processing of incoming data.
80: * In kludge linemode, this more closely corresponds to the
81: * whether normal processing is on or not. (ICANON in
82: * system V, or COOKED mode in BSD.)
83: * If the -l option was specified (alwayslinemode), then
84: * an attempt is made to force external processing on at
85: * all times.
86: *
87: * The following heuristics are applied to determine linemode
88: * handling within the server.
89: * 1) Early on in starting up the server, an attempt is made
90: * to negotiate the linemode option. If this succeeds
91: * then lmodetype is set to REAL_LINEMODE and all linemode
92: * processing occurs in the context of the linemode option.
93: * 2) If the attempt to negotiate the linemode option failed,
94: * then we try to use kludge linemode. We test for this
95: * capability by sending "do Timing Mark". If a positive
96: * response comes back, then we assume that the client
97: * understands kludge linemode (ech!) and the
98: * lmodetype flag is set to KLUDGE_LINEMODE.
99: * 3) Otherwise, linemode is not supported at all and
100: * lmodetype remains set to NO_LINEMODE (which happens
101: * to be 0 for convenience).
102: * 4) At any time a command arrives that implies a higher
103: * state of linemode support in the client, we move to that
104: * linemode support.
105: *
106: * A short explanation of kludge linemode is in order here.
107: * 1) The heuristic to determine support for kludge linemode
108: * is to send a do timing mark. We assume that a client
109: * that supports timing marks also supports kludge linemode.
110: * A risky proposition at best.
111: * 2) Further negotiation of linemode is done by changing the
112: * the server's state regarding SGA. If server will SGA,
113: * then linemode is off, if server won't SGA, then linemode
114: * is on.
115: */
116: localstat()
117: {
118: void netflush();
119:
120: #if defined(CRAY2) && defined(UNICOS5)
121: /*
122: * Keep track of that ol' CR/NL mapping while we're in the
123: * neighborhood.
124: */
125: newmap = tty_isnewmap();
126: #endif defined(CRAY2) && defined(UNICOS5)
127:
128: /*
129: * Check for state of BINARY options.
130: */
131: if (tty_isbinaryin()) {
132: if (his_want_state_is_wont(TELOPT_BINARY))
133: send_do(TELOPT_BINARY, 1);
134: } else {
135: if (his_want_state_is_will(TELOPT_BINARY))
136: send_dont(TELOPT_BINARY, 1);
137: }
138:
139: if (tty_isbinaryout()) {
140: if (my_want_state_is_wont(TELOPT_BINARY))
141: send_will(TELOPT_BINARY, 1);
142: } else {
143: if (my_want_state_is_will(TELOPT_BINARY))
144: send_wont(TELOPT_BINARY, 1);
145: }
146:
147: /*
148: * Check for changes to flow control if client supports it.
149: */
150: if (his_state_is_will(TELOPT_LFLOW)) {
151: if (tty_flowmode() != flowmode) {
152: flowmode = tty_flowmode();
153: (void) sprintf(nfrontp, "%c%c%c%c%c%c", IAC, SB,
154: TELOPT_LFLOW, flowmode, IAC, SE);
155: nfrontp += 6;
156: }
157: }
158:
159: /*
160: * Check linemode on/off state
161: */
162: uselinemode = tty_linemode();
163:
164: /*
165: * If alwayslinemode is on, and pty is changing to turn it off, then
166: * force linemode back on.
167: */
168: if (alwayslinemode && linemode && !uselinemode) {
169: uselinemode = 1;
170: tty_setlinemode(uselinemode);
171: }
172:
173: /*
174: * Do echo mode handling as soon as we know what the
175: * linemode is going to be.
176: * If the pty has echo turned off, then tell the client that
177: * the server will echo. If echo is on, then the server
178: * will echo if in character mode, but in linemode the
179: * client should do local echoing. The state machine will
180: * not send anything if it is unnecessary, so don't worry
181: * about that here.
182: */
183: if (tty_isecho() && uselinemode)
184: send_wont(TELOPT_ECHO, 1);
185: else
186: send_will(TELOPT_ECHO, 1);
187:
188: /*
189: * If linemode is being turned off, send appropriate
190: * command and then we're all done.
191: */
192: if (!uselinemode && linemode) {
193: # ifdef KLUDGELINEMODE
194: if (lmodetype == REAL_LINEMODE)
195: # endif /* KLUDGELINEMODE */
196: send_dont(TELOPT_LINEMODE, 1);
197: # ifdef KLUDGELINEMODE
198: else if (lmodetype == KLUDGE_LINEMODE)
199: send_will(TELOPT_SGA, 1);
200: # endif /* KLUDGELINEMODE */
201: linemode = uselinemode;
202: goto done;
203: }
204:
205: # ifdef KLUDGELINEMODE
206: /*
207: * If using real linemode check edit modes for possible later use.
208: * If we are in kludge linemode, do the SGA negotiation.
209: */
210: if (lmodetype == REAL_LINEMODE) {
211: # endif /* KLUDGELINEMODE */
212: useeditmode = 0;
213: if (tty_isediting())
214: useeditmode |= MODE_EDIT;
215: if (tty_istrapsig())
216: useeditmode |= MODE_TRAPSIG;
217: if (tty_issofttab())
218: useeditmode |= MODE_SOFT_TAB;
219: if (tty_islitecho())
220: useeditmode |= MODE_LIT_ECHO;
221: # ifdef KLUDGELINEMODE
222: } else if (lmodetype == KLUDGE_LINEMODE) {
223: if (tty_isediting() && uselinemode)
224: send_wont(TELOPT_SGA, 1);
225: else
226: send_will(TELOPT_SGA, 1);
227: }
228: # endif /* KLUDGELINEMODE */
229:
230: /*
231: * Negotiate linemode on if pty state has changed to turn it on.
232: * Send appropriate command and send along edit mode, then all done.
233: */
234: if (uselinemode && !linemode) {
235: # ifdef KLUDGELINEMODE
236: if (lmodetype == KLUDGE_LINEMODE) {
237: send_wont(TELOPT_SGA, 1);
238: } else if (lmodetype == REAL_LINEMODE) {
239: # endif /* KLUDGELINEMODE */
240: send_do(TELOPT_LINEMODE, 1);
241: /* send along edit modes */
242: (void) sprintf(nfrontp, "%c%c%c%c%c%c%c", IAC, SB,
243: TELOPT_LINEMODE, LM_MODE, useeditmode,
244: IAC, SE);
245: nfrontp += 7;
246: editmode = useeditmode;
247: # ifdef KLUDGELINEMODE
248: }
249: # endif /* KLUDGELINEMODE */
250: linemode = uselinemode;
251: goto done;
252: }
253:
254: # ifdef KLUDGELINEMODE
255: /*
256: * None of what follows is of any value if not using
257: * real linemode.
258: */
259: if (lmodetype < REAL_LINEMODE)
260: goto done;
261: # endif /* KLUDGELINEMODE */
262:
263: if (linemode) {
264: /*
265: * If edit mode changed, send edit mode.
266: */
267: if (useeditmode != editmode) {
268: /*
269: * Send along appropriate edit mode mask.
270: */
271: (void) sprintf(nfrontp, "%c%c%c%c%c%c%c", IAC, SB,
272: TELOPT_LINEMODE, LM_MODE, useeditmode,
273: IAC, SE);
274: nfrontp += 7;
275: editmode = useeditmode;
276: }
277:
278:
279: /*
280: * Check for changes to special characters in use.
281: */
282: start_slc(0);
283: check_slc();
284: end_slc(0);
285: }
286:
287: done:
288: /*
289: * Some things should be deferred until after the pty state has
290: * been set by the local process. Do those things that have been
291: * deferred now. This only happens once.
292: */
293: if (_terminit == 0) {
294: _terminit = 1;
295: defer_terminit();
296: }
297:
298: netflush();
299: set_termbuf();
300: return;
301:
302: } /* end of localstat */
303: #endif /* LINEMODE */
304:
305:
306: /*
307: * clientstat
308: *
309: * Process linemode related requests from the client.
310: * Client can request a change to only one of linemode, editmode or slc's
311: * at a time, and if using kludge linemode, then only linemode may be
312: * affected.
313: */
314: clientstat(code, parm1, parm2)
315: register int code, parm1, parm2;
316: {
317: void netflush();
318:
319: /*
320: * Get a copy of terminal characteristics.
321: */
322: init_termbuf();
323:
324: /*
325: * Process request from client. code tells what it is.
326: */
327: switch (code) {
328: #ifdef LINEMODE
329: case TELOPT_LINEMODE:
330: /*
331: * Don't do anything unless client is asking us to change
332: * modes.
333: */
334: uselinemode = (parm1 == WILL);
335: if (uselinemode != linemode) {
336: # ifdef KLUDGELINEMODE
337: /*
338: * If using kludge linemode, make sure that
339: * we can do what the client asks.
340: * We can not turn off linemode if alwayslinemode
341: * and the ICANON bit is set.
342: */
343: if (lmodetype == KLUDGE_LINEMODE) {
344: if (alwayslinemode && tty_isediting()) {
345: uselinemode = 1;
346: }
347: }
348:
349: /*
350: * Quit now if we can't do it.
351: */
352: if (uselinemode == linemode)
353: return;
354:
355: /*
356: * If using real linemode and linemode is being
357: * turned on, send along the edit mode mask.
358: */
359: if (lmodetype == REAL_LINEMODE && uselinemode)
360: # else /* KLUDGELINEMODE */
361: if (uselinemode)
362: # endif /* KLUDGELINEMODE */
363: {
364: useeditmode = 0;
365: if (tty_isediting())
366: useeditmode |= MODE_EDIT;
367: if (tty_istrapsig)
368: useeditmode |= MODE_TRAPSIG;
369: if (tty_issofttab())
370: useeditmode |= MODE_SOFT_TAB;
371: if (tty_islitecho())
372: useeditmode |= MODE_LIT_ECHO;
373: (void) sprintf(nfrontp, "%c%c%c%c%c%c%c", IAC,
374: SB, TELOPT_LINEMODE, LM_MODE,
375: useeditmode, IAC, SE);
376: nfrontp += 7;
377: editmode = useeditmode;
378: }
379:
380:
381: tty_setlinemode(uselinemode);
382:
383: linemode = uselinemode;
384:
385: }
386: break;
387:
388: case LM_MODE:
389: {
390: register int ack, changed;
391:
392: /*
393: * Client has sent along a mode mask. If it agrees with
394: * what we are currently doing, ignore it; if not, it could
395: * be viewed as a request to change. Note that the server
396: * will change to the modes in an ack if it is different from
397: * what we currently have, but we will not ack the ack.
398: */
399: useeditmode &= MODE_MASK;
400: ack = (useeditmode & MODE_ACK);
401: useeditmode &= ~MODE_ACK;
402:
403: if (changed = (useeditmode ^ editmode)) {
404: if (changed & MODE_EDIT)
405: tty_setedit(useeditmode & MODE_EDIT);
406:
407: if (changed & MODE_TRAPSIG)
408: tty_setsig(useeditmode & MODE_TRAPSIG);
409:
410: if (changed & MODE_SOFT_TAB)
411: tty_setsofttab(useeditmode & MODE_SOFT_TAB);
412:
413: if (changed & MODE_LIT_ECHO)
414: tty_setlitecho(useeditmode & MODE_LIT_ECHO);
415:
416: set_termbuf();
417:
418: if (!ack) {
419: (void) sprintf(nfrontp, "%c%c%c%c%c%c%c", IAC,
420: SB, TELOPT_LINEMODE, LM_MODE,
421: useeditmode|MODE_ACK,
422: IAC, SE);
423: nfrontp += 7;
424: }
425:
426: editmode = useeditmode;
427: }
428:
429: break;
430:
431: } /* end of case LM_MODE */
432: #endif /* LINEMODE */
433:
434: case TELOPT_NAWS:
435: #ifdef TIOCSWINSZ
436: {
437: struct winsize ws;
438:
439: #ifdef LINEMODE
440: /*
441: * Defer changing window size until after terminal is
442: * initialized.
443: */
444: if (terminit() == 0) {
445: def_col = parm1;
446: def_row = parm2;
447: return;
448: }
449: #endif /* LINEMODE */
450:
451: /*
452: * Change window size as requested by client.
453: */
454:
455: ws.ws_col = parm1;
456: ws.ws_row = parm2;
457: (void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
458: }
459: #endif /* TIOCSWINSZ */
460:
461: break;
462:
463: case TELOPT_TSPEED:
464: {
465: #ifdef LINEMODE
466: /*
467: * Defer changing the terminal speed.
468: */
469: if (terminit() == 0) {
470: def_tspeed = parm1;
471: def_rspeed = parm2;
472: return;
473: }
474: #endif /* LINEMODE */
475: /*
476: * Change terminal speed as requested by client.
477: */
478: tty_tspeed(parm1);
479: tty_rspeed(parm2);
480: set_termbuf();
481:
482: break;
483:
484: } /* end of case TELOPT_TSPEED */
485:
486: default:
487: /* What? */
488: break;
489: } /* end of switch */
490:
491: #if defined(CRAY2) && defined(UNICOS5)
492: /*
493: * Just in case of the likely event that we changed the pty state.
494: */
495: rcv_ioctl();
496: #endif /* defined(CRAY2) && defined(UNICOS5) */
497:
498: netflush();
499:
500: } /* end of clientstat */
501:
502: #if defined(CRAY2) && defined(UNICOS5)
503: termstat()
504: {
505: needtermstat = 1;
506: }
507:
508: _termstat()
509: {
510: needtermstat = 0;
511: init_termbuf();
512: localstat();
513: rcv_ioctl();
514: }
515: #endif /* defined(CRAY2) && defined(UNICOS5) */
516:
517: #ifdef LINEMODE
518: /*
519: * defer_terminit
520: *
521: * Some things should not be done until after the login process has started
522: * and all the pty modes are set to what they are supposed to be. This
523: * function is called when the pty state has been processed for the first time.
524: * It calls other functions that do things that were deferred in each module.
525: */
526: defer_terminit()
527: {
528:
529: /*
530: * local stuff that got deferred.
531: */
532: if (def_tspeed != -1) {
533: clientstat(TELOPT_TSPEED, def_tspeed, def_rspeed);
534: def_tspeed = def_rspeed = 0;
535: }
536:
537: #ifdef TIOCSWINSZ
538: if (def_col || def_row) {
539: struct winsize ws;
540:
541: ws.ws_col = def_col;
542: ws.ws_row = def_row;
543: (void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
544: }
545: #endif
546:
547: /*
548: * The only other module that currently defers anything.
549: */
550: deferslc();
551:
552: } /* end of defer_terminit */
553:
554: /*
555: * terminit
556: *
557: * Returns true if the pty state has been processed yet.
558: */
559: int terminit()
560: {
561: return _terminit;
562:
563: } /* end of terminit */
564: #endif /* LINEMODE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.