libio/oldfileops.c

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