libio/oldfileops.c

   1 /* Copyright (C) 1993, 1995, 1997-2004, 2005, 2007
   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 = _IO_SYSCLOSE (fp);
 159
 160   /* Free buffer. */
 161   INTUSE(_IO_setb) (fp, NULL, NULL, 0);
 162   _IO_setg (fp, NULL, NULL, NULL);
 163   _IO_setp (fp, NULL, NULL);
 164
 165   INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);
 166   fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
 167   fp->_fileno = -1;
 168   fp->_old_offset = _IO_pos_BAD;
 169
 170   return close_status ? close_status : write_status;
 171 }
 172
 173 void
 174 attribute_compat_text_section
 175 _IO_old_file_finish (fp, dummy)
 176      _IO_FILE *fp;
 177      int dummy;
 178 {
 179   if (_IO_file_is_open (fp))
 180     {
 181       _IO_old_do_flush (fp);
 182       if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
 183         _IO_SYSCLOSE (fp);
 184     }
 185   INTUSE(_IO_default_finish) (fp, 0);
 186 }
 187
 188 _IO_FILE *
 189 attribute_compat_text_section
 190 _IO_old_file_fopen (fp, filename, mode)
 191      _IO_FILE *fp;
 192      const char *filename;
 193      const char *mode;
 194 {
 195   int oflags = 0, omode;
 196   int read_write, fdesc;
 197   int oprot = 0666;
 198   if (_IO_file_is_open (fp))
 199     return 0;
 200   switch (*mode++)
 201     {
 202     case 'r':
 203       omode = O_RDONLY;
 204       read_write = _IO_NO_WRITES;
 205       break;
 206     case 'w':
 207       omode = O_WRONLY;
 208       oflags = O_CREAT|O_TRUNC;
 209       read_write = _IO_NO_READS;
 210       break;
 211     case 'a':
 212       omode = O_WRONLY;
 213       oflags = O_CREAT|O_APPEND;
 214       read_write = _IO_NO_READS|_IO_IS_APPENDING;
 215       break;
 216     default:
 217       __set_errno (EINVAL);
 218       return NULL;
 219     }
 220   if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
 221     {
 222       omode = O_RDWR;
 223       read_write &= _IO_IS_APPENDING;
 224     }
 225   fdesc = open (filename, omode|oflags, oprot);
 226   if (fdesc < 0)
 227     return NULL;
 228   fp->_fileno = fdesc;
 229   _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
 230   if (read_write & _IO_IS_APPENDING)
 231     if (_IO_SEEKOFF (fp, (_IO_off_t)0, _IO_seek_end, _IOS_INPUT|_IOS_OUTPUT)
 232         == _IO_pos_BAD && errno != ESPIPE)
 233       return NULL;
 234   INTUSE(_IO_link_in) ((struct _IO_FILE_plus *) fp);
 235   return fp;
 236 }
 237
 238 _IO_FILE *
 239 attribute_compat_text_section
 240 _IO_old_file_attach (fp, fd)
 241      _IO_FILE *fp;
 242      int fd;
 243 {
 244   if (_IO_file_is_open (fp))
 245     return NULL;
 246   fp->_fileno = fd;
 247   fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
 248   fp->_flags |= _IO_DELETE_DONT_CLOSE;
 249   /* Get the current position of the file. */
 250   /* We have to do that since that may be junk. */
 251   fp->_old_offset = _IO_pos_BAD;
 252   if (_IO_SEEKOFF (fp, (_IO_off_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
 253       == _IO_pos_BAD && errno != ESPIPE)
 254     return NULL;
 255   return fp;
 256 }
 257
 258 _IO_FILE *
 259 attribute_compat_text_section
 260 _IO_old_file_setbuf (fp, p, len)
 261      _IO_FILE *fp;
 262      char *p;
 263      _IO_ssize_t len;
 264 {
 265     if (_IO_default_setbuf (fp, p, len) == NULL)
 266       return NULL;
 267
 268     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 269       = fp->_IO_buf_base;
 270     _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 271
 272     return fp;
 273 }
 274
 275 static int old_do_write (_IO_FILE *, const char *, _IO_size_t);
 276
 277 /* Write TO_DO bytes from DATA to FP.
 278    Then mark FP as having empty buffers. */
 279
 280 int
 281 attribute_compat_text_section
 282 _IO_old_do_write (fp, data, to_do)
 283      _IO_FILE *fp;
 284      const char *data;
 285      _IO_size_t to_do;
 286 {
 287   return (to_do == 0 || (_IO_size_t) old_do_write (fp, data, to_do) == to_do)
 288          ? 0 : EOF;
 289 }
 290
 291 static int
 292 attribute_compat_text_section
 293 old_do_write (fp, data, to_do)
 294      _IO_FILE *fp;
 295      const char *data;
 296      _IO_size_t to_do;
 297 {
 298   _IO_size_t count;
 299   if (fp->_flags & _IO_IS_APPENDING)
 300     /* On a system without a proper O_APPEND implementation,
 301        you would need to sys_seek(0, SEEK_END) here, but is
 302        is not needed nor desirable for Unix- or Posix-like systems.
 303        Instead, just indicate that offset (before and after) is
 304        unpredictable. */
 305     fp->_old_offset = _IO_pos_BAD;
 306   else if (fp->_IO_read_end != fp->_IO_write_base)
 307     {
 308       _IO_off_t new_pos
 309         = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
 310       if (new_pos == _IO_pos_BAD)
 311         return 0;
 312       fp->_old_offset = new_pos;
 313     }
 314   count = _IO_SYSWRITE (fp, data, to_do);
 315   if (fp->_cur_column && count)
 316     fp->_cur_column = INTUSE(_IO_adjust_column) (fp->_cur_column - 1, data,
 317                                                  count) + 1;
 318   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 319   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
 320   fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 321                        ? fp->_IO_buf_base : fp->_IO_buf_end);
 322   return count;
 323 }
 324
 325 int
 326 attribute_compat_text_section
 327 _IO_old_file_underflow (fp)
 328      _IO_FILE *fp;
 329 {
 330   _IO_ssize_t count;
 331 #if 0
 332   /* SysV does not make this test; take it out for compatibility */
 333   if (fp->_flags & _IO_EOF_SEEN)
 334     return (EOF);
 335 #endif
 336
 337   if (fp->_flags & _IO_NO_READS)
 338     {
 339       fp->_flags |= _IO_ERR_SEEN;
 340       __set_errno (EBADF);
 341       return EOF;
 342     }
 343   if (fp->_IO_read_ptr < fp->_IO_read_end)
 344     return *(unsigned char *) fp->_IO_read_ptr;
 345
 346   if (fp->_IO_buf_base == NULL)
 347     {
 348       /* Maybe we already have a push back pointer.  */
 349       if (fp->_IO_save_base != NULL)
 350         {
 351           free (fp->_IO_save_base);
 352           fp->_flags &= ~_IO_IN_BACKUP;
 353         }
 354       INTUSE(_IO_doallocbuf) (fp);
 355     }
 356
 357   /* Flush all line buffered files before reading. */
 358   /* FIXME This can/should be moved to genops ?? */
 359   if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 360     INTUSE(_IO_flush_all_linebuffered) ();
 361
 362   INTUSE(_IO_switch_to_get_mode) (fp);
 363
 364   /* This is very tricky. We have to adjust those
 365      pointers before we call _IO_SYSREAD () since
 366      we may longjump () out while waiting for
 367      input. Those pointers may be screwed up. H.J. */
 368   fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
 369   fp->_IO_read_end = fp->_IO_buf_base;
 370   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 371     = fp->_IO_buf_base;
 372
 373   count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 374                        fp->_IO_buf_end - fp->_IO_buf_base);
 375   if (count <= 0)
 376     {
 377       if (count == 0)
 378         fp->_flags |= _IO_EOF_SEEN;
 379       else
 380         fp->_flags |= _IO_ERR_SEEN, count = 0;
 381   }
 382   fp->_IO_read_end += count;
 383   if (count == 0)
 384     return EOF;
 385   if (fp->_old_offset != _IO_pos_BAD)
 386     _IO_pos_adjust (fp->_old_offset, count);
 387   return *(unsigned char *) fp->_IO_read_ptr;
 388 }
 389
 390 int
 391 attribute_compat_text_section
 392 _IO_old_file_overflow (f, ch)
 393       _IO_FILE *f;
 394       int ch;
 395 {
 396   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
 397     {
 398       f->_flags |= _IO_ERR_SEEN;
 399       __set_errno (EBADF);
 400       return EOF;
 401     }
 402   /* If currently reading or no buffer allocated. */
 403   if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
 404     {
 405       /* Allocate a buffer if needed. */
 406       if (f->_IO_write_base == 0)
 407         {
 408           INTUSE(_IO_doallocbuf) (f);
 409           _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
 410         }
 411       /* Otherwise must be currently reading.
 412          If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
 413          logically slide the buffer forwards one block (by setting the
 414          read pointers to all point at the beginning of the block).  This
 415          makes room for subsequent output.
 416          Otherwise, set the read pointers to _IO_read_end (leaving that
 417          alone, so it can continue to correspond to the external position). */
 418       if (f->_IO_read_ptr == f->_IO_buf_end)
 419         f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
 420       f->_IO_write_ptr = f->_IO_read_ptr;
 421       f->_IO_write_base = f->_IO_write_ptr;
 422       f->_IO_write_end = f->_IO_buf_end;
 423       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 424
 425       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 426         f->_IO_write_end = f->_IO_write_ptr;
 427       f->_flags |= _IO_CURRENTLY_PUTTING;
 428     }
 429   if (ch == EOF)
 430     return _IO_old_do_flush (f);
 431   if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
 432     if (_IO_old_do_flush (f) == EOF)
 433       return EOF;
 434   *f->_IO_write_ptr++ = ch;
 435   if ((f->_flags & _IO_UNBUFFERED)
 436       || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
 437     if (_IO_old_do_flush (f) == EOF)
 438       return EOF;
 439   return (unsigned char) ch;
 440 }
 441
 442 int
 443 attribute_compat_text_section
 444 _IO_old_file_sync (fp)
 445      _IO_FILE *fp;
 446 {
 447   _IO_ssize_t delta;
 448   int retval = 0;
 449
 450   /*    char* ptr = cur_ptr(); */
 451   if (fp->_IO_write_ptr > fp->_IO_write_base)
 452     if (_IO_old_do_flush(fp)) return EOF;
 453   delta = fp->_IO_read_ptr - fp->_IO_read_end;
 454   if (delta != 0)
 455     {
 456 #ifdef TODO
 457       if (_IO_in_backup (fp))
 458         delta -= eGptr () - Gbase ();
 459 #endif
 460       _IO_off_t new_pos = _IO_SYSSEEK (fp, delta, 1);
 461       if (new_pos != (_IO_off_t) EOF)
 462         fp->_IO_read_end = fp->_IO_read_ptr;
 463 #ifdef ESPIPE
 464       else if (errno == ESPIPE)
 465         ; /* Ignore error from unseekable devices. */
 466 #endif
 467       else
 468         retval = EOF;
 469     }
 470   if (retval != EOF)
 471     fp->_old_offset = _IO_pos_BAD;
 472   /* FIXME: Cleanup - can this be shared? */
 473   /*    setg(base(), ptr, ptr); */
 474   return retval;
 475 }
 476
 477 _IO_off64_t
 478 attribute_compat_text_section
 479 _IO_old_file_seekoff (fp, offset, dir, mode)
 480      _IO_FILE *fp;
 481      _IO_off64_t offset;
 482      int dir;
 483      int mode;
 484 {
 485   _IO_off_t result;
 486   _IO_off64_t delta, new_offset;
 487   long count;
 488   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 489      offset of the underlying file must be exact.  */
 490   int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
 491                        && fp->_IO_write_base == fp->_IO_write_ptr);
 492
 493   if (mode == 0)
 494     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
 495
 496   /* Flush unwritten characters.
 497      (This may do an unneeded write if we seek within the buffer.
 498      But to be able to switch to reading, we would need to set
 499      egptr to ptr.  That can't be done in the current design,
 500      which assumes file_ptr() is eGptr.  Anyway, since we probably
 501      end up flushing when we close(), it doesn't make much difference.)
 502      FIXME: simulate mem-papped files. */
 503
 504   if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
 505     if (INTUSE(_IO_switch_to_get_mode) (fp))
 506       return EOF;
 507
 508   if (fp->_IO_buf_base == NULL)
 509     {
 510       /* It could be that we already have a pushback buffer.  */
 511       if (fp->_IO_read_base != NULL)
 512         {
 513           free (fp->_IO_read_base);
 514           fp->_flags &= ~_IO_IN_BACKUP;
 515         }
 516       INTUSE(_IO_doallocbuf) (fp);
 517       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 518       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 519     }
 520
 521   switch (dir)
 522     {
 523     case _IO_seek_cur:
 524       /* Adjust for read-ahead (bytes is buffer). */
 525       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 526       if (fp->_old_offset == _IO_pos_BAD)
 527         goto dumb;
 528       /* Make offset absolute, assuming current pointer is file_ptr(). */
 529       offset += fp->_old_offset;
 530
 531       dir = _IO_seek_set;
 532       break;
 533     case _IO_seek_set:
 534       break;
 535     case _IO_seek_end:
 536       {
 537         struct _G_stat64 st;
 538         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 539           {
 540             offset += st.st_size;
 541             dir = _IO_seek_set;
 542           }
 543         else
 544           goto dumb;
 545       }
 546     }
 547   /* At this point, dir==_IO_seek_set. */
 548
 549   /* If we are only interested in the current position we've found it now.  */
 550   if (mode == 0)
 551     return offset;
 552
 553   /* If destination is within current buffer, optimize: */
 554   if (fp->_old_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
 555       && !_IO_in_backup (fp))
 556     {
 557       /* Offset relative to start of main get area. */
 558       _IO_off_t rel_offset = (offset - fp->_old_offset
 559                               + (fp->_IO_read_end - fp->_IO_read_base));
 560       if (rel_offset >= 0)
 561         {
 562 #if 0
 563           if (_IO_in_backup (fp))
 564             _IO_switch_to_main_get_area (fp);
 565 #endif
 566           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 567             {
 568               _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
 569                         fp->_IO_read_end);
 570               _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 571               {
 572                 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 573                 goto resync;
 574               }
 575             }
 576 #ifdef TODO
 577             /* If we have streammarkers, seek forward by reading ahead. */
 578             if (_IO_have_markers (fp))
 579               {
 580                 int to_skip = rel_offset
 581                   - (fp->_IO_read_ptr - fp->_IO_read_base);
 582                 if (ignore (to_skip) != to_skip)
 583                   goto dumb;
 584                 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 585                 goto resync;
 586               }
 587 #endif
 588         }
 589 #ifdef TODO
 590       if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
 591         {
 592           if (!_IO_in_backup (fp))
 593             _IO_switch_to_backup_area (fp);
 594           gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 595           _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 596           goto resync;
 597         }
 598 #endif
 599     }
 600
 601 #ifdef TODO
 602   INTUSE(_IO_unsave_markers) (fp);
 603 #endif
 604
 605   if (fp->_flags & _IO_NO_READS)
 606     goto dumb;
 607
 608   /* Try to seek to a block boundary, to improve kernel page management. */
 609   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
 610   delta = offset - new_offset;
 611   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
 612     {
 613       new_offset = offset;
 614       delta = 0;
 615     }
 616   result = _IO_SYSSEEK (fp, new_offset, 0);
 617   if (result < 0)
 618     return EOF;
 619   if (delta == 0)
 620     count = 0;
 621   else
 622     {
 623       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 624                            (must_be_exact
 625                             ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
 626       if (count < delta)
 627         {
 628           /* We weren't allowed to read, but try to seek the remainder. */
 629           offset = count == EOF ? delta : delta-count;
 630           dir = _IO_seek_cur;
 631           goto dumb;
 632         }
 633     }
 634   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
 635             fp->_IO_buf_base + count);
 636   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 637   fp->_old_offset = result + count;
 638   _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 639   return offset;
 640  dumb:
 641
 642   INTUSE(_IO_unsave_markers) (fp);
 643   result = _IO_SYSSEEK (fp, offset, dir);
 644   if (result != EOF)
 645     {
 646       _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 647       fp->_old_offset = result;
 648       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 649       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 650     }
 651   return result;
 652
 653 resync:
 654   /* We need to do it since it is possible that the file offset in
 655      the kernel may be changed behind our back. It may happen when
 656      we fopen a file and then do a fork. One process may access the
 657      the file and the kernel file offset will be changed. */
 658   if (fp->_old_offset >= 0)
 659     _IO_SYSSEEK (fp, fp->_old_offset, 0);
 660
 661   return offset;
 662 }
 663
 664 _IO_ssize_t
 665 attribute_compat_text_section
 666 _IO_old_file_write (f, data, n)
 667      _IO_FILE *f;
 668      const void *data;
 669      _IO_ssize_t n;
 670 {
 671   _IO_ssize_t to_do = n;
 672   while (to_do > 0)
 673     {
 674       _IO_ssize_t count = write (f->_fileno, data, to_do);
 675       if (count == EOF)
 676         {
 677           f->_flags |= _IO_ERR_SEEN;
 678           break;
 679         }
 680       to_do -= count;
 681       data = (void *) ((char *) data + count);
 682     }
 683   n -= to_do;
 684   if (f->_old_offset >= 0)
 685     f->_old_offset += n;
 686   return n;
 687 }
 688
 689 _IO_size_t
 690 attribute_compat_text_section
 691 _IO_old_file_xsputn (f, data, n)
 692      _IO_FILE *f;
 693      const void *data;
 694      _IO_size_t n;
 695 {
 696   register const char *s = (char *) data;
 697   _IO_size_t to_do = n;
 698   int must_flush = 0;
 699   _IO_size_t count = 0;
 700
 701   if (n <= 0)
 702     return 0;
 703   /* This is an optimized implementation.
 704      If the amount to be written straddles a block boundary
 705      (or the filebuf is unbuffered), use sys_write directly. */
 706
 707   /* First figure out how much space is available in the buffer. */
 708   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 709     {
 710       count = f->_IO_buf_end - f->_IO_write_ptr;
 711       if (count >= n)
 712         {
 713           register const char *p;
 714           for (p = s + n; p > s; )
 715             {
 716               if (*--p == '\n')
 717                 {
 718                   count = p - s + 1;
 719                   must_flush = 1;
 720                   break;
 721                 }
 722             }
 723         }
 724     }
 725   else if (f->_IO_write_end > f->_IO_write_ptr)
 726     count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
 727
 728   /* Then fill the buffer. */
 729   if (count > 0)
 730     {
 731       if (count > to_do)
 732         count = to_do;
 733       if (count > 20)
 734         {
 735 #ifdef _LIBC
 736           f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
 737 #else
 738           memcpy (f->_IO_write_ptr, s, count);
 739           f->_IO_write_ptr += count;
 740 #endif
 741           s += count;
 742         }
 743       else
 744         {
 745           register char *p = f->_IO_write_ptr;
 746           register int i = (int) count;
 747           while (--i >= 0)
 748             *p++ = *s++;
 749           f->_IO_write_ptr = p;
 750         }
 751       to_do -= count;
 752     }
 753   if (to_do + must_flush > 0)
 754     {
 755       _IO_size_t block_size, do_write;
 756       /* Next flush the (full) buffer. */
 757       if (__overflow (f, EOF) == EOF)
 758         return to_do == 0 ? EOF : n - to_do;
 759
 760       /* Try to maintain alignment: write a whole number of blocks.
 761          dont_write is what gets left over. */
 762       block_size = f->_IO_buf_end - f->_IO_buf_base;
 763       do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
 764
 765       if (do_write)
 766         {
 767           count = old_do_write (f, s, do_write);
 768           to_do -= count;
 769           if (count < do_write)
 770             return n - to_do;
 771         }
 772
 773       /* Now write out the remainder.  Normally, this will fit in the
 774          buffer, but it's somewhat messier for line-buffered files,
 775          so we let _IO_default_xsputn handle the general case. */
 776       if (to_do)
 777         to_do -= INTUSE(_IO_default_xsputn) (f, s+do_write, to_do);
 778     }
 779   return n - to_do;
 780 }
 781
 782
 783 const struct _IO_jump_t _IO_old_file_jumps =
 784 {
 785   JUMP_INIT_DUMMY,
 786   JUMP_INIT(finish, _IO_old_file_finish),
 787   JUMP_INIT(overflow, _IO_old_file_overflow),
 788   JUMP_INIT(underflow, _IO_old_file_underflow),
 789   JUMP_INIT(uflow, INTUSE(_IO_default_uflow)),
 790   JUMP_INIT(pbackfail, INTUSE(_IO_default_pbackfail)),
 791   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 792   JUMP_INIT(xsgetn, INTUSE(_IO_default_xsgetn)),
 793   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 794   JUMP_INIT(seekpos, _IO_default_seekpos),
 795   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 796   JUMP_INIT(sync, _IO_old_file_sync),
 797   JUMP_INIT(doallocate, INTUSE(_IO_file_doallocate)),
 798   JUMP_INIT(read, INTUSE(_IO_file_read)),
 799   JUMP_INIT(write, _IO_old_file_write),
 800   JUMP_INIT(seek, INTUSE(_IO_file_seek)),
 801   JUMP_INIT(close, INTUSE(_IO_file_close)),
 802   JUMP_INIT(stat, INTUSE(_IO_file_stat))
 803 };
 804
 805 compat_symbol (libc, _IO_old_do_write, _IO_do_write, GLIBC_2_0);
 806 compat_symbol (libc, _IO_old_file_attach, _IO_file_attach, GLIBC_2_0);
 807 compat_symbol (libc, _IO_old_file_close_it, _IO_file_close_it, GLIBC_2_0);
 808 compat_symbol (libc, _IO_old_file_finish, _IO_file_finish, GLIBC_2_0);
 809 compat_symbol (libc, _IO_old_file_fopen, _IO_file_fopen, GLIBC_2_0);
 810 compat_symbol (libc, _IO_old_file_init, _IO_file_init, GLIBC_2_0);
 811 compat_symbol (libc, _IO_old_file_setbuf, _IO_file_setbuf, GLIBC_2_0);
 812 compat_symbol (libc, _IO_old_file_sync, _IO_file_sync, GLIBC_2_0);
 813 compat_symbol (libc, _IO_old_file_overflow, _IO_file_overflow, GLIBC_2_0);
 814 compat_symbol (libc, _IO_old_file_seekoff, _IO_file_seekoff, GLIBC_2_0);
 815 compat_symbol (libc, _IO_old_file_underflow, _IO_file_underflow, GLIBC_2_0);
 816 compat_symbol (libc, _IO_old_file_write, _IO_file_write, GLIBC_2_0);
 817 compat_symbol (libc, _IO_old_file_xsputn, _IO_file_xsputn, GLIBC_2_0);
 818
 819 #endif