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