1/* Copyright (C) 1993-2020 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 <https://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#define _IO_USE_OLD_IO_FILE
34#include "libioP.h"
35#include <fcntl.h>
36#include <sys/types.h>
37#include <sys/stat.h>
38#include <string.h>
39#include <errno.h>
40#include <stdlib.h>
41#include <unistd.h>
42
43/* An fstream can be in at most one of put mode, get mode, or putback mode.
44 Putback mode is a variant of get mode.
45
46 In a filebuf, there is only one current position, instead of two
47 separate get and put pointers. In get mode, the current position
48 is that of gptr(); in put mode that of pptr().
49
50 The position in the buffer that corresponds to the position
51 in external file system is normally _IO_read_end, except in putback
52 mode, when it is _IO_save_end.
53 If the field _fb._offset is >= 0, it gives the offset in
54 the file as a whole corresponding to eGptr(). (?)
55
56 PUT MODE:
57 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
58 and _IO_read_base are equal to each other. These are usually equal
59 to _IO_buf_base, though not necessarily if we have switched from
60 get mode to put mode. (The reason is to maintain the invariant
61 that _IO_read_end corresponds to the external file position.)
62 _IO_write_base is non-NULL and usually equal to _IO_buf_base.
63 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
64 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
65
66 GET MODE:
67 If a filebuf is in get or putback mode, eback() != egptr().
68 In get mode, the unread characters are between gptr() and egptr().
69 The OS file position corresponds to that of egptr().
70
71 PUTBACK MODE:
72 Putback mode is used to remember "excess" characters that have
73 been sputbackc'd in a separate putback buffer.
74 In putback mode, the get buffer points to the special putback buffer.
75 The unread characters are the characters between gptr() and egptr()
76 in the putback buffer, as well as the area between save_gptr()
77 and save_egptr(), which point into the original reserve buffer.
78 (The pointers save_gptr() and save_egptr() are the values
79 of gptr() and egptr() at the time putback mode was entered.)
80 The OS position corresponds to that of save_egptr().
81
82 LINE BUFFERED OUTPUT:
83 During line buffered output, _IO_write_base==base() && epptr()==base().
84 However, ptr() may be anywhere between base() and ebuf().
85 This forces a call to filebuf::overflow(int C) on every put.
86 If there is more space in the buffer, and C is not a '\n',
87 then C is inserted, and pptr() incremented.
88
89 UNBUFFERED STREAMS:
90 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
91*/
92
93#define CLOSED_FILEBUF_FLAGS \
94 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
95
96
97void
98attribute_compat_text_section
99_IO_old_file_init_internal (struct _IO_FILE_plus *fp)
100{
101 /* POSIX.1 allows another file handle to be used to change the position
102 of our file descriptor. Hence we actually don't know the actual
103 position before we do the first fseek (and until a following fflush). */
104 fp->file._old_offset = _IO_pos_BAD;
105 fp->file._flags |= CLOSED_FILEBUF_FLAGS;
106
107 _IO_link_in (fp);
108 fp->file._vtable_offset = ((int) sizeof (struct _IO_FILE)
109 - (int) sizeof (struct _IO_FILE_complete));
110 fp->file._fileno = -1;
111
112 if (&_IO_stdin_used != NULL || !_IO_legacy_file ((FILE *) fp))
113 /* The object is dynamically allocated and large enough. Initialize
114 the _mode element as well. */
115 ((struct _IO_FILE_complete *) fp)->_mode = -1;
116}
117
118void
119attribute_compat_text_section
120_IO_old_file_init (struct _IO_FILE_plus *fp)
121{
122 IO_set_accept_foreign_vtables (&_IO_vtable_check);
123 _IO_old_file_init_internal (fp);
124}
125
126int
127attribute_compat_text_section
128_IO_old_file_close_it (FILE *fp)
129{
130 int write_status, close_status;
131 if (!_IO_file_is_open (fp))
132 return EOF;
133
134 write_status = _IO_old_do_flush (fp);
135
136 _IO_unsave_markers (fp);
137
138 close_status = ((fp->_flags2 & _IO_FLAGS2_NOCLOSE) == 0
139 ? _IO_SYSCLOSE (fp) : 0);
140
141 /* Free buffer. */
142 _IO_setb (fp, NULL, NULL, 0);
143 _IO_setg (fp, NULL, NULL, NULL);
144 _IO_setp (fp, NULL, NULL);
145
146 _IO_un_link ((struct _IO_FILE_plus *) fp);
147 fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
148 fp->_fileno = -1;
149 fp->_old_offset = _IO_pos_BAD;
150
151 return close_status ? close_status : write_status;
152}
153
154void
155attribute_compat_text_section
156_IO_old_file_finish (FILE *fp, int dummy)
157{
158 if (_IO_file_is_open (fp))
159 {
160 _IO_old_do_flush (fp);
161 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
162 _IO_SYSCLOSE (fp);
163 }
164 _IO_default_finish (fp, 0);
165}
166
167FILE *
168attribute_compat_text_section
169_IO_old_file_fopen (FILE *fp, const char *filename, const char *mode)
170{
171 int oflags = 0, omode;
172 int read_write, fdesc;
173 int oprot = 0666;
174 if (_IO_file_is_open (fp))
175 return 0;
176 switch (*mode++)
177 {
178 case 'r':
179 omode = O_RDONLY;
180 read_write = _IO_NO_WRITES;
181 break;
182 case 'w':
183 omode = O_WRONLY;
184 oflags = O_CREAT|O_TRUNC;
185 read_write = _IO_NO_READS;
186 break;
187 case 'a':
188 omode = O_WRONLY;
189 oflags = O_CREAT|O_APPEND;
190 read_write = _IO_NO_READS|_IO_IS_APPENDING;
191 break;
192 default:
193 __set_errno (EINVAL);
194 return NULL;
195 }
196 if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
197 {
198 omode = O_RDWR;
199 read_write &= _IO_IS_APPENDING;
200 }
201 fdesc = __open (filename, omode|oflags, oprot);
202 if (fdesc < 0)
203 return NULL;
204 fp->_fileno = fdesc;
205 _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
206 if (read_write & _IO_IS_APPENDING)
207 if (_IO_SEEKOFF (fp, (off_t)0, _IO_seek_end, _IOS_INPUT|_IOS_OUTPUT)
208 == _IO_pos_BAD && errno != ESPIPE)
209 return NULL;
210 _IO_link_in ((struct _IO_FILE_plus *) fp);
211 return fp;
212}
213
214FILE *
215attribute_compat_text_section
216_IO_old_file_attach (FILE *fp, int fd)
217{
218 if (_IO_file_is_open (fp))
219 return NULL;
220 fp->_fileno = fd;
221 fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
222 fp->_flags |= _IO_DELETE_DONT_CLOSE;
223 /* Get the current position of the file. */
224 /* We have to do that since that may be junk. */
225 fp->_old_offset = _IO_pos_BAD;
226 if (_IO_SEEKOFF (fp, (off_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
227 == _IO_pos_BAD && errno != ESPIPE)
228 return NULL;
229 return fp;
230}
231
232FILE *
233attribute_compat_text_section
234_IO_old_file_setbuf (FILE *fp, char *p, ssize_t len)
235{
236 if (_IO_default_setbuf (fp, p, len) == NULL)
237 return NULL;
238
239 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
240 = fp->_IO_buf_base;
241 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
242
243 return fp;
244}
245
246static int old_do_write (FILE *, const char *, size_t);
247
248/* Write TO_DO bytes from DATA to FP.
249 Then mark FP as having empty buffers. */
250
251int
252attribute_compat_text_section
253_IO_old_do_write (FILE *fp, const char *data, size_t to_do)
254{
255 return (to_do == 0 || (size_t) old_do_write (fp, data, to_do) == to_do)
256 ? 0 : EOF;
257}
258
259static int
260attribute_compat_text_section
261old_do_write (FILE *fp, const char *data, size_t to_do)
262{
263 size_t count;
264 if (fp->_flags & _IO_IS_APPENDING)
265 /* On a system without a proper O_APPEND implementation,
266 you would need to sys_seek(0, SEEK_END) here, but is
267 not needed nor desirable for Unix- or Posix-like systems.
268 Instead, just indicate that offset (before and after) is
269 unpredictable. */
270 fp->_old_offset = _IO_pos_BAD;
271 else if (fp->_IO_read_end != fp->_IO_write_base)
272 {
273 off_t new_pos
274 = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
275 if (new_pos == _IO_pos_BAD)
276 return 0;
277 fp->_old_offset = new_pos;
278 }
279 count = _IO_SYSWRITE (fp, data, to_do);
280 if (fp->_cur_column && count)
281 fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
282 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
283 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
284 fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
285 ? fp->_IO_buf_base : fp->_IO_buf_end);
286 return count;
287}
288
289int
290attribute_compat_text_section
291_IO_old_file_underflow (FILE *fp)
292{
293 ssize_t count;
294
295 /* C99 requires EOF to be "sticky". */
296 if (fp->_flags & _IO_EOF_SEEN)
297 return EOF;
298
299 if (fp->_flags & _IO_NO_READS)
300 {
301 fp->_flags |= _IO_ERR_SEEN;
302 __set_errno (EBADF);
303 return EOF;
304 }
305 if (fp->_IO_read_ptr < fp->_IO_read_end)
306 return *(unsigned char *) fp->_IO_read_ptr;
307
308 if (fp->_IO_buf_base == NULL)
309 {
310 /* Maybe we already have a push back pointer. */
311 if (fp->_IO_save_base != NULL)
312 {
313 free (fp->_IO_save_base);
314 fp->_flags &= ~_IO_IN_BACKUP;
315 }
316 _IO_doallocbuf (fp);
317 }
318
319 /* Flush all line buffered files before reading. */
320 /* FIXME This can/should be moved to genops ?? */
321 if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
322 _IO_flush_all_linebuffered ();
323
324 _IO_switch_to_get_mode (fp);
325
326 /* This is very tricky. We have to adjust those
327 pointers before we call _IO_SYSREAD () since
328 we may longjump () out while waiting for
329 input. Those pointers may be screwed up. H.J. */
330 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
331 fp->_IO_read_end = fp->_IO_buf_base;
332 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
333 = fp->_IO_buf_base;
334
335 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
336 fp->_IO_buf_end - fp->_IO_buf_base);
337 if (count <= 0)
338 {
339 if (count == 0)
340 fp->_flags |= _IO_EOF_SEEN;
341 else
342 fp->_flags |= _IO_ERR_SEEN, count = 0;
343 }
344 fp->_IO_read_end += count;
345 if (count == 0)
346 return EOF;
347 if (fp->_old_offset != _IO_pos_BAD)
348 _IO_pos_adjust (fp->_old_offset, count);
349 return *(unsigned char *) fp->_IO_read_ptr;
350}
351
352int
353attribute_compat_text_section
354_IO_old_file_overflow (FILE *f, int ch)
355{
356 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
357 {
358 f->_flags |= _IO_ERR_SEEN;
359 __set_errno (EBADF);
360 return EOF;
361 }
362 /* If currently reading or no buffer allocated. */
363 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
364 {
365 /* Allocate a buffer if needed. */
366 if (f->_IO_write_base == 0)
367 {
368 _IO_doallocbuf (f);
369 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
370 }
371 /* Otherwise must be currently reading.
372 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
373 logically slide the buffer forwards one block (by setting the
374 read pointers to all point at the beginning of the block). This
375 makes room for subsequent output.
376 Otherwise, set the read pointers to _IO_read_end (leaving that
377 alone, so it can continue to correspond to the external position). */
378 if (f->_IO_read_ptr == f->_IO_buf_end)
379 f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
380 f->_IO_write_ptr = f->_IO_read_ptr;
381 f->_IO_write_base = f->_IO_write_ptr;
382 f->_IO_write_end = f->_IO_buf_end;
383 f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
384
385 if (f->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
386 f->_IO_write_end = f->_IO_write_ptr;
387 f->_flags |= _IO_CURRENTLY_PUTTING;
388 }
389 if (ch == EOF)
390 return _IO_old_do_flush (f);
391 if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
392 if (_IO_old_do_flush (f) == EOF)
393 return EOF;
394 *f->_IO_write_ptr++ = ch;
395 if ((f->_flags & _IO_UNBUFFERED)
396 || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
397 if (_IO_old_do_flush (f) == EOF)
398 return EOF;
399 return (unsigned char) ch;
400}
401
402int
403attribute_compat_text_section
404_IO_old_file_sync (FILE *fp)
405{
406 ssize_t delta;
407 int retval = 0;
408
409 /* char* ptr = cur_ptr(); */
410 if (fp->_IO_write_ptr > fp->_IO_write_base)
411 if (_IO_old_do_flush(fp)) return EOF;
412 delta = fp->_IO_read_ptr - fp->_IO_read_end;
413 if (delta != 0)
414 {
415#ifdef TODO
416 if (_IO_in_backup (fp))
417 delta -= eGptr () - Gbase ();
418#endif
419 off_t new_pos = _IO_SYSSEEK (fp, delta, 1);
420 if (new_pos != (off_t) EOF)
421 fp->_IO_read_end = fp->_IO_read_ptr;
422 else if (errno == ESPIPE)
423 ; /* Ignore error from unseekable devices. */
424 else
425 retval = EOF;
426 }
427 if (retval != EOF)
428 fp->_old_offset = _IO_pos_BAD;
429 /* FIXME: Cleanup - can this be shared? */
430 /* setg(base(), ptr, ptr); */
431 return retval;
432}
433
434off64_t
435attribute_compat_text_section
436_IO_old_file_seekoff (FILE *fp, off64_t offset, int dir, int mode)
437{
438 off_t result;
439 off64_t delta, new_offset;
440 long count;
441 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
442 offset of the underlying file must be exact. */
443 int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
444 && fp->_IO_write_base == fp->_IO_write_ptr);
445
446 if (mode == 0)
447 dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
448
449 /* Flush unwritten characters.
450 (This may do an unneeded write if we seek within the buffer.
451 But to be able to switch to reading, we would need to set
452 egptr to pptr. That can't be done in the current design,
453 which assumes file_ptr() is eGptr. Anyway, since we probably
454 end up flushing when we close(), it doesn't make much difference.)
455 FIXME: simulate mem-mapped files. */
456
457 if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
458 if (_IO_switch_to_get_mode (fp))
459 return EOF;
460
461 if (fp->_IO_buf_base == NULL)
462 {
463 /* It could be that we already have a pushback buffer. */
464 if (fp->_IO_read_base != NULL)
465 {
466 free (fp->_IO_read_base);
467 fp->_flags &= ~_IO_IN_BACKUP;
468 }
469 _IO_doallocbuf (fp);
470 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
471 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
472 }
473
474 switch (dir)
475 {
476 case _IO_seek_cur:
477 /* Adjust for read-ahead (bytes is buffer). */
478 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
479 if (fp->_old_offset == _IO_pos_BAD)
480 goto dumb;
481 /* Make offset absolute, assuming current pointer is file_ptr(). */
482 offset += fp->_old_offset;
483
484 dir = _IO_seek_set;
485 break;
486 case _IO_seek_set:
487 break;
488 case _IO_seek_end:
489 {
490 struct stat64 st;
491 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
492 {
493 offset += st.st_size;
494 dir = _IO_seek_set;
495 }
496 else
497 goto dumb;
498 }
499 }
500 /* At this point, dir==_IO_seek_set. */
501
502 /* If we are only interested in the current position we've found it now. */
503 if (mode == 0)
504 return offset;
505
506 /* If destination is within current buffer, optimize: */
507 if (fp->_old_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
508 && !_IO_in_backup (fp))
509 {
510 /* Offset relative to start of main get area. */
511 off_t rel_offset = (offset - fp->_old_offset
512 + (fp->_IO_read_end - fp->_IO_read_base));
513 if (rel_offset >= 0)
514 {
515 if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
516 {
517 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
518 fp->_IO_read_end);
519 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
520 {
521 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
522 goto resync;
523 }
524 }
525#ifdef TODO
526 /* If we have streammarkers, seek forward by reading ahead. */
527 if (_IO_have_markers (fp))
528 {
529 int to_skip = rel_offset
530 - (fp->_IO_read_ptr - fp->_IO_read_base);
531 if (ignore (to_skip) != to_skip)
532 goto dumb;
533 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
534 goto resync;
535 }
536#endif
537 }
538#ifdef TODO
539 if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
540 {
541 if (!_IO_in_backup (fp))
542 _IO_switch_to_backup_area (fp);
543 gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
544 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
545 goto resync;
546 }
547#endif
548 }
549
550#ifdef TODO
551 _IO_unsave_markers (fp);
552#endif
553
554 if (fp->_flags & _IO_NO_READS)
555 goto dumb;
556
557 /* Try to seek to a block boundary, to improve kernel page management. */
558 new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
559 delta = offset - new_offset;
560 if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
561 {
562 new_offset = offset;
563 delta = 0;
564 }
565 result = _IO_SYSSEEK (fp, new_offset, 0);
566 if (result < 0)
567 return EOF;
568 if (delta == 0)
569 count = 0;
570 else
571 {
572 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
573 (must_be_exact
574 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
575 if (count < delta)
576 {
577 /* We weren't allowed to read, but try to seek the remainder. */
578 offset = count == EOF ? delta : delta-count;
579 dir = _IO_seek_cur;
580 goto dumb;
581 }
582 }
583 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
584 fp->_IO_buf_base + count);
585 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
586 fp->_old_offset = result + count;
587 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
588 return offset;
589 dumb:
590
591 _IO_unsave_markers (fp);
592 result = _IO_SYSSEEK (fp, offset, dir);
593 if (result != EOF)
594 {
595 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
596 fp->_old_offset = result;
597 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
598 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
599 }
600 return result;
601
602resync:
603 /* We need to do it since it is possible that the file offset in
604 the kernel may be changed behind our back. It may happen when
605 we fopen a file and then do a fork. One process may access the
606 file and the kernel file offset will be changed. */
607 if (fp->_old_offset >= 0)
608 _IO_SYSSEEK (fp, fp->_old_offset, 0);
609
610 return offset;
611}
612
613ssize_t
614attribute_compat_text_section
615_IO_old_file_write (FILE *f, const void *data, ssize_t n)
616{
617 ssize_t to_do = n;
618 while (to_do > 0)
619 {
620 ssize_t count = __write (f->_fileno, data, to_do);
621 if (count == EOF)
622 {
623 f->_flags |= _IO_ERR_SEEN;
624 break;
625 }
626 to_do -= count;
627 data = (void *) ((char *) data + count);
628 }
629 n -= to_do;
630 if (f->_old_offset >= 0)
631 f->_old_offset += n;
632 return n;
633}
634
635size_t
636attribute_compat_text_section
637_IO_old_file_xsputn (FILE *f, const void *data, size_t n)
638{
639 const char *s = (char *) data;
640 size_t to_do = n;
641 int must_flush = 0;
642 size_t count = 0;
643
644 if (n <= 0)
645 return 0;
646 /* This is an optimized implementation.
647 If the amount to be written straddles a block boundary
648 (or the filebuf is unbuffered), use sys_write directly. */
649
650 /* First figure out how much space is available in the buffer. */
651 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
652 {
653 count = f->_IO_buf_end - f->_IO_write_ptr;
654 if (count >= n)
655 {
656 const char *p;
657 for (p = s + n; p > s; )
658 {
659 if (*--p == '\n')
660 {
661 count = p - s + 1;
662 must_flush = 1;
663 break;
664 }
665 }
666 }
667 }
668 else if (f->_IO_write_end > f->_IO_write_ptr)
669 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
670
671 /* Then fill the buffer. */
672 if (count > 0)
673 {
674 if (count > to_do)
675 count = to_do;
676 if (count > 20)
677 {
678 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
679 s += count;
680 }
681 else
682 {
683 char *p = f->_IO_write_ptr;
684 int i = (int) count;
685 while (--i >= 0)
686 *p++ = *s++;
687 f->_IO_write_ptr = p;
688 }
689 to_do -= count;
690 }
691 if (to_do + must_flush > 0)
692 {
693 size_t block_size, do_write;
694 /* Next flush the (full) buffer. */
695 if (__overflow (f, EOF) == EOF)
696 return to_do == 0 ? EOF : n - to_do;
697
698 /* Try to maintain alignment: write a whole number of blocks.
699 dont_write is what gets left over. */
700 block_size = f->_IO_buf_end - f->_IO_buf_base;
701 do_write = to_do - (block_size >= 128 ? to_do % block_size : 0);
702
703 if (do_write)
704 {
705 count = old_do_write (f, s, do_write);
706 to_do -= count;
707 if (count < do_write)
708 return n - to_do;
709 }
710
711 /* Now write out the remainder. Normally, this will fit in the
712 buffer, but it's somewhat messier for line-buffered files,
713 so we let _IO_default_xsputn handle the general case. */
714 if (to_do)
715 to_do -= _IO_default_xsputn (f, s+do_write, to_do);
716 }
717 return n - to_do;
718}
719
720
721const struct _IO_jump_t _IO_old_file_jumps libio_vtable =
722{
723 JUMP_INIT_DUMMY,
724 JUMP_INIT(finish, _IO_old_file_finish),
725 JUMP_INIT(overflow, _IO_old_file_overflow),
726 JUMP_INIT(underflow, _IO_old_file_underflow),
727 JUMP_INIT(uflow, _IO_default_uflow),
728 JUMP_INIT(pbackfail, _IO_default_pbackfail),
729 JUMP_INIT(xsputn, _IO_old_file_xsputn),
730 JUMP_INIT(xsgetn, _IO_default_xsgetn),
731 JUMP_INIT(seekoff, _IO_old_file_seekoff),
732 JUMP_INIT(seekpos, _IO_default_seekpos),
733 JUMP_INIT(setbuf, _IO_old_file_setbuf),
734 JUMP_INIT(sync, _IO_old_file_sync),
735 JUMP_INIT(doallocate, _IO_file_doallocate),
736 JUMP_INIT(read, _IO_file_read),
737 JUMP_INIT(write, _IO_old_file_write),
738 JUMP_INIT(seek, _IO_file_seek),
739 JUMP_INIT(close, _IO_file_close),
740 JUMP_INIT(stat, _IO_file_stat)
741};
742
743compat_symbol (libc, _IO_old_do_write, _IO_do_write, GLIBC_2_0);
744compat_symbol (libc, _IO_old_file_attach, _IO_file_attach, GLIBC_2_0);
745compat_symbol (libc, _IO_old_file_close_it, _IO_file_close_it, GLIBC_2_0);
746compat_symbol (libc, _IO_old_file_finish, _IO_file_finish, GLIBC_2_0);
747compat_symbol (libc, _IO_old_file_fopen, _IO_file_fopen, GLIBC_2_0);
748compat_symbol (libc, _IO_old_file_init, _IO_file_init, GLIBC_2_0);
749compat_symbol (libc, _IO_old_file_setbuf, _IO_file_setbuf, GLIBC_2_0);
750compat_symbol (libc, _IO_old_file_sync, _IO_file_sync, GLIBC_2_0);
751compat_symbol (libc, _IO_old_file_overflow, _IO_file_overflow, GLIBC_2_0);
752compat_symbol (libc, _IO_old_file_seekoff, _IO_file_seekoff, GLIBC_2_0);
753compat_symbol (libc, _IO_old_file_underflow, _IO_file_underflow, GLIBC_2_0);
754compat_symbol (libc, _IO_old_file_write, _IO_file_write, GLIBC_2_0);
755compat_symbol (libc, _IO_old_file_xsputn, _IO_file_xsputn, GLIBC_2_0);
756
757#endif
758