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>.
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.
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.
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/>.
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. */
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)
35 # define _POSIX_SOURCE
37 #define _IO_USE_OLD_IO_FILE
40 #include <sys/types.h>
49 # define __set_errno(Val) errno = (Val)
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)
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.
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().
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(). (?)
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.
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().
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().
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.
108 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
111 #define CLOSED_FILEBUF_FLAGS \
112 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
116 attribute_compat_text_section
117 _IO_old_file_init (fp)
118 struct _IO_FILE_plus *fp;
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;
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;
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;
143 attribute_compat_text_section
144 _IO_old_file_close_it (fp)
147 int write_status, close_status;
148 if (!_IO_file_is_open (fp))
151 write_status = _IO_old_do_flush (fp);
153 INTUSE(_IO_unsave_markers) (fp);
155 close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
156 ? _IO_SYSCLOSE (fp) : 0);
159 INTUSE(_IO_setb) (fp, NULL, NULL, 0);
160 _IO_setg (fp, NULL, NULL, NULL);
161 _IO_setp (fp, NULL, NULL);
163 INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);
164 fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
166 fp->_old_offset = _IO_pos_BAD;
168 return close_status ? close_status : write_status;
172 attribute_compat_text_section
173 _IO_old_file_finish (fp, dummy)
177 if (_IO_file_is_open (fp))
179 _IO_old_do_flush (fp);
180 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
183 INTUSE(_IO_default_finish) (fp, 0);
187 attribute_compat_text_section
188 _IO_old_file_fopen (fp, filename, mode)
190 const char *filename;
193 int oflags = 0, omode;
194 int read_write, fdesc;
196 if (_IO_file_is_open (fp))
202 read_write = _IO_NO_WRITES;
206 oflags = O_CREAT|O_TRUNC;
207 read_write = _IO_NO_READS;
211 oflags = O_CREAT|O_APPEND;
212 read_write = _IO_NO_READS|_IO_IS_APPENDING;
215 __set_errno (EINVAL);
218 if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
221 read_write &= _IO_IS_APPENDING;
223 fdesc = open (filename, omode|oflags, oprot);
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)
232 INTUSE(_IO_link_in) ((struct _IO_FILE_plus *) fp);
237 attribute_compat_text_section
238 _IO_old_file_attach (fp, fd)
242 if (_IO_file_is_open (fp))
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)
257 attribute_compat_text_section
258 _IO_old_file_setbuf (fp, p, len)
263 if (_IO_default_setbuf (fp, p, len) == NULL)
266 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
268 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
273 static int old_do_write (_IO_FILE *, const char *, _IO_size_t);
275 /* Write TO_DO bytes from DATA to FP.
276 Then mark FP as having empty buffers. */
279 attribute_compat_text_section
280 _IO_old_do_write (fp, data, to_do)
285 return (to_do == 0 || (_IO_size_t) old_do_write (fp, data, to_do) == to_do)
290 attribute_compat_text_section
291 old_do_write (fp, data, to_do)
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
303 fp->_old_offset = _IO_pos_BAD;
304 else if (fp->_IO_read_end != fp->_IO_write_base)
307 = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
308 if (new_pos == _IO_pos_BAD)
310 fp->_old_offset = new_pos;
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,
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);
324 attribute_compat_text_section
325 _IO_old_file_underflow (fp)
330 /* SysV does not make this test; take it out for compatibility */
331 if (fp->_flags & _IO_EOF_SEEN)
335 if (fp->_flags & _IO_NO_READS)
337 fp->_flags |= _IO_ERR_SEEN;
341 if (fp->_IO_read_ptr < fp->_IO_read_end)
342 return *(unsigned char *) fp->_IO_read_ptr;
344 if (fp->_IO_buf_base == NULL)
346 /* Maybe we already have a push back pointer. */
347 if (fp->_IO_save_base != NULL)
349 free (fp->_IO_save_base);
350 fp->_flags &= ~_IO_IN_BACKUP;
352 INTUSE(_IO_doallocbuf) (fp);
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) ();
360 INTUSE(_IO_switch_to_get_mode) (fp);
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
371 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
372 fp->_IO_buf_end - fp->_IO_buf_base);
376 fp->_flags |= _IO_EOF_SEEN;
378 fp->_flags |= _IO_ERR_SEEN, count = 0;
380 fp->_IO_read_end += count;
383 if (fp->_old_offset != _IO_pos_BAD)
384 _IO_pos_adjust (fp->_old_offset, count);
385 return *(unsigned char *) fp->_IO_read_ptr;
389 attribute_compat_text_section
390 _IO_old_file_overflow (f, ch)
394 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
396 f->_flags |= _IO_ERR_SEEN;
400 /* If currently reading or no buffer allocated. */
401 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
403 /* Allocate a buffer if needed. */
404 if (f->_IO_write_base == 0)
406 INTUSE(_IO_doallocbuf) (f);
407 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
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;
423 if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
424 f->_IO_write_end = f->_IO_write_ptr;
425 f->_flags |= _IO_CURRENTLY_PUTTING;
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)
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)
437 return (unsigned char) ch;
441 attribute_compat_text_section
442 _IO_old_file_sync (fp)
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;
455 if (_IO_in_backup (fp))
456 delta -= eGptr () - Gbase ();
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;
462 else if (errno == ESPIPE)
463 ; /* Ignore error from unseekable devices. */
469 fp->_old_offset = _IO_pos_BAD;
470 /* FIXME: Cleanup - can this be shared? */
471 /* setg(base(), ptr, ptr); */
476 attribute_compat_text_section
477 _IO_old_file_seekoff (fp, offset, dir, mode)
484 _IO_off64_t delta, new_offset;
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);
492 dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
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. */
502 if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
503 if (INTUSE(_IO_switch_to_get_mode) (fp))
506 if (fp->_IO_buf_base == NULL)
508 /* It could be that we already have a pushback buffer. */
509 if (fp->_IO_read_base != NULL)
511 free (fp->_IO_read_base);
512 fp->_flags &= ~_IO_IN_BACKUP;
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);
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)
526 /* Make offset absolute, assuming current pointer is file_ptr(). */
527 offset += fp->_old_offset;
536 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
538 offset += st.st_size;
545 /* At this point, dir==_IO_seek_set. */
547 /* If we are only interested in the current position we've found it now. */
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))
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));
561 if (_IO_in_backup (fp))
562 _IO_switch_to_main_get_area (fp);
564 if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
566 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
568 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
570 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
575 /* If we have streammarkers, seek forward by reading ahead. */
576 if (_IO_have_markers (fp))
578 int to_skip = rel_offset
579 - (fp->_IO_read_ptr - fp->_IO_read_base);
580 if (ignore (to_skip) != to_skip)
582 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
588 if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
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);
600 INTUSE(_IO_unsave_markers) (fp);
603 if (fp->_flags & _IO_NO_READS)
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)
614 result = _IO_SYSSEEK (fp, new_offset, 0);
621 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
623 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
626 /* We weren't allowed to read, but try to seek the remainder. */
627 offset = count == EOF ? delta : delta-count;
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);
640 INTUSE(_IO_unsave_markers) (fp);
641 result = _IO_SYSSEEK (fp, offset, dir);
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);
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);
663 attribute_compat_text_section
664 _IO_old_file_write (f, data, n)
669 _IO_ssize_t to_do = n;
672 _IO_ssize_t count = write (f->_fileno, data, to_do);
675 f->_flags |= _IO_ERR_SEEN;
679 data = (void *) ((char *) data + count);
682 if (f->_old_offset >= 0)
688 attribute_compat_text_section
689 _IO_old_file_xsputn (f, data, n)
694 register const char *s = (char *) data;
695 _IO_size_t to_do = n;
697 _IO_size_t count = 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. */
705 /* First figure out how much space is available in the buffer. */
706 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
708 count = f->_IO_buf_end - f->_IO_write_ptr;
711 register const char *p;
712 for (p = s + n; p > s; )
723 else if (f->_IO_write_end > f->_IO_write_ptr)
724 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
726 /* Then fill the buffer. */
734 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
736 memcpy (f->_IO_write_ptr, s, count);
737 f->_IO_write_ptr += count;
743 register char *p = f->_IO_write_ptr;
744 register int i = (int) count;
747 f->_IO_write_ptr = p;
751 if (to_do + must_flush > 0)
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;
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);
765 count = old_do_write (f, s, do_write);
767 if (count < do_write)
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. */
775 to_do -= INTUSE(_IO_default_xsputn) (f, s+do_write, to_do);
781 const struct _IO_jump_t _IO_old_file_jumps =
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))
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);