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