stdio-common/fxprintf.c

   1 /* Copyright (C) 2005-2018 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@gnu.org>.
   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    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <stdarg.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <wchar.h>
  24 #include <libioP.h>
  25
  26 static int
  27 locked_vfxprintf (FILE *fp, const char *fmt, va_list ap)
  28 {
  29   if (_IO_fwide (fp, 0) <= 0)
  30     return _IO_vfprintf (fp, fmt, ap);
  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 = _IO_vfwprintf (fp, wfmt, ap);
  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 {
  67   if (fp == NULL)
  68     fp = stderr;
  69   _IO_flockfile (fp);
  70   int res = locked_vfxprintf (fp, fmt, ap);
  71   _IO_funlockfile (fp);
  72   return res;
  73 }
  74
  75 int
  76 __fxprintf (FILE *fp, const char *fmt, ...)
  77 {
  78   va_list ap;
  79   va_start (ap, fmt);
  80   int res = __vfxprintf (fp, fmt, ap);
  81   va_end (ap);
  82   return res;
  83 }
  84
  85 int
  86 __fxprintf_nocancel (FILE *fp, const char *fmt, ...)
  87 {
  88   if (fp == NULL)
  89     fp = stderr;
  90
  91   va_list ap;
  92   va_start (ap, fmt);
  93   _IO_flockfile (fp);
  94   int save_flags2 = fp->_flags2;
  95   fp->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  96
  97   int res = locked_vfxprintf (fp, fmt, ap);
  98
  99   fp->_flags2 = save_flags2;
 100   _IO_funlockfile (fp);
 101   va_end (ap);
 102   return res;
 103 }