(old_do_write): Remove __THROW.
[kopensolaris-gnu/glibc.git] / 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