libio/wfileops.c

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