void
relay_raw_print (struct t_relay_client *client, int flags,
const char *format, ...)
{
struct t_relay_raw_message *new_raw_message;
weechat_va_format (format);
if (!vbuffer)
return;
/* auto-open Relay raw buffer if debug for irc plugin is >= 1 */
if (!relay_raw_buffer && (weechat_relay_plugin->debug >= 1))
relay_raw_open (0);
new_raw_message = relay_raw_message_add (client, flags, vbuffer);
if (new_raw_message)
{
if (relay_raw_buffer)
relay_raw_message_print (new_raw_message);
if (weechat_config_integer (relay_config_look_raw_messages) == 0)
relay_raw_message_free (new_raw_message);
}
free (vbuffer);
}
void
xfer_chat_sendf (struct t_xfer *xfer, const char *format, ...)
{
char *ptr_msg, *msg_encoded;
if (!xfer || (xfer->sock < 0))
return;
weechat_va_format (format);
if (!vbuffer)
return;
msg_encoded = (xfer->charset_modifier) ?
weechat_hook_modifier_exec ("charset_encode",
xfer->charset_modifier,
vbuffer) : NULL;
ptr_msg = (msg_encoded) ? msg_encoded : vbuffer;
if (xfer_chat_send (xfer, ptr_msg, strlen (ptr_msg)) <= 0)
{
weechat_printf (NULL,
_("%s%s: error sending data to \"%s\" via xfer chat"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
xfer->remote_nick);
xfer_close (xfer, XFER_STATUS_FAILED);
}
if (msg_encoded)
free (msg_encoded);
free (vbuffer);
}
void
weechat_backtrace_printf (const char *message, ...)
{
weechat_va_format (message);
if (vbuffer)
{
string_fprintf (stderr, "%s\n", vbuffer);
log_printf ("%s", vbuffer);
free (vbuffer);
}
}
void
log_printf (const char *message, ...)
{
char *ptr_buffer;
static time_t seconds;
struct tm *date_tmp;
if (!weechat_log_file)
return;
weechat_va_format (message);
if (vbuffer)
{
/* keep only valid chars */
ptr_buffer = vbuffer;
while (ptr_buffer[0])
{
if ((ptr_buffer[0] != '\n')
&& (ptr_buffer[0] != '\r')
&& ((unsigned char)(ptr_buffer[0]) < 32))
ptr_buffer[0] = '.';
ptr_buffer++;
}
if (weechat_log_use_time)
{
seconds = time (NULL);
date_tmp = localtime (&seconds);
if (date_tmp)
{
string_iconv_fprintf (weechat_log_file,
"[%04d-%02d-%02d %02d:%02d:%02d] %s\n",
date_tmp->tm_year + 1900, date_tmp->tm_mon + 1,
date_tmp->tm_mday, date_tmp->tm_hour,
date_tmp->tm_min, date_tmp->tm_sec,
vbuffer);
}
else
string_iconv_fprintf (weechat_log_file, "%s\n", vbuffer);
}
else
string_iconv_fprintf (weechat_log_file, "%s\n", vbuffer);
fflush (weechat_log_file);
free (vbuffer);
}
}
void
gui_chat_printf_y (struct t_gui_buffer *buffer, int y, const char *message, ...)
{
struct t_gui_line *ptr_line;
int i, num_lines_to_add;
if (!gui_buffer_valid (buffer))
return;
if (gui_init_ok)
{
if (!buffer)
buffer = gui_buffer_search_main ();
if (!buffer || buffer->closing)
return;
if (buffer->type != GUI_BUFFER_TYPE_FREE)
buffer = gui_buffers;
if (buffer->type != GUI_BUFFER_TYPE_FREE)
return;
}
weechat_va_format (message);
if (!vbuffer)
return;
utf8_normalize (vbuffer, '?');
/* no message: delete line */
if (!vbuffer[0])
{
if (gui_init_ok && (y >= 0))
{
for (ptr_line = buffer->own_lines->first_line; ptr_line;
ptr_line = ptr_line->next_line)
{
if (ptr_line->data->y >= y)
break;
}
if (ptr_line && (ptr_line->data->y == y))
{
if (ptr_line->next_line)
gui_line_clear (ptr_line);
else
gui_line_free (buffer, ptr_line);
gui_buffer_ask_chat_refresh (buffer, 2);
}
}
}
else
{
if (gui_init_ok)
{
/* if y is negative, add a line -N lines after the last line */
if (y < 0)
{
y = (buffer->own_lines && buffer->own_lines->last_line) ?
buffer->own_lines->last_line->data->y - y : (-1 * y) - 1;
}
/* compute the number of lines to add before y */
if (buffer->own_lines && buffer->own_lines->last_line)
num_lines_to_add = y - buffer->own_lines->last_line->data->y - 1;
else
num_lines_to_add = y;
if (num_lines_to_add > 0)
{
/*
* add empty line(s) before asked line, to ensure there is at
* least "y" lines in buffer, and then be able to scroll
* properly buffer page by page
*/
for (i = y - num_lines_to_add; i < y; i++)
{
gui_line_add_y (buffer, i, "");
}
}
gui_line_add_y (buffer, y, vbuffer);
gui_buffer_ask_chat_refresh (buffer, 1);
}
else
string_fprintf (stdout, "%s\n", vbuffer);
}
free (vbuffer);
}
void
gui_chat_printf_date_tags (struct t_gui_buffer *buffer, time_t date,
const char *tags, const char *message, ...)
{
time_t date_printed;
int display_time, length, at_least_one_message_printed, msg_discarded;
char *pos, *pos_prefix, *pos_tab, *pos_end, *pos_lines;
char *modifier_data, *new_msg, *ptr_msg, *lines_waiting;
struct t_gui_line *ptr_line;
if (!message)
return;
if (!gui_buffer_valid (buffer))
return;
if (gui_init_ok)
{
if (!buffer)
buffer = gui_buffer_search_main ();
if (!buffer || buffer->closing)
return;
if (buffer->type != GUI_BUFFER_TYPE_FORMATTED)
buffer = gui_buffers;
if (buffer->type != GUI_BUFFER_TYPE_FORMATTED)
return;
}
/* if mute is enabled for buffer (or all buffers), then just return */
if ((gui_chat_mute == GUI_CHAT_MUTE_ALL_BUFFERS)
|| ((gui_chat_mute == GUI_CHAT_MUTE_BUFFER)
&& (gui_chat_mute_buffer == buffer)))
return;
weechat_va_format (message);
if (!vbuffer)
return;
utf8_normalize (vbuffer, '?');
date_printed = time (NULL);
if (date <= 0)
date = date_printed;
at_least_one_message_printed = 0;
pos = vbuffer;
while (pos)
{
/* display until next end of line */
pos_end = strchr (pos, '\n');
if (pos_end)
pos_end[0] = '\0';
/* call modifier for message printed ("weechat_print") */
new_msg = NULL;
msg_discarded = 0;
if (buffer)
{
length = strlen (gui_buffer_get_plugin_name (buffer)) + 1 +
strlen (buffer->name) + 1 + ((tags) ? strlen (tags) : 0) + 1;
modifier_data = malloc (length);
if (modifier_data)
{
snprintf (modifier_data, length, "%s;%s;%s",
gui_buffer_get_plugin_name (buffer),
buffer->name,
(tags) ? tags : "");
new_msg = hook_modifier_exec (NULL,
"weechat_print",
modifier_data,
pos);
free (modifier_data);
if (new_msg)
{
if (!new_msg[0] && pos[0])
{
/*
* modifier returned empty message, then we'll not
* print anything
*/
free (new_msg);
new_msg = NULL;
msg_discarded = 1;
}
else if (strcmp (message, new_msg) == 0)
{
/* no changes in new message */
free (new_msg);
new_msg = NULL;
}
}
}
}
if (!msg_discarded)
{
pos_prefix = NULL;
display_time = 1;
ptr_msg = (new_msg) ? new_msg : pos;
/* space followed by tab => prefix ignored */
if ((ptr_msg[0] == ' ') && (ptr_msg[1] == '\t'))
{
ptr_msg += 2;
}
else
{
/* if two first chars are tab, then do not display time */
if ((ptr_msg[0] == '\t') && (ptr_msg[1] == '\t'))
{
display_time = 0;
ptr_msg += 2;
}
else
{
/* if tab found, use prefix (before tab) */
pos_tab = strchr (ptr_msg, '\t');
if (pos_tab)
{
pos_tab[0] = '\0';
pos_prefix = ptr_msg;
ptr_msg = pos_tab + 1;
}
}
}
if (gui_init_ok)
{
ptr_line = gui_line_add (buffer, (display_time) ? date : 0,
date_printed, tags, pos_prefix, ptr_msg);
if (ptr_line)
{
if (buffer && buffer->print_hooks_enabled)
hook_print_exec (buffer, ptr_line);
if (ptr_line->data->displayed)
at_least_one_message_printed = 1;
}
}
else
{
length = ((pos_prefix) ? strlen (pos_prefix) + 1 : 0) +
strlen (ptr_msg) + 1;
if (gui_chat_lines_waiting_buffer)
{
length += strlen (gui_chat_lines_waiting_buffer) + 1;
lines_waiting = realloc (gui_chat_lines_waiting_buffer, length);
if (lines_waiting)
{
gui_chat_lines_waiting_buffer = lines_waiting;
}
else
{
free (gui_chat_lines_waiting_buffer);
gui_chat_lines_waiting_buffer = NULL;
}
}
else
{
gui_chat_lines_waiting_buffer = malloc (length);
if (gui_chat_lines_waiting_buffer)
gui_chat_lines_waiting_buffer[0] = '\0';
}
if (gui_chat_lines_waiting_buffer)
{
pos_lines = gui_chat_lines_waiting_buffer +
strlen (gui_chat_lines_waiting_buffer);
if (pos_lines > gui_chat_lines_waiting_buffer)
{
pos_lines[0] = '\n';
pos_lines++;
}
if (pos_prefix)
{
memcpy (pos_lines, pos_prefix, strlen (pos_prefix));
pos_lines += strlen (pos_prefix);
pos_lines[0] = '\t';
pos_lines++;
}
memcpy (pos_lines, ptr_msg, strlen (ptr_msg) + 1);
}
}
}
if (new_msg)
free (new_msg);
pos = (pos_end && pos_end[1]) ? pos_end + 1 : NULL;
}
if (gui_init_ok && at_least_one_message_printed)
gui_buffer_ask_chat_refresh (buffer, 1);
free (vbuffer);
}
void
logger_write_line (struct t_logger_buffer *logger_buffer,
const char *format, ...)
{
char *message, buf_time[256], buf_beginning[1024];
const char *charset;
time_t seconds;
struct tm *date_tmp;
int log_level;
charset = weechat_info_get ("charset_terminal", "");
if (!logger_buffer->log_file)
{
log_level = logger_get_level_for_buffer (logger_buffer->buffer);
if (log_level == 0)
{
logger_buffer_free (logger_buffer);
return;
}
if (!logger_create_directory ())
{
weechat_printf_tags (NULL,
"no_log",
_("%s%s: unable to create directory for logs "
"(\"%s\")"),
weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
weechat_config_string (logger_config_file_path));
logger_buffer_free (logger_buffer);
return;
}
if (!logger_buffer->log_filename)
logger_set_log_filename (logger_buffer);
if (!logger_buffer->log_filename)
{
logger_buffer_free (logger_buffer);
return;
}
logger_buffer->log_file =
fopen (logger_buffer->log_filename, "a");
if (!logger_buffer->log_file)
{
weechat_printf_tags (
NULL,
"no_log",
_("%s%s: unable to write log file \"%s\": %s"),
weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
logger_buffer->log_filename, strerror (errno));
logger_buffer_free (logger_buffer);
return;
}
if (weechat_config_boolean (logger_config_file_info_lines)
&& logger_buffer->write_start_info_line)
{
buf_time[0] = '\0';
seconds = time (NULL);
date_tmp = localtime (&seconds);
if (date_tmp)
{
strftime (buf_time, sizeof (buf_time) - 1,
weechat_config_string (logger_config_file_time_format),
date_tmp);
}
snprintf (buf_beginning, sizeof (buf_beginning),
_("%s\t**** Beginning of log ****"),
buf_time);
message = (charset) ?
weechat_iconv_from_internal (charset, buf_beginning) : NULL;
fprintf (logger_buffer->log_file,
"%s\n", (message) ? message : buf_beginning);
if (message)
free (message);
logger_buffer->flush_needed = 1;
}
logger_buffer->write_start_info_line = 0;
}
weechat_va_format (format);
if (vbuffer)
{
message = (charset) ?
weechat_iconv_from_internal (charset, vbuffer) : NULL;
fprintf (logger_buffer->log_file,
"%s\n", (message) ? message : vbuffer);
if (message)
free (message);
logger_buffer->flush_needed = 1;
if (!logger_timer)
{
fflush (logger_buffer->log_file);
logger_buffer->flush_needed = 0;
}
free (vbuffer);
}
}
