libio/oldfileops.c

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