libio/fileops.c

   1 /* Copyright (C) 1993, 1995, 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3    Written by Per Bothner <bothner@cygnus.com>.
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2, or (at
   8    your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this library; see the file COPYING.  If not, write to
  17    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  18    MA 02111-1307, USA.
  19
  20    As a special exception, if you link this library with files
  21    compiled with a GNU compiler to produce an executable, this does
  22    not cause the resulting executable to be covered by the GNU General
  23    Public License.  This exception does not however invalidate any
  24    other reasons why the executable file might be covered by the GNU
  25    General Public License.  */
  26
  27
  28 #ifndef _POSIX_SOURCE
  29 # define _POSIX_SOURCE
  30 #endif
  31 #include "libioP.h"
  32 #include <fcntl.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <string.h>
  36 #include <errno.h>
  37 #ifndef errno
  38 extern int errno;
  39 #endif
  40 #ifndef __set_errno
  41 # define __set_errno(Val) errno = (Val)
  42 #endif
  43
  44
  45 #ifdef _LIBC
  46 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
  47 # define close(FD) __close (FD)
  48 # define fstat(FD, Statbuf) __fstat (FD, Statbuf)
  49 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
  50 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
  51 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
  52 #endif
  53
  54 /* An fstream can be in at most one of put mode, get mode, or putback mode.
  55    Putback mode is a variant of get mode.
  56
  57    In a filebuf, there is only one current position, instead of two
  58    separate get and put pointers.  In get mode, the current position
  59    is that of gptr(); in put mode that of pptr().
  60
  61    The position in the buffer that corresponds to the position
  62    in external file system is normally _IO_read_end, except in putback
  63    mode, when it is _IO_save_end.
  64    If the field _fb._offset is >= 0, it gives the offset in
  65    the file as a whole corresponding to eGptr(). (?)
  66
  67    PUT MODE:
  68    If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
  69    and _IO_read_base are equal to each other.  These are usually equal
  70    to _IO_buf_base, though not necessarily if we have switched from
  71    get mode to put mode.  (The reason is to maintain the invariant
  72    that _IO_read_end corresponds to the external file position.)
  73    _IO_write_base is non-NULL and usually equal to _IO_base_base.
  74    We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
  75    The un-flushed character are those between _IO_write_base and _IO_write_ptr.
  76
  77    GET MODE:
  78    If a filebuf is in get or putback mode, eback() != egptr().
  79    In get mode, the unread characters are between gptr() and egptr().
  80    The OS file position corresponds to that of egptr().
  81
  82    PUTBACK MODE:
  83    Putback mode is used to remember "excess" characters that have
  84    been sputbackc'd in a separate putback buffer.
  85    In putback mode, the get buffer points to the special putback buffer.
  86    The unread characters are the characters between gptr() and egptr()
  87    in the putback buffer, as well as the area between save_gptr()
  88    and save_egptr(), which point into the original reserve buffer.
  89    (The pointers save_gptr() and save_egptr() are the values
  90    of gptr() and egptr() at the time putback mode was entered.)
  91    The OS position corresponds to that of save_egptr().
  92
  93    LINE BUFFERED OUTPUT:
  94    During line buffered output, _IO_write_base==base() && epptr()==base().
  95    However, ptr() may be anywhere between base() and ebuf().
  96    This forces a call to filebuf::overflow(int C) on every put.
  97    If there is more space in the buffer, and C is not a '\n',
  98    then C is inserted, and pptr() incremented.
  99
 100    UNBUFFERED STREAMS:
 101    If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
 102 */
 103
 104 #define CLOSED_FILEBUF_FLAGS \
 105   (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
 106
 107
 108 void
 109 _IO_file_init (fp)
 110      _IO_FILE *fp;
 111 {
 112   /* POSIX.1 allows another file handle to be used to change the position
 113      of our file descriptor.  Hence we actually don't know the actual
 114      position before we do the first fseek (and until a following fflush). */
 115   fp->_offset = _IO_pos_BAD;
 116   fp->_IO_file_flags |= CLOSED_FILEBUF_FLAGS;
 117
 118   _IO_link_in(fp);
 119   fp->_fileno = -1;
 120 }
 121
 122 int
 123 _IO_file_close_it (fp)
 124      _IO_FILE *fp;
 125 {
 126   int write_status, close_status;
 127   if (!_IO_file_is_open (fp))
 128     return EOF;
 129
 130   write_status = _IO_do_flush (fp);
 131
 132   _IO_unsave_markers(fp);
 133
 134   close_status = _IO_SYSCLOSE (fp);
 135
 136   /* Free buffer. */
 137   _IO_setb (fp, NULL, NULL, 0);
 138   _IO_setg (fp, NULL, NULL, NULL);
 139   _IO_setp (fp, NULL, NULL);
 140
 141   _IO_un_link (fp);
 142   fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
 143   fp->_fileno = EOF;
 144   fp->_offset = _IO_pos_BAD;
 145
 146   return close_status ? close_status : write_status;
 147 }
 148
 149 void
 150 _IO_file_finish (fp, dummy)
 151      _IO_FILE *fp;
 152      int dummy;
 153 {
 154   if (_IO_file_is_open (fp))
 155     {
 156       _IO_do_flush (fp);
 157       if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
 158         _IO_SYSCLOSE (fp);
 159     }
 160   _IO_default_finish (fp, 0);
 161 }
 162
 163 _IO_FILE *
 164 _IO_file_fopen (fp, filename, mode, is32not64)
 165      _IO_FILE *fp;
 166      const char *filename;
 167      const char *mode;
 168      int is32not64;
 169 {
 170   int oflags = 0, omode;
 171   int read_write, fdesc;
 172   int oprot = 0666;
 173   if (_IO_file_is_open (fp))
 174     return 0;
 175   switch (*mode++)
 176     {
 177     case 'r':
 178       omode = O_RDONLY;
 179       read_write = _IO_NO_WRITES;
 180       break;
 181     case 'w':
 182       omode = O_WRONLY;
 183       oflags = O_CREAT|O_TRUNC;
 184       read_write = _IO_NO_READS;
 185       break;
 186     case 'a':
 187       omode = O_WRONLY;
 188       oflags = O_CREAT|O_APPEND;
 189       read_write = _IO_NO_READS|_IO_IS_APPENDING;
 190       break;
 191     default:
 192       __set_errno (EINVAL);
 193       return NULL;
 194     }
 195   if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
 196     {
 197       omode = O_RDWR;
 198       read_write &= _IO_IS_APPENDING;
 199     }
 200 #ifdef _G_OPEN64
 201   fdesc = (is32not64
 202            ? open (filename, omode|oflags, oprot)
 203            : _G_OPEN64 (filename, omode|oflags, oprot));
 204 #else
 205   fdesc = open (filename, omode|oflags, oprot);
 206 #endif
 207   if (fdesc < 0)
 208     return NULL;
 209   fp->_fileno = fdesc;
 210   _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
 211   if (read_write & _IO_IS_APPENDING)
 212     if (_IO_SEEKOFF (fp, (_IO_off64_t)0, _IO_seek_end, _IOS_INPUT|_IOS_OUTPUT)
 213         == _IO_pos_BAD && errno != ESPIPE)
 214       return NULL;
 215   _IO_link_in (fp);
 216   return fp;
 217 }
 218
 219 _IO_FILE *
 220 _IO_file_attach (fp, fd)
 221      _IO_FILE *fp;
 222      int fd;
 223 {
 224   if (_IO_file_is_open (fp))
 225     return NULL;
 226   fp->_fileno = fd;
 227   fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
 228   fp->_flags |= _IO_DELETE_DONT_CLOSE;
 229   /* Get the current position of the file. */
 230   /* We have to do that since that may be junk. */
 231   fp->_offset = _IO_pos_BAD;
 232   if (_IO_SEEKOFF (fp, (_IO_off64_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
 233       == _IO_pos_BAD && errno != ESPIPE)
 234     return NULL;
 235   return fp;
 236 }
 237
 238 _IO_FILE *
 239 _IO_file_setbuf (fp, p, len)
 240      _IO_FILE *fp;
 241      char *p;
 242      _IO_ssize_t len;
 243 {
 244     if (_IO_default_setbuf (fp, p, len) == NULL)
 245       return NULL;
 246
 247     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 248       = fp->_IO_buf_base;
 249     _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 250
 251     return fp;
 252 }
 253
 254 /* Write TO_DO bytes from DATA to FP.
 255    Then mark FP as having empty buffers. */
 256
 257 int
 258 _IO_do_write (fp, data, to_do)
 259      _IO_FILE *fp;
 260      const char *data;
 261      _IO_size_t to_do;
 262 {
 263   _IO_size_t count;
 264   if (to_do == 0)
 265     return 0;
 266   if (fp->_flags & _IO_IS_APPENDING)
 267     /* On a system without a proper O_APPEND implementation,
 268        you would need to sys_seek(0, SEEK_END) here, but is
 269        is not needed nor desirable for Unix- or Posix-like systems.
 270        Instead, just indicate that offset (before and after) is
 271        unpredictable. */
 272     fp->_offset = _IO_pos_BAD;
 273   else if (fp->_IO_read_end != fp->_IO_write_base)
 274     {
 275       _IO_fpos64_t new_pos
 276         = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
 277       if (new_pos == _IO_pos_BAD)
 278         return EOF;
 279       fp->_offset = new_pos;
 280     }
 281   count = _IO_SYSWRITE (fp, data, to_do);
 282   if (fp->_cur_column)
 283     fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, to_do) + 1;
 284   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 285   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
 286   fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 287                        ? fp->_IO_buf_base : fp->_IO_buf_end);
 288   return count != to_do ? EOF : 0;
 289 }
 290
 291 int
 292 _IO_file_underflow (fp)
 293      _IO_FILE *fp;
 294 {
 295   _IO_ssize_t count;
 296 #if 0
 297   /* SysV does not make this test; take it out for compatibility */
 298   if (fp->_flags & _IO_EOF_SEEN)
 299     return (EOF);
 300 #endif
 301
 302   if (fp->_flags & _IO_NO_READS)
 303     {
 304       __set_errno (EBADF);
 305       return EOF;
 306     }
 307   if (fp->_IO_read_ptr < fp->_IO_read_end)
 308     return *(unsigned char *) fp->_IO_read_ptr;
 309
 310   if (fp->_IO_buf_base == NULL)
 311     _IO_doallocbuf (fp);
 312
 313   /* Flush all line buffered files before reading. */
 314   /* FIXME This can/should be moved to genops ?? */
 315   if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 316     _IO_flush_all_linebuffered ();
 317
 318   _IO_switch_to_get_mode (fp);
 319
 320   /* This is very tricky. We have to adjust those
 321      pointers before we call _IO_SYSREAD () since
 322      we may longjump () out while waiting for
 323      input. Those pointers may be screwed up. H.J. */
 324   fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
 325   fp->_IO_read_end = fp->_IO_buf_base;
 326   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 327     = fp->_IO_buf_base;
 328
 329   count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 330                        fp->_IO_buf_end - fp->_IO_buf_base);
 331   if (count <= 0)
 332     {
 333       if (count == 0)
 334         fp->_flags |= _IO_EOF_SEEN;
 335       else
 336         fp->_flags |= _IO_ERR_SEEN, count = 0;
 337   }
 338   fp->_IO_read_end += count;
 339   if (count == 0)
 340     return EOF;
 341   if (fp->_offset != _IO_pos_BAD)
 342     _IO_pos_adjust (fp->_offset, count);
 343   return *(unsigned char *) fp->_IO_read_ptr;
 344 }
 345
 346 int
 347 _IO_file_overflow (f, ch)
 348       _IO_FILE *f;
 349       int ch;
 350 {
 351   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
 352     {
 353       f->_flags |= _IO_ERR_SEEN;
 354       __set_errno (EBADF);
 355       return EOF;
 356     }
 357   /* If currently reading or no buffer allocated. */
 358   if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
 359     {
 360       /* Allocate a buffer if needed. */
 361       if (f->_IO_write_base == 0)
 362         {
 363           _IO_doallocbuf (f);
 364           _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
 365         }
 366       /* Otherwise must be currently reading.
 367          If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
 368          logically slide the buffer forwards one block (by setting the
 369          read pointers to all point at the beginning of the block).  This
 370          makes room for subsequent output.
 371          Otherwise, set the read pointers to _IO_read_end (leaving that
 372          alone, so it can continue to correspond to the external position). */
 373       if (f->_IO_read_ptr == f->_IO_buf_end)
 374         f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
 375       f->_IO_write_ptr = f->_IO_read_ptr;
 376       f->_IO_write_base = f->_IO_write_ptr;
 377       f->_IO_write_end = f->_IO_buf_end;
 378       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 379
 380       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 381         f->_IO_write_end = f->_IO_write_ptr;
 382       f->_flags |= _IO_CURRENTLY_PUTTING;
 383     }
 384   if (ch == EOF)
 385     return _IO_do_flush (f);
 386   if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
 387     if (_IO_do_flush (f) == EOF)
 388       return EOF;
 389   *f->_IO_write_ptr++ = ch;
 390   if ((f->_flags & _IO_UNBUFFERED)
 391       || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
 392     if (_IO_do_flush (f) == EOF)
 393       return EOF;
 394   return (unsigned char) ch;
 395 }
 396
 397 int
 398 _IO_file_sync (fp)
 399      _IO_FILE *fp;
 400 {
 401   _IO_size_t delta;
 402   int retval = 0;
 403
 404   _IO_cleanup_region_start ((void (*) __P ((void *))) _IO_funlockfile, fp);
 405   _IO_flockfile (fp);
 406   /*    char* ptr = cur_ptr(); */
 407   if (fp->_IO_write_ptr > fp->_IO_write_base)
 408     if (_IO_do_flush(fp)) return EOF;
 409   delta = fp->_IO_read_ptr - fp->_IO_read_end;
 410   if (delta != 0)
 411     {
 412 #ifdef TODO
 413       if (_IO_in_backup (fp))
 414         delta -= eGptr () - Gbase ();
 415 #endif
 416       _IO_off64_t new_pos = _IO_SYSSEEK (fp, delta, 1);
 417       if (new_pos != (_IO_off64_t) EOF)
 418         fp->_IO_read_end = fp->_IO_read_ptr;
 419 #ifdef ESPIPE
 420       else if (errno == ESPIPE)
 421         ; /* Ignore error from unseekable devices. */
 422 #endif
 423       else
 424         retval = EOF;
 425     }
 426   if (retval != EOF)
 427     fp->_offset = _IO_pos_BAD;
 428   /* FIXME: Cleanup - can this be shared? */
 429   /*    setg(base(), ptr, ptr); */
 430   _IO_cleanup_region_end (1);
 431   return retval;
 432 }
 433
 434 _IO_fpos64_t
 435 _IO_file_seekoff (fp, offset, dir, mode)
 436      _IO_FILE *fp;
 437      _IO_off64_t offset;
 438      int dir;
 439      int mode;
 440 {
 441   _IO_fpos64_t result;
 442   _IO_off64_t delta, new_offset;
 443   long count;
 444   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 445      offset of the underlying file must be exact.  */
 446   int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
 447                        && fp->_IO_write_base == fp->_IO_write_ptr);
 448
 449   if (mode == 0)
 450     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
 451
 452   /* Flush unwritten characters.
 453      (This may do an unneeded write if we seek within the buffer.
 454      But to be able to switch to reading, we would need to set
 455      egptr to ptr.  That can't be done in the current design,
 456      which assumes file_ptr() is eGptr.  Anyway, since we probably
 457      end up flushing when we close(), it doesn't make much difference.)
 458      FIXME: simulate mem-papped files. */
 459
 460   if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
 461     if (_IO_switch_to_get_mode (fp))
 462       return EOF;
 463
 464   if (fp->_IO_buf_base == NULL)
 465     {
 466       _IO_doallocbuf (fp);
 467       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 468       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 469     }
 470
 471   switch (dir)
 472     {
 473     case _IO_seek_cur:
 474       /* Adjust for read-ahead (bytes is buffer). */
 475       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 476       if (fp->_offset == _IO_pos_BAD)
 477         goto dumb;
 478       /* Make offset absolute, assuming current pointer is file_ptr(). */
 479       offset += _IO_pos_as_off (fp->_offset);
 480
 481       dir = _IO_seek_set;
 482       break;
 483     case _IO_seek_set:
 484       break;
 485     case _IO_seek_end:
 486       {
 487         struct _G_stat64 st;
 488         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 489           {
 490             offset += st.st_size;
 491             dir = _IO_seek_set;
 492           }
 493         else
 494           goto dumb;
 495       }
 496     }
 497   /* At this point, dir==_IO_seek_set. */
 498
 499   /* If destination is within current buffer, optimize: */
 500   if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
 501       && !_IO_in_backup (fp))
 502     {
 503       /* Offset relative to start of main get area. */
 504       _IO_fpos64_t rel_offset = (offset - fp->_offset
 505                                  + (fp->_IO_read_end - fp->_IO_read_base));
 506       if (rel_offset >= 0)
 507         {
 508 #if 0
 509           if (_IO_in_backup (fp))
 510             _IO_switch_to_main_get_area (fp);
 511 #endif
 512           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 513             {
 514               _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
 515                         fp->_IO_read_end);
 516               _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 517               return offset;
 518             }
 519 #ifdef TODO
 520             /* If we have streammarkers, seek forward by reading ahead. */
 521             if (_IO_have_markers (fp))
 522               {
 523                 int to_skip = rel_offset
 524                   - (fp->_IO_read_ptr - fp->_IO_read_base);
 525                 if (ignore (to_skip) != to_skip)
 526                   goto dumb;
 527                 return offset;
 528               }
 529 #endif
 530         }
 531 #ifdef TODO
 532       if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
 533         {
 534           if (!_IO_in_backup (fp))
 535             _IO_switch_to_backup_area (fp);
 536           gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 537           return offset;
 538         }
 539 #endif
 540     }
 541
 542 #ifdef TODO
 543   _IO_unsave_markers (fp);
 544 #endif
 545
 546   if (fp->_flags & _IO_NO_READS)
 547     goto dumb;
 548
 549   /* Try to seek to a block boundary, to improve kernel page management. */
 550   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
 551   delta = offset - new_offset;
 552   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
 553     {
 554       new_offset = offset;
 555       delta = 0;
 556     }
 557   result = _IO_SYSSEEK (fp, new_offset, 0);
 558   if (result < 0)
 559     return EOF;
 560   if (delta == 0)
 561     count = 0;
 562   else
 563     {
 564       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 565                            (must_be_exact
 566                             ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
 567       if (count < delta)
 568         {
 569           /* We weren't allowed to read, but try to seek the remainder. */
 570           offset = count == EOF ? delta : delta-count;
 571           dir = _IO_seek_cur;
 572           goto dumb;
 573         }
 574     }
 575   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
 576             fp->_IO_buf_base + count);
 577   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 578   fp->_offset = result + count;
 579   _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 580   return offset;
 581  dumb:
 582
 583   _IO_unsave_markers (fp);
 584   result = _IO_SYSSEEK (fp, offset, dir);
 585   if (result != EOF)
 586     _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 587   fp->_offset = result;
 588   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 589   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 590   return result;
 591 }
 592
 593 _IO_ssize_t
 594 _IO_file_read (fp, buf, size)
 595      _IO_FILE *fp;
 596      void *buf;
 597      _IO_ssize_t size;
 598 {
 599   return read (fp->_fileno, buf, size);
 600 }
 601
 602 _IO_fpos64_t
 603 _IO_file_seek (fp, offset, dir)
 604      _IO_FILE *fp;
 605      _IO_off64_t offset;
 606      int dir;
 607 {
 608 #ifdef _G_LSEEK64
 609   return _G_LSEEK64 (fp->_fileno, offset, dir);
 610 #else
 611   return lseek (fp->_fileno, offset, dir);
 612 #endif
 613 }
 614
 615 int
 616 _IO_file_stat (fp, st)
 617      _IO_FILE *fp;
 618      void *st;
 619 {
 620 #ifdef _G_STAT64
 621   return _G_FSTAT64 (fp->_fileno, (struct _G_stat64 *) st);
 622 #else
 623   return fstat (fp->_fileno, (struct _G_stat64 *) st);
 624 #endif
 625 }
 626
 627 int
 628 _IO_file_close (fp)
 629      _IO_FILE *fp;
 630 {
 631   return close (fp->_fileno);
 632 }
 633
 634 _IO_ssize_t
 635 _IO_file_write (f, data, n)
 636      _IO_FILE *f;
 637      const void *data;
 638      _IO_ssize_t n;
 639 {
 640   _IO_ssize_t to_do = n;
 641   while (to_do > 0)
 642     {
 643       _IO_ssize_t count = write (f->_fileno, data, to_do);
 644       if (count == EOF)
 645         {
 646           f->_flags |= _IO_ERR_SEEN;
 647           break;
 648         }
 649       to_do -= count;
 650       data = (void *) ((char *) data + count);
 651     }
 652   n -= to_do;
 653   if (f->_offset >= 0)
 654     f->_offset += n;
 655   return n;
 656 }
 657
 658 _IO_size_t
 659 _IO_file_xsputn (f, data, n)
 660      _IO_FILE *f;
 661      const void *data;
 662      _IO_size_t n;
 663 {
 664   register const char *s = (char *) data;
 665   _IO_size_t to_do = n;
 666   int must_flush = 0;
 667   _IO_size_t count;
 668
 669   if (n <= 0)
 670     return 0;
 671   /* This is an optimized implementation.
 672      If the amount to be written straddles a block boundary
 673      (or the filebuf is unbuffered), use sys_write directly. */
 674
 675   /* First figure out how much space is available in the buffer. */
 676   count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
 677   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 678     {
 679       count = f->_IO_buf_end - f->_IO_write_ptr;
 680       if (count >= n)
 681         {
 682           register const char *p;
 683           for (p = s + n; p > s; )
 684             {
 685               if (*--p == '\n')
 686                 {
 687                   count = p - s + 1;
 688                   must_flush = 1;
 689                   break;
 690                 }
 691             }
 692         }
 693     }
 694   /* Then fill the buffer. */
 695   if (count > 0)
 696     {
 697       if (count > to_do)
 698         count = to_do;
 699       if (count > 20)
 700         {
 701           memcpy (f->_IO_write_ptr, s, count);
 702           s += count;
 703         }
 704       else
 705         {
 706           register char *p = f->_IO_write_ptr;
 707           register int i = (int) count;
 708           while (--i >= 0)
 709             *p++ = *s++;
 710         }
 711       f->_IO_write_ptr += count;
 712       to_do -= count;
 713     }
 714   if (to_do + must_flush > 0)
 715     {
 716       _IO_size_t block_size, dont_write;
 717       /* Next flush the (full) buffer. */
 718       if (__overflow (f, EOF) == EOF)
 719         return n - to_do;
 720
 721       /* Try to maintain alignment: write a whole number of blocks.
 722          dont_write is what gets left over. */
 723       block_size = f->_IO_buf_end - f->_IO_buf_base;
 724       dont_write = block_size >= 128 ? to_do % block_size : 0;
 725
 726       count = to_do - dont_write;
 727       if (_IO_do_write (f, s, count) == EOF)
 728         return n - to_do;
 729       to_do = dont_write;
 730
 731       /* Now write out the remainder.  Normally, this will fit in the
 732          buffer, but it's somewhat messier for line-buffered files,
 733          so we let _IO_default_xsputn handle the general case. */
 734       if (dont_write)
 735         to_do -= _IO_default_xsputn (f, s+count, dont_write);
 736     }
 737   return n - to_do;
 738 }
 739
 740 #if 0
 741 /* Work in progress */
 742 _IO_size_t
 743 _IO_file_xsgetn (fp, data, n)
 744      _IO_FILE *fp;
 745      void *data;
 746      _IO_size_t n;
 747 {
 748   register _IO_size_t more = n;
 749   register char *s = data;
 750   for (;;)
 751     {
 752       /* Data available. */
 753       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr;
 754       if (count > 0)
 755         {
 756           if (count > more)
 757             count = more;
 758           if (count > 20)
 759             {
 760               memcpy (s, fp->_IO_read_ptr, count);
 761               s += count;
 762               fp->_IO_read_ptr += count;
 763             }
 764           else if (count <= 0)
 765             count = 0;
 766           else
 767             {
 768               register char *p = fp->_IO_read_ptr;
 769               register int i = (int) count;
 770               while (--i >= 0)
 771                 *s++ = *p++;
 772               fp->_IO_read_ptr = p;
 773             }
 774             more -= count;
 775         }
 776 #if 0
 777       if (! _IO_in put_mode (fp)
 778           && ! _IO_have_markers (fp) && ! IO_have_backup (fp))
 779         {
 780           /* This is an optimization of _IO_file_underflow */
 781           if (fp->_flags & _IO_NO_READS)
 782             break;
 783           /* If we're reading a lot of data, don't bother allocating
 784              a buffer.  But if we're only reading a bit, perhaps we should ??*/
 785           if (count <= 512 && fp->_IO_buf_base == NULL)
 786             _IO_doallocbuf (fp);
 787           if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 788             _IO_flush_all_linebuffered ();
 789
 790           _IO_switch_to_get_mode (fp); ???;
 791           count = _IO_SYSREAD (fp, s, more);
 792           if (count <= 0)
 793              {
 794                if (count == 0)
 795                  fp->_flags |= _IO_EOF_SEEN;
 796                else
 797                  fp->_flags |= _IO_ERR_SEEN, count = 0;
 798              }
 799
 800           s += count;
 801           more -= count;
 802         }
 803 #endif
 804       if (more == 0 || __underflow (fp) == EOF)
 805         break;
 806     }
 807   return n - more;
 808 }
 809 #endif
 810
 811 struct _IO_jump_t _IO_file_jumps =
 812 {
 813   JUMP_INIT_DUMMY,
 814   JUMP_INIT(finish, _IO_file_finish),
 815   JUMP_INIT(overflow, _IO_file_overflow),
 816   JUMP_INIT(underflow, _IO_file_underflow),
 817   JUMP_INIT(uflow, _IO_default_uflow),
 818   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 819   JUMP_INIT(xsputn, _IO_file_xsputn),
 820   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 821   JUMP_INIT(seekoff, _IO_file_seekoff),
 822   JUMP_INIT(seekpos, _IO_default_seekpos),
 823   JUMP_INIT(setbuf, _IO_file_setbuf),
 824   JUMP_INIT(sync, _IO_file_sync),
 825   JUMP_INIT(doallocate, _IO_file_doallocate),
 826   JUMP_INIT(read, _IO_file_read),
 827   JUMP_INIT(write, _IO_file_write),
 828   JUMP_INIT(seek, _IO_file_seek),
 829   JUMP_INIT(close, _IO_file_close),
 830   JUMP_INIT(stat, _IO_file_stat),
 831   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 832   JUMP_INIT(imbue, _IO_default_imbue)
 833 };