1 /* input.c -- character input functions for readline. */
2
3 /* Copyright (C) 1994-2017 Free Software Foundation, Inc.
4
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
7
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #define READLINE_LIBRARY
23
24 #if defined (__TANDEM)
25 # define _XOPEN_SOURCE_EXTENDED 1
26 # define _TANDEM_SOURCE 1
27 # include <floss.h>
28 #endif
29
30 #if defined (HAVE_CONFIG_H)
31 # include <config.h>
32 #endif
33
34 #include <sys/types.h>
35 #include <fcntl.h>
36 #if defined (HAVE_SYS_FILE_H)
37 # include <sys/file.h>
38 #endif /* HAVE_SYS_FILE_H */
39
40 #if defined (HAVE_UNISTD_H)
41 # include <unistd.h>
42 #endif /* HAVE_UNISTD_H */
43
44 #if defined (HAVE_STDLIB_H)
45 # include <stdlib.h>
46 #else
47 # include "ansi_stdlib.h"
48 #endif /* HAVE_STDLIB_H */
49
50 #include <signal.h>
51
52 #include "posixselect.h"
53
54 #if defined (FIONREAD_IN_SYS_IOCTL)
55 # include <sys/ioctl.h>
56 #endif
57
58 #include <stdio.h>
59 #include <errno.h>
60
61 #if !defined (errno)
62 extern int errno;
63 #endif /* !errno */
64
65 /* System-specific feature definitions and include files. */
66 #include "rldefs.h"
67 #include "rlmbutil.h"
68
69 /* Some standard library routines. */
70 #include "readline.h"
71
72 #include "rlprivate.h"
73 #include "rlshell.h"
74 #include "xmalloc.h"
75
76 /* What kind of non-blocking I/O do we have? */
77 #if !defined (O_NDELAY) && defined (O_NONBLOCK)
78 # define O_NDELAY O_NONBLOCK /* Posix style */
79 #endif
80
81 #if defined (HAVE_PSELECT)
82 extern sigset_t _rl_orig_sigset;
83 #endif
84
85 /* Non-null means it is a pointer to a function to run while waiting for
86 character input. */
87 rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
88
89 /* A function to call if a read(2) is interrupted by a signal. */
90 rl_hook_func_t *rl_signal_event_hook = (rl_hook_func_t *)NULL;
91
92 /* A function to replace _rl_input_available for applications using the
93 callback interface. */
94 rl_hook_func_t *rl_input_available_hook = (rl_hook_func_t *)NULL;
95
96 rl_getc_func_t *rl_getc_function = rl_getc;
97
98 static int _keyboard_input_timeout = 100000; /* 0.1 seconds; it's in usec */
99
100 static int ibuffer_space PARAMS((void));
101 static int rl_get_char PARAMS((int *));
102 static int rl_gather_tyi PARAMS((void));
103
104 /* Windows isatty returns true for every character device, including the null
105 device, so we need to perform additional checks. */
106 #if defined (_WIN32) && !defined (__CYGWIN__)
107 #include <io.h>
108 #include <conio.h>
109 #define WIN32_LEAN_AND_MEAN 1
110 #include <windows.h>
111
112 int
win32_isatty(int fd)113 win32_isatty (int fd)
114 {
115 if (_isatty(fd))
116 {
117 HANDLE h;
118 DWORD ignored;
119
120 if ((h = (HANDLE) _get_osfhandle (fd)) == INVALID_HANDLE_VALUE)
121 {
122 errno = EBADF;
123 return 0;
124 }
125 if (GetConsoleMode (h, &ignored) != 0)
126 return 1;
127 }
128 errno = ENOTTY;
129 return 0;
130 }
131
132 #define isatty(x) win32_isatty(x)
133 #endif
134
135 /* **************************************************************** */
136 /* */
137 /* Character Input Buffering */
138 /* */
139 /* **************************************************************** */
140
141 static int pop_index, push_index;
142 static unsigned char ibuffer[512];
143 static int ibuffer_len = sizeof (ibuffer) - 1;
144
145 #define any_typein (push_index != pop_index)
146
147 int
_rl_any_typein(void)148 _rl_any_typein (void)
149 {
150 return any_typein;
151 }
152
153 int
_rl_pushed_input_available(void)154 _rl_pushed_input_available (void)
155 {
156 return (push_index != pop_index);
157 }
158
159 /* Return the amount of space available in the buffer for stuffing
160 characters. */
161 static int
ibuffer_space(void)162 ibuffer_space (void)
163 {
164 if (pop_index > push_index)
165 return (pop_index - push_index - 1);
166 else
167 return (ibuffer_len - (push_index - pop_index));
168 }
169
170 /* Get a key from the buffer of characters to be read.
171 Return the key in KEY.
172 Result is non-zero if there was a key, or 0 if there wasn't. */
173 static int
rl_get_char(int * key)174 rl_get_char (int *key)
175 {
176 if (push_index == pop_index)
177 return (0);
178
179 *key = ibuffer[pop_index++];
180 #if 0
181 if (pop_index >= ibuffer_len)
182 #else
183 if (pop_index > ibuffer_len)
184 #endif
185 pop_index = 0;
186
187 return (1);
188 }
189
190 /* Stuff KEY into the *front* of the input buffer.
191 Returns non-zero if successful, zero if there is
192 no space left in the buffer. */
193 int
_rl_unget_char(int key)194 _rl_unget_char (int key)
195 {
196 if (ibuffer_space ())
197 {
198 pop_index--;
199 if (pop_index < 0)
200 pop_index = ibuffer_len;
201 ibuffer[pop_index] = key;
202 return (1);
203 }
204 return (0);
205 }
206
207 /* If a character is available to be read, then read it and stuff it into
208 IBUFFER. Otherwise, just return. Returns number of characters read
209 (0 if none available) and -1 on error (EIO). */
210 static int
rl_gather_tyi(void)211 rl_gather_tyi (void)
212 {
213 int tty;
214 register int tem, result;
215 int chars_avail, k;
216 char input;
217 #if defined(HAVE_SELECT)
218 fd_set readfds, exceptfds;
219 struct timeval timeout;
220 #endif
221
222 chars_avail = 0;
223 input = 0;
224 tty = fileno (rl_instream);
225
226 #if defined (HAVE_SELECT)
227 FD_ZERO (&readfds);
228 FD_ZERO (&exceptfds);
229 FD_SET (tty, &readfds);
230 FD_SET (tty, &exceptfds);
231 USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
232 result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
233 if (result <= 0)
234 return 0; /* Nothing to read. */
235 #endif
236
237 result = -1;
238 errno = 0;
239 #if defined (FIONREAD)
240 result = ioctl (tty, FIONREAD, &chars_avail);
241 if (result == -1 && errno == EIO)
242 return -1;
243 if (result == -1)
244 chars_avail = 0;
245 #endif
246
247 #if defined (O_NDELAY)
248 if (result == -1)
249 {
250 tem = fcntl (tty, F_GETFL, 0);
251
252 fcntl (tty, F_SETFL, (tem | O_NDELAY));
253 chars_avail = read (tty, &input, 1);
254
255 fcntl (tty, F_SETFL, tem);
256 if (chars_avail == -1 && errno == EAGAIN)
257 return 0;
258 if (chars_avail == -1 && errno == EIO)
259 return -1;
260 if (chars_avail == 0) /* EOF */
261 {
262 rl_stuff_char (EOF);
263 return (0);
264 }
265 }
266 #endif /* O_NDELAY */
267
268 #if defined (__MINGW32__)
269 /* Use getch/_kbhit to check for available console input, in the same way
270 that we read it normally. */
271 chars_avail = isatty (tty) ? _kbhit () : 0;
272 result = 0;
273 #endif
274
275 /* If there's nothing available, don't waste time trying to read
276 something. */
277 if (chars_avail <= 0)
278 return 0;
279
280 tem = ibuffer_space ();
281
282 if (chars_avail > tem)
283 chars_avail = tem;
284
285 /* One cannot read all of the available input. I can only read a single
286 character at a time, or else programs which require input can be
287 thwarted. If the buffer is larger than one character, I lose.
288 Damn! */
289 if (tem < ibuffer_len)
290 chars_avail = 0;
291
292 if (result != -1)
293 {
294 while (chars_avail--)
295 {
296 RL_CHECK_SIGNALS ();
297 k = (*rl_getc_function) (rl_instream);
298 if (rl_stuff_char (k) == 0)
299 break; /* some problem; no more room */
300 if (k == NEWLINE || k == RETURN)
301 break;
302 }
303 }
304 else
305 {
306 if (chars_avail)
307 rl_stuff_char (input);
308 }
309
310 return 1;
311 }
312
313 int
rl_set_keyboard_input_timeout(int u)314 rl_set_keyboard_input_timeout (int u)
315 {
316 int o;
317
318 o = _keyboard_input_timeout;
319 if (u >= 0)
320 _keyboard_input_timeout = u;
321 return (o);
322 }
323
324 /* Is there input available to be read on the readline input file
325 descriptor? Only works if the system has select(2) or FIONREAD.
326 Uses the value of _keyboard_input_timeout as the timeout; if another
327 readline function wants to specify a timeout and not leave it up to
328 the user, it should use _rl_input_queued(timeout_value_in_microseconds)
329 instead. */
330 int
_rl_input_available(void)331 _rl_input_available (void)
332 {
333 #if defined(HAVE_SELECT)
334 fd_set readfds, exceptfds;
335 struct timeval timeout;
336 #endif
337 #if !defined (HAVE_SELECT) && defined(FIONREAD)
338 int chars_avail;
339 #endif
340 int tty;
341
342 if (rl_input_available_hook)
343 return (*rl_input_available_hook) ();
344
345 tty = fileno (rl_instream);
346
347 #if defined (HAVE_SELECT)
348 FD_ZERO (&readfds);
349 FD_ZERO (&exceptfds);
350 FD_SET (tty, &readfds);
351 FD_SET (tty, &exceptfds);
352 USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
353 return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
354 #else
355
356 #if defined (FIONREAD)
357 if (ioctl (tty, FIONREAD, &chars_avail) == 0)
358 return (chars_avail);
359 #endif
360
361 #endif
362
363 #if defined (__MINGW32__)
364 if (isatty (tty))
365 return (_kbhit ());
366 #endif
367
368 return 0;
369 }
370
371 int
_rl_nchars_available()372 _rl_nchars_available ()
373 {
374 int chars_avail, fd, result;
375
376 chars_avail = 0;
377
378 #if defined (FIONREAD)
379 fd = fileno (rl_instream);
380 errno = 0;
381 result = ioctl (fd, FIONREAD, &chars_avail);
382 if (result == -1 && errno == EIO)
383 return -1;
384 #endif
385
386 return chars_avail;
387 }
388
389 int
_rl_input_queued(int t)390 _rl_input_queued (int t)
391 {
392 int old_timeout, r;
393
394 old_timeout = rl_set_keyboard_input_timeout (t);
395 r = _rl_input_available ();
396 rl_set_keyboard_input_timeout (old_timeout);
397 return r;
398 }
399
400 void
_rl_insert_typein(int c)401 _rl_insert_typein (int c)
402 {
403 int key, t, i;
404 char *string;
405
406 i = key = 0;
407 string = (char *)xmalloc (ibuffer_len + 1);
408 string[i++] = (char) c;
409
410 while ((t = rl_get_char (&key)) &&
411 _rl_keymap[key].type == ISFUNC &&
412 _rl_keymap[key].function == rl_insert)
413 string[i++] = key;
414
415 if (t)
416 _rl_unget_char (key);
417
418 string[i] = '\0';
419 rl_insert_text (string);
420 xfree (string);
421 }
422
423 /* Add KEY to the buffer of characters to be read. Returns 1 if the
424 character was stuffed correctly; 0 otherwise. */
425 int
rl_stuff_char(int key)426 rl_stuff_char (int key)
427 {
428 if (ibuffer_space () == 0)
429 return 0;
430
431 if (key == EOF)
432 {
433 key = NEWLINE;
434 rl_pending_input = EOF;
435 RL_SETSTATE (RL_STATE_INPUTPENDING);
436 }
437 ibuffer[push_index++] = key;
438 #if 0
439 if (push_index >= ibuffer_len)
440 #else
441 if (push_index > ibuffer_len)
442 #endif
443 push_index = 0;
444
445 return 1;
446 }
447
448 /* Make C be the next command to be executed. */
449 int
rl_execute_next(int c)450 rl_execute_next (int c)
451 {
452 rl_pending_input = c;
453 RL_SETSTATE (RL_STATE_INPUTPENDING);
454 return 0;
455 }
456
457 /* Clear any pending input pushed with rl_execute_next() */
458 int
rl_clear_pending_input(void)459 rl_clear_pending_input (void)
460 {
461 rl_pending_input = 0;
462 RL_UNSETSTATE (RL_STATE_INPUTPENDING);
463 return 0;
464 }
465
466 /* **************************************************************** */
467 /* */
468 /* Character Input */
469 /* */
470 /* **************************************************************** */
471
472 /* Read a key, including pending input. */
473 int
rl_read_key(void)474 rl_read_key (void)
475 {
476 int c, r;
477
478 if (rl_pending_input)
479 {
480 c = rl_pending_input; /* XXX - cast to unsigned char if > 0? */
481 rl_clear_pending_input ();
482 }
483 else
484 {
485 /* If input is coming from a macro, then use that. */
486 if (c = _rl_next_macro_key ())
487 return ((unsigned char)c);
488
489 /* If the user has an event function, then call it periodically. */
490 if (rl_event_hook)
491 {
492 while (rl_event_hook)
493 {
494 if (rl_get_char (&c) != 0)
495 break;
496
497 if ((r = rl_gather_tyi ()) < 0) /* XXX - EIO */
498 {
499 rl_done = 1;
500 return (errno == EIO ? (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF) : '\n');
501 }
502 else if (r > 0) /* read something */
503 continue;
504
505 RL_CHECK_SIGNALS ();
506 if (rl_done) /* XXX - experimental */
507 return ('\n');
508 (*rl_event_hook) ();
509 }
510 }
511 else
512 {
513 if (rl_get_char (&c) == 0)
514 c = (*rl_getc_function) (rl_instream);
515 /* fprintf(stderr, "rl_read_key: calling RL_CHECK_SIGNALS: _rl_caught_signal = %d\r\n", _rl_caught_signal); */
516 RL_CHECK_SIGNALS ();
517 }
518 }
519
520 return (c);
521 }
522
523 int
rl_getc(FILE * stream)524 rl_getc (FILE *stream)
525 {
526 int result;
527 unsigned char c;
528 #if defined (HAVE_PSELECT)
529 sigset_t empty_set;
530 fd_set readfds;
531 #endif
532
533 while (1)
534 {
535 RL_CHECK_SIGNALS ();
536
537 /* We know at this point that _rl_caught_signal == 0 */
538
539 #if defined (__MINGW32__)
540 if (isatty (fileno (stream)))
541 return (_getch ()); /* "There is no error return." */
542 #endif
543 result = 0;
544 #if defined (HAVE_PSELECT)
545 FD_ZERO (&readfds);
546 FD_SET (fileno (stream), &readfds);
547 # if defined (HANDLE_SIGNALS)
548 result = pselect (fileno (stream) + 1, &readfds, NULL, NULL, NULL, &_rl_orig_sigset);
549 # else
550 sigemptyset (&empty_set);
551 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &empty_set);
552 result = pselect (fileno (stream) + 1, &readfds, NULL, NULL, NULL, &empty_set);
553 # endif /* HANDLE_SIGNALS */
554 #endif
555 if (result >= 0)
556 result = read (fileno (stream), &c, sizeof (unsigned char));
557
558 if (result == sizeof (unsigned char))
559 return (c);
560
561 /* If zero characters are returned, then the file that we are
562 reading from is empty! Return EOF in that case. */
563 if (result == 0)
564 return (EOF);
565
566 #if defined (__BEOS__)
567 if (errno == EINTR)
568 continue;
569 #endif
570
571 #if defined (EWOULDBLOCK)
572 # define X_EWOULDBLOCK EWOULDBLOCK
573 #else
574 # define X_EWOULDBLOCK -99
575 #endif
576
577 #if defined (EAGAIN)
578 # define X_EAGAIN EAGAIN
579 #else
580 # define X_EAGAIN -99
581 #endif
582
583 if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
584 {
585 if (sh_unset_nodelay_mode (fileno (stream)) < 0)
586 return (EOF);
587 continue;
588 }
589
590 #undef X_EWOULDBLOCK
591 #undef X_EAGAIN
592
593 /* fprintf(stderr, "rl_getc: result = %d errno = %d\n", result, errno); */
594
595 handle_error:
596 /* If the error that we received was EINTR, then try again,
597 this is simply an interrupted system call to read (). We allow
598 the read to be interrupted if we caught SIGHUP, SIGTERM, or any
599 of the other signals readline treats specially. If the
600 application sets an event hook, call it for other signals.
601 Otherwise (not EINTR), some error occurred, also signifying EOF. */
602 if (errno != EINTR)
603 return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
604 /* fatal signals of interest */
605 #if defined (SIGHUP)
606 else if (_rl_caught_signal == SIGHUP || _rl_caught_signal == SIGTERM)
607 #else
608 else if (_rl_caught_signal == SIGTERM)
609 #endif
610 return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
611 /* keyboard-generated signals of interest */
612 #if defined (SIGQUIT)
613 else if (_rl_caught_signal == SIGINT || _rl_caught_signal == SIGQUIT)
614 #else
615 else if (_rl_caught_signal == SIGINT)
616 #endif
617 RL_CHECK_SIGNALS ();
618 #if defined (SIGTSTP)
619 else if (_rl_caught_signal == SIGTSTP)
620 RL_CHECK_SIGNALS ();
621 #endif
622 /* non-keyboard-generated signals of interest */
623 #if defined (SIGWINCH)
624 else if (_rl_caught_signal == SIGWINCH)
625 RL_CHECK_SIGNALS ();
626 #endif /* SIGWINCH */
627 #if defined (SIGALRM)
628 else if (_rl_caught_signal == SIGALRM
629 # if defined (SIGVTALRM)
630 || _rl_caught_signal == SIGVTALRM
631 # endif
632 )
633 RL_CHECK_SIGNALS ();
634 #endif /* SIGALRM */
635
636 if (rl_signal_event_hook)
637 (*rl_signal_event_hook) ();
638 }
639 }
640
641 #if defined (HANDLE_MULTIBYTE)
642 /* read multibyte char */
643 int
_rl_read_mbchar(char * mbchar,int size)644 _rl_read_mbchar (char *mbchar, int size)
645 {
646 int mb_len, c;
647 size_t mbchar_bytes_length;
648 wchar_t wc;
649 mbstate_t ps, ps_back;
650
651 memset(&ps, 0, sizeof (mbstate_t));
652 memset(&ps_back, 0, sizeof (mbstate_t));
653
654 mb_len = 0;
655 while (mb_len < size)
656 {
657 c = (mb_len == 0) ? _rl_bracketed_read_key () : rl_read_key ();
658
659 if (c < 0)
660 break;
661
662 mbchar[mb_len++] = c;
663
664 mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
665 if (mbchar_bytes_length == (size_t)(-1))
666 break; /* invalid byte sequence for the current locale */
667 else if (mbchar_bytes_length == (size_t)(-2))
668 {
669 /* shorted bytes */
670 ps = ps_back;
671 continue;
672 }
673 else if (mbchar_bytes_length == 0)
674 {
675 mbchar[0] = '\0'; /* null wide character */
676 mb_len = 1;
677 break;
678 }
679 else if (mbchar_bytes_length > (size_t)(0))
680 break;
681 }
682
683 return mb_len;
684 }
685
686 /* Read a multibyte-character string whose first character is FIRST into
687 the buffer MB of length MLEN. Returns the last character read, which
688 may be FIRST. Used by the search functions, among others. Very similar
689 to _rl_read_mbchar. */
690 int
_rl_read_mbstring(int first,char * mb,int mlen)691 _rl_read_mbstring (int first, char *mb, int mlen)
692 {
693 int i, c, n;
694 mbstate_t ps;
695
696 c = first;
697 memset (mb, 0, mlen);
698 for (i = 0; c >= 0 && i < mlen; i++)
699 {
700 mb[i] = (char)c;
701 memset (&ps, 0, sizeof (mbstate_t));
702 n = _rl_get_char_len (mb, &ps);
703 if (n == -2)
704 {
705 /* Read more for multibyte character */
706 RL_SETSTATE (RL_STATE_MOREINPUT);
707 c = rl_read_key ();
708 RL_UNSETSTATE (RL_STATE_MOREINPUT);
709 }
710 else
711 break;
712 }
713 return c;
714 }
715 #endif /* HANDLE_MULTIBYTE */
716