.
[glibc/history.git] / libio / oldfileops.c
blob3bd0aa175b9494a94ce9b849dffc4578a75e6c9c
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>.
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, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA.
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. */
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)
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
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
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.
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().
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(). (?)
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.
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().
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().
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.
110 UNBUFFERED STREAMS:
111 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
114 #define CLOSED_FILEBUF_FLAGS \
115 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
118 void
119 attribute_compat_text_section
120 _IO_old_file_init (fp)
121 struct _IO_FILE_plus *fp;
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;
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;
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
146 attribute_compat_text_section
147 _IO_old_file_close_it (fp)
148 _IO_FILE *fp;
150 int write_status, close_status;
151 if (!_IO_file_is_open (fp))
152 return EOF;
154 write_status = _IO_old_do_flush (fp);
156 INTUSE(_IO_unsave_markers) (fp);
158 close_status = _IO_SYSCLOSE (fp);
160 /* Free buffer. */
161 INTUSE(_IO_setb) (fp, NULL, NULL, 0);
162 _IO_setg (fp, NULL, NULL, NULL);
163 _IO_setp (fp, NULL, NULL);
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;
170 return close_status ? close_status : write_status;
173 void
174 attribute_compat_text_section
175 _IO_old_file_finish (fp, dummy)
176 _IO_FILE *fp;
177 int dummy;
179 if (_IO_file_is_open (fp))
181 _IO_old_do_flush (fp);
182 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
183 _IO_SYSCLOSE (fp);
185 INTUSE(_IO_default_finish) (fp, 0);
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;
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++)
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;
220 if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
222 omode = O_RDWR;
223 read_write &= _IO_IS_APPENDING;
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;
238 _IO_FILE *
239 attribute_compat_text_section
240 _IO_old_file_attach (fp, fd)
241 _IO_FILE *fp;
242 int fd;
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;
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;
265 if (_IO_default_setbuf (fp, p, len) == NULL)
266 return NULL;
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);
272 return fp;
275 static int old_do_write (_IO_FILE *, const char *, _IO_size_t);
277 /* Write TO_DO bytes from DATA to FP.
278 Then mark FP as having empty buffers. */
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;
287 return (to_do == 0 || (_IO_size_t) old_do_write (fp, data, to_do) == to_do)
288 ? 0 : EOF;
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;
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)
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;
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;
326 attribute_compat_text_section
327 _IO_old_file_underflow (fp)
328 _IO_FILE *fp;
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
337 if (fp->_flags & _IO_NO_READS)
339 fp->_flags |= _IO_ERR_SEEN;
340 __set_errno (EBADF);
341 return EOF;
343 if (fp->_IO_read_ptr < fp->_IO_read_end)
344 return *(unsigned char *) fp->_IO_read_ptr;
346 if (fp->_IO_buf_base == NULL)
348 /* Maybe we already have a push back pointer. */
349 if (fp->_IO_save_base != NULL)
351 free (fp->_IO_save_base);
352 fp->_flags &= ~_IO_IN_BACKUP;
354 INTUSE(_IO_doallocbuf) (fp);
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) ();
362 INTUSE(_IO_switch_to_get_mode) (fp);
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;
373 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
374 fp->_IO_buf_end - fp->_IO_buf_base);
375 if (count <= 0)
377 if (count == 0)
378 fp->_flags |= _IO_EOF_SEEN;
379 else
380 fp->_flags |= _IO_ERR_SEEN, count = 0;
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;
391 attribute_compat_text_section
392 _IO_old_file_overflow (f, ch)
393 _IO_FILE *f;
394 int ch;
396 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
398 f->_flags |= _IO_ERR_SEEN;
399 __set_errno (EBADF);
400 return EOF;
402 /* If currently reading or no buffer allocated. */
403 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
405 /* Allocate a buffer if needed. */
406 if (f->_IO_write_base == 0)
408 INTUSE(_IO_doallocbuf) (f);
409 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
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;
425 if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
426 f->_IO_write_end = f->_IO_write_ptr;
427 f->_flags |= _IO_CURRENTLY_PUTTING;
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;
443 attribute_compat_text_section
444 _IO_old_file_sync (fp)
445 _IO_FILE *fp;
447 _IO_ssize_t delta;
448 int retval = 0;
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)
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;
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;
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;
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);
493 if (mode == 0)
494 dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
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. */
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;
508 if (fp->_IO_buf_base == NULL)
510 /* It could be that we already have a pushback buffer. */
511 if (fp->_IO_read_base != NULL)
513 free (fp->_IO_read_base);
514 fp->_flags &= ~_IO_IN_BACKUP;
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);
521 switch (dir)
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;
531 dir = _IO_seek_set;
532 break;
533 case _IO_seek_set:
534 break;
535 case _IO_seek_end:
537 struct _G_stat64 st;
538 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
540 offset += st.st_size;
541 dir = _IO_seek_set;
543 else
544 goto dumb;
547 /* At this point, dir==_IO_seek_set. */
549 /* If we are only interested in the current position we've found it now. */
550 if (mode == 0)
551 return offset;
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))
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)
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)
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);
572 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
573 goto resync;
576 #ifdef TODO
577 /* If we have streammarkers, seek forward by reading ahead. */
578 if (_IO_have_markers (fp))
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;
587 #endif
589 #ifdef TODO
590 if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
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;
598 #endif
601 #ifdef TODO
602 INTUSE(_IO_unsave_markers) (fp);
603 #endif
605 if (fp->_flags & _IO_NO_READS)
606 goto dumb;
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)
613 new_offset = offset;
614 delta = 0;
616 result = _IO_SYSSEEK (fp, new_offset, 0);
617 if (result < 0)
618 return EOF;
619 if (delta == 0)
620 count = 0;
621 else
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)
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;
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:
642 INTUSE(_IO_unsave_markers) (fp);
643 result = _IO_SYSSEEK (fp, offset, dir);
644 if (result != EOF)
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);
651 return result;
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);
661 return offset;
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;
671 _IO_ssize_t to_do = n;
672 while (to_do > 0)
674 _IO_ssize_t count = write (f->_fileno, data, to_do);
675 if (count == EOF)
677 f->_flags |= _IO_ERR_SEEN;
678 break;
680 to_do -= count;
681 data = (void *) ((char *) data + count);
683 n -= to_do;
684 if (f->_old_offset >= 0)
685 f->_old_offset += n;
686 return n;
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;
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;
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. */
707 /* First figure out how much space is available in the buffer. */
708 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
710 count = f->_IO_buf_end - f->_IO_write_ptr;
711 if (count >= n)
713 register const char *p;
714 for (p = s + n; p > s; )
716 if (*--p == '\n')
718 count = p - s + 1;
719 must_flush = 1;
720 break;
725 else if (f->_IO_write_end > f->_IO_write_ptr)
726 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
728 /* Then fill the buffer. */
729 if (count > 0)
731 if (count > to_do)
732 count = to_do;
733 if (count > 20)
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;
743 else
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;
751 to_do -= count;
753 if (to_do + must_flush > 0)
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;
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);
765 if (do_write)
767 count = old_do_write (f, s, do_write);
768 to_do -= count;
769 if (count < do_write)
770 return n - to_do;
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);
779 return n - to_do;
783 const struct _IO_jump_t _IO_old_file_jumps =
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))
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);
819 #endif