int ___vsprintf_chk (char *s, int flags, size_t slen, const char *format, va_list args) { _IO_strfile f; int ret; #ifdef _IO_MTSAFE_IO f._sbf._f._lock = NULL; #endif if (slen == 0) __chk_fail (); _IO_no_init (&f._sbf._f, _IO_USER_LOCK, -1, NULL, NULL); _IO_JUMPS (&f._sbf) = &_IO_str_chk_jumps; s[0] = '\0'; _IO_str_init_static_internal (&f, s, slen - 1, s); /* For flags > 0 (i.e. __USE_FORTIFY_LEVEL > 1) request that %n can only come from read-only format strings. */ if (flags > 0) f._sbf._f._flags2 |= _IO_FLAGS2_FORTIFY; ret = _IO_vfprintf (&f._sbf._f, format, args); *f._sbf._f._IO_write_ptr = '\0'; return ret; }
int _IO_vdprintf (int d, const char *format, _IO_va_list arg) { struct _IO_FILE_plus tmpfil; struct _IO_wide_data wd; int done; #ifdef _IO_MTSAFE_IO tmpfil.file._lock = NULL; #endif _IO_no_init (&tmpfil.file, _IO_USER_LOCK, 0, &wd, &_IO_wfile_jumps); _IO_JUMPS (&tmpfil) = &_IO_file_jumps; _IO_new_file_init_internal (&tmpfil); #if !_IO_UNIFIED_JUMPTABLES tmpfil.vtable = NULL; #endif if (_IO_file_attach (&tmpfil.file, d) == NULL) { _IO_un_link (&tmpfil); return EOF; } tmpfil.file._flags |= _IO_DELETE_DONT_CLOSE; _IO_mask_flags (&tmpfil.file, _IO_NO_READS, _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING); done = _IO_vfprintf (&tmpfil.file, format, arg); if (done != EOF && _IO_do_flush (&tmpfil.file) == EOF) done = EOF; _IO_FINISH (&tmpfil.file); return done; }
int __vdprintf_chk (int d, int flags, const char *format, va_list arg) { struct _IO_FILE_plus tmpfil; struct _IO_wide_data wd; int done; #ifdef _IO_MTSAFE_IO tmpfil.file._lock = NULL; #endif _IO_no_init (&tmpfil.file, _IO_USER_LOCK, 0, &wd, &_IO_wfile_jumps); _IO_JUMPS (&tmpfil) = &_IO_file_jumps; _IO_new_file_init_internal (&tmpfil); if (_IO_file_attach (&tmpfil.file, d) == NULL) { _IO_un_link (&tmpfil); return EOF; } tmpfil.file._flags |= _IO_DELETE_DONT_CLOSE; _IO_mask_flags (&tmpfil.file, _IO_NO_READS, _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING); /* For flags > 0 (i.e. __USE_FORTIFY_LEVEL > 1) request that %n can only come from read-only format strings. */ if (flags > 0) tmpfil.file._flags2 |= _IO_FLAGS2_FORTIFY; done = _IO_vfprintf (&tmpfil.file, format, arg); _IO_FINISH (&tmpfil.file); return done; }
int _IO_obstack_vprintf (struct obstack *obstack, const char *format, va_list args) { struct obstack_FILE { struct _IO_obstack_file ofile; } new_f; int result; int size; int room; #ifdef _IO_MTSAFE_IO new_f.ofile.file.file._lock = NULL; #endif _IO_no_init (&new_f.ofile.file.file, _IO_USER_LOCK, -1, NULL, NULL); _IO_JUMPS (&new_f.ofile.file) = &_IO_obstack_jumps; room = obstack_room (obstack); size = obstack_object_size (obstack) + room; if (size == 0) { /* We have to handle the allocation a bit different since the `_IO_str_init_static' function would handle a size of zero different from what we expect. */ /* Get more memory. */ obstack_make_room (obstack, 64); /* Recompute how much room we have. */ room = obstack_room (obstack); size = room; assert (size != 0); } _IO_str_init_static_internal ((struct _IO_strfile_ *) &new_f.ofile, obstack_base (obstack), size, obstack_next_free (obstack)); /* Now allocate the rest of the current chunk. */ assert (size == (new_f.ofile.file.file._IO_write_end - new_f.ofile.file.file._IO_write_base)); assert (new_f.ofile.file.file._IO_write_ptr == (new_f.ofile.file.file._IO_write_base + obstack_object_size (obstack))); obstack_blank_fast (obstack, room); new_f.ofile.obstack = obstack; result = _IO_vfprintf (&new_f.ofile.file.file, format, args); /* Shrink the buffer to the space we really currently need. */ obstack_blank_fast (obstack, (new_f.ofile.file.file._IO_write_ptr - new_f.ofile.file.file._IO_write_end)); return result; }
int attribute_compat_text_section __nldbl_vfprintf (FILE *s, const char *fmt, va_list ap) { int done; set_no_long_double (); done = _IO_vfprintf (s, fmt, ap); clear_no_long_double (); return done; }
/* VARARGS5 */ int ___vsnprintf_chk (char *s, size_t maxlen, int flags, size_t slen, const char *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 (__glibc_unlikely (slen < maxlen)) __chk_fail (); _IO_strnfile sf; 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 (maxlen == 0) { s = sf.overflow_buf; maxlen = sizeof (sf.overflow_buf); } _IO_no_init (&sf.f._sbf._f, _IO_USER_LOCK, -1, NULL, NULL); _IO_JUMPS (&sf.f._sbf) = &_IO_strn_jumps; s[0] = '\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_str_init_static_internal (&sf.f, s, maxlen - 1, s); ret = _IO_vfprintf (&sf.f._sbf._f, format, args); if (sf.f._sbf._f._IO_buf_base != sf.overflow_buf) *sf.f._sbf._f._IO_write_ptr = '\0'; return ret; }