1 /* $NetBSD: tty.c,v 1.51 2024/12/23 02:58:04 blymn Exp $ */
2
3 /*-
4 * Copyright (c) 1992, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)tty.c 8.6 (Berkeley) 1/10/95";
36 #else
37 __RCSID("$NetBSD: tty.c,v 1.51 2024/12/23 02:58:04 blymn Exp $");
38 #endif
39 #endif /* not lint */
40
41 #include <sys/fcntl.h>
42 #include <sys/ioctl.h>
43 #include <sys/param.h>
44 #include <sys/types.h>
45
46 #include <stdlib.h>
47 #include <termios.h>
48 #include <unistd.h>
49
50 #include "curses.h"
51 #include "curses_private.h"
52
53 /*
54 * In general, curses should leave tty hardware settings alone (speed, parity,
55 * word size). This is most easily done in BSD by using TCSASOFT on all
56 * tcsetattr calls. On other systems, it would be better to get and restore
57 * those attributes at each change, or at least when stopped and restarted.
58 * See also the comments in getterm().
59 */
60 #ifndef TCSASOFT
61 #define TCSASOFT 0
62 #endif
63
64 int __tcaction = TCSASOFT != 0; /* Ignore hardware settings */
65
66 #ifndef OXTABS
67 #ifdef XTABS /* SMI uses XTABS. */
68 #define OXTABS XTABS
69 #else
70 #define OXTABS 0
71 #endif
72 #endif
73
74 /*
75 * baudrate --
76 * Return the current baudrate
77 */
78 int
baudrate(void)79 baudrate(void)
80 {
81
82 if (_cursesi_screen->notty == TRUE)
83 return 0;
84
85 return cfgetospeed(&_cursesi_screen->baset);
86 }
87
88 /*
89 * gettmode --
90 * Do terminal type initialization.
91 */
92 int
gettmode(void)93 gettmode(void)
94 {
95
96 if (_cursesi_gettmode(_cursesi_screen) == ERR)
97 return ERR;
98
99 __GT = _cursesi_screen->GT;
100 __NONL = _cursesi_screen->NONL;
101 return OK;
102 }
103
104 /*
105 * _cursesi_gettmode --
106 * Do the terminal type initialisation for the tty attached to the
107 * given screen.
108 */
109 int
_cursesi_gettmode(SCREEN * screen)110 _cursesi_gettmode(SCREEN *screen)
111 {
112 screen->useraw = 0;
113
114 if (tcgetattr(fileno(screen->infd), &screen->orig_termios)) {
115 /* if the input fd is not a tty try the output */
116 if (tcgetattr(fileno(screen->outfd), &screen->orig_termios)) {
117 /* not a tty ... we will disable tty related stuff */
118 screen->notty = TRUE;
119 __GT = 0;
120 __NONL = 0;
121 return OK;
122 }
123 }
124
125 screen->baset = screen->orig_termios;
126 screen->baset.c_oflag &= ~OXTABS;
127
128 screen->GT = 0; /* historical. was used before we wired OXTABS off */
129 screen->NONL = (screen->baset.c_oflag & ONLCR) == 0;
130
131 /*
132 * XXX
133 * System V and SMI systems overload VMIN and VTIME, such that
134 * VMIN is the same as the VEOF element, and VTIME is the same
135 * as the VEOL element. This means that, if VEOF was ^D, the
136 * default VMIN is 4. Majorly stupid.
137 */
138 screen->cbreakt = screen->baset;
139 screen->cbreakt.c_lflag &= ~(ECHO | ECHONL | ICANON);
140 screen->cbreakt.c_cc[VMIN] = 1;
141 screen->cbreakt.c_cc[VTIME] = 0;
142
143 screen->rawt = screen->cbreakt;
144 screen->rawt.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | INLCR | IGNCR |
145 ICRNL | IXON);
146 screen->rawt.c_oflag &= ~OPOST;
147 screen->rawt.c_lflag &= ~(ISIG | IEXTEN);
148
149 #if TCSASOFT == 0
150 /*
151 * In general, curses should leave hardware-related settings alone.
152 * This includes parity and word size. Older versions set the tty
153 * to 8 bits, no parity in raw(), but this is considered to be an
154 * artifact of the old tty interface. If it's desired to change
155 * parity and word size, the TCSASOFT bit has to be removed from the
156 * calls that switch to/from "raw" mode.
157 */
158 screen->rawt.c_iflag &= ~ISTRIP;
159 screen->rawt.c_cflag &= ~(CSIZE | PARENB);
160 screen->rawt.c_cflag |= CS8;
161 #endif
162
163 screen->curt = &screen->baset;
164 return tcsetattr(fileno(screen->infd), TCSASOFT | TCSADRAIN,
165 screen->curt) ? ERR : OK;
166 }
167
168 /*
169 * raw --
170 * Put the terminal into raw mode
171 */
172 int
raw(void)173 raw(void)
174 {
175 __CTRACE(__CTRACE_MISC, "raw()\n");
176 /* Check if we need to restart ... */
177 if (_cursesi_screen->endwin)
178 __restartwin();
179
180 _cursesi_screen->useraw = __pfast = __rawmode = 1;
181 _cursesi_screen->curt = &_cursesi_screen->rawt;
182 if (_cursesi_screen->notty == TRUE)
183 return OK;
184 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
185 _cursesi_screen->curt) ? ERR : OK;
186 }
187
188 /*
189 * noraw --
190 * Put the terminal into cooked mode
191 */
192 int
noraw(void)193 noraw(void)
194 {
195 __CTRACE(__CTRACE_MISC, "noraw()\n");
196 /* Check if we need to restart ... */
197 if (_cursesi_screen->endwin)
198 __restartwin();
199
200 _cursesi_screen->useraw = __pfast = __rawmode = 0;
201 if (_cursesi_screen->notty == TRUE)
202 return OK;
203 _cursesi_screen->curt = &_cursesi_screen->baset;
204 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
205 _cursesi_screen->curt) ? ERR : OK;
206 }
207
208 /*
209 * cbreak --
210 * Enable cbreak mode
211 */
212 int
cbreak(void)213 cbreak(void)
214 {
215 __CTRACE(__CTRACE_MISC, "cbreak()\n");
216 /* Check if we need to restart ... */
217 if (_cursesi_screen->endwin)
218 __restartwin();
219
220 __rawmode = 1;
221 if (_cursesi_screen->notty == TRUE)
222 return OK;
223 _cursesi_screen->curt = _cursesi_screen->useraw ?
224 &_cursesi_screen->rawt : &_cursesi_screen->cbreakt;
225 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
226 _cursesi_screen->curt) ? ERR : OK;
227 }
228
229 /*
230 * nocbreak --
231 * Disable cbreak mode
232 */
233 int
nocbreak(void)234 nocbreak(void)
235 {
236 __CTRACE(__CTRACE_MISC, "nocbreak()\n");
237 /* Check if we need to restart ... */
238 if (_cursesi_screen->endwin)
239 __restartwin();
240
241 __rawmode = 0;
242 if (_cursesi_screen->notty == TRUE)
243 return OK;
244 /* if we were in halfdelay mode then nuke the timeout */
245 if ((stdscr->flags & __HALFDELAY) &&
246 (__notimeout() == ERR))
247 return ERR;
248
249 stdscr->flags &= ~__HALFDELAY;
250 _cursesi_screen->curt = _cursesi_screen->useraw ?
251 &_cursesi_screen->rawt : &_cursesi_screen->baset;
252 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
253 _cursesi_screen->curt) ? ERR : OK;
254 }
255
256 /*
257 * halfdelay --
258 * Put the terminal into cbreak mode with the specified timeout.
259 *
260 */
261 int
halfdelay(int duration)262 halfdelay(int duration)
263 {
264 if ((duration < 1) || (duration > 255))
265 return ERR;
266
267 if (cbreak() == ERR)
268 return ERR;
269
270 if (duration > 255)
271 stdscr->delay = 255;
272 else
273 stdscr->delay = duration;
274
275 stdscr->flags |= __HALFDELAY;
276 return OK;
277 }
278
279 int
__delay(void)280 __delay(void)
281 {
282 __CTRACE(__CTRACE_MISC, "__delay()\n");
283 /* Check if we need to restart ... */
284 if (_cursesi_screen->endwin)
285 __restartwin();
286
287 if (_cursesi_screen->notty == TRUE)
288 return OK;
289 _cursesi_screen->rawt.c_cc[VMIN] = 1;
290 _cursesi_screen->rawt.c_cc[VTIME] = 0;
291 _cursesi_screen->cbreakt.c_cc[VMIN] = 1;
292 _cursesi_screen->cbreakt.c_cc[VTIME] = 0;
293 _cursesi_screen->baset.c_cc[VMIN] = 1;
294 _cursesi_screen->baset.c_cc[VTIME] = 0;
295
296 if (tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSANOW,
297 _cursesi_screen->curt)) {
298 __restore_termios();
299 return ERR;
300 }
301
302 return OK;
303 }
304
305 int
__nodelay(void)306 __nodelay(void)
307 {
308 __CTRACE(__CTRACE_MISC, "__nodelay()\n");
309 /* Check if we need to restart ... */
310 if (_cursesi_screen->endwin)
311 __restartwin();
312
313 if (_cursesi_screen->notty == TRUE)
314 return OK;
315 _cursesi_screen->rawt.c_cc[VMIN] = 0;
316 _cursesi_screen->rawt.c_cc[VTIME] = 0;
317 _cursesi_screen->cbreakt.c_cc[VMIN] = 0;
318 _cursesi_screen->cbreakt.c_cc[VTIME] = 0;
319 _cursesi_screen->baset.c_cc[VMIN] = 0;
320 _cursesi_screen->baset.c_cc[VTIME] = 0;
321
322 if (tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSANOW,
323 _cursesi_screen->curt)) {
324 __restore_termios();
325 return ERR;
326 }
327
328 return OK;
329 }
330
331 void
__save_termios(void)332 __save_termios(void)
333 {
334 /* Check if we need to restart ... */
335 if (_cursesi_screen->endwin)
336 __restartwin();
337
338 if (_cursesi_screen->notty == TRUE)
339 return;
340 _cursesi_screen->ovmin = _cursesi_screen->cbreakt.c_cc[VMIN];
341 _cursesi_screen->ovtime = _cursesi_screen->cbreakt.c_cc[VTIME];
342 }
343
344 void
__restore_termios(void)345 __restore_termios(void)
346 {
347 /* Check if we need to restart ... */
348 if (_cursesi_screen->endwin)
349 __restartwin();
350
351 if (_cursesi_screen->notty == TRUE)
352 return;
353 _cursesi_screen->rawt.c_cc[VMIN] = _cursesi_screen->ovmin;
354 _cursesi_screen->rawt.c_cc[VTIME] = _cursesi_screen->ovtime;
355 _cursesi_screen->cbreakt.c_cc[VMIN] = _cursesi_screen->ovmin;
356 _cursesi_screen->cbreakt.c_cc[VTIME] = _cursesi_screen->ovtime;
357 _cursesi_screen->baset.c_cc[VMIN] = _cursesi_screen->ovmin;
358 _cursesi_screen->baset.c_cc[VTIME] = _cursesi_screen->ovtime;
359 }
360
361 int
__timeout(int delay)362 __timeout(int delay)
363 {
364 __CTRACE(__CTRACE_MISC, "__timeout()\n");
365 /* Check if we need to restart ... */
366 if (_cursesi_screen->endwin)
367 __restartwin();
368
369 if (_cursesi_screen->notty == TRUE)
370 return OK;
371 _cursesi_screen->ovmin = _cursesi_screen->cbreakt.c_cc[VMIN];
372 _cursesi_screen->ovtime = _cursesi_screen->cbreakt.c_cc[VTIME];
373 _cursesi_screen->rawt.c_cc[VMIN] = 0;
374 _cursesi_screen->rawt.c_cc[VTIME] = delay;
375 _cursesi_screen->cbreakt.c_cc[VMIN] = 0;
376 _cursesi_screen->cbreakt.c_cc[VTIME] = delay;
377 _cursesi_screen->baset.c_cc[VMIN] = 0;
378 _cursesi_screen->baset.c_cc[VTIME] = delay;
379
380 if (tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSANOW,
381 _cursesi_screen->curt)) {
382 __restore_termios();
383 return ERR;
384 }
385
386 return OK;
387 }
388
389 int
__notimeout(void)390 __notimeout(void)
391 {
392 __CTRACE(__CTRACE_MISC, "__notimeout()\n");
393 /* Check if we need to restart ... */
394 if (_cursesi_screen->endwin)
395 __restartwin();
396
397 if (_cursesi_screen->notty == TRUE)
398 return OK;
399 _cursesi_screen->rawt.c_cc[VMIN] = 1;
400 _cursesi_screen->rawt.c_cc[VTIME] = 0;
401 _cursesi_screen->cbreakt.c_cc[VMIN] = 1;
402 _cursesi_screen->cbreakt.c_cc[VTIME] = 0;
403 _cursesi_screen->baset.c_cc[VMIN] = 1;
404 _cursesi_screen->baset.c_cc[VTIME] = 0;
405
406 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSANOW,
407 _cursesi_screen->curt) ? ERR : OK;
408 }
409
410 int
echo(void)411 echo(void)
412 {
413 __CTRACE(__CTRACE_MISC, "echo()\n");
414 /* Check if we need to restart ... */
415 if (_cursesi_screen->endwin)
416 __restartwin();
417
418 __echoit = 1;
419 return OK;
420 }
421
422 int
noecho(void)423 noecho(void)
424 {
425 __CTRACE(__CTRACE_MISC, "noecho()\n");
426 /* Check if we need to restart ... */
427 if (_cursesi_screen->endwin)
428 __restartwin();
429
430 __echoit = 0;
431 return OK;
432 }
433
434 int
nl(void)435 nl(void)
436 {
437 __CTRACE(__CTRACE_MISC, "nl()\n");
438 /* Check if we need to restart ... */
439 if (_cursesi_screen->endwin)
440 __restartwin();
441
442 if (_cursesi_screen->notty == TRUE)
443 return OK;
444 _cursesi_screen->rawt.c_iflag |= ICRNL;
445 _cursesi_screen->rawt.c_oflag |= ONLCR;
446 _cursesi_screen->cbreakt.c_iflag |= ICRNL;
447 _cursesi_screen->cbreakt.c_oflag |= ONLCR;
448 _cursesi_screen->baset.c_iflag |= ICRNL;
449 _cursesi_screen->baset.c_oflag |= ONLCR;
450
451 _cursesi_screen->nl = 1;
452 _cursesi_screen->pfast = _cursesi_screen->rawmode;
453 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
454 _cursesi_screen->curt) ? ERR : OK;
455 }
456
457 int
nonl(void)458 nonl(void)
459 {
460 __CTRACE(__CTRACE_MISC, "nonl()\n");
461 /* Check if we need to restart ... */
462 if (_cursesi_screen->endwin)
463 __restartwin();
464
465 if (_cursesi_screen->notty == TRUE)
466 return OK;
467 _cursesi_screen->rawt.c_iflag &= ~ICRNL;
468 _cursesi_screen->rawt.c_oflag &= ~ONLCR;
469 _cursesi_screen->cbreakt.c_iflag &= ~ICRNL;
470 _cursesi_screen->cbreakt.c_oflag &= ~ONLCR;
471 _cursesi_screen->baset.c_iflag &= ~ICRNL;
472 _cursesi_screen->baset.c_oflag &= ~ONLCR;
473
474 _cursesi_screen->nl = 0;
475 __pfast = 1;
476 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
477 _cursesi_screen->curt) ? ERR : OK;
478 }
479
480 #ifndef _CURSES_USE_MACROS
481 void
noqiflush(void)482 noqiflush(void)
483 {
484
485 (void)intrflush(stdscr, FALSE);
486 }
487
488 void
qiflush(void)489 qiflush(void)
490 {
491
492 (void)intrflush(stdscr, TRUE);
493 }
494 #endif /* _CURSES_USE_MACROS */
495
496 /*ARGSUSED*/
497 int
intrflush(WINDOW * win,bool bf)498 intrflush(WINDOW *win, bool bf)
499 {
500 if (__predict_false(win == NULL))
501 return ERR;
502
503 /* Check if we need to restart ... */
504 if (_cursesi_screen->endwin)
505 __restartwin();
506
507 if (_cursesi_screen->notty == TRUE)
508 return OK;
509 if (bf) {
510 _cursesi_screen->rawt.c_lflag &= ~NOFLSH;
511 _cursesi_screen->cbreakt.c_lflag &= ~NOFLSH;
512 _cursesi_screen->baset.c_lflag &= ~NOFLSH;
513 } else {
514 _cursesi_screen->rawt.c_lflag |= NOFLSH;
515 _cursesi_screen->cbreakt.c_lflag |= NOFLSH;
516 _cursesi_screen->baset.c_lflag |= NOFLSH;
517 }
518
519 __pfast = 1;
520 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
521 _cursesi_screen->curt) ? ERR : OK;
522 }
523
524 void
__startwin(SCREEN * screen)525 __startwin(SCREEN *screen)
526 {
527
528 (void)fflush(screen->infd);
529
530 #ifdef BSD
531 /*
532 * Some C libraries default to a 1K buffer when talking to a tty.
533 * With a larger screen, especially across a network, we'd like
534 * to get it to all flush in a single write. Make it twice as big
535 * as just the characters (so that we have room for cursor motions
536 * and attribute information) but no more than 8K.
537 *
538 * However, setvbuf may only be used after opening a stream and
539 * before any operations have been performed on it.
540 * This means we cannot work portably if an application wants
541 * to stop curses and start curses after a resize.
542 * Curses resizing is not standard, and thus not strictly portable
543 * even though all curses today support it.
544 * The BSD systems do not suffer from this limitation on setvbuf.
545 */
546 if (screen->stdbuf == NULL) {
547 screen->len = LINES * COLS * 2;
548 if (screen->len > 8192)
549 screen->len = 8192;
550 if ((screen->stdbuf = malloc(screen->len)) == NULL)
551 screen->len = 0;
552 }
553 (void)setvbuf(screen->outfd, screen->stdbuf, _IOFBF, screen->len);
554 #endif
555
556 ti_puts(screen->term, t_enter_ca_mode(screen->term), 0,
557 __cputchar_args, (void *) screen->outfd);
558 ti_puts(screen->term, t_cursor_normal(screen->term), 0,
559 __cputchar_args, (void *) screen->outfd);
560 if (screen->curscr->flags & __KEYPAD)
561 ti_puts(screen->term, t_keypad_xmit(screen->term), 0,
562 __cputchar_args, (void *) screen->outfd);
563 screen->endwin = 0;
564 }
565
566 int
endwin(void)567 endwin(void)
568 {
569 __CTRACE(__CTRACE_MISC, "endwin\n");
570 return __stopwin();
571 }
572
573 bool
isendwin(void)574 isendwin(void)
575 {
576
577 return _cursesi_screen->endwin ? TRUE : FALSE;
578 }
579
580 int
flushinp(void)581 flushinp(void)
582 {
583
584 (void)fpurge(_cursesi_screen->infd);
585 return OK;
586 }
587
588 /*
589 * The following routines, savetty and resetty are completely useless and
590 * are left in only as stubs. If people actually use them they will almost
591 * certainly screw up the state of the world.
592 */
593 /*static struct termios savedtty;*/
594 int
savetty(void)595 savetty(void)
596 {
597
598 if (_cursesi_screen->notty == TRUE)
599 return OK;
600 return tcgetattr(fileno(_cursesi_screen->infd),
601 &_cursesi_screen->savedtty) ? ERR : OK;
602 }
603
604 int
resetty(void)605 resetty(void)
606 {
607
608 if (_cursesi_screen->notty == TRUE)
609 return OK;
610 return tcsetattr(fileno(_cursesi_screen->infd), TCSASOFT | TCSADRAIN,
611 &_cursesi_screen->savedtty) ? ERR : OK;
612 }
613
614 /*
615 * erasechar --
616 * Return the character of the erase key.
617 */
618 char
erasechar(void)619 erasechar(void)
620 {
621
622 if (_cursesi_screen->notty == TRUE)
623 return 0;
624 return _cursesi_screen->baset.c_cc[VERASE];
625 }
626
627 /*
628 * killchar --
629 * Return the character of the kill key.
630 */
631 char
killchar(void)632 killchar(void)
633 {
634
635 if (_cursesi_screen->notty == TRUE)
636 return 0;
637 return _cursesi_screen->baset.c_cc[VKILL];
638 }
639
640 /*
641 * erasewchar --
642 * Return the wide character of the erase key.
643 */
644 int
erasewchar(wchar_t * ch)645 erasewchar(wchar_t *ch)
646 {
647
648 #ifndef HAVE_WCHAR
649 return ERR;
650 #else
651 if (_cursesi_screen->notty == TRUE)
652 return ERR;
653 *ch = _cursesi_screen->baset.c_cc[VERASE];
654 return OK;
655 #endif /* HAVE_WCHAR */
656 }
657
658 /*
659 * killwchar --
660 * Return the wide character of the kill key.
661 */
662 int
killwchar(wchar_t * ch)663 killwchar( wchar_t *ch )
664 {
665
666 #ifndef HAVE_WCHAR
667 return ERR;
668 #else
669 if (_cursesi_screen->notty == TRUE)
670 return 0;
671 *ch = _cursesi_screen->baset.c_cc[VKILL];
672 return OK;
673 #endif /* HAVE_WCHAR */
674 }
675
676 int
typeahead(int filedes)677 typeahead(int filedes)
678 {
679
680 _cursesi_screen->checkfd = filedes;
681 return OK;
682 }
683