libio/oldfileops.c

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