Exemple #1
0
int
_IO_vswprintf (wchar_t *string, _IO_size_t maxlen, const wchar_t *format,
               _IO_va_list args)
{
    _IO_wstrnfile sf;
    int ret;
    struct _IO_wide_data wd;
#ifdef _IO_MTSAFE_IO
    sf.f._sbf._f._lock = NULL;
#endif

    if (maxlen == 0)
        /* Since we have to write at least the terminating L'\0' a buffer
           length of zero always makes the function fail.  */
        return -1;

    _IO_no_init (&sf.f._sbf._f, _IO_USER_LOCK, 0, &wd, &_IO_wstrn_jumps);
    _IO_fwide (&sf.f._sbf._f, 1);
    string[0] = L'\0';
    _IO_wstr_init_static (&sf.f._sbf._f, string, maxlen - 1, string);
    ret = _IO_vfwprintf ((_IO_FILE *) &sf.f._sbf, format, args);

    if (sf.f._sbf._f._wide_data->_IO_buf_base == sf.overflow_buf)
        /* ISO C99 requires swprintf/vswprintf to return an error if the
           output does not fit in the provided buffer.  */
        return -1;

    /* Terminate the string.  */
    *sf.f._sbf._f._wide_data->_IO_write_ptr = '\0';

    return ret;
}
Exemple #2
0
int
__vswscanf (const wchar_t *string, const wchar_t *format, _IO_va_list args)
{
  int ret;
  _IO_strfile sf;
  struct _IO_wide_data wd;
#ifdef _IO_MTSAFE_IO
  sf._sbf._f._lock = NULL;
#endif
  _IO_no_init (&sf._sbf._f, _IO_USER_LOCK, 0, &wd, &_IO_wstr_jumps);
  _IO_fwide (&sf._sbf._f, 1);
  _IO_wstr_init_static (&sf._sbf._f, (wchar_t *)string, 0, NULL);
  ret = _IO_vfwscanf ((_IO_FILE *) &sf._sbf, format, args, NULL);
  return ret;
}
/* VARARGS5 */
int
__vswprintf_chk (wchar_t *s, size_t maxlen, int flags, size_t slen,
		 const wchar_t *format, va_list args)
{
  /* XXX Maybe for less strict version do not fail immediately.
     Though, maxlen is supposed to be the size of buffer pointed
     to by s, so a conforming program can't pass such maxlen
     to *snprintf.  */
  if (__builtin_expect (slen < maxlen, 0))
    __chk_fail ();

  _IO_wstrnfile sf;
  struct _IO_wide_data wd;
  int ret;
#ifdef _IO_MTSAFE_IO
  sf.f._sbf._f._lock = NULL;
#endif

  /* We need to handle the special case where MAXLEN is 0.  Use the
     overflow buffer right from the start.  */
  if (__builtin_expect (maxlen == 0, 0))
    /* Since we have to write at least the terminating L'\0' a buffer
       length of zero always makes the function fail.  */
    return -1;

  _IO_no_init (&sf.f._sbf._f, _IO_USER_LOCK, 0, &wd, &_IO_wstrn_jumps);
  _IO_fwide (&sf.f._sbf._f, 1);
  s[0] = L'\0';

  /* For flags > 0 (i.e. __USE_FORTIFY_LEVEL > 1) request that %n
     can only come from read-only format strings.  */
  if (flags > 0)
    sf.f._sbf._f._flags2 |= _IO_FLAGS2_FORTIFY;

  _IO_wstr_init_static (&sf.f._sbf._f, s, maxlen - 1, s);
  ret = _IO_vfwprintf ((_IO_FILE *) &sf.f._sbf, format, args);

  if (sf.f._sbf._f._wide_data->_IO_buf_base == sf.overflow_buf)
    /* ISO C99 requires swprintf/vswprintf to return an error if the
       output does not fit int he provided buffer.  */
    return -1;

  /* Terminate the string.  */
  *sf.f._sbf._f._wide_data->_IO_write_ptr = '\0';

  return ret;
}