lib/readline/input.c

   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
 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
 148 _rl_any_typein (void)
 149 {
 150   return any_typein;
 151 }
 152
 153 int
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 */