static void pop3_gen_send(Pop3Session *session, const gchar *format, ...)
{
gchar buf[POPBUFSIZE + 1];
va_list args;
va_start(args, format);
g_vsnprintf(buf, sizeof(buf) - 2, format, args);
va_end(args);
if (!g_ascii_strncasecmp(buf, "PASS ", 5))
log_print(LOG_PROTOCOL, "POP3> PASS ********\n");
else
log_print(LOG_PROTOCOL, "POP3> %s\n", buf);
session_send_msg(SESSION(session), SESSION_MSG_NORMAL, buf);
}
void
dfilter_fail(const char *format, ...)
{
va_list args;
/* If we've already reported one error, don't overwite it */
if (dfilter_error_msg != NULL)
return;
va_start(args, format);
g_vsnprintf(dfilter_error_msg_buf, sizeof(dfilter_error_msg_buf),
format, args);
dfilter_error_msg = dfilter_error_msg_buf;
va_end(args);
}
void LogDebug(const char *func,
const char *file,
unsigned line,
const char *fmt,
...)
{
gchar buf[4096];
va_list args;
va_start(args, fmt);
g_vsnprintf(buf, sizeof buf, fmt, args);
buf[sizeof buf - 1] = '\0';
va_end(args);
g_debug("[function %s, file %s, line %d], %s\n",
func, file, line, 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;
}
void
say (char *fmt, ...)
{
va_list ap;
char buf[200];
guint context_id;
if (test_computer_play > 0) return;
va_start (ap, fmt);
g_vsnprintf (buf, 200, fmt, ap);
va_end (ap);
context_id =
gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar), "message");
gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context_id);
gtk_statusbar_push (GTK_STATUSBAR (statusbar), context_id, buf);
}
static void parent_fatal(int exit_code, const char* fmt, ...) {
va_list ap;
char str[1024];
va_start(ap,fmt);
g_vsnprintf(str,1024,fmt,ap);
va_end(ap);
#ifdef DEBUG_PARENT
PARENT_DBG((0,"Fatal error: exit_code=%d str=%s",exit_code,str));
#else
fprintf(stderr,"Fatal error: exit_code=%d str=%s",exit_code,str);
#endif
kill(parent.dispatcher_pid,SIGTERM);
exit(exit_code);
}
janus_sdp_attribute *janus_sdp_attribute_create(const char *name, const char *value, ...) {
if(!name)
return NULL;
janus_sdp_attribute *a = g_malloc(sizeof(janus_sdp_attribute));
a->name = g_strdup(name);
a->direction = JANUS_SDP_DEFAULT;
a->value = NULL;
if(value) {
char buffer[512];
va_list ap;
va_start(ap, value);
g_vsnprintf(buffer, sizeof(buffer), value, ap);
va_end(ap);
a->value = g_strdup(buffer);
}
return a;
}
static void
LogErrorPosixCodeV(int code,
const char *func,
const char *file,
unsigned line,
const char *fmt,
va_list args)
{
char errMsg[4096];
gchar buf[4096];
g_vsnprintf(buf, sizeof buf, fmt, args);
buf[sizeof buf - 1] = '\0';
strerror_s(errMsg, sizeof errMsg, code);
g_warning("[function %s, file %s, line %d], %s, [errno = %d] %s\n",
func, file, line, buf, code, errMsg);
}
/**
* 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);
}
}
/**
* gnomemeeting_dialog
*
* @parent: The parent window of the dialog.
* @format: a char * including printf formats
* @args : va_list that the @format char * uses.
* @type : specifies the kind of GtkMessageType dialogs to use.
*
* Creates and runs a dialog and destroys it afterward.
**/
static GtkWidget *
gnomemeeting_dialog (GtkWindow *parent,
const char *prim_text,
const char *format,
va_list args,
GtkMessageType type)
{
GtkWidget *dialog;
gchar *primary_text = NULL;
gchar *dialog_text = NULL;
char buffer [1025];
primary_text =
g_strdup_printf ("<span weight=\"bold\" size=\"larger\">%s</span>",
prim_text);
if (format == NULL)
buffer[0] = 0;
else
g_vsnprintf (buffer, 1024, format, args);
dialog_text =
g_strdup_printf ("%s\n\n%s", primary_text, buffer);
dialog =
gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL,
type,
GTK_BUTTONS_OK, NULL);
gtk_window_set_title (GTK_WINDOW (dialog), "");
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog),
dialog_text);
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (gtk_widget_destroy),
dialog);
/* Can be called from threads */
gm_window_show (dialog);
g_free (dialog_text);
g_free (primary_text);
return dialog;
}
/*
* This function writes data to the parent process.
* A line feed, or a null must be the last character written.
*/
int write_to_parent(int command, const char *format, ...)
{
va_list val;
int len, size;
char real_buf[WRITE_MAX_BUF+32];
char *buf;
char cmd[20];
buf=&(real_buf[16]);
buf[0] = '\0';
va_start(val, format);
g_vsnprintf(buf, WRITE_MAX_BUF, format, val);
/* glibc >2.1 can return size > WRITE_MAX_BUF */
/* just in case g_vsnprintf reached the max */
buf[WRITE_MAX_BUF-1] = '\0';
size=strlen(buf);
va_end(val);
/* This is for jpilot-sync */
if (pipe_to_parent==STDOUT_FILENO) {
if (command==PIPE_PRINT) {
if (write(pipe_to_parent, buf, strlen(buf)) < 0) {
jp_logf(JP_LOG_WARN, "write failed %s %d\n", __FILE__, __LINE__);
}
}
return TRUE;
}
sprintf(cmd, "%d:", command);
len = strlen(cmd);
buf = buf-len;
strncpy(buf, cmd, len);
size += len;
/* The pipe doesn't flush unless a CR is written */
/* This is our key to the parent for a record separator */
buf[size]='\0';
buf[size+1]='\n';
size += 2;
if (write(pipe_to_parent, buf, size) < 0) {
jp_logf(JP_LOG_WARN, "write failed %s %d\n", __FILE__, __LINE__);
}
return TRUE;
}
void dbg_print(const gint* which, gint how, FILE* where, const gchar* fmt, ... ) {
static gchar debug_buffer[DEBUG_BUFFER_SIZE];
va_list list;
if ( ! which || *which < how ) return;
va_start( list, fmt );
g_vsnprintf(debug_buffer,DEBUG_BUFFER_SIZE,fmt,list);
va_end( list );
if (! where) {
g_message("%s", debug_buffer);
} else {
fputs(debug_buffer,where);
fputs("\n",where);
}
}
int
sio_printf (struct siobuf *sio, const char *format, ...)
{
va_list alist;
char buf[1024];
int len;
assert (sio != NULL && format != NULL);
va_start (alist, format);
len = g_vsnprintf (buf, sizeof buf, format, alist);
va_end (alist);
if (len >= (int) sizeof buf - 1)
len = sizeof buf - 1;
if (len > 0)
sio_write (sio, buf, len);
return len;
}
static void admin_write(gchar * fmt, ...)
{
char buff[ADMIN_BUFSIZE];
va_list ap;
strncpy(buff, "admin ", ADMIN_PREFIX_LEN);
if (!_admin_session) {
admin_open_session();
}
va_start(ap, fmt);
g_vsnprintf(&buff[ADMIN_PREFIX_LEN],
ADMIN_BUFSIZE - ADMIN_PREFIX_LEN, fmt, ap);
va_end(ap);
net_write(_admin_session, buff);
}
static void
LogErrorWinCodeV(int code,
const char *func,
const char *file,
unsigned line,
const char *fmt,
va_list args)
{
char *msgBuf = WinUtil_GetErrorText(code);
gchar buf[4096];
g_vsnprintf(buf, sizeof buf, fmt, args);
buf[sizeof buf - 1] = '\0';
g_warning("[function %s, file %s, line %d], %s, [Win32 Error = %d] %s\n",
func, file, line, buf, code, (const char *)msgBuf);
g_free(msgBuf);
}
/* For the benefit of the podcast parsing code */
void
rb_debug_realf (const char *func,
const char *file,
int line,
gboolean newline,
const char *format, ...)
{
va_list args;
char buffer[1025];
if (debug == FALSE)
return;
va_start (args, format);
g_vsnprintf (buffer, 1024, format, args);
va_end (args);
g_printerr (newline ? "%s:%d [%s] %s\n" : "%s:%d [%s] %s",
file, line, func, buffer);
}
static gint
print (gchar *buf,
gint len,
gint start,
const gchar *fmt,
...)
{
va_list args;
gint printed;
va_start (args, fmt);
printed = g_vsnprintf (buf + start, len - start, fmt, args);
if (printed < 0)
printed = len - start;
va_end (args);
return printed;
}
/**
* g_process_message:
* @fmt: format string
* @...: arguments to @fmt
*
* This function sends a message to the client preferring to use the stderr
* channel as long as it is available and switching to using syslog() if it
* isn't. Generally the stderr channell will be available in the startup
* process and in the beginning of the first startup in the
* supervisor/daemon processes. Later on the stderr fd will be closed and we
* have to fall back to using the system log.
**/
void
g_process_message(const gchar *fmt, ...)
{
gchar buf[2048];
va_list ap;
va_start(ap, fmt);
g_vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (stderr_present)
fprintf(stderr, "%s: %s\n", process_opts.name, buf);
else
{
gchar name[32];
g_snprintf(name, sizeof(name), "%s/%s", process_kind == G_PK_SUPERVISOR ? "supervise" : "daemon", process_opts.name);
openlog(name, LOG_PID, LOG_DAEMON);
syslog(LOG_CRIT, "%s\n", buf);
closelog();
}
}
/**
* rb_debug_realf:
* @func: function name
* @file: file name
* @line: line number
* @newline: if TRUE, add a newline to the output
* @format: printf style format specifier
* @Varargs: substitution values for @format
*
* If the debug output settings match the function or file names,
* the debug message will be formatted and written to standard error.
*/
void
rb_debug_realf (const char *func,
const char *file,
const int line,
gboolean newline,
const char *format, ...)
{
va_list args;
char buffer[1025];
if (!rb_debug_matches (func, file))
return;
va_start (args, format);
g_vsnprintf (buffer, 1024, format, args);
va_end (args);
_rb_debug_print (func, file, line, newline, buffer);
}
void
InterfaceGtk::vmsg(MessageType type, const gchar *fmt, va_list ap)
{
static const GtkMessageType type2gtk[] = {
/* [MSG_USER] = */ GTK_MESSAGE_OTHER,
/* [MSG_INFO] = */ GTK_MESSAGE_INFO,
/* [MSG_WARNING] = */ GTK_MESSAGE_WARNING,
/* [MSG_ERROR] = */ GTK_MESSAGE_ERROR
};
va_list aq;
gchar buf[255];
va_copy(aq, ap);
stdio_vmsg(type, fmt, ap);
g_vsnprintf(buf, sizeof(buf), fmt, aq);
va_end(aq);
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_widget),
type2gtk[type]);
gtk_label_set_text(GTK_LABEL(message_widget), buf);
}
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);
}
void
console_print(ConsoleUI *cui, char *type, const char *text, ...) {
char buf[4096];
va_list ap;
GtkTextBuffer *buffer;
GtkTextIter iter;
va_start(ap, text);
g_vsnprintf(buf, 4096, text, ap);
va_end(ap);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(cui->display));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (type) {
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
buf, -1, type, NULL);
} else {
gtk_text_buffer_insert(buffer, &iter, buf, -1);
}
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(cui->display),
cui->mark_end, 0.0, FALSE, 0, 0);
}
static void
print_padded_string (gint columns, gchar padchar, gboolean padright, const gchar *fmt, ...)
{
gchar buf[1024];
gchar *padstring;
va_list ap;
va_start (ap, fmt);
g_vsnprintf (buf, 1024, fmt, ap);
va_end (ap);
padstring = g_strnfill (columns - g_utf8_strlen (buf, -1), padchar);
if (padright) {
print_info ("%s%s", buf, padstring);
} else {
print_info ("%s%s", padstring, buf);
}
g_free (padstring);
}
void
nm_utils_strbuf_append (char **buf, gsize *len, const char *format, ...)
{
char *p = *buf;
va_list args;
gint retval;
if (*len == 0)
return;
va_start (args, format);
retval = g_vsnprintf (p, *len, format, args);
va_end (args);
if (retval >= *len) {
*buf = &p[*len];
*len = 0;
} else {
*buf = &p[retval];
*len -= retval;
}
}
printf_arglist_function2(char *log_genstring, logtype_t, typ, char *, pname, char *, format)
{
va_list argp;
char *leader = NULL;
char linebuf[STR_SIZE];
char *xlated_fmt = dgettext("C", format);
/* format error message */
if((int)typ <= (int)L_BOGUS || (int)typ > (int)L_MARKER) typ = L_BOGUS;
if(multiline > 0) {
leader = stralloc(" "); /* continuation line */
} else {
leader = vstralloc(logtype_str[(int)typ], " ", pname, " ", NULL);
}
arglist_start(argp, format);
g_vsnprintf(linebuf, SIZEOF(linebuf)-1, xlated_fmt, argp);
/* -1 to allow for '\n' */
arglist_end(argp);
return(vstralloc(leader, linebuf, "\n", NULL));
}
void
xmr_debug_real(
const gchar *func,
const gchar *file,
gint line,
gboolean newline,
const gchar *format,
...
)
{
va_list args;
gchar buffer[1025];
if (!enable_debug)
return;
va_start(args, format);
g_vsnprintf(buffer, 1024, format, args);
va_end(args);
xmr_debug_print(func, file, line, newline, buffer);
}
/*!
*\brief display an error with a View Log button
*
*/
void alertpanel_error_log(const gchar *format, ...)
{
va_list args;
int val;
MainWindow *mainwin;
gchar buf[ALERT_PANEL_BUFSIZE];
va_start(args, format);
g_vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
strretchomp(buf);
mainwin = mainwindow_get_mainwindow();
if (mainwin && mainwin->logwin) {
mainwindow_clear_error(mainwin);
val = alertpanel_full(_("Error"), buf, GTK_STOCK_CLOSE,
_("_View log"), NULL, ALERTFOCUS_FIRST, FALSE, NULL,
ALERT_ERROR);
if (val == G_ALERTALTERNATE)
log_window_show(mainwin->logwin);
} else
alertpanel_error("%s", buf);
}
void print_vfs_message (char *msg, ...)
{
va_list ap;
char str [128];
va_start (ap, msg);
g_vsnprintf (str, sizeof (str), msg, ap);
va_end (ap);
if (midnight_shutdown)
return;
if (!message_visible || !the_hint || !the_hint->widget.parent) {
int col, row;
if (!nice_rotating_dash || (ok_to_refresh <= 0))
return;
/* Preserve current cursor position */
getyx (stdscr, row, col);
move (0, 0);
attrset (NORMAL_COLOR);
printw ("%-*s", COLS-1, str);
/* Restore cursor position */
move(row, col);
mc_refresh ();
return;
}
if (message_visible) {
set_hintbar(str);
}
}
static gchar*
internal_get_file_r (const gchar *dir,
gchar *buffer,
gsize len,
const gchar *format,
va_list ap)
{
gsize n;
g_return_val_if_fail(buffer != NULL, NULL);
g_return_val_if_fail(format != NULL, NULL);
g_return_val_if_fail(len > 0, NULL);
if ((n = g_strlcpy(buffer, dir, len)) >= len)
return NULL;
if ((n = g_strlcat(buffer, G_DIR_SEPARATOR_S, len)) >= len)
return NULL;
if ((gsize) g_vsnprintf(buffer + n, len - n, format, ap) >= len - n)
return NULL;
return buffer;
}
/* used to intensivelly check ep canaries
*/
void ep_check_canary_integrity(const char* fmt, ...) {
va_list ap;
static gchar there[128] = {
'L','a','u','n','c','h',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
gchar here[128];
emem_chunk_t* npc = NULL;
if (! intense_canary_checking ) return;
here[126] = '\0';
here[127] = '\0';
va_start(ap,fmt);
g_vsnprintf(here, 126,fmt, ap);
va_end(ap);
for (npc = ep_packet_mem.free_list; npc != NULL; npc = npc->next) {
static unsigned i_ctr;
if (npc->canary_info->c_count > 0x00ffffff) {
g_error("ep_packet_mem.free_list was corrupted\nbetween: %s\nand: %s",there, here);
}
for (i_ctr = 0; i_ctr < npc->canary_info->c_count; i_ctr++) {
if (memcmp(npc->canary_info->canary[i_ctr], &ep_canary, npc->canary_info->cmp_len[i_ctr]) != 0) {
g_error("Per-packet memory corrupted\nbetween: %s\nand: %s",there, here);
}
}
}
strncpy(there,here,126);
}