input.c

   1 /* input.c -- functions to perform buffered input with synchronization. */
   2
   3 /* Copyright (C) 1992-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   7    Bash is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    Bash is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "config.h"
  22
  23 #include "bashtypes.h"
  24 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
  25 #  include <sys/file.h>
  26 #endif
  27 #include "filecntl.h"
  28 #include "posixstat.h"
  29 #include <stdio.h>
  30 #include <errno.h>
  31
  32 #if defined (HAVE_UNISTD_H)
  33 #  include <unistd.h>
  34 #endif
  35
  36 #include "bashansi.h"
  37 #include "bashintl.h"
  38
  39 #include "shell.h"
  40 #include "input.h"
  41 #include "externs.h"
  42 #include "trap.h"
  43
  44 #if !defined (errno)
  45 extern int errno;
  46 #endif /* !errno */
  47
  48 #if defined (EAGAIN)
  49 #  define X_EAGAIN EAGAIN
  50 #else
  51 #  define X_EAGAIN -99
  52 #endif
  53
  54 #if defined (EWOULDBLOCK)
  55 #  define X_EWOULDBLOCK EWOULDBLOCK
  56 #else
  57 #  define X_EWOULDBLOCK -99
  58 #endif
  59
  60 extern void termsig_handler __P((int));
  61
  62 /* Functions to handle reading input on systems that don't restart read(2)
  63    if a signal is received. */
  64
  65 static char localbuf[128];
  66 static int local_index = 0, local_bufused = 0;
  67
  68 /* Posix and USG systems do not guarantee to restart read () if it is
  69    interrupted by a signal.  We do the read ourselves, and restart it
  70    if it returns EINTR. */
  71 int
  72 getc_with_restart (stream)
  73      FILE *stream;
  74 {
  75   unsigned char uc;
  76
  77   CHECK_TERMSIG;
  78
  79   /* Try local buffering to reduce the number of read(2) calls. */
  80   if (local_index == local_bufused || local_bufused == 0)
  81     {
  82       while (1)
  83         {
  84           QUIT;
  85           run_pending_traps ();
  86
  87           local_bufused = read (fileno (stream), localbuf, sizeof(localbuf));
  88           if (local_bufused > 0)
  89             break;
  90           else if (local_bufused == 0)
  91             {
  92               local_index = 0;
  93               return EOF;
  94             }
  95           else if (errno == X_EAGAIN || errno == X_EWOULDBLOCK)
  96             {
  97               if (sh_unset_nodelay_mode (fileno (stream)) < 0)
  98                 {
  99                   sys_error (_("cannot reset nodelay mode for fd %d"), fileno (stream));
 100                   local_index = local_bufused = 0;
 101                   return EOF;
 102                 }
 103               continue;
 104             }
 105           else if (errno != EINTR)
 106             {
 107               local_index = local_bufused = 0;
 108               return EOF;
 109             }
 110           else if (interrupt_state || terminating_signal)       /* QUIT; */
 111             local_index = local_bufused = 0;
 112         }
 113       local_index = 0;
 114     }
 115   uc = localbuf[local_index++];
 116   return uc;
 117 }
 118
 119 int
 120 ungetc_with_restart (c, stream)
 121      int c;
 122      FILE *stream;
 123 {
 124   if (local_index == 0 || c == EOF)
 125     return EOF;
 126   localbuf[--local_index] = c;
 127   return c;
 128 }
 129
 130 #if defined (BUFFERED_INPUT)
 131
 132 /* A facility similar to stdio, but input-only. */
 133
 134 #if defined (USING_BASH_MALLOC)
 135 #  define MAX_INPUT_BUFFER_SIZE 8176
 136 #else
 137 #  define MAX_INPUT_BUFFER_SIZE 8192
 138 #endif
 139
 140 #if !defined (SEEK_CUR)
 141 #  define SEEK_CUR 1
 142 #endif /* !SEEK_CUR */
 143
 144 #ifdef max
 145 #  undef max
 146 #endif
 147 #define max(a, b)       (((a) > (b)) ? (a) : (b))
 148 #ifdef min
 149 #  undef min
 150 #endif
 151 #define min(a, b)       ((a) > (b) ? (b) : (a))
 152
 153 int bash_input_fd_changed;
 154
 155 /* This provides a way to map from a file descriptor to the buffer
 156    associated with that file descriptor, rather than just the other
 157    way around.  This is needed so that buffers are managed properly
 158    in constructs like 3<&4.  buffers[x]->b_fd == x -- that is how the
 159    correspondence is maintained. */
 160 static BUFFERED_STREAM **buffers = (BUFFERED_STREAM **)NULL;
 161 static int nbuffers;
 162
 163 #define ALLOCATE_BUFFERS(n) \
 164         do { if ((n) >= nbuffers) allocate_buffers (n); } while (0)
 165
 166 /* Make sure `buffers' has at least N elements. */
 167 static void
 168 allocate_buffers (n)
 169      int n;
 170 {
 171   register int i, orig_nbuffers;
 172
 173   orig_nbuffers = nbuffers;
 174   nbuffers = n + 20;
 175   buffers = (BUFFERED_STREAM **)xrealloc
 176     (buffers, nbuffers * sizeof (BUFFERED_STREAM *));
 177
 178   /* Zero out the new buffers. */
 179   for (i = orig_nbuffers; i < nbuffers; i++)
 180     buffers[i] = (BUFFERED_STREAM *)NULL;
 181 }
 182
 183 /* Construct and return a BUFFERED_STREAM corresponding to file descriptor
 184    FD, using BUFFER. */
 185 static BUFFERED_STREAM *
 186 make_buffered_stream (fd, buffer, bufsize)
 187      int fd;
 188      char *buffer;
 189      size_t bufsize;
 190 {
 191   BUFFERED_STREAM *bp;
 192
 193   bp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM));
 194   ALLOCATE_BUFFERS (fd);
 195   buffers[fd] = bp;
 196   bp->b_fd = fd;
 197   bp->b_buffer = buffer;
 198   bp->b_size = bufsize;
 199   bp->b_used = bp->b_inputp = bp->b_flag = 0;
 200   if (bufsize == 1)
 201     bp->b_flag |= B_UNBUFF;
 202   if (O_TEXT && (fcntl (fd, F_GETFL) & O_TEXT) != 0)
 203     bp->b_flag |= B_TEXT;
 204   return (bp);
 205 }
 206
 207 /* Allocate a new BUFFERED_STREAM, copy BP to it, and return the new copy. */
 208 static BUFFERED_STREAM *
 209 copy_buffered_stream (bp)
 210      BUFFERED_STREAM *bp;
 211 {
 212   BUFFERED_STREAM *nbp;
 213
 214   if (!bp)
 215     return ((BUFFERED_STREAM *)NULL);
 216
 217   nbp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM));
 218   xbcopy ((char *)bp, (char *)nbp, sizeof (BUFFERED_STREAM));
 219   return (nbp);
 220 }
 221
 222 int
 223 set_bash_input_fd (fd)
 224      int fd;
 225 {
 226   if (bash_input.type == st_bstream)
 227     bash_input.location.buffered_fd = fd;
 228   else if (interactive_shell == 0)
 229     default_buffered_input = fd;
 230   return 0;
 231 }
 232
 233 int
 234 fd_is_bash_input (fd)
 235      int fd;
 236 {
 237   if (bash_input.type == st_bstream && bash_input.location.buffered_fd == fd)
 238     return 1;
 239   else if (interactive_shell == 0 && default_buffered_input == fd)
 240     return 1;
 241   return 0;
 242 }
 243
 244 /* Save the buffered stream corresponding to file descriptor FD (which bash
 245    is using to read input) to a buffered stream associated with NEW_FD.  If
 246    NEW_FD is -1, a new file descriptor is allocated with fcntl.  The new
 247    file descriptor is returned on success, -1 on error. */
 248 int
 249 save_bash_input (fd, new_fd)
 250      int fd, new_fd;
 251 {
 252   int nfd;
 253
 254   /* Sync the stream so we can re-read from the new file descriptor.  We
 255      might be able to avoid this by copying the buffered stream verbatim
 256      to the new file descriptor. */
 257   if (buffers[fd])
 258     sync_buffered_stream (fd);
 259
 260   /* Now take care of duplicating the file descriptor that bash is
 261      using for input, so we can reinitialize it later. */
 262   nfd = (new_fd == -1) ? fcntl (fd, F_DUPFD, 10) : new_fd;
 263   if (nfd == -1)
 264     {
 265       if (fcntl (fd, F_GETFD, 0) == 0)
 266         sys_error (_("cannot allocate new file descriptor for bash input from fd %d"), fd);
 267       return -1;
 268     }
 269
 270   if (nfd < nbuffers && buffers[nfd])
 271     {
 272       /* What's this?  A stray buffer without an associated open file
 273          descriptor?  Free up the buffer and report the error. */
 274       internal_error (_("save_bash_input: buffer already exists for new fd %d"), nfd);
 275       if (buffers[nfd]->b_flag & B_SHAREDBUF)
 276         buffers[nfd]->b_buffer = (char *)NULL;
 277       free_buffered_stream (buffers[nfd]);
 278     }
 279
 280   /* Reinitialize bash_input.location. */
 281   if (bash_input.type == st_bstream)
 282     {
 283       bash_input.location.buffered_fd = nfd;
 284       fd_to_buffered_stream (nfd);
 285       close_buffered_fd (fd);   /* XXX */
 286     }
 287   else
 288     /* If the current input type is not a buffered stream, but the shell
 289        is not interactive and therefore using a buffered stream to read
 290        input (e.g. with an `eval exec 3>output' inside a script), note
 291        that the input fd has been changed.  pop_stream() looks at this
 292        value and adjusts the input fd to the new value of
 293        default_buffered_input accordingly. */
 294     bash_input_fd_changed++;
 295
 296   if (default_buffered_input == fd)
 297     default_buffered_input = nfd;
 298
 299   SET_CLOSE_ON_EXEC (nfd);
 300   return nfd;
 301 }
 302
 303 /* Check that file descriptor FD is not the one that bash is currently
 304    using to read input from a script.  FD is about to be duplicated onto,
 305    which means that the kernel will close it for us.  If FD is the bash
 306    input file descriptor, we need to seek backwards in the script (if
 307    possible and necessary -- scripts read from stdin are still unbuffered),
 308    allocate a new file descriptor to use for bash input, and re-initialize
 309    the buffered stream.  Make sure the file descriptor used to save bash
 310    input is set close-on-exec. Returns 0 on success, -1 on failure.  This
 311    works only if fd is > 0 -- if fd == 0 and bash is reading input from
 312    fd 0, sync_buffered_stream is used instead, to cooperate with input
 313    redirection (look at redir.c:add_undo_redirect()). */
 314 int
 315 check_bash_input (fd)
 316      int fd;
 317 {
 318   if (fd_is_bash_input (fd))
 319     {
 320       if (fd > 0)
 321         return ((save_bash_input (fd, -1) == -1) ? -1 : 0);
 322       else if (fd == 0)
 323         return ((sync_buffered_stream (fd) == -1) ? -1 : 0);
 324     }
 325   return 0;
 326 }
 327
 328 /* This is the buffered stream analogue of dup2(fd1, fd2).  The
 329    BUFFERED_STREAM corresponding to fd2 is deallocated, if one exists.
 330    BUFFERS[fd1] is copied to BUFFERS[fd2].  This is called by the
 331    redirect code for constructs like 4<&0 and 3</etc/rc.local. */
 332 int
 333 duplicate_buffered_stream (fd1, fd2)
 334      int fd1, fd2;
 335 {
 336   int is_bash_input, m;
 337
 338   if (fd1 == fd2)
 339     return 0;
 340
 341   m = max (fd1, fd2);
 342   ALLOCATE_BUFFERS (m);
 343
 344   /* If FD2 is the file descriptor bash is currently using for shell input,
 345      we need to do some extra work to make sure that the buffered stream
 346      actually exists (it might not if fd1 was not active, and the copy
 347      didn't actually do anything). */
 348   is_bash_input = (bash_input.type == st_bstream) &&
 349                   (bash_input.location.buffered_fd == fd2);
 350
 351   if (buffers[fd2])
 352     {
 353       /* If the two objects share the same b_buffer, don't free it. */
 354       if (buffers[fd1] && buffers[fd1]->b_buffer && buffers[fd1]->b_buffer == buffers[fd2]->b_buffer)
 355         buffers[fd2] = (BUFFERED_STREAM *)NULL;
 356       /* If this buffer is shared with another fd, don't free the buffer */
 357       else if (buffers[fd2]->b_flag & B_SHAREDBUF)
 358         {
 359           buffers[fd2]->b_buffer = (char *)NULL;
 360           free_buffered_stream (buffers[fd2]);
 361         }
 362       else
 363         free_buffered_stream (buffers[fd2]);
 364     }
 365   buffers[fd2] = copy_buffered_stream (buffers[fd1]);
 366   if (buffers[fd2])
 367     buffers[fd2]->b_fd = fd2;
 368
 369   if (is_bash_input)
 370     {
 371       if (!buffers[fd2])
 372         fd_to_buffered_stream (fd2);
 373       buffers[fd2]->b_flag |= B_WASBASHINPUT;
 374     }
 375
 376   if (fd_is_bash_input (fd1) || (buffers[fd1] && (buffers[fd1]->b_flag & B_SHAREDBUF)))
 377     buffers[fd2]->b_flag |= B_SHAREDBUF;
 378
 379   return (fd2);
 380 }
 381
 382 /* Return 1 if a seek on FD will succeed. */
 383 #define fd_is_seekable(fd) (lseek ((fd), 0L, SEEK_CUR) >= 0)
 384
 385 /* Take FD, a file descriptor, and create and return a buffered stream
 386    corresponding to it.  If something is wrong and the file descriptor
 387    is invalid, return a NULL stream. */
 388 BUFFERED_STREAM *
 389 fd_to_buffered_stream (fd)
 390      int fd;
 391 {
 392   char *buffer;
 393   size_t size;
 394   struct stat sb;
 395
 396   if (fstat (fd, &sb) < 0)
 397     {
 398       close (fd);
 399       return ((BUFFERED_STREAM *)NULL);
 400     }
 401
 402   size = (fd_is_seekable (fd)) ? min (sb.st_size, MAX_INPUT_BUFFER_SIZE) : 1;
 403   if (size == 0)
 404     size = 1;
 405   buffer = (char *)xmalloc (size);
 406
 407   return (make_buffered_stream (fd, buffer, size));
 408 }
 409
 410 /* Return a buffered stream corresponding to FILE, a file name. */
 411 BUFFERED_STREAM *
 412 open_buffered_stream (file)
 413      char *file;
 414 {
 415   int fd;
 416
 417   fd = open (file, O_RDONLY);
 418   return ((fd >= 0) ? fd_to_buffered_stream (fd) : (BUFFERED_STREAM *)NULL);
 419 }
 420
 421 /* Deallocate a buffered stream and free up its resources.  Make sure we
 422    zero out the slot in BUFFERS that points to BP. */
 423 void
 424 free_buffered_stream (bp)
 425      BUFFERED_STREAM *bp;
 426 {
 427   int n;
 428
 429   if (!bp)
 430     return;
 431
 432   n = bp->b_fd;
 433   if (bp->b_buffer)
 434     free (bp->b_buffer);
 435   free (bp);
 436   buffers[n] = (BUFFERED_STREAM *)NULL;
 437 }
 438
 439 /* Close the file descriptor associated with BP, a buffered stream, and free
 440    up the stream.  Return the status of closing BP's file descriptor. */
 441 int
 442 close_buffered_stream (bp)
 443      BUFFERED_STREAM *bp;
 444 {
 445   int fd;
 446
 447   if (!bp)
 448     return (0);
 449   fd = bp->b_fd;
 450   if (bp->b_flag & B_SHAREDBUF)
 451     bp->b_buffer = (char *)NULL;
 452   free_buffered_stream (bp);
 453   return (close (fd));
 454 }
 455
 456 /* Deallocate the buffered stream associated with file descriptor FD, and
 457    close FD.  Return the status of the close on FD. */
 458 int
 459 close_buffered_fd (fd)
 460      int fd;
 461 {
 462   if (fd < 0)
 463     {
 464       errno = EBADF;
 465       return -1;
 466     }
 467   if (fd >= nbuffers || !buffers || !buffers[fd])
 468     return (close (fd));
 469   return (close_buffered_stream (buffers[fd]));
 470 }
 471
 472 /* Make the BUFFERED_STREAM associated with buffers[FD] be BP, and return
 473    the old BUFFERED_STREAM. */
 474 BUFFERED_STREAM *
 475 set_buffered_stream (fd, bp)
 476      int fd;
 477      BUFFERED_STREAM *bp;
 478 {
 479   BUFFERED_STREAM *ret;
 480
 481   ret = buffers[fd];
 482   buffers[fd] = bp;
 483   return ret;
 484 }
 485
 486 /* Read a buffer full of characters from BP, a buffered stream. */
 487 static int
 488 b_fill_buffer (bp)
 489      BUFFERED_STREAM *bp;
 490 {
 491   ssize_t nr;
 492   off_t o;
 493
 494   CHECK_TERMSIG;
 495   /* In an environment where text and binary files are treated differently,
 496      compensate for lseek() on text files returning an offset different from
 497      the count of characters read() returns.  Text-mode streams have to be
 498      treated as unbuffered. */
 499   if ((bp->b_flag & (B_TEXT | B_UNBUFF)) == B_TEXT)
 500     {
 501       o = lseek (bp->b_fd, 0, SEEK_CUR);
 502       nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
 503       if (nr > 0 && nr < lseek (bp->b_fd, 0, SEEK_CUR) - o)
 504         {
 505           lseek (bp->b_fd, o, SEEK_SET);
 506           bp->b_flag |= B_UNBUFF;
 507           bp->b_size = 1;
 508           nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
 509         }
 510     }
 511   else
 512     nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
 513   if (nr <= 0)
 514     {
 515       bp->b_used = bp->b_inputp = 0;
 516       bp->b_buffer[0] = 0;
 517       if (nr == 0)
 518         bp->b_flag |= B_EOF;
 519       else
 520         bp->b_flag |= B_ERROR;
 521       return (EOF);
 522     }
 523
 524   bp->b_used = nr;
 525   bp->b_inputp = 0;
 526   return (bp->b_buffer[bp->b_inputp++] & 0xFF);
 527 }
 528
 529 /* Get a character from buffered stream BP. */
 530 #define bufstream_getc(bp) \
 531   (bp->b_inputp == bp->b_used || !bp->b_used) \
 532                 ? b_fill_buffer (bp) \
 533                 : bp->b_buffer[bp->b_inputp++] & 0xFF
 534
 535 /* Push C back onto buffered stream BP. */
 536 static int
 537 bufstream_ungetc(c, bp)
 538      int c;
 539      BUFFERED_STREAM *bp;
 540 {
 541   if (c == EOF || bp == 0 || bp->b_inputp == 0)
 542     return (EOF);
 543
 544   bp->b_buffer[--bp->b_inputp] = c;
 545   return (c);
 546 }
 547
 548 /* Seek backwards on file BFD to synchronize what we've read so far
 549    with the underlying file pointer. */
 550 int
 551 sync_buffered_stream (bfd)
 552      int bfd;
 553 {
 554   BUFFERED_STREAM *bp;
 555   off_t chars_left;
 556
 557   if (buffers == 0 || (bp = buffers[bfd]) == 0)
 558     return (-1);
 559
 560   chars_left = bp->b_used - bp->b_inputp;
 561   if (chars_left)
 562     lseek (bp->b_fd, -chars_left, SEEK_CUR);
 563   bp->b_used = bp->b_inputp = 0;
 564   return (0);
 565 }
 566
 567 int
 568 buffered_getchar ()
 569 {
 570   CHECK_TERMSIG;
 571
 572   if (bash_input.location.buffered_fd < 0 || buffers[bash_input.location.buffered_fd] == 0)
 573     return EOF;
 574
 575 #if !defined (DJGPP)
 576   return (bufstream_getc (buffers[bash_input.location.buffered_fd]));
 577 #else
 578   /* On DJGPP, ignore \r. */
 579   int ch;
 580   while ((ch = bufstream_getc (buffers[bash_input.location.buffered_fd])) == '\r')
 581     ;
 582   return ch;
 583 #endif
 584 }
 585
 586 int
 587 buffered_ungetchar (c)
 588      int c;
 589 {
 590   return (bufstream_ungetc (c, buffers[bash_input.location.buffered_fd]));
 591 }
 592
 593 /* Make input come from file descriptor BFD through a buffered stream. */
 594 void
 595 with_input_from_buffered_stream (bfd, name)
 596      int bfd;
 597      char *name;
 598 {
 599   INPUT_STREAM location;
 600   BUFFERED_STREAM *bp;
 601
 602   location.buffered_fd = bfd;
 603   /* Make sure the buffered stream exists. */
 604   bp = fd_to_buffered_stream (bfd);
 605   init_yy_io (bp == 0 ? return_EOF : buffered_getchar,
 606               buffered_ungetchar, st_bstream, name, location);
 607 }
 608
 609 #if defined (TEST)
 610 void *
 611 xmalloc(s)
 612 int s;
 613 {
 614         return (malloc (s));
 615 }
 616
 617 void *
 618 xrealloc(s, size)
 619 char    *s;
 620 int     size;
 621 {
 622         if (!s)
 623                 return(malloc (size));
 624         else
 625                 return(realloc (s, size));
 626 }
 627
 628 void
 629 init_yy_io ()
 630 {
 631 }
 632
 633 process(bp)
 634 BUFFERED_STREAM *bp;
 635 {
 636         int c;
 637
 638         while ((c = bufstream_getc(bp)) != EOF)
 639                 putchar(c);
 640 }
 641
 642 BASH_INPUT bash_input;
 643
 644 struct stat dsb;                /* can be used from gdb */
 645
 646 /* imitate /bin/cat */
 647 main(argc, argv)
 648 int     argc;
 649 char    **argv;
 650 {
 651         register int i;
 652         BUFFERED_STREAM *bp;
 653
 654         if (argc == 1) {
 655                 bp = fd_to_buffered_stream (0);
 656                 process(bp);
 657                 exit(0);
 658         }
 659         for (i = 1; i < argc; i++) {
 660                 if (argv[i][0] == '-' && argv[i][1] == '\0') {
 661                         bp = fd_to_buffered_stream (0);
 662                         if (!bp)
 663                                 continue;
 664                         process(bp);
 665                         free_buffered_stream (bp);
 666                 } else {
 667                         bp = open_buffered_stream (argv[i]);
 668                         if (!bp)
 669                                 continue;
 670                         process(bp);
 671                         close_buffered_stream (bp);
 672                 }
 673         }
 674         exit(0);
 675 }
 676 #endif /* TEST */
 677 #endif /* BUFFERED_INPUT */