Commit | Line | Data |
---|---|---|
984263bc MD |
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. | |
dc71b7ab | 13 | * 3. Neither the name of the University nor the names of its contributors |
984263bc MD |
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. | |
1de703da MD |
28 | * |
29 | * @(#)termstat.c 8.2 (Berkeley) 5/30/95 | |
068e7061 | 30 | * $FreeBSD: src/crypto/telnet/telnetd/termstat.c,v 1.4.2.4 2002/04/13 10:59:09 markm Exp $ |
984263bc MD |
31 | */ |
32 | ||
984263bc MD |
33 | #include "telnetd.h" |
34 | ||
068e7061 PA |
35 | #ifdef ENCRYPTION |
36 | #include <libtelnet/encrypt.h> | |
37 | #endif | |
984263bc MD |
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 | |
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 | ||
068e7061 PA |
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 */ | |
984263bc MD |
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 | |
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 | |
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; | |
6d16a2c0 | 433 | if (tty_istrapsig()) |
984263bc MD |
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 | |
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 | |
618 | terminit(void) | |
619 | { | |
620 | return(_terminit); | |
621 | ||
622 | } /* end of terminit */ | |
623 | #endif /* LINEMODE */ |