static void
stderr_message_internal(const char *title, enum ShowAgainStyle showAgain,
const char *fmt, va_list args, va_list args2)
{
static gchar *buf = NULL;
static gint alloc = 0;
gint len;
len = g_printf_string_upper_bound (fmt, args);
if (len >= alloc) {
if (buf)
g_free (buf);
alloc = nearest_pow (MAX(len + 1, 1024));
buf = g_new (char, alloc);
}
vsprintf (buf, fmt, args2);
fprintf(stderr,
"%s: %s\n",
title,buf);
}
PurpleStringref *purple_stringref_printf(const char *format, ...)
{
PurpleStringref *newref;
va_list ap;
if (format == NULL)
return NULL;
va_start(ap, format);
newref = g_malloc(sizeof(PurpleStringref) + g_printf_string_upper_bound(format, ap));
vsprintf(newref->value, format, ap);
va_end(ap);
newref->ref = 1;
return newref;
}
/**
* rig_protobuf_c_data_buffer_vprintf:
* @buffer: the buffer to append to.
* @format: printf-style format string describing what to append to buffer.
* @args: values referenced by @format string.
*
* Append printf-style content to a buffer, given a va_list.
*/
void rig_protobuf_c_data_buffer_vprintf (ProtobufCDataBuffer *buffer,
const char *format,
va_list args)
{
gsize size = g_printf_string_upper_bound (format, args);
if (size < 1024)
{
char buf[1024];
g_vsnprintf (buf, sizeof (buf), format, args);
rig_protobuf_c_data_buffer_append_string (buffer, buf);
}
else
{
char *buf = g_strdup_vprintf (format, args);
rig_protobuf_c_data_buffer_append_foreign (buffer, buf, strlen (buf), g_free, buf);
}
}
gchar *
wmem_strdup_vprintf(wmem_allocator_t *allocator, const gchar *fmt, va_list ap)
{
va_list ap2;
gsize len;
gchar* dst;
G_VA_COPY(ap2, ap);
len = g_printf_string_upper_bound(fmt, ap);
dst = (gchar *)wmem_alloc(allocator, len+1);
g_vsnprintf(dst, (gulong) len, fmt, ap2);
va_end(ap2);
return dst;
}
/**
* g_vasprintf:
* @string: the return location for the newly-allocated string.
* @format: a standard printf() format string, but notice
* <link linkend="string-precision">string precision pitfalls</link>.
* @args: the list of arguments to insert in the output.
*
* An implementation of the GNU vasprintf() function which supports
* positional parameters, as specified in the Single Unix Specification.
* This function is similar to g_vsprintf(), except that it allocates a
* string to hold the output, instead of putting the output in a buffer
* you allocate in advance.
*
* Returns: the number of bytes printed.
*
* Since: 2.4
**/
gint
g_vasprintf (gchar **string,
gchar const *format,
va_list args)
{
gint len;
g_return_val_if_fail (string != NULL, -1);
#if !defined(HAVE_GOOD_PRINTF)
len = _g_gnulib_vasprintf (string, format, args);
if (len < 0)
*string = NULL;
#elif defined (HAVE_VASPRINTF)
len = vasprintf (string, format, args);
if (len < 0)
*string = NULL;
else if (!g_mem_is_system_malloc ())
{
/* vasprintf returns malloc-allocated memory */
gchar *string1 = g_strndup (*string, len);
free (*string);
*string = string1;
}
#else
{
va_list args2;
G_VA_COPY (args2, args);
*string = g_new (gchar, g_printf_string_upper_bound (format, args));
len = _g_vsprintf (*string, format, args2);
va_end (args2);
}
#endif
return len;
}
static void
wmem_strbuf_append_vprintf(wmem_strbuf_t *strbuf, const gchar *fmt, va_list ap)
{
va_list ap2;
gsize append_len;
G_VA_COPY(ap2, ap);
append_len = g_printf_string_upper_bound(fmt, ap);
/* -1 because g_printf_string_upper_bound counts the null-terminator, but
* wmem_strbuf_grow does not */
wmem_strbuf_grow(strbuf, append_len - 1);
append_len = g_vsnprintf(&strbuf->str[strbuf->len],
(gulong) WMEM_STRBUF_RAW_ROOM(strbuf),
fmt, ap2);
va_end(ap2);
strbuf->len = MIN(strbuf->len + append_len, strbuf->alloc_len - 1);
}
static gint
mem_vprintf (MIO *mio,
const gchar *format,
va_list ap)
{
gint rv = -1;
gsize n;
gsize old_pos;
gsize old_size;
va_list ap_copy;
old_pos = mio->impl.mem.pos;
old_size = mio->impl.mem.size;
G_VA_COPY (ap_copy, ap);
/* compute the size we will need into the buffer */
n = g_printf_string_upper_bound (format, ap_copy);
va_end (ap_copy);
if (mem_try_ensure_space (mio, n)) {
guchar c;
/* backup character at n+1 that will be overwritten by a \0 ... */
c = mio->impl.mem.buf[mio->impl.mem.pos + (n - 1)];
rv = vsprintf ((gchar *)&mio->impl.mem.buf[mio->impl.mem.pos], format, ap);
/* ...and restore it */
mio->impl.mem.buf[mio->impl.mem.pos + (n - 1)] = c;
if (G_LIKELY (rv >= 0 && (gsize)rv == (n - 1))) {
/* re-compute the actual size since we might have allocated one byte
* more than needed */
mio->impl.mem.size = MAX (old_size, old_pos + (guint)rv);
mio->impl.mem.pos += (guint)rv;
} else {
mio->impl.mem.size = old_size;
rv = -1;
}
}
return rv;
}
gchar *
make_smtp_error (rspamd_mempool_t *pool,
gint error_code,
const gchar *format,
...)
{
va_list vp;
gchar *result = NULL, *p;
size_t len;
va_start (vp, format);
len = g_printf_string_upper_bound (format, vp);
va_end (vp);
va_start (vp, format);
len += sizeof ("65535 ") + sizeof (CRLF) - 1;
result = rspamd_mempool_alloc (pool, len);
p = result + rspamd_snprintf (result, len, "%d ", error_code);
p = rspamd_vsnprintf (p, len - (p - result), format, vp);
*p++ = CR; *p++ = LF; *p = '\0';
va_end (vp);
return result;
}
static void
gtk_message_internal(const char* title, enum ShowAgainStyle showAgain,
char const *fmt,
va_list args, va_list args2)
{
static gchar *buf = NULL;
static gint alloc = 0;
gint len;
DiaMessageInfo *msginfo;
GtkTextBuffer *textbuffer;
gboolean askForShowAgain = FALSE;
if (showAgain != ALWAYS_SHOW) {
/* We persistently stored that the user has chosen to not see the
* dialog again (whether by checking or not unchecking the box) */
persistence_register_boolean((gchar *)title, FALSE);
if (persistence_get_boolean((gchar *)title)) {
/* If not showing again, just return at once */
return;
}
askForShowAgain = TRUE;
}
if (message_hash_table == NULL) {
message_hash_table = g_hash_table_new(g_str_hash, g_str_equal);
}
len = g_printf_string_upper_bound (fmt, args);
if (len >= alloc) {
if (buf)
g_free (buf);
alloc = nearest_pow (MAX(len + 1, 1024));
buf = g_new (char, alloc);
}
vsprintf (buf, fmt, args2);
msginfo = (DiaMessageInfo*)g_hash_table_lookup(message_hash_table, fmt);
if (msginfo == NULL) {
msginfo = g_new0(DiaMessageInfo, 1);
g_hash_table_insert(message_hash_table, (char *)fmt, msginfo);
}
if (msginfo->dialog == NULL)
message_create_dialog(title, msginfo, buf);
if (msginfo->repeats != NULL) {
if (g_list_length(msginfo->repeats) > 1) {
char *newlabel;
guint num = g_list_length(msginfo->repeats);
/* See: https://live.gnome.org/TranslationProject/DevGuidelines/Plurals */
newlabel = g_strdup_printf(g_dngettext (GETTEXT_PACKAGE,
"There is %d similar message.", /* not triggered */
"There are %d similar messages.", num), num);
gtk_label_set_text(GTK_LABEL(msginfo->repeat_label), newlabel);
}
/* for repeated messages, show the last one */
g_object_set (msginfo->dialog, "text", buf, NULL);
gtk_widget_show(msginfo->repeat_label);
gtk_widget_show(msginfo->show_repeats);
}
/* Insert in scrollable view, but only the repeated ones */
if (msginfo->repeats != NULL) {
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(msginfo->repeat_view));
gtk_text_buffer_insert_at_cursor(textbuffer, buf, -1);
}
msginfo->repeats = g_list_prepend(msginfo->repeats, g_strdup(buf));
if (askForShowAgain) {
gtk_widget_show(msginfo->no_show_again);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msginfo->no_show_again),
showAgain == SUGGEST_NO_SHOW_AGAIN);
} else {
gtk_widget_hide(msginfo->no_show_again);
}
gtk_widget_show (msginfo->dialog);
}
void
g_logv (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *format,
va_list args1)
{
va_list args2;
gchar buffer[1025];
register gint i;
log_level &= G_LOG_LEVEL_MASK;
if (!log_level)
return;
/* we use a stack buffer of fixed size, because we might get called
* recursively.
*/
G_VA_COPY (args2, args1);
if (g_printf_string_upper_bound (format, args1) < 1024)
vsprintf (buffer, format, args2);
else
{
/* since we might be out of memory, we can't use g_vsnprintf(). */
#ifdef HAVE_VSNPRINTF
vsnprintf (buffer, 1024, format, args2);
#else /* !HAVE_VSNPRINTF */
/* we are out of luck here */
strncpy (buffer, format, 1024);
#endif /* !HAVE_VSNPRINTF */
buffer[1024] = 0;
}
va_end (args2);
for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i))
{
register GLogLevelFlags test_level;
test_level = 1 << i;
if (log_level & test_level)
{
guint depth = GPOINTER_TO_UINT (g_private_get (g_log_depth));
GLogDomain *domain;
GLogFunc log_func;
gpointer data = NULL;
domain = g_log_find_domain (log_domain ? log_domain : "");
if (depth)
test_level |= G_LOG_FLAG_RECURSION;
depth++;
g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
g_mutex_lock (g_messages_lock);
if ((((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) |
g_log_always_fatal) & test_level) != 0)
test_level |= G_LOG_FLAG_FATAL;
g_mutex_unlock (g_messages_lock);
log_func = g_log_domain_get_handler (domain, test_level, &data);
log_func (log_domain, test_level, buffer, data);
/* *domain can be cluttered now */
if (test_level & G_LOG_FLAG_FATAL)
abort ();
depth--;
g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
}
}
}
