1/* Copyright (C) 1993-2017 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
46extern 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
115void
116attribute_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
141void
142attribute_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
149int
150attribute_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
177void
178attribute_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 *
191attribute_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 *
238attribute_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 *
256attribute_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
269static 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
274int
275attribute_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
282static int
283attribute_compat_text_section
284old_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
312int
313attribute_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
376int
377attribute_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
426int
427attribute_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
461attribute_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
632resync:
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
644attribute_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
666attribute_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
756const 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
778compat_symbol (libc, _IO_old_do_write, _IO_do_write, GLIBC_2_0);
779compat_symbol (libc, _IO_old_file_attach, _IO_file_attach, GLIBC_2_0);
780compat_symbol (libc, _IO_old_file_close_it, _IO_file_close_it, GLIBC_2_0);
781compat_symbol (libc, _IO_old_file_finish, _IO_file_finish, GLIBC_2_0);
782compat_symbol (libc, _IO_old_file_fopen, _IO_file_fopen, GLIBC_2_0);
783compat_symbol (libc, _IO_old_file_init, _IO_file_init, GLIBC_2_0);
784compat_symbol (libc, _IO_old_file_setbuf, _IO_file_setbuf, GLIBC_2_0);
785compat_symbol (libc, _IO_old_file_sync, _IO_file_sync, GLIBC_2_0);
786compat_symbol (libc, _IO_old_file_overflow, _IO_file_overflow, GLIBC_2_0);
787compat_symbol (libc, _IO_old_file_seekoff, _IO_file_seekoff, GLIBC_2_0);
788compat_symbol (libc, _IO_old_file_underflow, _IO_file_underflow, GLIBC_2_0);
789compat_symbol (libc, _IO_old_file_write, _IO_file_write, GLIBC_2_0);
790compat_symbol (libc, _IO_old_file_xsputn, _IO_file_xsputn, GLIBC_2_0);
791
792#endif
793