1/* Copyright (C) 1993-2018 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Written by Ulrich Drepper <drepper@cygnus.com>.
4 Based on the single byte version by Per Bothner <bothner@cygnus.com>.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>.
19
20 As a special exception, if you link the code in this file with
21 files compiled with a GNU compiler to produce an executable,
22 that does not cause the resulting executable to be covered by
23 the GNU Lesser General Public License. This exception does not
24 however invalidate any other reasons why the executable file
25 might be covered by the GNU Lesser General Public License.
26 This exception applies to code released by its copyright holders
27 in files containing the exception. */
28
29#include <assert.h>
30#include <libioP.h>
31#include <wchar.h>
32#include <gconv.h>
33#include <stdlib.h>
34#include <string.h>
35
36/* Convert TO_DO wide character from DATA to FP.
37 Then mark FP as having empty buffers. */
38int
39_IO_wdo_write (FILE *fp, const wchar_t *data, size_t to_do)
40{
41 struct _IO_codecvt *cc = fp->_codecvt;
42
43 if (to_do > 0)
44 {
45 if (fp->_IO_write_end == fp->_IO_write_ptr
46 && fp->_IO_write_end != fp->_IO_write_base)
47 {
48 if (_IO_new_do_write (fp, fp->_IO_write_base,
49 fp->_IO_write_ptr - fp->_IO_write_base) == EOF)
50 return WEOF;
51 }
52
53 do
54 {
55 enum __codecvt_result result;
56 const wchar_t *new_data;
57 char mb_buf[MB_LEN_MAX];
58 char *write_base, *write_ptr, *buf_end;
59
60 if (fp->_IO_write_ptr - fp->_IO_write_base < sizeof (mb_buf))
61 {
62 /* Make sure we have room for at least one multibyte
63 character. */
64 write_ptr = write_base = mb_buf;
65 buf_end = mb_buf + sizeof (mb_buf);
66 }
67 else
68 {
69 write_ptr = fp->_IO_write_ptr;
70 write_base = fp->_IO_write_base;
71 buf_end = fp->_IO_buf_end;
72 }
73
74 /* Now convert from the internal format into the external buffer. */
75 result = (*cc->__codecvt_do_out) (cc, &fp->_wide_data->_IO_state,
76 data, data + to_do, &new_data,
77 write_ptr,
78 buf_end,
79 &write_ptr);
80
81 /* Write out what we produced so far. */
82 if (_IO_new_do_write (fp, write_base, write_ptr - write_base) == EOF)
83 /* Something went wrong. */
84 return WEOF;
85
86 to_do -= new_data - data;
87
88 /* Next see whether we had problems during the conversion. If yes,
89 we cannot go on. */
90 if (result != __codecvt_ok
91 && (result != __codecvt_partial || new_data - data == 0))
92 break;
93
94 data = new_data;
95 }
96 while (to_do > 0);
97 }
98
99 _IO_wsetg (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base,
100 fp->_wide_data->_IO_buf_base);
101 fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr
102 = fp->_wide_data->_IO_buf_base;
103 fp->_wide_data->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
104 ? fp->_wide_data->_IO_buf_base
105 : fp->_wide_data->_IO_buf_end);
106
107 return to_do == 0 ? 0 : WEOF;
108}
109libc_hidden_def (_IO_wdo_write)
110
111
112wint_t
113_IO_wfile_underflow (FILE *fp)
114{
115 struct _IO_codecvt *cd;
116 enum __codecvt_result status;
117 ssize_t count;
118
119 /* C99 requires EOF to be "sticky". */
120 if (fp->_flags & _IO_EOF_SEEN)
121 return WEOF;
122
123 if (__glibc_unlikely (fp->_flags & _IO_NO_READS))
124 {
125 fp->_flags |= _IO_ERR_SEEN;
126 __set_errno (EBADF);
127 return WEOF;
128 }
129 if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
130 return *fp->_wide_data->_IO_read_ptr;
131
132 cd = fp->_codecvt;
133
134 /* Maybe there is something left in the external buffer. */
135 if (fp->_IO_read_ptr < fp->_IO_read_end)
136 {
137 /* There is more in the external. Convert it. */
138 const char *read_stop = (const char *) fp->_IO_read_ptr;
139
140 fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
141 fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr =
142 fp->_wide_data->_IO_buf_base;
143 status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
144 fp->_IO_read_ptr, fp->_IO_read_end,
145 &read_stop,
146 fp->_wide_data->_IO_read_ptr,
147 fp->_wide_data->_IO_buf_end,
148 &fp->_wide_data->_IO_read_end);
149
150 fp->_IO_read_base = fp->_IO_read_ptr;
151 fp->_IO_read_ptr = (char *) read_stop;
152
153 /* If we managed to generate some text return the next character. */
154 if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
155 return *fp->_wide_data->_IO_read_ptr;
156
157 if (status == __codecvt_error)
158 {
159 __set_errno (EILSEQ);
160 fp->_flags |= _IO_ERR_SEEN;
161 return WEOF;
162 }
163
164 /* Move the remaining content of the read buffer to the beginning. */
165 memmove (fp->_IO_buf_base, fp->_IO_read_ptr,
166 fp->_IO_read_end - fp->_IO_read_ptr);
167 fp->_IO_read_end = (fp->_IO_buf_base
168 + (fp->_IO_read_end - fp->_IO_read_ptr));
169 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
170 }
171 else
172 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end =
173 fp->_IO_buf_base;
174
175 if (fp->_IO_buf_base == NULL)
176 {
177 /* Maybe we already have a push back pointer. */
178 if (fp->_IO_save_base != NULL)
179 {
180 free (fp->_IO_save_base);
181 fp->_flags &= ~_IO_IN_BACKUP;
182 }
183 _IO_doallocbuf (fp);
184
185 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end =
186 fp->_IO_buf_base;
187 }
188
189 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end =
190 fp->_IO_buf_base;
191
192 if (fp->_wide_data->_IO_buf_base == NULL)
193 {
194 /* Maybe we already have a push back pointer. */
195 if (fp->_wide_data->_IO_save_base != NULL)
196 {
197 free (fp->_wide_data->_IO_save_base);
198 fp->_flags &= ~_IO_IN_BACKUP;
199 }
200 _IO_wdoallocbuf (fp);
201 }
202
203 /* FIXME This can/should be moved to genops ?? */
204 if (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
205 {
206 /* We used to flush all line-buffered stream. This really isn't
207 required by any standard. My recollection is that
208 traditional Unix systems did this for stdout. stderr better
209 not be line buffered. So we do just that here
210 explicitly. --drepper */
211 _IO_acquire_lock (_IO_stdout);
212
213 if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
214 == (_IO_LINKED | _IO_LINE_BUF))
215 _IO_OVERFLOW (_IO_stdout, EOF);
216
217 _IO_release_lock (_IO_stdout);
218 }
219
220 _IO_switch_to_get_mode (fp);
221
222 fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr =
223 fp->_wide_data->_IO_buf_base;
224 fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_buf_base;
225 fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr =
226 fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_buf_base;
227
228 const char *read_ptr_copy;
229 char accbuf[MB_LEN_MAX];
230 size_t naccbuf = 0;
231 again:
232 count = _IO_SYSREAD (fp, fp->_IO_read_end,
233 fp->_IO_buf_end - fp->_IO_read_end);
234 if (count <= 0)
235 {
236 if (count == 0 && naccbuf == 0)
237 {
238 fp->_flags |= _IO_EOF_SEEN;
239 fp->_offset = _IO_pos_BAD;
240 }
241 else
242 fp->_flags |= _IO_ERR_SEEN, count = 0;
243 }
244 fp->_IO_read_end += count;
245 if (count == 0)
246 {
247 if (naccbuf != 0)
248 /* There are some bytes in the external buffer but they don't
249 convert to anything. */
250 __set_errno (EILSEQ);
251 return WEOF;
252 }
253 if (fp->_offset != _IO_pos_BAD)
254 _IO_pos_adjust (fp->_offset, count);
255
256 /* Now convert the read input. */
257 fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
258 fp->_IO_read_base = fp->_IO_read_ptr;
259 const char *from = fp->_IO_read_ptr;
260 const char *to = fp->_IO_read_end;
261 size_t to_copy = count;
262 if (__glibc_unlikely (naccbuf != 0))
263 {
264 to_copy = MIN (sizeof (accbuf) - naccbuf, count);
265 to = __mempcpy (&accbuf[naccbuf], from, to_copy);
266 naccbuf += to_copy;
267 from = accbuf;
268 }
269 status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
270 from, to, &read_ptr_copy,
271 fp->_wide_data->_IO_read_end,
272 fp->_wide_data->_IO_buf_end,
273 &fp->_wide_data->_IO_read_end);
274
275 if (__glibc_unlikely (naccbuf != 0))
276 fp->_IO_read_ptr += MAX (0, read_ptr_copy - &accbuf[naccbuf - to_copy]);
277 else
278 fp->_IO_read_ptr = (char *) read_ptr_copy;
279 if (fp->_wide_data->_IO_read_end == fp->_wide_data->_IO_buf_base)
280 {
281 if (status == __codecvt_error)
282 {
283 out_eilseq:
284 __set_errno (EILSEQ);
285 fp->_flags |= _IO_ERR_SEEN;
286 return WEOF;
287 }
288
289 /* The read bytes make no complete character. Try reading again. */
290 assert (status == __codecvt_partial);
291
292 if (naccbuf == 0)
293 {
294 if (fp->_IO_read_base < fp->_IO_read_ptr)
295 {
296 /* Partially used the buffer for some input data that
297 produces no output. */
298 size_t avail = fp->_IO_read_end - fp->_IO_read_ptr;
299 memmove (fp->_IO_read_base, fp->_IO_read_ptr, avail);
300 fp->_IO_read_ptr = fp->_IO_read_base;
301 fp->_IO_read_end -= avail;
302 goto again;
303 }
304 naccbuf = fp->_IO_read_end - fp->_IO_read_ptr;
305 if (naccbuf >= sizeof (accbuf))
306 goto out_eilseq;
307
308 memcpy (accbuf, fp->_IO_read_ptr, naccbuf);
309 }
310 else
311 {
312 size_t used = read_ptr_copy - accbuf;
313 if (used > 0)
314 {
315 memmove (accbuf, read_ptr_copy, naccbuf - used);
316 naccbuf -= used;
317 }
318
319 if (naccbuf == sizeof (accbuf))
320 goto out_eilseq;
321 }
322
323 fp->_IO_read_ptr = fp->_IO_read_end = fp->_IO_read_base;
324
325 goto again;
326 }
327
328 return *fp->_wide_data->_IO_read_ptr;
329}
330libc_hidden_def (_IO_wfile_underflow)
331
332
333static wint_t
334_IO_wfile_underflow_mmap (FILE *fp)
335{
336 struct _IO_codecvt *cd;
337 const char *read_stop;
338
339 if (__glibc_unlikely (fp->_flags & _IO_NO_READS))
340 {
341 fp->_flags |= _IO_ERR_SEEN;
342 __set_errno (EBADF);
343 return WEOF;
344 }
345 if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
346 return *fp->_wide_data->_IO_read_ptr;
347
348 cd = fp->_codecvt;
349
350 /* Maybe there is something left in the external buffer. */
351 if (fp->_IO_read_ptr >= fp->_IO_read_end
352 /* No. But maybe the read buffer is not fully set up. */
353 && _IO_file_underflow_mmap (fp) == EOF)
354 /* Nothing available. _IO_file_underflow_mmap has set the EOF or error
355 flags as appropriate. */
356 return WEOF;
357
358 /* There is more in the external. Convert it. */
359 read_stop = (const char *) fp->_IO_read_ptr;
360
361 if (fp->_wide_data->_IO_buf_base == NULL)
362 {
363 /* Maybe we already have a push back pointer. */
364 if (fp->_wide_data->_IO_save_base != NULL)
365 {
366 free (fp->_wide_data->_IO_save_base);
367 fp->_flags &= ~_IO_IN_BACKUP;
368 }
369 _IO_wdoallocbuf (fp);
370 }
371
372 fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
373 fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr =
374 fp->_wide_data->_IO_buf_base;
375 (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
376 fp->_IO_read_ptr, fp->_IO_read_end,
377 &read_stop,
378 fp->_wide_data->_IO_read_ptr,
379 fp->_wide_data->_IO_buf_end,
380 &fp->_wide_data->_IO_read_end);
381
382 fp->_IO_read_ptr = (char *) read_stop;
383
384 /* If we managed to generate some text return the next character. */
385 if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
386 return *fp->_wide_data->_IO_read_ptr;
387
388 /* There is some garbage at the end of the file. */
389 __set_errno (EILSEQ);
390 fp->_flags |= _IO_ERR_SEEN;
391 return WEOF;
392}
393
394static wint_t
395_IO_wfile_underflow_maybe_mmap (FILE *fp)
396{
397 /* This is the first read attempt. Doing the underflow will choose mmap
398 or vanilla operations and then punt to the chosen underflow routine.
399 Then we can punt to ours. */
400 if (_IO_file_underflow_maybe_mmap (fp) == EOF)
401 return WEOF;
402
403 return _IO_WUNDERFLOW (fp);
404}
405
406
407wint_t
408_IO_wfile_overflow (FILE *f, wint_t wch)
409{
410 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
411 {
412 f->_flags |= _IO_ERR_SEEN;
413 __set_errno (EBADF);
414 return WEOF;
415 }
416 /* If currently reading or no buffer allocated. */
417 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
418 {
419 /* Allocate a buffer if needed. */
420 if (f->_wide_data->_IO_write_base == 0)
421 {
422 _IO_wdoallocbuf (f);
423 _IO_free_wbackup_area (f);
424 _IO_wsetg (f, f->_wide_data->_IO_buf_base,
425 f->_wide_data->_IO_buf_base, f->_wide_data->_IO_buf_base);
426
427 if (f->_IO_write_base == NULL)
428 {
429 _IO_doallocbuf (f);
430 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
431 }
432 }
433 else
434 {
435 /* Otherwise must be currently reading. If _IO_read_ptr
436 (and hence also _IO_read_end) is at the buffer end,
437 logically slide the buffer forwards one block (by setting
438 the read pointers to all point at the beginning of the
439 block). This makes room for subsequent output.
440 Otherwise, set the read pointers to _IO_read_end (leaving
441 that alone, so it can continue to correspond to the
442 external position). */
443 if (f->_wide_data->_IO_read_ptr == f->_wide_data->_IO_buf_end)
444 {
445 f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
446 f->_wide_data->_IO_read_end = f->_wide_data->_IO_read_ptr =
447 f->_wide_data->_IO_buf_base;
448 }
449 }
450 f->_wide_data->_IO_write_ptr = f->_wide_data->_IO_read_ptr;
451 f->_wide_data->_IO_write_base = f->_wide_data->_IO_write_ptr;
452 f->_wide_data->_IO_write_end = f->_wide_data->_IO_buf_end;
453 f->_wide_data->_IO_read_base = f->_wide_data->_IO_read_ptr =
454 f->_wide_data->_IO_read_end;
455
456 f->_IO_write_ptr = f->_IO_read_ptr;
457 f->_IO_write_base = f->_IO_write_ptr;
458 f->_IO_write_end = f->_IO_buf_end;
459 f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
460
461 f->_flags |= _IO_CURRENTLY_PUTTING;
462 if (f->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
463 f->_wide_data->_IO_write_end = f->_wide_data->_IO_write_ptr;
464 }
465 if (wch == WEOF)
466 return _IO_do_flush (f);
467 if (f->_wide_data->_IO_write_ptr == f->_wide_data->_IO_buf_end)
468 /* Buffer is really full */
469 if (_IO_do_flush (f) == EOF)
470 return WEOF;
471 *f->_wide_data->_IO_write_ptr++ = wch;
472 if ((f->_flags & _IO_UNBUFFERED)
473 || ((f->_flags & _IO_LINE_BUF) && wch == L'\n'))
474 if (_IO_do_flush (f) == EOF)
475 return WEOF;
476 return wch;
477}
478libc_hidden_def (_IO_wfile_overflow)
479
480wint_t
481_IO_wfile_sync (FILE *fp)
482{
483 ssize_t delta;
484 wint_t retval = 0;
485
486 /* char* ptr = cur_ptr(); */
487 if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
488 if (_IO_do_flush (fp))
489 return WEOF;
490 delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
491 if (delta != 0)
492 {
493 /* We have to find out how many bytes we have to go back in the
494 external buffer. */
495 struct _IO_codecvt *cv = fp->_codecvt;
496 off64_t new_pos;
497
498 int clen = (*cv->__codecvt_do_encoding) (cv);
499
500 if (clen > 0)
501 /* It is easy, a fixed number of input bytes are used for each
502 wide character. */
503 delta *= clen;
504 else
505 {
506 /* We have to find out the hard way how much to back off.
507 To do this we determine how much input we needed to
508 generate the wide characters up to the current reading
509 position. */
510 int nread;
511 size_t wnread = (fp->_wide_data->_IO_read_ptr
512 - fp->_wide_data->_IO_read_base);
513 fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
514 nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
515 fp->_IO_read_base,
516 fp->_IO_read_end, wnread);
517 fp->_IO_read_ptr = fp->_IO_read_base + nread;
518 delta = -(fp->_IO_read_end - fp->_IO_read_base - nread);
519 }
520
521 new_pos = _IO_SYSSEEK (fp, delta, 1);
522 if (new_pos != (off64_t) EOF)
523 {
524 fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
525 fp->_IO_read_end = fp->_IO_read_ptr;
526 }
527 else if (errno == ESPIPE)
528 ; /* Ignore error from unseekable devices. */
529 else
530 retval = WEOF;
531 }
532 if (retval != WEOF)
533 fp->_offset = _IO_pos_BAD;
534 /* FIXME: Cleanup - can this be shared? */
535 /* setg(base(), ptr, ptr); */
536 return retval;
537}
538libc_hidden_def (_IO_wfile_sync)
539
540/* Adjust the internal buffer pointers to reflect the state in the external
541 buffer. The content between fp->_IO_read_base and fp->_IO_read_ptr is
542 assumed to be converted and available in the range
543 fp->_wide_data->_IO_read_base and fp->_wide_data->_IO_read_end.
544
545 Returns 0 on success and -1 on error with the _IO_ERR_SEEN flag set. */
546static int
547adjust_wide_data (FILE *fp, bool do_convert)
548{
549 struct _IO_codecvt *cv = fp->_codecvt;
550
551 int clen = (*cv->__codecvt_do_encoding) (cv);
552
553 /* Take the easy way out for constant length encodings if we don't need to
554 convert. */
555 if (!do_convert && clen > 0)
556 {
557 fp->_wide_data->_IO_read_end += ((fp->_IO_read_ptr - fp->_IO_read_base)
558 / clen);
559 goto done;
560 }
561
562 enum __codecvt_result status;
563 const char *read_stop = (const char *) fp->_IO_read_base;
564 do
565 {
566
567 fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
568 status = (*cv->__codecvt_do_in) (cv, &fp->_wide_data->_IO_state,
569 fp->_IO_read_base, fp->_IO_read_ptr,
570 &read_stop,
571 fp->_wide_data->_IO_read_base,
572 fp->_wide_data->_IO_buf_end,
573 &fp->_wide_data->_IO_read_end);
574
575 /* Should we return EILSEQ? */
576 if (__glibc_unlikely (status == __codecvt_error))
577 {
578 fp->_flags |= _IO_ERR_SEEN;
579 return -1;
580 }
581 }
582 while (__builtin_expect (status == __codecvt_partial, 0));
583
584done:
585 /* Now seek to _IO_read_end to behave as if we have read it all in. */
586 fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
587
588 return 0;
589}
590
591/* ftell{,o} implementation for wide mode. Don't modify any state of the file
592 pointer while we try to get the current state of the stream except in one
593 case, which is when we have unflushed writes in append mode. */
594static off64_t
595do_ftell_wide (FILE *fp)
596{
597 off64_t result, offset = 0;
598
599 /* No point looking for offsets in the buffer if it hasn't even been
600 allocated. */
601 if (fp->_wide_data->_IO_buf_base != NULL)
602 {
603 const wchar_t *wide_read_base;
604 const wchar_t *wide_read_ptr;
605 const wchar_t *wide_read_end;
606 bool unflushed_writes = (fp->_wide_data->_IO_write_ptr
607 > fp->_wide_data->_IO_write_base);
608
609 bool append_mode = (fp->_flags & _IO_IS_APPENDING) == _IO_IS_APPENDING;
610
611 /* When we have unflushed writes in append mode, seek to the end of the
612 file and record that offset. This is the only time we change the file
613 stream state and it is safe since the file handle is active. */
614 if (unflushed_writes && append_mode)
615 {
616 result = _IO_SYSSEEK (fp, 0, _IO_seek_end);
617 if (result == _IO_pos_BAD)
618 return EOF;
619 else
620 fp->_offset = result;
621 }
622
623 /* XXX For wide stream with backup store it is not very
624 reasonable to determine the offset. The pushed-back
625 character might require a state change and we need not be
626 able to compute the initial state by reverse transformation
627 since there is no guarantee of symmetry. So we don't even
628 try and return an error. */
629 if (_IO_in_backup (fp))
630 {
631 if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
632 {
633 __set_errno (EINVAL);
634 return -1;
635 }
636
637 /* Nothing in the backup store, so note the backed up pointers
638 without changing the state. */
639 wide_read_base = fp->_wide_data->_IO_save_base;
640 wide_read_ptr = wide_read_base;
641 wide_read_end = fp->_wide_data->_IO_save_end;
642 }
643 else
644 {
645 wide_read_base = fp->_wide_data->_IO_read_base;
646 wide_read_ptr = fp->_wide_data->_IO_read_ptr;
647 wide_read_end = fp->_wide_data->_IO_read_end;
648 }
649
650 struct _IO_codecvt *cv = fp->_codecvt;
651 int clen = (*cv->__codecvt_do_encoding) (cv);
652
653 if (!unflushed_writes)
654 {
655 if (clen > 0)
656 {
657 offset -= (wide_read_end - wide_read_ptr) * clen;
658 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
659 }
660 else
661 {
662 int nread;
663
664 size_t delta = wide_read_ptr - wide_read_base;
665 __mbstate_t state = fp->_wide_data->_IO_last_state;
666 nread = (*cv->__codecvt_do_length) (cv, &state,
667 fp->_IO_read_base,
668 fp->_IO_read_end, delta);
669 offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
670 }
671 }
672 else
673 {
674 if (clen > 0)
675 offset += (fp->_wide_data->_IO_write_ptr
676 - fp->_wide_data->_IO_write_base) * clen;
677 else
678 {
679 size_t delta = (fp->_wide_data->_IO_write_ptr
680 - fp->_wide_data->_IO_write_base);
681
682 /* Allocate enough space for the conversion. */
683 size_t outsize = delta * sizeof (wchar_t);
684 char *out = malloc (outsize);
685 char *outstop = out;
686 const wchar_t *in = fp->_wide_data->_IO_write_base;
687
688 enum __codecvt_result status;
689
690 __mbstate_t state = fp->_wide_data->_IO_last_state;
691 status = (*cv->__codecvt_do_out) (cv, &state,
692 in, in + delta, &in,
693 out, out + outsize, &outstop);
694
695 /* We don't check for __codecvt_partial because it can be
696 returned on one of two conditions: either the output
697 buffer is full or the input sequence is incomplete. We
698 take care to allocate enough buffer and our input
699 sequences must be complete since they are accepted as
700 wchar_t; if not, then that is an error. */
701 if (__glibc_unlikely (status != __codecvt_ok))
702 {
703 free (out);
704 return WEOF;
705 }
706
707 offset += outstop - out;
708 free (out);
709 }
710
711 /* We don't trust _IO_read_end to represent the current file offset
712 when writing in append mode because the value would have to be
713 shifted to the end of the file during a flush. Use the write base
714 instead, along with the new offset we got above when we did a seek
715 to the end of the file. */
716 if (append_mode)
717 offset += fp->_IO_write_ptr - fp->_IO_write_base;
718 /* For all other modes, _IO_read_end represents the file offset. */
719 else
720 offset += fp->_IO_write_ptr - fp->_IO_read_end;
721 }
722 }
723
724 if (fp->_offset != _IO_pos_BAD)
725 result = fp->_offset;
726 else
727 result = _IO_SYSSEEK (fp, 0, _IO_seek_cur);
728
729 if (result == EOF)
730 return result;
731
732 result += offset;
733
734 if (result < 0)
735 {
736 __set_errno (EINVAL);
737 return EOF;
738 }
739
740 return result;
741}
742
743off64_t
744_IO_wfile_seekoff (FILE *fp, off64_t offset, int dir, int mode)
745{
746 off64_t result;
747 off64_t delta, new_offset;
748 long int count;
749
750 /* Short-circuit into a separate function. We don't want to mix any
751 functionality and we don't want to touch anything inside the FILE
752 object. */
753 if (mode == 0)
754 return do_ftell_wide (fp);
755
756 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
757 offset of the underlying file must be exact. */
758 int must_be_exact = ((fp->_wide_data->_IO_read_base
759 == fp->_wide_data->_IO_read_end)
760 && (fp->_wide_data->_IO_write_base
761 == fp->_wide_data->_IO_write_ptr));
762
763 bool was_writing = ((fp->_wide_data->_IO_write_ptr
764 > fp->_wide_data->_IO_write_base)
765 || _IO_in_put_mode (fp));
766
767 /* Flush unwritten characters.
768 (This may do an unneeded write if we seek within the buffer.
769 But to be able to switch to reading, we would need to set
770 egptr to pptr. That can't be done in the current design,
771 which assumes file_ptr() is eGptr. Anyway, since we probably
772 end up flushing when we close(), it doesn't make much difference.)
773 FIXME: simulate mem-mapped files. */
774 if (was_writing && _IO_switch_to_wget_mode (fp))
775 return WEOF;
776
777 if (fp->_wide_data->_IO_buf_base == NULL)
778 {
779 /* It could be that we already have a pushback buffer. */
780 if (fp->_wide_data->_IO_read_base != NULL)
781 {
782 free (fp->_wide_data->_IO_read_base);
783 fp->_flags &= ~_IO_IN_BACKUP;
784 }
785 _IO_doallocbuf (fp);
786 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
787 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
788 _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
789 fp->_wide_data->_IO_buf_base);
790 _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
791 fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
792 }
793
794 switch (dir)
795 {
796 struct _IO_codecvt *cv;
797 int clen;
798
799 case _IO_seek_cur:
800 /* Adjust for read-ahead (bytes is buffer). To do this we must
801 find out which position in the external buffer corresponds to
802 the current position in the internal buffer. */
803 cv = fp->_codecvt;
804 clen = (*cv->__codecvt_do_encoding) (cv);
805
806 if (mode != 0 || !was_writing)
807 {
808 if (clen > 0)
809 {
810 offset -= (fp->_wide_data->_IO_read_end
811 - fp->_wide_data->_IO_read_ptr) * clen;
812 /* Adjust by readahead in external buffer. */
813 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
814 }
815 else
816 {
817 int nread;
818
819 delta = (fp->_wide_data->_IO_read_ptr
820 - fp->_wide_data->_IO_read_base);
821 fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
822 nread = (*cv->__codecvt_do_length) (cv,
823 &fp->_wide_data->_IO_state,
824 fp->_IO_read_base,
825 fp->_IO_read_end, delta);
826 fp->_IO_read_ptr = fp->_IO_read_base + nread;
827 fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
828 offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
829 }
830 }
831
832 if (fp->_offset == _IO_pos_BAD)
833 goto dumb;
834
835 /* Make offset absolute, assuming current pointer is file_ptr(). */
836 offset += fp->_offset;
837
838 dir = _IO_seek_set;
839 break;
840 case _IO_seek_set:
841 break;
842 case _IO_seek_end:
843 {
844 struct stat64 st;
845 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
846 {
847 offset += st.st_size;
848 dir = _IO_seek_set;
849 }
850 else
851 goto dumb;
852 }
853 }
854
855 _IO_free_wbackup_area (fp);
856
857 /* At this point, dir==_IO_seek_set. */
858
859 /* If destination is within current buffer, optimize: */
860 if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
861 && !_IO_in_backup (fp))
862 {
863 off64_t start_offset = (fp->_offset
864 - (fp->_IO_read_end - fp->_IO_buf_base));
865 if (offset >= start_offset && offset < fp->_offset)
866 {
867 _IO_setg (fp, fp->_IO_buf_base,
868 fp->_IO_buf_base + (offset - start_offset),
869 fp->_IO_read_end);
870 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
871 _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
872 fp->_wide_data->_IO_buf_base,
873 fp->_wide_data->_IO_buf_base);
874 _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
875 fp->_wide_data->_IO_buf_base);
876
877 if (adjust_wide_data (fp, false))
878 goto dumb;
879
880 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
881 goto resync;
882 }
883 }
884
885 if (fp->_flags & _IO_NO_READS)
886 goto dumb;
887
888 /* Try to seek to a block boundary, to improve kernel page management. */
889 new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
890 delta = offset - new_offset;
891 if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
892 {
893 new_offset = offset;
894 delta = 0;
895 }
896 result = _IO_SYSSEEK (fp, new_offset, 0);
897 if (result < 0)
898 return EOF;
899 if (delta == 0)
900 count = 0;
901 else
902 {
903 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
904 (must_be_exact
905 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
906 if (count < delta)
907 {
908 /* We weren't allowed to read, but try to seek the remainder. */
909 offset = count == EOF ? delta : delta-count;
910 dir = _IO_seek_cur;
911 goto dumb;
912 }
913 }
914 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
915 fp->_IO_buf_base + count);
916 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
917 _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
918 fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
919 _IO_wsetp (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
920
921 if (adjust_wide_data (fp, true))
922 goto dumb;
923
924 fp->_offset = result + count;
925 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
926 return offset;
927 dumb:
928
929 _IO_unsave_markers (fp);
930 result = _IO_SYSSEEK (fp, offset, dir);
931 if (result != EOF)
932 {
933 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
934 fp->_offset = result;
935 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
936 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
937 _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
938 fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
939 _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
940 fp->_wide_data->_IO_buf_base);
941 }
942 return result;
943
944resync:
945 /* We need to do it since it is possible that the file offset in
946 the kernel may be changed behind our back. It may happen when
947 we fopen a file and then do a fork. One process may access the
948 file and the kernel file offset will be changed. */
949 if (fp->_offset >= 0)
950 _IO_SYSSEEK (fp, fp->_offset, 0);
951
952 return offset;
953}
954libc_hidden_def (_IO_wfile_seekoff)
955
956
957size_t
958_IO_wfile_xsputn (FILE *f, const void *data, size_t n)
959{
960 const wchar_t *s = (const wchar_t *) data;
961 size_t to_do = n;
962 int must_flush = 0;
963 size_t count;
964
965 if (n <= 0)
966 return 0;
967 /* This is an optimized implementation.
968 If the amount to be written straddles a block boundary
969 (or the filebuf is unbuffered), use sys_write directly. */
970
971 /* First figure out how much space is available in the buffer. */
972 count = f->_wide_data->_IO_write_end - f->_wide_data->_IO_write_ptr;
973 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
974 {
975 count = f->_wide_data->_IO_buf_end - f->_wide_data->_IO_write_ptr;
976 if (count >= n)
977 {
978 const wchar_t *p;
979 for (p = s + n; p > s; )
980 {
981 if (*--p == L'\n')
982 {
983 count = p - s + 1;
984 must_flush = 1;
985 break;
986 }
987 }
988 }
989 }
990 /* Then fill the buffer. */
991 if (count > 0)
992 {
993 if (count > to_do)
994 count = to_do;
995 if (count > 20)
996 {
997 f->_wide_data->_IO_write_ptr =
998 __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
999 s += count;
1000 }
1001 else
1002 {
1003 wchar_t *p = f->_wide_data->_IO_write_ptr;
1004 int i = (int) count;
1005 while (--i >= 0)
1006 *p++ = *s++;
1007 f->_wide_data->_IO_write_ptr = p;
1008 }
1009 to_do -= count;
1010 }
1011 if (to_do > 0)
1012 to_do -= _IO_wdefault_xsputn (f, s, to_do);
1013 if (must_flush
1014 && f->_wide_data->_IO_write_ptr != f->_wide_data->_IO_write_base)
1015 _IO_wdo_write (f, f->_wide_data->_IO_write_base,
1016 f->_wide_data->_IO_write_ptr
1017 - f->_wide_data->_IO_write_base);
1018
1019 return n - to_do;
1020}
1021libc_hidden_def (_IO_wfile_xsputn)
1022
1023
1024const struct _IO_jump_t _IO_wfile_jumps libio_vtable =
1025{
1026 JUMP_INIT_DUMMY,
1027 JUMP_INIT(finish, _IO_new_file_finish),
1028 JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1029 JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow),
1030 JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1031 JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1032 JUMP_INIT(xsputn, _IO_wfile_xsputn),
1033 JUMP_INIT(xsgetn, _IO_file_xsgetn),
1034 JUMP_INIT(seekoff, _IO_wfile_seekoff),
1035 JUMP_INIT(seekpos, _IO_default_seekpos),
1036 JUMP_INIT(setbuf, _IO_new_file_setbuf),
1037 JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1038 JUMP_INIT(doallocate, _IO_wfile_doallocate),
1039 JUMP_INIT(read, _IO_file_read),
1040 JUMP_INIT(write, _IO_new_file_write),
1041 JUMP_INIT(seek, _IO_file_seek),
1042 JUMP_INIT(close, _IO_file_close),
1043 JUMP_INIT(stat, _IO_file_stat),
1044 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1045 JUMP_INIT(imbue, _IO_default_imbue)
1046};
1047libc_hidden_data_def (_IO_wfile_jumps)
1048
1049
1050const struct _IO_jump_t _IO_wfile_jumps_mmap libio_vtable =
1051{
1052 JUMP_INIT_DUMMY,
1053 JUMP_INIT(finish, _IO_new_file_finish),
1054 JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1055 JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow_mmap),
1056 JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1057 JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1058 JUMP_INIT(xsputn, _IO_wfile_xsputn),
1059 JUMP_INIT(xsgetn, _IO_file_xsgetn),
1060 JUMP_INIT(seekoff, _IO_wfile_seekoff),
1061 JUMP_INIT(seekpos, _IO_default_seekpos),
1062 JUMP_INIT(setbuf, _IO_file_setbuf_mmap),
1063 JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1064 JUMP_INIT(doallocate, _IO_wfile_doallocate),
1065 JUMP_INIT(read, _IO_file_read),
1066 JUMP_INIT(write, _IO_new_file_write),
1067 JUMP_INIT(seek, _IO_file_seek),
1068 JUMP_INIT(close, _IO_file_close_mmap),
1069 JUMP_INIT(stat, _IO_file_stat),
1070 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1071 JUMP_INIT(imbue, _IO_default_imbue)
1072};
1073
1074const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap libio_vtable =
1075{
1076 JUMP_INIT_DUMMY,
1077 JUMP_INIT(finish, _IO_new_file_finish),
1078 JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1079 JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow_maybe_mmap),
1080 JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1081 JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1082 JUMP_INIT(xsputn, _IO_wfile_xsputn),
1083 JUMP_INIT(xsgetn, _IO_file_xsgetn),
1084 JUMP_INIT(seekoff, _IO_wfile_seekoff),
1085 JUMP_INIT(seekpos, _IO_default_seekpos),
1086 JUMP_INIT(setbuf, _IO_file_setbuf_mmap),
1087 JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1088 JUMP_INIT(doallocate, _IO_wfile_doallocate),
1089 JUMP_INIT(read, _IO_file_read),
1090 JUMP_INIT(write, _IO_new_file_write),
1091 JUMP_INIT(seek, _IO_file_seek),
1092 JUMP_INIT(close, _IO_file_close),
1093 JUMP_INIT(stat, _IO_file_stat),
1094 JUMP_INIT(showmanyc, _IO_default_showmanyc),
1095 JUMP_INIT(imbue, _IO_default_imbue)
1096};
1097