libio/oldfileops.c

   1 /* Copyright (C) 1993, 1995, 1997-2004, 2005, 2007, 2011-2012
   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, see
  18    <http://www.gnu.org/licenses/>.
  19
  20    As a special exception, if you link the code in this file with
  21    files compiled with a GNU compiler to produce an executable,
  22    that does not cause the resulting executable to be covered by
  23    the GNU Lesser General Public License.  This exception does not
  24    however invalidate any other reasons why the executable file
  25    might be covered by the GNU Lesser General Public License.
  26    This exception applies to code released by its copyright holders
  27    in files containing the exception.  */
  28
  29 /* This is a compatibility file.  If we don't build the libc with
  30    versioning don't compile this file.  */
  31 #include <shlib-compat.h>
  32 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
  33
  34 #ifndef _POSIX_SOURCE
  35 # define _POSIX_SOURCE
  36 #endif
  37 #define _IO_USE_OLD_IO_FILE
  38 #include "libioP.h"
  39 #include <fcntl.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <string.h>
  43 #include <errno.h>
  44 #include <stdlib.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_base_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   INTUSE(_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   INTUSE(_IO_unsave_markers) (fp);
 154
 155   close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
 156                   ? _IO_SYSCLOSE (fp) : 0);
 157
 158   /* Free buffer. */
 159   INTUSE(_IO_setb) (fp, NULL, NULL, 0);
 160   _IO_setg (fp, NULL, NULL, NULL);
 161   _IO_setp (fp, NULL, NULL);
 162
 163   INTUSE(_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   INTUSE(_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   INTUSE(_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 = INTUSE(_IO_adjust_column) (fp->_cur_column - 1, data,
 315                                                  count) + 1;
 316   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 317   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
 318   fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 319                        ? fp->_IO_buf_base : fp->_IO_buf_end);
 320   return count;
 321 }
 322
 323 int
 324 attribute_compat_text_section
 325 _IO_old_file_underflow (fp)
 326      _IO_FILE *fp;
 327 {
 328   _IO_ssize_t count;
 329 #if 0
 330   /* SysV does not make this test; take it out for compatibility */
 331   if (fp->_flags & _IO_EOF_SEEN)
 332     return (EOF);
 333 #endif
 334
 335   if (fp->_flags & _IO_NO_READS)
 336     {
 337       fp->_flags |= _IO_ERR_SEEN;
 338       __set_errno (EBADF);
 339       return EOF;
 340     }
 341   if (fp->_IO_read_ptr < fp->_IO_read_end)
 342     return *(unsigned char *) fp->_IO_read_ptr;
 343
 344   if (fp->_IO_buf_base == NULL)
 345     {
 346       /* Maybe we already have a push back pointer.  */
 347       if (fp->_IO_save_base != NULL)
 348         {
 349           free (fp->_IO_save_base);
 350           fp->_flags &= ~_IO_IN_BACKUP;
 351         }
 352       INTUSE(_IO_doallocbuf) (fp);
 353     }
 354
 355   /* Flush all line buffered files before reading. */
 356   /* FIXME This can/should be moved to genops ?? */
 357   if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 358     INTUSE(_IO_flush_all_linebuffered) ();
 359
 360   INTUSE(_IO_switch_to_get_mode) (fp);
 361
 362   /* This is very tricky. We have to adjust those
 363      pointers before we call _IO_SYSREAD () since
 364      we may longjump () out while waiting for
 365      input. Those pointers may be screwed up. H.J. */
 366   fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
 367   fp->_IO_read_end = fp->_IO_buf_base;
 368   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 369     = fp->_IO_buf_base;
 370
 371   count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 372                        fp->_IO_buf_end - fp->_IO_buf_base);
 373   if (count <= 0)
 374     {
 375       if (count == 0)
 376         fp->_flags |= _IO_EOF_SEEN;
 377       else
 378         fp->_flags |= _IO_ERR_SEEN, count = 0;
 379   }
 380   fp->_IO_read_end += count;
 381   if (count == 0)
 382     return EOF;
 383   if (fp->_old_offset != _IO_pos_BAD)
 384     _IO_pos_adjust (fp->_old_offset, count);
 385   return *(unsigned char *) fp->_IO_read_ptr;
 386 }
 387
 388 int
 389 attribute_compat_text_section
 390 _IO_old_file_overflow (f, ch)
 391       _IO_FILE *f;
 392       int ch;
 393 {
 394   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
 395     {
 396       f->_flags |= _IO_ERR_SEEN;
 397       __set_errno (EBADF);
 398       return EOF;
 399     }
 400   /* If currently reading or no buffer allocated. */
 401   if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
 402     {
 403       /* Allocate a buffer if needed. */
 404       if (f->_IO_write_base == 0)
 405         {
 406           INTUSE(_IO_doallocbuf) (f);
 407           _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
 408         }
 409       /* Otherwise must be currently reading.
 410          If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
 411          logically slide the buffer forwards one block (by setting the
 412          read pointers to all point at the beginning of the block).  This
 413          makes room for subsequent output.
 414          Otherwise, set the read pointers to _IO_read_end (leaving that
 415          alone, so it can continue to correspond to the external position). */
 416       if (f->_IO_read_ptr == f->_IO_buf_end)
 417         f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
 418       f->_IO_write_ptr = f->_IO_read_ptr;
 419       f->_IO_write_base = f->_IO_write_ptr;
 420       f->_IO_write_end = f->_IO_buf_end;
 421       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 422
 423       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 424         f->_IO_write_end = f->_IO_write_ptr;
 425       f->_flags |= _IO_CURRENTLY_PUTTING;
 426     }
 427   if (ch == EOF)
 428     return _IO_old_do_flush (f);
 429   if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
 430     if (_IO_old_do_flush (f) == EOF)
 431       return EOF;
 432   *f->_IO_write_ptr++ = ch;
 433   if ((f->_flags & _IO_UNBUFFERED)
 434       || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
 435     if (_IO_old_do_flush (f) == EOF)
 436       return EOF;
 437   return (unsigned char) ch;
 438 }
 439
 440 int
 441 attribute_compat_text_section
 442 _IO_old_file_sync (fp)
 443      _IO_FILE *fp;
 444 {
 445   _IO_ssize_t delta;
 446   int retval = 0;
 447
 448   /*    char* ptr = cur_ptr(); */
 449   if (fp->_IO_write_ptr > fp->_IO_write_base)
 450     if (_IO_old_do_flush(fp)) return EOF;
 451   delta = fp->_IO_read_ptr - fp->_IO_read_end;
 452   if (delta != 0)
 453     {
 454 #ifdef TODO
 455       if (_IO_in_backup (fp))
 456         delta -= eGptr () - Gbase ();
 457 #endif
 458       _IO_off_t new_pos = _IO_SYSSEEK (fp, delta, 1);
 459       if (new_pos != (_IO_off_t) EOF)
 460         fp->_IO_read_end = fp->_IO_read_ptr;
 461 #ifdef ESPIPE
 462       else if (errno == ESPIPE)
 463         ; /* Ignore error from unseekable devices. */
 464 #endif
 465       else
 466         retval = EOF;
 467     }
 468   if (retval != EOF)
 469     fp->_old_offset = _IO_pos_BAD;
 470   /* FIXME: Cleanup - can this be shared? */
 471   /*    setg(base(), ptr, ptr); */
 472   return retval;
 473 }
 474
 475 _IO_off64_t
 476 attribute_compat_text_section
 477 _IO_old_file_seekoff (fp, offset, dir, mode)
 478      _IO_FILE *fp;
 479      _IO_off64_t offset;
 480      int dir;
 481      int mode;
 482 {
 483   _IO_off_t result;
 484   _IO_off64_t delta, new_offset;
 485   long count;
 486   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 487      offset of the underlying file must be exact.  */
 488   int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
 489                        && fp->_IO_write_base == fp->_IO_write_ptr);
 490
 491   if (mode == 0)
 492     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
 493
 494   /* Flush unwritten characters.
 495      (This may do an unneeded write if we seek within the buffer.
 496      But to be able to switch to reading, we would need to set
 497      egptr to ptr.  That can't be done in the current design,
 498      which assumes file_ptr() is eGptr.  Anyway, since we probably
 499      end up flushing when we close(), it doesn't make much difference.)
 500      FIXME: simulate mem-papped files. */
 501
 502   if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
 503     if (INTUSE(_IO_switch_to_get_mode) (fp))
 504       return EOF;
 505
 506   if (fp->_IO_buf_base == NULL)
 507     {
 508       /* It could be that we already have a pushback buffer.  */
 509       if (fp->_IO_read_base != NULL)
 510         {
 511           free (fp->_IO_read_base);
 512           fp->_flags &= ~_IO_IN_BACKUP;
 513         }
 514       INTUSE(_IO_doallocbuf) (fp);
 515       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 516       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 517     }
 518
 519   switch (dir)
 520     {
 521     case _IO_seek_cur:
 522       /* Adjust for read-ahead (bytes is buffer). */
 523       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 524       if (fp->_old_offset == _IO_pos_BAD)
 525         goto dumb;
 526       /* Make offset absolute, assuming current pointer is file_ptr(). */
 527       offset += fp->_old_offset;
 528
 529       dir = _IO_seek_set;
 530       break;
 531     case _IO_seek_set:
 532       break;
 533     case _IO_seek_end:
 534       {
 535         struct _G_stat64 st;
 536         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 537           {
 538             offset += st.st_size;
 539             dir = _IO_seek_set;
 540           }
 541         else
 542           goto dumb;
 543       }
 544     }
 545   /* At this point, dir==_IO_seek_set. */
 546
 547   /* If we are only interested in the current position we've found it now.  */
 548   if (mode == 0)
 549     return offset;
 550
 551   /* If destination is within current buffer, optimize: */
 552   if (fp->_old_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
 553       && !_IO_in_backup (fp))
 554     {
 555       /* Offset relative to start of main get area. */
 556       _IO_off_t rel_offset = (offset - fp->_old_offset
 557                               + (fp->_IO_read_end - fp->_IO_read_base));
 558       if (rel_offset >= 0)
 559         {
 560 #if 0
 561           if (_IO_in_backup (fp))
 562             _IO_switch_to_main_get_area (fp);
 563 #endif
 564           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 565             {
 566               _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
 567                         fp->_IO_read_end);
 568               _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 569               {
 570                 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 571                 goto resync;
 572               }
 573             }
 574 #ifdef TODO
 575             /* If we have streammarkers, seek forward by reading ahead. */
 576             if (_IO_have_markers (fp))
 577               {
 578                 int to_skip = rel_offset
 579                   - (fp->_IO_read_ptr - fp->_IO_read_base);
 580                 if (ignore (to_skip) != to_skip)
 581                   goto dumb;
 582                 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 583                 goto resync;
 584               }
 585 #endif
 586         }
 587 #ifdef TODO
 588       if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
 589         {
 590           if (!_IO_in_backup (fp))
 591             _IO_switch_to_backup_area (fp);
 592           gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 593           _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 594           goto resync;
 595         }
 596 #endif
 597     }
 598
 599 #ifdef TODO
 600   INTUSE(_IO_unsave_markers) (fp);
 601 #endif
 602
 603   if (fp->_flags & _IO_NO_READS)
 604     goto dumb;
 605
 606   /* Try to seek to a block boundary, to improve kernel page management. */
 607   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
 608   delta = offset - new_offset;
 609   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
 610     {
 611       new_offset = offset;
 612       delta = 0;
 613     }
 614   result = _IO_SYSSEEK (fp, new_offset, 0);
 615   if (result < 0)
 616     return EOF;
 617   if (delta == 0)
 618     count = 0;
 619   else
 620     {
 621       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 622                            (must_be_exact
 623                             ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
 624       if (count < delta)
 625         {
 626           /* We weren't allowed to read, but try to seek the remainder. */
 627           offset = count == EOF ? delta : delta-count;
 628           dir = _IO_seek_cur;
 629           goto dumb;
 630         }
 631     }
 632   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
 633             fp->_IO_buf_base + count);
 634   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 635   fp->_old_offset = result + count;
 636   _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 637   return offset;
 638  dumb:
 639
 640   INTUSE(_IO_unsave_markers) (fp);
 641   result = _IO_SYSSEEK (fp, offset, dir);
 642   if (result != EOF)
 643     {
 644       _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 645       fp->_old_offset = result;
 646       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 647       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 648     }
 649   return result;
 650
 651 resync:
 652   /* We need to do it since it is possible that the file offset in
 653      the kernel may be changed behind our back. It may happen when
 654      we fopen a file and then do a fork. One process may access the
 655      file and the kernel file offset will be changed. */
 656   if (fp->_old_offset >= 0)
 657     _IO_SYSSEEK (fp, fp->_old_offset, 0);
 658
 659   return offset;
 660 }
 661
 662 _IO_ssize_t
 663 attribute_compat_text_section
 664 _IO_old_file_write (f, data, n)
 665      _IO_FILE *f;
 666      const void *data;
 667      _IO_ssize_t n;
 668 {
 669   _IO_ssize_t to_do = n;
 670   while (to_do > 0)
 671     {
 672       _IO_ssize_t count = write (f->_fileno, data, to_do);
 673       if (count == EOF)
 674         {
 675           f->_flags |= _IO_ERR_SEEN;
 676           break;
 677         }
 678       to_do -= count;
 679       data = (void *) ((char *) data + count);
 680     }
 681   n -= to_do;
 682   if (f->_old_offset >= 0)
 683     f->_old_offset += n;
 684   return n;
 685 }
 686
 687 _IO_size_t
 688 attribute_compat_text_section
 689 _IO_old_file_xsputn (f, data, n)
 690      _IO_FILE *f;
 691      const void *data;
 692      _IO_size_t n;
 693 {
 694   register const char *s = (char *) data;
 695   _IO_size_t to_do = n;
 696   int must_flush = 0;
 697   _IO_size_t count = 0;
 698
 699   if (n <= 0)
 700     return 0;
 701   /* This is an optimized implementation.
 702      If the amount to be written straddles a block boundary
 703      (or the filebuf is unbuffered), use sys_write directly. */
 704
 705   /* First figure out how much space is available in the buffer. */
 706   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 707     {
 708       count = f->_IO_buf_end - f->_IO_write_ptr;
 709       if (count >= n)
 710         {
 711           register const char *p;
 712           for (p = s + n; p > s; )
 713             {
 714               if (*--p == '\n')
 715                 {
 716                   count = p - s + 1;
 717                   must_flush = 1;
 718                   break;
 719                 }
 720             }
 721         }
 722     }
 723   else if (f->_IO_write_end > f->_IO_write_ptr)
 724     count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
 725
 726   /* Then fill the buffer. */
 727   if (count > 0)
 728     {
 729       if (count > to_do)
 730         count = to_do;
 731       if (count > 20)
 732         {
 733 #ifdef _LIBC
 734           f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
 735 #else
 736           memcpy (f->_IO_write_ptr, s, count);
 737           f->_IO_write_ptr += count;
 738 #endif
 739           s += count;
 740         }
 741       else
 742         {
 743           register char *p = f->_IO_write_ptr;
 744           register int i = (int) count;
 745           while (--i >= 0)
 746             *p++ = *s++;
 747           f->_IO_write_ptr = p;
 748         }
 749       to_do -= count;
 750     }
 751   if (to_do + must_flush > 0)
 752     {
 753       _IO_size_t block_size, do_write;
 754       /* Next flush the (full) buffer. */
 755       if (__overflow (f, EOF) == EOF)
 756         return to_do == 0 ? EOF : n - to_do;
 757
 758       /* Try to maintain alignment: write a whole number of blocks.
 759          dont_write is what gets left over. */
 760       block_size = f->_IO_buf_end - f->_IO_buf_base;
 761       do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
 762
 763       if (do_write)
 764         {
 765           count = old_do_write (f, s, do_write);
 766           to_do -= count;
 767           if (count < do_write)
 768             return n - to_do;
 769         }
 770
 771       /* Now write out the remainder.  Normally, this will fit in the
 772          buffer, but it's somewhat messier for line-buffered files,
 773          so we let _IO_default_xsputn handle the general case. */
 774       if (to_do)
 775         to_do -= INTUSE(_IO_default_xsputn) (f, s+do_write, to_do);
 776     }
 777   return n - to_do;
 778 }
 779
 780
 781 const struct _IO_jump_t _IO_old_file_jumps =
 782 {
 783   JUMP_INIT_DUMMY,
 784   JUMP_INIT(finish, _IO_old_file_finish),
 785   JUMP_INIT(overflow, _IO_old_file_overflow),
 786   JUMP_INIT(underflow, _IO_old_file_underflow),
 787   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
 788   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
 789   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 790   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
 791   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 792   JUMP_INIT(seekpos, _IO_default_seekpos),
 793   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 794   JUMP_INIT(sync, _IO_old_file_sync),
 795   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
 796   JUMP_INIT(read, INTUSE(_IO_file_read)),
 797   JUMP_INIT(write, _IO_old_file_write),
 798   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
 799   JUMP_INIT(close, INTUSE(_IO_file_close)),
 800   JUMP_INIT(stat, INTUSE(_IO_file_stat))
 801 };
 802
 803 compat_symbol (libc, _IO_old_do_write, _IO_do_write, GLIBC_2_0);
 804 compat_symbol (libc, _IO_old_file_attach, _IO_file_attach, GLIBC_2_0);
 805 compat_symbol (libc, _IO_old_file_close_it, _IO_file_close_it, GLIBC_2_0);
 806 compat_symbol (libc, _IO_old_file_finish, _IO_file_finish, GLIBC_2_0);
 807 compat_symbol (libc, _IO_old_file_fopen, _IO_file_fopen, GLIBC_2_0);
 808 compat_symbol (libc, _IO_old_file_init, _IO_file_init, GLIBC_2_0);
 809 compat_symbol (libc, _IO_old_file_setbuf, _IO_file_setbuf, GLIBC_2_0);
 810 compat_symbol (libc, _IO_old_file_sync, _IO_file_sync, GLIBC_2_0);
 811 compat_symbol (libc, _IO_old_file_overflow, _IO_file_overflow, GLIBC_2_0);
 812 compat_symbol (libc, _IO_old_file_seekoff, _IO_file_seekoff, GLIBC_2_0);
 813 compat_symbol (libc, _IO_old_file_underflow, _IO_file_underflow, GLIBC_2_0);
 814 compat_symbol (libc, _IO_old_file_write, _IO_file_write, GLIBC_2_0);
 815 compat_symbol (libc, _IO_old_file_xsputn, _IO_file_xsputn, GLIBC_2_0);
 816
 817 #endif