1  /* Copyright (C) 2005-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C Library is free software; you can redistribute it and/or
       5     modify it under the terms of the GNU Lesser General Public
       6     License as published by the Free Software Foundation; either
       7     version 2.1 of the License, or (at your option) any later version.
       8  
       9     The GNU C Library is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12     Lesser General Public License for more details.
      13  
      14     You should have received a copy of the GNU Lesser General Public
      15     License along with the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <stdarg.h>
      19  #include <stdio.h>
      20  #include <stdlib.h>
      21  #include <string.h>
      22  #include <wchar.h>
      23  #include <libioP.h>
      24  
      25  static int
      26  locked_vfxprintf (FILE *fp, const char *fmt, va_list ap,
      27  		  unsigned int mode_flags)
      28  {
      29    if (_IO_fwide (fp, 0) <= 0)
      30      return __vfprintf_internal (fp, fmt, ap, mode_flags);
      31  
      32    /* We must convert the narrow format string to a wide one.
      33       Each byte can produce at most one wide character.  */
      34    wchar_t *wfmt;
      35    mbstate_t mbstate;
      36    int res;
      37    int used_malloc = 0;
      38    size_t len = strlen (fmt) + 1;
      39  
      40    if (__glibc_unlikely (len > SIZE_MAX / sizeof (wchar_t)))
      41      {
      42        __set_errno (EOVERFLOW);
      43        return -1;
      44      }
      45    if (__libc_use_alloca (len * sizeof (wchar_t)))
      46      wfmt = alloca (len * sizeof (wchar_t));
      47    else if ((wfmt = malloc (len * sizeof (wchar_t))) == NULL)
      48      return -1;
      49    else
      50      used_malloc = 1;
      51  
      52    memset (&mbstate, 0, sizeof mbstate);
      53    res = __mbsrtowcs (wfmt, &fmt, len, &mbstate);
      54  
      55    if (res != -1)
      56      res = __vfwprintf_internal (fp, wfmt, ap, mode_flags);
      57  
      58    if (used_malloc)
      59      free (wfmt);
      60  
      61    return res;
      62  }
      63  
      64  int
      65  __vfxprintf (FILE *fp, const char *fmt, va_list ap,
      66  	     unsigned int mode_flags)
      67  {
      68    if (fp == NULL)
      69      fp = stderr;
      70    _IO_flockfile (fp);
      71    int res = locked_vfxprintf (fp, fmt, ap, mode_flags);
      72    _IO_funlockfile (fp);
      73    return res;
      74  }
      75  
      76  int
      77  __fxprintf (FILE *fp, const char *fmt, ...)
      78  {
      79    va_list ap;
      80    va_start (ap, fmt);
      81    int res = __vfxprintf (fp, fmt, ap, 0);
      82    va_end (ap);
      83    return res;
      84  }
      85  
      86  int
      87  __fxprintf_nocancel (FILE *fp, const char *fmt, ...)
      88  {
      89    if (fp == NULL)
      90      fp = stderr;
      91  
      92    va_list ap;
      93    va_start (ap, fmt);
      94    _IO_flockfile (fp);
      95    int save_flags2 = fp->_flags2;
      96    fp->_flags2 |= _IO_FLAGS2_NOTCANCEL;
      97  
      98    int res = locked_vfxprintf (fp, fmt, ap, 0);
      99  
     100    fp->_flags2 = save_flags2;
     101    _IO_funlockfile (fp);
     102    va_end (ap);
     103    return res;
     104  }