1  /* Multibyte printf buffers writing data to a FILE * stream.
       2     Copyright (C) 2022-2023 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       4  
       5     The GNU C Library is free software; you can redistribute it and/or
       6     modify it under the terms of the GNU Lesser General Public
       7     License as published by the Free Software Foundation; either
       8     version 2.1 of the License, or (at your option) any later version.
       9  
      10     The GNU C Library is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13     Lesser General Public License for more details.
      14  
      15     You should have received a copy of the GNU Lesser General Public
      16     License along with the GNU C Library; if not, see
      17     <https://www.gnu.org/licenses/>.  */
      18  
      19  #include <printf_buffer_to_file.h>
      20  
      21  #include <assert.h>
      22  #include <array_length.h>
      23  #include <libio/libioP.h>
      24  
      25  /* Switch to the file buffer if possible.  If the file has write_ptr
      26     == write_end, use the stage buffer instead.  */
      27  void
      28  __printf_buffer_to_file_switch (struct __printf_buffer_to_file *buf)
      29  {
      30    if (buf->fp->_IO_write_ptr < buf->fp->_IO_write_end)
      31      {
      32        /* buf->fp has a buffer associated with it, so write directly to
      33           it from now on.  */
      34        buf->base.write_ptr = buf->fp->_IO_write_ptr;
      35        buf->base.write_end = buf->fp->_IO_write_end;
      36      }
      37    else
      38      {
      39        /* Use the staging area if no buffer is available in buf->fp.  */
      40        buf->base.write_ptr = buf->stage;
      41        buf->base.write_end = array_end (buf->stage);
      42      }
      43  
      44    buf->base.write_base = buf->base.write_ptr;
      45  }
      46  
      47  void
      48  __printf_buffer_flush_to_file (struct __printf_buffer_to_file *buf)
      49  {
      50    /* The bytes in the buffer are always consumed.  */
      51    buf->base.written += buf->base.write_ptr - buf->base.write_base;
      52  
      53    if (buf->base.write_end == array_end (buf->stage))
      54      {
      55        /* If the stage buffer is used, make a copy into the file.  The
      56           stage buffer is always consumed fully, even if just partially
      57           written, to ensure that the file stream has all the data.  */
      58        size_t count = buf->base.write_ptr - buf->stage;
      59        if ((size_t) _IO_sputn (buf->fp, buf->stage, count) != count)
      60          {
      61            __printf_buffer_mark_failed (&buf->base);
      62            return;
      63          }
      64        /* buf->fp may have a buffer now.  */
      65        __printf_buffer_to_file_switch (buf);
      66        return;
      67      }
      68    else if (buf->base.write_end == buf->stage + 1)
      69      {
      70        /* Special one-character buffer case.  This is used to avoid
      71           flush-only overflow below.  */
      72        if (buf->base.write_ptr == buf->base.write_end)
      73          {
      74            if (__overflow (buf->fp, (unsigned char) *buf->stage) == EOF)
      75              {
      76                __printf_buffer_mark_failed (&buf->base);
      77                return;
      78              }
      79            __printf_buffer_to_file_switch (buf);
      80          }
      81        /* Else there is nothing to write.  */
      82        return;
      83      }
      84  
      85    /* We have written directly into the buf->fp buffer.  */
      86    assert (buf->base.write_end == buf->fp->_IO_write_end);
      87  
      88    /* Mark the bytes as written.  */
      89    buf->fp->_IO_write_ptr = buf->base.write_ptr;
      90  
      91    if (buf->base.write_ptr == buf->base.write_end)
      92      {
      93        /* The buffer in buf->fp has been filled.  This should just call
      94           __overflow (buf->fp, EOF), but flush-only overflow is obscure
      95           and not always correctly implemented.  See bug 28949.  Be
      96           conservative and switch to a one-character buffer instead, to
      97           obtain one more character for a regular __overflow call.  */
      98        buf->base.write_ptr = buf->stage;
      99        buf->base.write_end = buf->stage + 1;
     100      }
     101    /* The bytes in the file stream were already marked as written above.  */
     102  
     103    buf->base.write_base = buf->base.write_ptr;
     104  }
     105  
     106  void
     107  __printf_buffer_to_file_init (struct __printf_buffer_to_file *buf, FILE *fp)
     108  {
     109    __printf_buffer_init (&buf->base, buf->stage, array_length (buf->stage),
     110                          __printf_buffer_mode_to_file);
     111    buf->fp = fp;
     112    __printf_buffer_to_file_switch (buf);
     113  }
     114  
     115  int
     116  __printf_buffer_to_file_done (struct __printf_buffer_to_file *buf)
     117  {
     118    if (__printf_buffer_has_failed (&buf->base))
     119      return -1;
     120    __printf_buffer_flush_to_file (buf);
     121    return __printf_buffer_done (&buf->base);
     122  }