libio/wfileops.c

   1 /* Copyright (C) 1993-2019 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. */
  38 int
  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 }
 109 libc_hidden_def (_IO_wdo_write)
 110
 111
 112 wint_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 (stdout);
 212
 213       if ((stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF))
 214           == (_IO_LINKED | _IO_LINE_BUF))
 215         _IO_OVERFLOW (stdout, EOF);
 216
 217       _IO_release_lock (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 }
 330 libc_hidden_def (_IO_wfile_underflow)
 331
 332
 333 static 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
 394 static 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
 407 wint_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 }
 478 libc_hidden_def (_IO_wfile_overflow)
 479
 480 wint_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
 512           fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
 513           nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
 514                                               fp->_IO_read_base,
 515                                               fp->_IO_read_end, delta);
 516           fp->_IO_read_ptr = fp->_IO_read_base + nread;
 517           delta = -(fp->_IO_read_end - fp->_IO_read_base - nread);
 518         }
 519
 520       new_pos = _IO_SYSSEEK (fp, delta, 1);
 521       if (new_pos != (off64_t) EOF)
 522         {
 523           fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
 524           fp->_IO_read_end = fp->_IO_read_ptr;
 525         }
 526       else if (errno == ESPIPE)
 527         ; /* Ignore error from unseekable devices. */
 528       else
 529         retval = WEOF;
 530     }
 531   if (retval != WEOF)
 532     fp->_offset = _IO_pos_BAD;
 533   /* FIXME: Cleanup - can this be shared? */
 534   /*    setg(base(), ptr, ptr); */
 535   return retval;
 536 }
 537 libc_hidden_def (_IO_wfile_sync)
 538
 539 /* Adjust the internal buffer pointers to reflect the state in the external
 540    buffer.  The content between fp->_IO_read_base and fp->_IO_read_ptr is
 541    assumed to be converted and available in the range
 542    fp->_wide_data->_IO_read_base and fp->_wide_data->_IO_read_end.
 543
 544    Returns 0 on success and -1 on error with the _IO_ERR_SEEN flag set.  */
 545 static int
 546 adjust_wide_data (FILE *fp, bool do_convert)
 547 {
 548   struct _IO_codecvt *cv = fp->_codecvt;
 549
 550   int clen = (*cv->__codecvt_do_encoding) (cv);
 551
 552   /* Take the easy way out for constant length encodings if we don't need to
 553      convert.  */
 554   if (!do_convert && clen > 0)
 555     {
 556       fp->_wide_data->_IO_read_end += ((fp->_IO_read_ptr - fp->_IO_read_base)
 557                                        / clen);
 558       goto done;
 559     }
 560
 561   enum __codecvt_result status;
 562   const char *read_stop = (const char *) fp->_IO_read_base;
 563   do
 564     {
 565
 566       fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
 567       status = (*cv->__codecvt_do_in) (cv, &fp->_wide_data->_IO_state,
 568                                        fp->_IO_read_base, fp->_IO_read_ptr,
 569                                        &read_stop,
 570                                        fp->_wide_data->_IO_read_base,
 571                                        fp->_wide_data->_IO_buf_end,
 572                                        &fp->_wide_data->_IO_read_end);
 573
 574       /* Should we return EILSEQ?  */
 575       if (__glibc_unlikely (status == __codecvt_error))
 576         {
 577           fp->_flags |= _IO_ERR_SEEN;
 578           return -1;
 579         }
 580     }
 581   while (__builtin_expect (status == __codecvt_partial, 0));
 582
 583 done:
 584   /* Now seek to _IO_read_end to behave as if we have read it all in.  */
 585   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
 586
 587   return 0;
 588 }
 589
 590 /* ftell{,o} implementation for wide mode.  Don't modify any state of the file
 591    pointer while we try to get the current state of the stream except in one
 592    case, which is when we have unflushed writes in append mode.  */
 593 static off64_t
 594 do_ftell_wide (FILE *fp)
 595 {
 596   off64_t result, offset = 0;
 597
 598   /* No point looking for offsets in the buffer if it hasn't even been
 599      allocated.  */
 600   if (fp->_wide_data->_IO_buf_base != NULL)
 601     {
 602       const wchar_t *wide_read_base;
 603       const wchar_t *wide_read_ptr;
 604       const wchar_t *wide_read_end;
 605       bool unflushed_writes = (fp->_wide_data->_IO_write_ptr
 606                                > fp->_wide_data->_IO_write_base);
 607
 608       bool append_mode = (fp->_flags & _IO_IS_APPENDING) == _IO_IS_APPENDING;
 609
 610       /* When we have unflushed writes in append mode, seek to the end of the
 611          file and record that offset.  This is the only time we change the file
 612          stream state and it is safe since the file handle is active.  */
 613       if (unflushed_writes && append_mode)
 614         {
 615           result = _IO_SYSSEEK (fp, 0, _IO_seek_end);
 616           if (result == _IO_pos_BAD)
 617             return EOF;
 618           else
 619             fp->_offset = result;
 620         }
 621
 622       /* XXX For wide stream with backup store it is not very
 623          reasonable to determine the offset.  The pushed-back
 624          character might require a state change and we need not be
 625          able to compute the initial state by reverse transformation
 626          since there is no guarantee of symmetry.  So we don't even
 627          try and return an error.  */
 628       if (_IO_in_backup (fp))
 629         {
 630           if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 631             {
 632               __set_errno (EINVAL);
 633               return -1;
 634             }
 635
 636           /* Nothing in the backup store, so note the backed up pointers
 637              without changing the state.  */
 638           wide_read_base = fp->_wide_data->_IO_save_base;
 639           wide_read_ptr = wide_read_base;
 640           wide_read_end = fp->_wide_data->_IO_save_end;
 641         }
 642       else
 643         {
 644           wide_read_base = fp->_wide_data->_IO_read_base;
 645           wide_read_ptr = fp->_wide_data->_IO_read_ptr;
 646           wide_read_end = fp->_wide_data->_IO_read_end;
 647         }
 648
 649       struct _IO_codecvt *cv = fp->_codecvt;
 650       int clen = (*cv->__codecvt_do_encoding) (cv);
 651
 652       if (!unflushed_writes)
 653         {
 654           if (clen > 0)
 655             {
 656               offset -= (wide_read_end - wide_read_ptr) * clen;
 657               offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 658             }
 659           else
 660             {
 661               int nread;
 662
 663               size_t delta = wide_read_ptr - wide_read_base;
 664               __mbstate_t state = fp->_wide_data->_IO_last_state;
 665               nread = (*cv->__codecvt_do_length) (cv, &state,
 666                                                   fp->_IO_read_base,
 667                                                   fp->_IO_read_end, delta);
 668               offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
 669             }
 670         }
 671       else
 672         {
 673           if (clen > 0)
 674             offset += (fp->_wide_data->_IO_write_ptr
 675                        - fp->_wide_data->_IO_write_base) * clen;
 676           else
 677             {
 678               size_t delta = (fp->_wide_data->_IO_write_ptr
 679                               - fp->_wide_data->_IO_write_base);
 680
 681               /* Allocate enough space for the conversion.  */
 682               size_t outsize = delta * sizeof (wchar_t);
 683               char *out = malloc (outsize);
 684               char *outstop = out;
 685               const wchar_t *in = fp->_wide_data->_IO_write_base;
 686
 687               enum __codecvt_result status;
 688
 689               __mbstate_t state = fp->_wide_data->_IO_last_state;
 690               status = (*cv->__codecvt_do_out) (cv, &state,
 691                                                 in, in + delta, &in,
 692                                                 out, out + outsize, &outstop);
 693
 694               /* We don't check for __codecvt_partial because it can be
 695                  returned on one of two conditions: either the output
 696                  buffer is full or the input sequence is incomplete.  We
 697                  take care to allocate enough buffer and our input
 698                  sequences must be complete since they are accepted as
 699                  wchar_t; if not, then that is an error.  */
 700               if (__glibc_unlikely (status != __codecvt_ok))
 701                 {
 702                   free (out);
 703                   return WEOF;
 704                 }
 705
 706               offset += outstop - out;
 707               free (out);
 708             }
 709
 710           /* We don't trust _IO_read_end to represent the current file offset
 711              when writing in append mode because the value would have to be
 712              shifted to the end of the file during a flush.  Use the write base
 713              instead, along with the new offset we got above when we did a seek
 714              to the end of the file.  */
 715           if (append_mode)
 716             offset += fp->_IO_write_ptr - fp->_IO_write_base;
 717           /* For all other modes, _IO_read_end represents the file offset.  */
 718           else
 719             offset += fp->_IO_write_ptr - fp->_IO_read_end;
 720         }
 721     }
 722
 723   if (fp->_offset != _IO_pos_BAD)
 724     result = fp->_offset;
 725   else
 726     result = _IO_SYSSEEK (fp, 0, _IO_seek_cur);
 727
 728   if (result == EOF)
 729     return result;
 730
 731   result += offset;
 732
 733   if (result < 0)
 734     {
 735       __set_errno (EINVAL);
 736       return EOF;
 737     }
 738
 739   return result;
 740 }
 741
 742 off64_t
 743 _IO_wfile_seekoff (FILE *fp, off64_t offset, int dir, int mode)
 744 {
 745   off64_t result;
 746   off64_t delta, new_offset;
 747   long int count;
 748
 749   /* Short-circuit into a separate function.  We don't want to mix any
 750      functionality and we don't want to touch anything inside the FILE
 751      object. */
 752   if (mode == 0)
 753     return do_ftell_wide (fp);
 754
 755   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 756      offset of the underlying file must be exact.  */
 757   int must_be_exact = ((fp->_wide_data->_IO_read_base
 758                         == fp->_wide_data->_IO_read_end)
 759                        && (fp->_wide_data->_IO_write_base
 760                            == fp->_wide_data->_IO_write_ptr));
 761
 762   bool was_writing = ((fp->_wide_data->_IO_write_ptr
 763                        > fp->_wide_data->_IO_write_base)
 764                       || _IO_in_put_mode (fp));
 765
 766   /* Flush unwritten characters.
 767      (This may do an unneeded write if we seek within the buffer.
 768      But to be able to switch to reading, we would need to set
 769      egptr to pptr.  That can't be done in the current design,
 770      which assumes file_ptr() is eGptr.  Anyway, since we probably
 771      end up flushing when we close(), it doesn't make much difference.)
 772      FIXME: simulate mem-mapped files. */
 773   if (was_writing && _IO_switch_to_wget_mode (fp))
 774     return WEOF;
 775
 776   if (fp->_wide_data->_IO_buf_base == NULL)
 777     {
 778       /* It could be that we already have a pushback buffer.  */
 779       if (fp->_wide_data->_IO_read_base != NULL)
 780         {
 781           free (fp->_wide_data->_IO_read_base);
 782           fp->_flags &= ~_IO_IN_BACKUP;
 783         }
 784       _IO_doallocbuf (fp);
 785       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 786       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 787       _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
 788                  fp->_wide_data->_IO_buf_base);
 789       _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
 790                  fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
 791     }
 792
 793   switch (dir)
 794     {
 795       struct _IO_codecvt *cv;
 796       int clen;
 797
 798     case _IO_seek_cur:
 799       /* Adjust for read-ahead (bytes is buffer).  To do this we must
 800          find out which position in the external buffer corresponds to
 801          the current position in the internal buffer.  */
 802       cv = fp->_codecvt;
 803       clen = (*cv->__codecvt_do_encoding) (cv);
 804
 805       if (mode != 0 || !was_writing)
 806         {
 807           if (clen > 0)
 808             {
 809               offset -= (fp->_wide_data->_IO_read_end
 810                          - fp->_wide_data->_IO_read_ptr) * clen;
 811               /* Adjust by readahead in external buffer.  */
 812               offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 813             }
 814           else
 815             {
 816               int nread;
 817
 818               delta = (fp->_wide_data->_IO_read_ptr
 819                        - fp->_wide_data->_IO_read_base);
 820               fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
 821               nread = (*cv->__codecvt_do_length) (cv,
 822                                                   &fp->_wide_data->_IO_state,
 823                                                   fp->_IO_read_base,
 824                                                   fp->_IO_read_end, delta);
 825               fp->_IO_read_ptr = fp->_IO_read_base + nread;
 826               fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
 827               offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
 828             }
 829         }
 830
 831       if (fp->_offset == _IO_pos_BAD)
 832         goto dumb;
 833
 834       /* Make offset absolute, assuming current pointer is file_ptr(). */
 835       offset += fp->_offset;
 836
 837       dir = _IO_seek_set;
 838       break;
 839     case _IO_seek_set:
 840       break;
 841     case _IO_seek_end:
 842       {
 843         struct stat64 st;
 844         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 845           {
 846             offset += st.st_size;
 847             dir = _IO_seek_set;
 848           }
 849         else
 850           goto dumb;
 851       }
 852     }
 853
 854   _IO_free_wbackup_area (fp);
 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       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 size_t
 957 _IO_wfile_xsputn (FILE *f, const void *data, size_t n)
 958 {
 959   const wchar_t *s = (const wchar_t *) data;
 960   size_t to_do = n;
 961   int must_flush = 0;
 962   size_t count;
 963
 964   if (n <= 0)
 965     return 0;
 966   /* This is an optimized implementation.
 967      If the amount to be written straddles a block boundary
 968      (or the filebuf is unbuffered), use sys_write directly. */
 969
 970   /* First figure out how much space is available in the buffer. */
 971   count = f->_wide_data->_IO_write_end - f->_wide_data->_IO_write_ptr;
 972   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 973     {
 974       count = f->_wide_data->_IO_buf_end - f->_wide_data->_IO_write_ptr;
 975       if (count >= n)
 976         {
 977           const wchar_t *p;
 978           for (p = s + n; p > s; )
 979             {
 980               if (*--p == L'\n')
 981                 {
 982                   count = p - s + 1;
 983                   must_flush = 1;
 984                   break;
 985                 }
 986             }
 987         }
 988     }
 989   /* Then fill the buffer. */
 990   if (count > 0)
 991     {
 992       if (count > to_do)
 993         count = to_do;
 994       if (count > 20)
 995         {
 996           f->_wide_data->_IO_write_ptr =
 997             __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
 998           s += count;
 999         }
1000       else
1001         {
1002           wchar_t *p = f->_wide_data->_IO_write_ptr;
1003           int i = (int) count;
1004           while (--i >= 0)
1005             *p++ = *s++;
1006           f->_wide_data->_IO_write_ptr = p;
1007         }
1008       to_do -= count;
1009     }
1010   if (to_do > 0)
1011     to_do -= _IO_wdefault_xsputn (f, s, to_do);
1012   if (must_flush
1013       && f->_wide_data->_IO_write_ptr != f->_wide_data->_IO_write_base)
1014     _IO_wdo_write (f, f->_wide_data->_IO_write_base,
1015                    f->_wide_data->_IO_write_ptr
1016                    - f->_wide_data->_IO_write_base);
1017
1018   return n - to_do;
1019 }
1020 libc_hidden_def (_IO_wfile_xsputn)
1021
1022
1023 const struct _IO_jump_t _IO_wfile_jumps libio_vtable =
1024 {
1025   JUMP_INIT_DUMMY,
1026   JUMP_INIT(finish, _IO_new_file_finish),
1027   JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1028   JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow),
1029   JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1030   JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1031   JUMP_INIT(xsputn, _IO_wfile_xsputn),
1032   JUMP_INIT(xsgetn, _IO_file_xsgetn),
1033   JUMP_INIT(seekoff, _IO_wfile_seekoff),
1034   JUMP_INIT(seekpos, _IO_default_seekpos),
1035   JUMP_INIT(setbuf, _IO_new_file_setbuf),
1036   JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1037   JUMP_INIT(doallocate, _IO_wfile_doallocate),
1038   JUMP_INIT(read, _IO_file_read),
1039   JUMP_INIT(write, _IO_new_file_write),
1040   JUMP_INIT(seek, _IO_file_seek),
1041   JUMP_INIT(close, _IO_file_close),
1042   JUMP_INIT(stat, _IO_file_stat),
1043   JUMP_INIT(showmanyc, _IO_default_showmanyc),
1044   JUMP_INIT(imbue, _IO_default_imbue)
1045 };
1046 libc_hidden_data_def (_IO_wfile_jumps)
1047
1048
1049 const struct _IO_jump_t _IO_wfile_jumps_mmap libio_vtable =
1050 {
1051   JUMP_INIT_DUMMY,
1052   JUMP_INIT(finish, _IO_new_file_finish),
1053   JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1054   JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow_mmap),
1055   JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1056   JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1057   JUMP_INIT(xsputn, _IO_wfile_xsputn),
1058   JUMP_INIT(xsgetn, _IO_file_xsgetn),
1059   JUMP_INIT(seekoff, _IO_wfile_seekoff),
1060   JUMP_INIT(seekpos, _IO_default_seekpos),
1061   JUMP_INIT(setbuf, _IO_file_setbuf_mmap),
1062   JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1063   JUMP_INIT(doallocate, _IO_wfile_doallocate),
1064   JUMP_INIT(read, _IO_file_read),
1065   JUMP_INIT(write, _IO_new_file_write),
1066   JUMP_INIT(seek, _IO_file_seek),
1067   JUMP_INIT(close, _IO_file_close_mmap),
1068   JUMP_INIT(stat, _IO_file_stat),
1069   JUMP_INIT(showmanyc, _IO_default_showmanyc),
1070   JUMP_INIT(imbue, _IO_default_imbue)
1071 };
1072
1073 const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap libio_vtable =
1074 {
1075   JUMP_INIT_DUMMY,
1076   JUMP_INIT(finish, _IO_new_file_finish),
1077   JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
1078   JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow_maybe_mmap),
1079   JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
1080   JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
1081   JUMP_INIT(xsputn, _IO_wfile_xsputn),
1082   JUMP_INIT(xsgetn, _IO_file_xsgetn),
1083   JUMP_INIT(seekoff, _IO_wfile_seekoff),
1084   JUMP_INIT(seekpos, _IO_default_seekpos),
1085   JUMP_INIT(setbuf, _IO_file_setbuf_mmap),
1086   JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
1087   JUMP_INIT(doallocate, _IO_wfile_doallocate),
1088   JUMP_INIT(read, _IO_file_read),
1089   JUMP_INIT(write, _IO_new_file_write),
1090   JUMP_INIT(seek, _IO_file_seek),
1091   JUMP_INIT(close, _IO_file_close),
1092   JUMP_INIT(stat, _IO_file_stat),
1093   JUMP_INIT(showmanyc, _IO_default_showmanyc),
1094   JUMP_INIT(imbue, _IO_default_imbue)
1095 };