stdio/internals.c

   1 /* Copyright (C) 1991 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <ansidecl.h>
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25
  26 /* Minimum size of a buffer we will allocate by default.
  27    If this much memory is not available,
  28    the stream in question will be made unbuffered instead.  */
  29 #define MIN_BUFSIZE     128
  30
  31 /* Figure out what kind of buffering (none, line, or full)
  32    and what buffer size to give FP.  */
  33 static void
  34 DEFUN(init_stream, (fp), register FILE *fp)
  35 {
  36   if (!fp->__seen)
  37     {
  38       /* Initialize the stream's info, including buffering info.
  39          This may give a buffer, change I/O functions, etc.
  40          If no buffer is set (and the stream is not made explicitly
  41          unbuffered), we allocate a buffer below, using the bufsize
  42          set by this function.  */
  43       extern void EXFUN(__stdio_init_stream, (FILE *));
  44       fp->__room_funcs = __default_room_functions;
  45       fp->__io_funcs = __default_io_functions;
  46       __stdio_init_stream(fp);
  47       fp->__seen = 1;
  48     }
  49
  50   if (fp->__buffer == NULL && !fp->__userbuf)
  51     {
  52       int save;
  53
  54       if (fp->__bufsize == 0)
  55         fp->__bufsize = BUFSIZ;
  56
  57       /* Try to get however many bytes of buffering __stdio_pickbuf
  58          specified, but if that much memory isn't available,
  59          try half as much each time until it succeeds or the buffer
  60          size becomes too small to be useful.  */
  61       save = errno;
  62       while (fp->__bufsize >= MIN_BUFSIZE)
  63         {
  64           fp->__buffer = (char *) malloc(fp->__bufsize);
  65           if (fp->__buffer == NULL)
  66             fp->__bufsize /= 2;
  67           else
  68             break;
  69         }
  70       errno = save;
  71
  72       if (fp->__buffer == NULL)
  73         {
  74           /* We can't get space for the buffer, so make it unbuffered.  */
  75           fp->__userbuf = 1;
  76           fp->__bufsize = 0;
  77         }
  78     }
  79
  80   if (fp->__bufp == NULL)
  81     {
  82       /* Set the buffer pointer to the beginning of the buffer.  */
  83       fp->__bufp = fp->__buffer;
  84       fp->__put_limit = fp->__get_limit = fp->__buffer;
  85     }
  86 }
  87
  88
  89 /* Determine the current file position of STREAM if it is unknown.  */
  90 int
  91 DEFUN(__stdio_check_offset, (stream), FILE *stream)
  92 {
  93   init_stream (stream);
  94
  95   if (stream->__offset == (fpos_t) -1)
  96     {
  97       /* This stream's offset is unknown or unknowable.  */
  98       if (stream->__io_funcs.__seek == NULL)
  99         {
 100           /* Unknowable.  */
 101           errno = ESPIPE;
 102           return EOF;
 103         }
 104       else
 105         {
 106           /* Unknown.  Find it out. */
 107           fpos_t pos = (fpos_t) 0;
 108           if ((*stream->__io_funcs.__seek)(stream->__cookie,
 109                                            &pos, SEEK_CUR) < 0)
 110             {
 111               if (errno == ESPIPE)
 112                 /* Object is incapable of seeking.  */
 113                 stream->__io_funcs.__seek = NULL;
 114               return EOF;
 115             }
 116           stream->__offset = pos;
 117         }
 118     }
 119
 120   if (stream->__target == (fpos_t) -1)
 121     /* This stream was opened on an existing object with
 122        an unknown file position.  The position is now known.
 123        Make this the target position.  */
 124     stream->__target = stream->__offset;
 125
 126   return 0;
 127 }
 128
 129
 130 /* Move FP's file position to its target file position,
 131    seeking as necessary and updating its `offset' field.
 132    Sets ferror(FP) (and possibly errno) for errors.  */
 133 static void
 134 DEFUN(seek_to_target, (fp), FILE *fp)
 135 {
 136   if (__stdio_check_offset (fp) == EOF)
 137     fp->__error = 1;
 138   else if (fp->__target != fp->__offset)
 139     {
 140       /* We are not at the target file position.
 141          Seek to that position.  */
 142       if (fp->__io_funcs.__seek == NULL)
 143         {
 144           /* We can't seek!  */
 145           errno = ESPIPE;
 146           fp->__error = 1;
 147         }
 148       else
 149         {
 150           fpos_t pos = fp->__target;
 151           if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
 152             /* Seek failed!  */
 153             fp->__error = 1;
 154           else
 155             {
 156               fp->__offset = pos;
 157               if (pos != fp->__target)
 158                 /* Seek didn't go to the right place!  */
 159                 fp->__error = 1;
 160             }
 161         }
 162     }
 163 }
 164
 165 /* Flush the buffer for FP.
 166    If C is not EOF, it is also to be written.
 167    If the stream is line buffered and C is a newline, it is written
 168    to the output, otherwise it is put in the buffer after it has been
 169    flushed to avoid a system call for a single character.
 170    This is the default `output room' function.  */
 171 static void
 172 DEFUN(flushbuf, (fp, c),
 173       register FILE *fp AND int c)
 174 {
 175   int flush_only = c == EOF;
 176   size_t buffer_written;
 177   size_t to_write;
 178
 179   /* Set if target and get_limit have already been twiddled appropriately.  */
 180   int twiddled = 0;
 181
 182   if (fp->__put_limit == fp->__buffer)
 183     {
 184       /* The stream needs to be primed for writing.  */
 185
 186       size_t buffer_offset = 0;
 187
 188       if (fp->__mode.__read && fp->__room_funcs.__input != NULL)
 189         {
 190           int save = errno;
 191           CONST int aligned = (__stdio_check_offset(fp) == EOF ||
 192                                fp->__target % fp->__bufsize == 0);
 193           errno = save;
 194
 195           if (!aligned)
 196             {
 197               /* Move to a block (buffer size) boundary and read in a block.
 198                  Then the output will be written as a whole block, too.  */
 199               CONST size_t o = fp->__target % fp->__bufsize;
 200               fp->__target -= o;
 201               if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
 202                 return;
 203               else
 204                 __clearerr(fp);
 205
 206               if (fp->__get_limit - fp->__buffer < o)
 207                 /* Oops.  We didn't read enough (probably because we got EOF).
 208                    Forget we even mentioned it.  */
 209                 fp->__target += o;
 210               else
 211                 /* Start bufp as far into the buffer as we were into
 212                    this block before we read it.  */
 213                 buffer_offset = o;
 214             }
 215
 216           /* The target position is now set to where the beginning of the
 217              buffer maps to; and the get_limit was set by the input-room
 218              function.  */
 219           twiddled = 1;
 220         }
 221
 222       if (fp->__buffer != NULL)
 223         {
 224           /* Set up to write output into the buffer.  */
 225           fp->__put_limit = fp->__buffer + fp->__bufsize;
 226           fp->__bufp = fp->__buffer + buffer_offset;
 227           if (!flush_only)
 228             {
 229               *fp->__bufp++ = (unsigned char) c;
 230               if (!fp->__linebuf || (unsigned char) c != '\n')
 231                 return;
 232               flush_only = 1;
 233             }
 234         }
 235     }
 236
 237   /* If there is read data in the buffer past what was written,
 238      write all of that as well.  Otherwise, just write what has been
 239      written into the buffer.  */
 240   buffer_written = fp->__bufp - fp->__buffer;
 241   to_write = (buffer_written == 0 ? 0 :
 242               fp->__get_limit > fp->__bufp ?
 243               fp->__get_limit - fp->__buffer :
 244               buffer_written);
 245
 246   if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
 247     {
 248       /* There is no writing function or we're coming from an fflush
 249          call with nothing in the buffer, so just say the buffer's
 250          been flushed, increment the file offset, and return.  */
 251       fp->__bufp = fp->__buffer;
 252       fp->__offset += to_write;
 253       goto end;
 254     }
 255
 256   if (to_write > 0)
 257     {
 258       int wrote;
 259
 260       /* Go to the target file position.  */
 261       seek_to_target(fp);
 262
 263       if (!ferror(fp))
 264         {
 265           /* Write out the buffered data.  */
 266           wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
 267                                             to_write);
 268           if (wrote > 0)
 269             /* Record that we've moved forward in the file.  */
 270             fp->__offset += wrote;
 271           if (wrote < (int) to_write)
 272             /* The writing function should always write
 273                the whole buffer unless there is an error.  */
 274             fp->__error = 1;
 275         }
 276     }
 277
 278   /* Reset the buffer pointer to the beginning of the buffer.  */
 279   fp->__bufp = fp->__buffer;
 280
 281   /* If we're not just flushing, write the last character, C.  */
 282   if (!flush_only && !ferror(fp))
 283     {
 284       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
 285         {
 286           /* Either we're unbuffered, or we're line-buffered and
 287              C is a newline, so really write it out immediately.  */
 288           char cc = (unsigned char) c;
 289           if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
 290             fp->__error = 1;
 291           else
 292             /* Record that we've moved forward in the file.  */
 293             ++fp->__offset;
 294         }
 295       else
 296         /* Just put C in the buffer.  */
 297         *fp->__bufp++ = (unsigned char) c;
 298     }
 299
 300  end:
 301
 302   if (!twiddled)
 303     {
 304       /* The new target position moves up as
 305          much as the user wrote into the buffer.  */
 306       fp->__target += buffer_written;
 307
 308       /* Set the reading limit to the beginning of the buffer,
 309          so the next `getc' will call __fillbf.  */
 310       fp->__get_limit = fp->__buffer;
 311     }
 312
 313   if (feof(fp) || ferror(fp))
 314     fp->__bufp = fp->__put_limit;
 315 }
 316
 317
 318 /* Fill the buffer for FP and return the first character read (or EOF).
 319    This is the default `input_room' function.  */
 320 static int
 321 DEFUN(fillbuf, (fp), register FILE *fp)
 322 {
 323   /* How far into the buffer we read we want to start bufp.  */
 324   size_t buffer_offset = 0;
 325   register char *buffer;
 326   register size_t to_read, nread = 0;
 327   char c;
 328
 329   if (fp->__io_funcs.__read == NULL)
 330     {
 331       /* There is no read function, so always return EOF.  */
 332       fp->__eof = 1;
 333       goto end;
 334     }
 335
 336   if (fp->__buffer == NULL)
 337     {
 338       /* We're unbuffered, so we want to read only one character.  */
 339       buffer = &c;
 340       to_read = 1;
 341     }
 342   else
 343     {
 344       /* We're buffered, so try to fill the buffer.  */
 345       buffer = fp->__buffer;
 346       to_read = fp->__bufsize;
 347     }
 348
 349   /* We're reading, so we're not at the end-of-file.  */
 350   fp->__eof = 0;
 351
 352   /* Go to the target file position.  */
 353   {
 354     int save = errno;
 355     if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
 356       {
 357         /* Move to a block (buffer size) boundary.  */
 358         if (fp->__bufsize != 0)
 359           {
 360             buffer_offset = fp->__target % fp->__bufsize;
 361             fp->__target -= buffer_offset;
 362           }
 363         seek_to_target (fp);
 364       }
 365     errno = save;
 366   }
 367
 368   while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
 369     {
 370       /* Try to fill the buffer.  */
 371       int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
 372       if (count == 0)
 373         fp->__eof = 1;
 374       else if (count < 0)
 375         fp->__error = 1;
 376       else
 377         {
 378           buffer += count;
 379           nread += count;
 380           to_read -= count;
 381           /* Record that we've moved forward in the file.  */
 382           fp->__offset += count;
 383         }
 384     }
 385
 386   if (fp->__buffer == NULL)
 387     /* There is no buffer, so return the character we read
 388        without all the buffer pointer diddling.  */
 389     return (feof(fp) || ferror(fp)) ? EOF : c;
 390
 391   /* Reset the buffer pointer to the beginning of the buffer
 392      (plus whatever offset we may have set above).  */
 393   fp->__bufp = fp->__buffer + buffer_offset;
 394
 395  end:;
 396
 397   if (feof(fp) || ferror(fp))
 398     {
 399       /* Set both end pointers to the beginning of the buffer so
 400          the next i/o call will force a call to __fillbf/__flshfp.  */
 401       fp->__put_limit = fp->__get_limit = fp->__buffer;
 402       return EOF;
 403     }
 404
 405   /* Set the end pointer to one past the last character we read.  */
 406   fp->__get_limit = fp->__buffer + nread;
 407
 408   /* Make it so the next `putc' will call __flshfp.  */
 409   fp->__put_limit = fp->__buffer;
 410
 411   /* Return the first character in the buffer.  */
 412   return (unsigned char) *fp->__bufp++;
 413 }
 414
 415
 416 /* Default I/O and room functions.  */
 417
 418 extern __io_read __stdio_read;
 419 extern __io_write __stdio_write;
 420 extern __io_seek __stdio_seek;
 421 extern __io_close __stdio_close;
 422 CONST __io_functions __default_io_functions =
 423   {
 424     __stdio_read, __stdio_write, __stdio_seek, __stdio_close
 425   };
 426
 427 CONST __room_functions __default_room_functions =
 428   {
 429     fillbuf, flushbuf
 430   };
 431
 432
 433 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
 434    This is the function used by putc and fflush.  */
 435 int
 436 DEFUN(__flshfp, (fp, c),
 437       register FILE *fp AND int c)
 438 {
 439   int flush_only = c == EOF;
 440
 441   if (!__validfp(fp) || !fp->__mode.__write)
 442     {
 443       errno = EINVAL;
 444       return EOF;
 445     }
 446
 447   if (ferror(fp))
 448     return EOF;
 449
 450   /* Make sure the stream is initialized (has functions and buffering).  */
 451   init_stream(fp);
 452
 453   if (!flush_only && fp->__get_limit == fp->__buffer &&
 454       fp->__bufp > fp->__buffer && fp->__bufp < fp->__buffer + fp->__bufsize)
 455     {
 456       /* The character will fit in the buffer, so put it there.  */
 457       *fp->__bufp++ = (unsigned char) c;
 458       if (fp->__linebuf && (unsigned char) c == '\n')
 459         flush_only = 1;
 460       else
 461         return (unsigned char) c;
 462     }
 463
 464   if (fp->__room_funcs.__output == NULL)
 465     {
 466       /* A NULL `output room' function means
 467          to always return an output error.  */
 468       fp->__error = 1;
 469       return EOF;
 470     }
 471
 472   if (!flush_only || fp->__bufp > fp->__buffer)
 473     {
 474       if (fp->__linebuf && fp->__bufp > fp->__buffer)
 475         /* This is a line-buffered stream, so its put-limit is
 476            set to the beginning of the buffer in order to force
 477            a __flshfp call on each putc.  We undo this hack here
 478            (by setting the limit to the end of the buffer) to simplify
 479            the interface with the output-room function.
 480            However, we must make sure we don't do this if there isn't
 481            actually anything in the buffer, because in that case we
 482            want to give the output-room function a chance to prime
 483            the stream for writing in whatever fashion turns it on.  */
 484         fp->__put_limit = fp->__buffer + fp->__bufsize;
 485
 486       /* Make room in the buffer.  */
 487       (*fp->__room_funcs.__output)(fp, flush_only ? EOF : (unsigned char) c);
 488
 489       if (fp->__linebuf)
 490         /* Set the end pointer to the beginning of the buffer,
 491            so the next `putc' call will force a call to this function
 492            (see comment above about line-buffered streams).  */
 493         fp->__put_limit = fp->__buffer;
 494     }
 495
 496   if (ferror (fp))
 497     return EOF;
 498   if (flush_only)
 499     return 0;
 500   return (unsigned char) c;
 501 }
 502
 503
 504 /* Fill the buffer for FP and return the first character read.
 505    This is the function used by getc.  */
 506 int
 507 DEFUN(__fillbf, (fp), register FILE *fp)
 508 {
 509   register int c;
 510   fpos_t new_target;
 511
 512   if (!__validfp(fp) || !fp->__mode.__read)
 513     {
 514       errno = EINVAL;
 515       return EOF;
 516     }
 517
 518   if (fp->__pushed_back)
 519     {
 520       /* Return the char pushed back by ungetc.  */
 521       fp->__bufp = fp->__pushback_bufp;
 522       fp->__pushed_back = 0;
 523       return fp->__pushback;
 524     }
 525
 526   /* Make sure the stream is initialized (has functions and buffering). */
 527   init_stream(fp);
 528
 529   /* If we're trying to read the first character of a new
 530      line of input from an unbuffered or line buffered stream,
 531      we must flush all line-buffered output streams. */
 532   if (fp->__buffer == NULL || fp->__linebuf)
 533     {
 534       register FILE *f;
 535       for (f = __stdio_head; f != NULL; f = f->__next)
 536         if (__validfp(f) && f->__linebuf && f->__mode.__write &&
 537             f->__put_limit > f->__buffer)
 538           (void) __flshfp(f, EOF);
 539     }
 540
 541   /* We want the beginning of the buffer to now
 542      map to just past the last data we read.  */
 543   new_target = fp->__target + (fp->__get_limit - fp->__buffer);
 544
 545   if (fp->__put_limit > fp->__buffer)
 546     {
 547       /* There is written data in the buffer.
 548          Flush it out.  */
 549       if (fp->__room_funcs.__output == NULL)
 550         fp->__error = 1;
 551       else
 552         (*fp->__room_funcs.__output)(fp, EOF);
 553     }
 554
 555   fp->__target = new_target;
 556
 557   if (ferror(fp))
 558     c = EOF;
 559   else if (fp->__room_funcs.__input != NULL)
 560     {
 561       c = (*fp->__room_funcs.__input)(fp);
 562       if (fp->__buffer == NULL)
 563         /* This is an unbuffered stream, so the target sync above
 564            won't do anything the next time around.  Instead, note that
 565            we have read one character.  The (nonexistent) buffer now
 566            maps to the position just past that character.  */
 567         ++fp->__target;
 568     }
 569   else
 570     {
 571       /* A NULL `input_room' function means always return EOF.  */
 572       fp->__eof = 1;
 573       c = EOF;
 574     }
 575
 576   return c;
 577 }
 578
 579
 580 /* Nuke a stream, but don't kill its link in the chain.  */
 581 void
 582 DEFUN(__invalidate, (stream), register FILE *stream)
 583 {
 584   /* Save its link.  */
 585   register FILE *next = stream->__next;
 586
 587   /* Pulverize the fucker.  */
 588   memset((PTR) stream, 0, sizeof(FILE));
 589
 590   /* Restore the deceased's link.  */
 591   stream->__next = next;
 592 }
 593
 594
 595 /* Abort with an error message.  */
 596 __NORETURN
 597 void
 598 DEFUN(__libc_fatal, (message), CONST char *message)
 599 {
 600   __stdio_errmsg(message, strlen(message));
 601   abort();
 602 }