void
logger_set_log_filename (struct t_logger_buffer *logger_buffer)
{
char *log_filename, *pos_last_sep;
const char *dir_separator;
struct t_logger_buffer *ptr_logger_buffer;
/* get log filename for buffer */
log_filename = logger_get_filename (logger_buffer->buffer);
if (!log_filename)
{
weechat_printf_tags (NULL,
"no_log",
_("%s%s: not enough memory"),
weechat_prefix ("error"),
LOGGER_PLUGIN_NAME);
return;
}
/* log file is already used by another buffer? */
ptr_logger_buffer = logger_buffer_search_log_filename (log_filename);
if (ptr_logger_buffer)
{
weechat_printf_tags (NULL,
"no_log",
_("%s%s: unable to start logging for buffer "
"\"%s\": filename \"%s\" is already used by "
"another buffer (check your log settings)"),
weechat_prefix ("error"),
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (logger_buffer->buffer, "name"),
log_filename);
free (log_filename);
return;
}
/* create directory for path in "log_filename" */
dir_separator = weechat_info_get ("dir_separator", "");
if (dir_separator)
{
pos_last_sep = strrchr (log_filename, dir_separator[0]);
if (pos_last_sep)
{
pos_last_sep[0] = '\0';
weechat_mkdir_parents (log_filename, 0700);
pos_last_sep[0] = dir_separator[0];
}
}
/* set log filename */
logger_buffer->log_filename = log_filename;
}
void
trigger_command_rename (struct t_trigger *trigger, const char *new_name)
{
char *name, *name2;
name = strdup (trigger->name);
name2 = weechat_string_remove_quotes (new_name, "'\"");
if (name && name2)
{
/* check that new name is valid */
if (!trigger_name_valid (name2))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid name for trigger"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);
goto end;
}
/* check that no trigger already exists with the new name */
if (trigger_search (name2))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" already "
"exists"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
name2);
goto end;
}
/* rename the trigger */
if (trigger_rename (trigger, name2))
{
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" renamed to \"%s\""),
name, trigger->name);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: failed to rename trigger "
"\"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
name);
}
}
end:
if (name)
free (name);
if (name2)
free (name2);
}
int
logger_timer_cb (void *data, int remaining_calls)
{
struct t_logger_buffer *ptr_logger_buffer;
/* make C compiler happy */
(void) data;
(void) remaining_calls;
for (ptr_logger_buffer = logger_buffers; ptr_logger_buffer;
ptr_logger_buffer = ptr_logger_buffer->next_buffer)
{
if (ptr_logger_buffer->log_file && ptr_logger_buffer->flush_needed)
{
if (weechat_logger_plugin->debug >= 2)
{
weechat_printf_tags (NULL,
"no_log",
"%s: flush file %s",
LOGGER_PLUGIN_NAME,
ptr_logger_buffer->log_filename);
}
fflush (ptr_logger_buffer->log_file);
ptr_logger_buffer->flush_needed = 0;
}
}
return WEECHAT_RC_OK;
}
char *
logger_get_filename (struct t_gui_buffer *buffer)
{
char *res, *mask_expanded, *file_path;
const char *mask;
const char *dir_separator, *weechat_dir;
int length;
res = NULL;
mask_expanded = NULL;
file_path = NULL;
dir_separator = weechat_info_get ("dir_separator", "");
if (!dir_separator)
return NULL;
weechat_dir = weechat_info_get ("weechat_dir", "");
if (!weechat_dir)
return NULL;
/* get filename mask for buffer */
mask = logger_get_mask_for_buffer (buffer);
if (!mask)
{
weechat_printf_tags (NULL,
"no_log",
_("%s%s: unable to find filename mask for buffer "
"\"%s\", logging is disabled for this buffer"),
weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"));
return NULL;
}
mask_expanded = logger_get_mask_expanded (buffer, mask);
if (!mask_expanded)
goto end;
file_path = logger_get_file_path ();
if (!file_path)
goto end;
/* build string with path + mask */
length = strlen (file_path) + strlen (dir_separator) +
strlen (mask_expanded) + 1;
res = malloc (length);
if (res)
{
snprintf (res, length, "%s%s%s",
file_path,
(file_path[strlen (file_path) - 1] == dir_separator[0]) ? "" : dir_separator,
mask_expanded);
}
end:
if (mask_expanded)
free (mask_expanded);
if (file_path)
free (file_path);
return res;
}
void
irc_input_user_message_display (struct t_gui_buffer *buffer, const char *text)
{
struct t_irc_nick *ptr_nick;
char *text_decoded;
text_decoded = irc_color_decode (text,
weechat_config_boolean (irc_config_network_colors_send));
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (ptr_channel)
{
ptr_nick = NULL;
if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL)
{
ptr_nick = irc_nick_search (ptr_server, ptr_channel,
ptr_server->nick);
}
weechat_printf_tags (buffer,
irc_protocol_tags ("privmsg",
"notify_none,no_highlight",
(ptr_nick) ? ptr_nick->name : ptr_server->nick),
"%s%s",
irc_nick_as_prefix (ptr_server,
(ptr_nick) ? ptr_nick : NULL,
(ptr_nick) ? NULL : ptr_server->nick,
IRC_COLOR_CHAT_NICK_SELF),
(text_decoded) ? text_decoded : text);
}
if (text_decoded)
free (text_decoded);
}
void
trigger_command_display_status ()
{
weechat_printf_tags (NULL, "no_trigger",
(trigger_enabled) ?
_("Triggers enabled") : _("Triggers disabled"));
}
void
irc_ctcp_display_request (struct t_irc_server *server,
const char *command,
struct t_irc_channel *channel,
const char *nick, const char *ctcp,
const char *arguments,
const char *reply)
{
/* CTCP blocked and user doesn't want to see message? then just return */
if (reply && !reply[0]
&& !weechat_config_boolean (irc_config_look_display_ctcp_blocked))
return;
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server, nick,
NULL, "ctcp",
(channel) ? channel->buffer : NULL),
irc_protocol_tags (command, "irc_ctcp", NULL),
_("%sCTCP requested by %s%s%s: %s%s%s%s%s%s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
ctcp,
IRC_COLOR_RESET,
(arguments) ? " " : "",
(arguments) ? arguments : "",
(reply && !reply[0]) ? _(" (blocked)") : "");
}
void
trigger_command_list_default (int verbose)
{
int i, regex_count, commands_count;
struct t_trigger_regex *regex;
char **commands;
regex_count = 0;
regex = NULL;
commands_count = 0;
commands = NULL;
weechat_printf_tags (NULL, "no_trigger", "");
weechat_printf_tags (NULL, "no_trigger", _("List of default triggers:"));
for (i = 0; trigger_config_default_list[i][0]; i++)
{
if (trigger_regex_split (trigger_config_default_list[i][5],
®ex_count,
®ex) < 0)
continue;
trigger_split_command (trigger_config_default_list[i][6],
&commands_count,
&commands);
trigger_command_display_trigger_internal (
trigger_config_default_list[i][0],
weechat_config_string_to_boolean (trigger_config_default_list[i][1]),
trigger_config_default_list[i][2],
trigger_config_default_list[i][3],
trigger_config_default_list[i][4],
0,
0,
0,
regex_count,
regex,
commands_count,
commands,
trigger_search_return_code (trigger_config_default_list[i][7]),
verbose);
}
trigger_regex_free (®ex_count, ®ex);
if (commands)
weechat_string_free_split (commands);
}
void
trigger_command_error_running (struct t_trigger *trigger, const char *action)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: action \"%s\" can not be executed on "
"trigger \"%s\" because it is currently running"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
action, trigger->name);
}
void
irc_ctcp_reply_to_nick (struct t_irc_server *server,
const char *command,
struct t_irc_channel *channel,
const char *nick, const char *ctcp,
const char *arguments)
{
struct t_hashtable *hashtable;
int number;
char hash_key[32];
const char *str_args;
hashtable = irc_server_sendf (server,
IRC_SERVER_SEND_OUTQ_PRIO_LOW | IRC_SERVER_SEND_RETURN_HASHTABLE,
NULL,
"NOTICE %s :\01%s%s%s\01",
nick, ctcp,
(arguments) ? " " : "",
(arguments) ? arguments : "");
if (hashtable)
{
if (weechat_config_boolean (irc_config_look_display_ctcp_reply))
{
number = 1;
while (1)
{
snprintf (hash_key, sizeof (hash_key), "args%d", number);
str_args = weechat_hashtable_get (hashtable, hash_key);
if (!str_args)
break;
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server,
nick,
NULL,
"ctcp",
(channel) ? channel->buffer : NULL),
irc_protocol_tags (command,
"irc_ctcp,irc_ctcp_reply,"
"notify_none,no_highlight",
NULL),
_("%sCTCP reply to %s%s%s: %s%s%s%s%s"),
weechat_prefix ("network"),
irc_nick_color_for_message (server, NULL,
nick),
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
ctcp,
(str_args[0]) ? IRC_COLOR_RESET : "",
(str_args[0]) ? " " : "",
str_args);
number++;
}
}
weechat_hashtable_free (hashtable);
}
}
void
trigger_command_set_enabled (struct t_trigger *trigger,
int enable, const char *enable_string,
int display_error)
{
if (trigger->hook_running)
{
trigger_command_error_running (trigger, enable_string);
return;
}
if (enable == 2)
{
if (weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]))
{
trigger_hook (trigger);
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" restarted"),
trigger->name);
}
else if (display_error)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: a disabled trigger can not be "
"restarted"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);
}
}
else
{
if (enable < 0)
{
enable = weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]) ?
0 : 1;
}
weechat_config_option_set (trigger->options[TRIGGER_OPTION_ENABLED],
(enable) ? "on" : "off", 1);
weechat_printf_tags (NULL, "no_trigger",
(enable) ?
_("Trigger \"%s\" enabled") :
_("Trigger \"%s\" disabled"),
trigger->name);
}
}
void
trigger_command_list (const char *message, int verbose)
{
struct t_trigger *ptr_trigger;
weechat_printf_tags (NULL, "no_trigger", "");
trigger_command_display_status ();
if (!triggers)
{
weechat_printf_tags (NULL, "no_trigger", _("No trigger defined"));
return;
}
weechat_printf_tags (NULL, "no_trigger", message);
for (ptr_trigger = triggers; ptr_trigger;
ptr_trigger = ptr_trigger->next_trigger)
{
trigger_command_display_trigger (ptr_trigger, verbose);
}
}
void
logger_config_flush_delay_change (void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) data;
(void) option;
if (logger_config_loading)
return;
if (logger_timer)
{
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: stopping timer", LOGGER_PLUGIN_NAME);
}
weechat_unhook (logger_timer);
logger_timer = NULL;
}
if (weechat_config_integer (logger_config_file_flush_delay) > 0)
{
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: starting timer (interval: %d seconds)",
LOGGER_PLUGIN_NAME,
weechat_config_integer (logger_config_file_flush_delay));
}
logger_timer = weechat_hook_timer (weechat_config_integer (logger_config_file_flush_delay) * 1000,
0, 0,
&logger_timer_cb, NULL);
}
}
void
trigger_callback_run_command (struct t_trigger *trigger,
struct t_gui_buffer *buffer,
struct t_hashtable *pointers,
struct t_hashtable *extra_vars,
int display_monitor)
{
char *command_eval;
int i;
if (!trigger->commands)
return;
if (!buffer)
{
buffer = weechat_buffer_search_main ();
if (!buffer)
return;
}
for (i = 0; trigger->commands[i]; i++)
{
command_eval = weechat_string_eval_expression (trigger->commands[i],
pointers, extra_vars,
NULL);
if (command_eval)
{
/* display debug info on trigger buffer */
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
_("%s running command %s\"%s%s%s\"%s "
"on buffer %s%s%s"),
"\t",
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
command_eval,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
weechat_color ("chat_buffer"),
weechat_buffer_get_string (buffer,
"full_name"),
weechat_color ("reset"));
}
weechat_command (buffer, command_eval);
trigger->hook_count_cmd++;
}
free (command_eval);
}
}
int
xfer_chat_buffer_input_cb (void *data, struct t_gui_buffer *buffer,
const char *input_data)
{
struct t_xfer *ptr_xfer;
char *input_data_color, str_tags[256], *str_color;
/* make C compiler happy */
(void) data;
ptr_xfer = xfer_search_by_buffer (buffer);
if (ptr_xfer)
{
if (!XFER_HAS_ENDED(ptr_xfer->status))
{
xfer_chat_sendf (ptr_xfer, "%s\r\n", input_data);
if (!XFER_HAS_ENDED(ptr_xfer->status))
{
str_color = xfer_chat_color_for_tags (weechat_config_color (weechat_config_get ("weechat.color.chat_nick_self")));
snprintf (str_tags, sizeof (str_tags),
"irc_privmsg,no_highlight,prefix_nick_%s,nick_%s,log1",
(str_color) ? str_color : "default",
ptr_xfer->local_nick);
if (str_color)
free (str_color);
input_data_color = weechat_hook_modifier_exec ("irc_color_decode",
"1",
input_data);
weechat_printf_tags (buffer,
str_tags,
"%s%s\t%s",
weechat_color ("chat_nick_self"),
ptr_xfer->local_nick,
(input_data_color) ? input_data_color : input_data);
if (input_data_color)
free (input_data_color);
}
}
}
return WEECHAT_RC_OK;
}
void
logger_buffer_free (struct t_logger_buffer *logger_buffer)
{
struct t_logger_buffer *new_logger_buffers;
struct t_gui_buffer *ptr_buffer;
ptr_buffer = logger_buffer->buffer;
/* remove logger buffer */
if (last_logger_buffer == logger_buffer)
last_logger_buffer = logger_buffer->prev_buffer;
if (logger_buffer->prev_buffer)
{
(logger_buffer->prev_buffer)->next_buffer = logger_buffer->next_buffer;
new_logger_buffers = logger_buffers;
}
else
new_logger_buffers = logger_buffer->next_buffer;
if (logger_buffer->next_buffer)
(logger_buffer->next_buffer)->prev_buffer = logger_buffer->prev_buffer;
/* free data */
if (logger_buffer->log_filename)
free (logger_buffer->log_filename);
if (logger_buffer->log_file)
fclose (logger_buffer->log_file);
free (logger_buffer);
logger_buffers = new_logger_buffers;
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: stop logging for buffer \"%s\"",
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (ptr_buffer, "name"));
}
}
char *
logger_get_file_path ()
{
char *path, *path2;
int length;
time_t seconds;
struct tm *date_tmp;
path = NULL;
path2 = NULL;
/* replace %h and "~", evaluate path */
path = weechat_string_eval_path_home (
weechat_config_string (logger_config_file_path), NULL, NULL, NULL);
if (!path)
goto end;
/* replace date/time specifiers in path */
length = strlen (path) + 256 + 1;
path2 = malloc (length);
if (!path2)
goto end;
seconds = time (NULL);
date_tmp = localtime (&seconds);
path2[0] = '\0';
strftime (path2, length - 1, path, date_tmp);
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: file path = \"%s\"",
LOGGER_PLUGIN_NAME, path2);
}
end:
if (path)
free (path);
return path2;
}
struct t_logger_buffer *
logger_buffer_add (struct t_gui_buffer *buffer, int log_level)
{
struct t_logger_buffer *new_logger_buffer;
if (!buffer)
return NULL;
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: start logging for buffer \"%s\"",
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"));
}
new_logger_buffer = malloc (sizeof (*new_logger_buffer));
if (new_logger_buffer)
{
new_logger_buffer->buffer = buffer;
new_logger_buffer->log_filename = NULL;
new_logger_buffer->log_file = NULL;
new_logger_buffer->log_enabled = 1;
new_logger_buffer->log_level = log_level;
new_logger_buffer->write_start_info_line = 1;
new_logger_buffer->flush_needed = 0;
new_logger_buffer->prev_buffer = last_logger_buffer;
new_logger_buffer->next_buffer = NULL;
if (logger_buffers)
last_logger_buffer->next_buffer = new_logger_buffer;
else
logger_buffers = new_logger_buffer;
last_logger_buffer = new_logger_buffer;
}
return new_logger_buffer;
}
int
xfer_command_me (void *data, struct t_gui_buffer *buffer, int argc,
char **argv, char **argv_eol)
{
struct t_xfer *ptr_xfer;
/* make C compiler happy */
(void) data;
(void) argc;
(void) argv;
ptr_xfer = xfer_search_by_buffer (buffer);
if (!ptr_xfer)
{
weechat_printf (NULL,
_("%s%s: can't find xfer for buffer \"%s\""),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"));
return WEECHAT_RC_OK;
}
if (!XFER_HAS_ENDED(ptr_xfer->status))
{
xfer_chat_sendf (ptr_xfer, "\01ACTION %s\01\n",
(argv_eol[1]) ? argv_eol[1] : "");
weechat_printf_tags (buffer,
"no_highlight",
"%s%s%s %s%s",
weechat_prefix ("action"),
weechat_color ("chat_nick_self"),
ptr_xfer->local_nick,
weechat_color ("chat"),
(argv_eol[1]) ? argv_eol[1] : "");
}
return WEECHAT_RC_OK;
}
void
logger_flush ()
{
struct t_logger_buffer *ptr_logger_buffer;
for (ptr_logger_buffer = logger_buffers; ptr_logger_buffer;
ptr_logger_buffer = ptr_logger_buffer->next_buffer)
{
if (ptr_logger_buffer->log_file && ptr_logger_buffer->flush_needed)
{
if (weechat_logger_plugin->debug >= 2)
{
weechat_printf_tags (NULL,
"no_log",
"%s: flush file %s",
LOGGER_PLUGIN_NAME,
ptr_logger_buffer->log_filename);
}
fflush (ptr_logger_buffer->log_file);
ptr_logger_buffer->flush_needed = 0;
}
}
}
void
irc_input_user_message_display (struct t_gui_buffer *buffer, int action,
const char *text)
{
struct t_irc_nick *ptr_nick;
char *pos, *text2, *text_decoded, str_tags[256], *str_color;
const char *ptr_text;
/* if message is an action, force "action" to 1 and extract message */
if (strncmp (text, "\01ACTION ", 8) == 0)
{
action = 1;
pos = strrchr (text + 8, '\01');
if (pos)
text2 = weechat_strndup (text + 8, pos - text - 8);
else
text2 = strdup (text + 8);
}
else
text2 = strdup (text);
text_decoded = irc_color_decode (
(text2) ? text2 : text,
weechat_config_boolean (irc_config_network_colors_send));
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (ptr_channel)
{
ptr_nick = NULL;
if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL)
{
ptr_nick = irc_nick_search (ptr_server, ptr_channel,
ptr_server->nick);
}
if (action)
{
snprintf (str_tags, sizeof (str_tags),
"irc_action,notify_none,no_highlight");
}
else
{
str_color = irc_color_for_tags (
weechat_config_color (
weechat_config_get ("weechat.color.chat_nick_self")));
snprintf (str_tags, sizeof (str_tags),
"notify_none,no_highlight,prefix_nick_%s",
(str_color) ? str_color : "default");
if (str_color)
free (str_color);
}
ptr_text = (text_decoded) ? text_decoded : ((text2) ? text2 : text);
if (action)
{
weechat_printf_tags (
buffer,
irc_protocol_tags (
"privmsg", str_tags,
(ptr_nick) ? ptr_nick->name : ptr_server->nick,
NULL),
"%s%s%s%s%s %s",
weechat_prefix ("action"),
irc_nick_mode_for_display (ptr_server, ptr_nick, 0),
IRC_COLOR_CHAT_NICK_SELF,
ptr_server->nick,
IRC_COLOR_RESET,
ptr_text);
}
else
{
weechat_printf_tags (
buffer,
irc_protocol_tags (
"privmsg", str_tags,
(ptr_nick) ? ptr_nick->name : ptr_server->nick,
NULL),
"%s%s",
irc_nick_as_prefix (
ptr_server,
(ptr_nick) ? ptr_nick : NULL,
(ptr_nick) ? NULL : ptr_server->nick,
IRC_COLOR_CHAT_NICK_SELF),
ptr_text);
}
}
if (text2)
free (text2);
if (text_decoded)
free (text_decoded);
}
void
irc_ctcp_display_reply_from_nick (struct t_irc_server *server,
const char *command, const char *nick,
char *arguments)
{
char *pos_end, *pos_space, *pos_args, *pos_usec;
struct timeval tv;
long sec1, usec1, sec2, usec2, difftime;
while (arguments && arguments[0])
{
pos_end = strchr (arguments + 1, '\01');
if (pos_end)
pos_end[0] = '\0';
pos_space = strchr (arguments + 1, ' ');
if (pos_space)
{
pos_space[0] = '\0';
pos_args = pos_space + 1;
while (pos_args[0] == ' ')
{
pos_args++;
}
if (strcmp (arguments + 1, "PING") == 0)
{
pos_usec = strchr (pos_args, ' ');
if (pos_usec)
{
pos_usec[0] = '\0';
gettimeofday (&tv, NULL);
sec1 = atol (pos_args);
usec1 = atol (pos_usec + 1);
sec2 = tv.tv_sec;
usec2 = tv.tv_usec;
difftime = ((sec2 * 1000000) + usec2) -
((sec1 * 1000000) + usec1);
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server,
nick,
NULL,
"ctcp",
NULL),
irc_protocol_tags (command,
"irc_ctcp",
NULL),
_("%sCTCP reply from %s%s%s: %s%s%s "
"%ld.%ld %s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
arguments + 1,
IRC_COLOR_RESET,
difftime / 1000000,
(difftime % 1000000) / 1000,
(NG_("second", "seconds",
(difftime / 1000000))));
pos_usec[0] = ' ';
}
}
else
{
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server,
nick,
NULL,
"ctcp",
NULL),
irc_protocol_tags (command,
"irc_ctcp",
NULL),
_("%sCTCP reply from %s%s%s: %s%s%s%s%s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
arguments + 1,
IRC_COLOR_RESET,
" ",
pos_args);
}
pos_space[0] = ' ';
}
else
{
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server, nick,
NULL, "ctcp",
NULL),
irc_protocol_tags (command, NULL, NULL),
_("%sCTCP reply from %s%s%s: %s%s%s%s%s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
arguments + 1,
"",
"",
"");
}
if (pos_end)
pos_end[0] = '\01';
arguments = (pos_end) ? pos_end + 1 : NULL;
}
}
void
irc_ctcp_recv (struct t_irc_server *server, const char *command,
struct t_irc_channel *channel, const char *address,
const char *nick, const char *remote_nick, char *arguments,
char *message)
{
char *pos_end, *pos_space, *pos_args;
const char *reply;
char *decoded_reply;
struct t_irc_channel *ptr_channel;
struct t_irc_nick *ptr_nick;
int nick_is_me;
while (arguments && arguments[0])
{
pos_end = strrchr (arguments + 1, '\01');
if (pos_end)
pos_end[0] = '\0';
pos_args = NULL;
pos_space = strchr (arguments + 1, ' ');
if (pos_space)
{
pos_space[0] = '\0';
pos_args = pos_space + 1;
while (pos_args[0] == ' ')
{
pos_args++;
}
}
/* CTCP ACTION */
if (strcmp (arguments + 1, "ACTION") == 0)
{
nick_is_me = (irc_server_strcasecmp (server, server->nick, nick) == 0);
if (channel)
{
ptr_nick = irc_nick_search (server, channel, nick);
irc_channel_nick_speaking_add (channel,
nick,
(pos_args) ?
weechat_string_has_highlight (pos_args,
server->nick) : 0);
irc_channel_nick_speaking_time_remove_old (channel);
irc_channel_nick_speaking_time_add (server, channel, nick,
time (NULL));
weechat_printf_tags (channel->buffer,
irc_protocol_tags (command,
(nick_is_me) ?
"irc_action,notify_none,no_highlight" :
"irc_action,notify_message",
nick),
"%s%s%s%s%s%s",
weechat_prefix ("action"),
(ptr_nick) ? ptr_nick->color : ((nick) ? irc_nick_find_color (nick) : IRC_COLOR_CHAT_NICK),
nick,
(pos_args) ? IRC_COLOR_RESET : "",
(pos_args) ? " " : "",
(pos_args) ? pos_args : "");
}
else
{
ptr_channel = irc_channel_search (server, remote_nick);
if (!ptr_channel)
{
ptr_channel = irc_channel_new (server,
IRC_CHANNEL_TYPE_PRIVATE,
remote_nick, 0, 0);
if (!ptr_channel)
{
weechat_printf (server->buffer,
_("%s%s: cannot create new "
"private buffer \"%s\""),
weechat_prefix ("error"),
IRC_PLUGIN_NAME, remote_nick);
}
}
if (ptr_channel)
{
if (!ptr_channel->topic)
irc_channel_set_topic (ptr_channel, address);
weechat_printf_tags (ptr_channel->buffer,
irc_protocol_tags (command,
(nick_is_me) ?
"irc_action,notify_none,no_highlight" :
"irc_action,notify_private",
nick),
"%s%s%s%s%s%s",
weechat_prefix ("action"),
(nick_is_me) ?
IRC_COLOR_CHAT_NICK_SELF : irc_nick_color_for_pv (ptr_channel, nick),
nick,
(pos_args) ? IRC_COLOR_RESET : "",
(pos_args) ? " " : "",
(pos_args) ? pos_args : "");
weechat_hook_signal_send ("irc_pv",
WEECHAT_HOOK_SIGNAL_STRING,
message);
}
}
}
/* CTCP PING */
else if (strcmp (arguments + 1, "PING") == 0)
{
reply = irc_ctcp_get_reply (server, arguments + 1);
irc_ctcp_display_request (server, command, channel, nick,
arguments + 1, pos_args, reply);
if (!reply || reply[0])
{
irc_ctcp_reply_to_nick (server, command, channel, nick,
arguments + 1, pos_args);
}
}
/* CTCP DCC */
else if (strcmp (arguments + 1, "DCC") == 0)
{
irc_ctcp_recv_dcc (server, nick, pos_args, message);
}
/* other CTCP */
else
{
reply = irc_ctcp_get_reply (server, arguments + 1);
if (reply)
{
irc_ctcp_display_request (server, command, channel, nick,
arguments + 1, pos_args, reply);
if (reply[0])
{
decoded_reply = irc_ctcp_replace_variables (server, reply);
if (decoded_reply)
{
irc_ctcp_reply_to_nick (server, command, channel, nick,
arguments + 1, decoded_reply);
free (decoded_reply);
}
}
}
else
{
if (weechat_config_boolean (irc_config_look_display_ctcp_unknown))
{
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server,
nick,
NULL,
"ctcp",
(channel) ? channel->buffer : NULL),
irc_protocol_tags (command,
"irc_ctcp",
NULL),
_("%sUnknown CTCP requested by %s%s%s: "
"%s%s%s%s%s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
arguments + 1,
(pos_args) ? IRC_COLOR_RESET : "",
(pos_args) ? " " : "",
(pos_args) ? pos_args : "");
}
}
}
weechat_hook_signal_send ("irc_ctcp",
WEECHAT_HOOK_SIGNAL_STRING,
message);
if (pos_space)
pos_space[0] = ' ';
if (pos_end)
pos_end[0] = '\01';
arguments = (pos_end) ? pos_end + 1 : NULL;
}
}
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);
}
}
char *
logger_get_mask_expanded (struct t_gui_buffer *buffer, const char *mask)
{
char *mask2, *mask_decoded, *mask_decoded2, *mask_decoded3, *mask_decoded4;
char *mask_decoded5;
const char *dir_separator;
int length;
time_t seconds;
struct tm *date_tmp;
mask2 = NULL;
mask_decoded = NULL;
mask_decoded2 = NULL;
mask_decoded3 = NULL;
mask_decoded4 = NULL;
mask_decoded5 = NULL;
dir_separator = weechat_info_get ("dir_separator", "");
if (!dir_separator)
return NULL;
/*
* we first replace directory separator (commonly '/') by \01 because
* buffer mask can contain this char, and will be replaced by replacement
* char ('_' by default)
*/
mask2 = weechat_string_replace (mask, dir_separator, "\01");
if (!mask2)
goto end;
mask_decoded = weechat_buffer_string_replace_local_var (buffer, mask2);
if (!mask_decoded)
goto end;
mask_decoded2 = weechat_string_replace (mask_decoded,
dir_separator,
weechat_config_string (logger_config_file_replacement_char));
if (!mask_decoded2)
goto end;
#ifdef __CYGWIN__
mask_decoded3 = weechat_string_replace (mask_decoded2, "\\",
weechat_config_string (logger_config_file_replacement_char));
#else
mask_decoded3 = strdup (mask_decoded2);
#endif /* __CYGWIN__ */
if (!mask_decoded3)
goto end;
/* restore directory separator */
mask_decoded4 = weechat_string_replace (mask_decoded3,
"\01", dir_separator);
if (!mask_decoded4)
goto end;
/* replace date/time specifiers in mask */
length = strlen (mask_decoded4) + 256 + 1;
mask_decoded5 = malloc (length);
if (!mask_decoded5)
goto end;
seconds = time (NULL);
date_tmp = localtime (&seconds);
mask_decoded5[0] = '\0';
strftime (mask_decoded5, length - 1, mask_decoded4, date_tmp);
/* convert to lower case? */
if (weechat_config_boolean (logger_config_file_name_lower_case))
weechat_string_tolower (mask_decoded5);
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: buffer = \"%s\", mask = \"%s\", "
"decoded mask = \"%s\"",
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"),
mask, mask_decoded5);
}
end:
if (mask2)
free (mask2);
if (mask_decoded)
free (mask_decoded);
if (mask_decoded2)
free (mask_decoded2);
if (mask_decoded3)
free (mask_decoded3);
if (mask_decoded4)
free (mask_decoded4);
return mask_decoded5;
}
void
trigger_callback_replace_regex (struct t_trigger *trigger,
struct t_hashtable *pointers,
struct t_hashtable *extra_vars,
int display_monitor)
{
char *value;
const char *ptr_key, *ptr_value;
int i, pointers_allocated;
pointers_allocated = 0;
if (trigger->regex_count == 0)
return;
if (!pointers)
{
pointers = weechat_hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_POINTER,
NULL,
NULL);
if (!pointers)
return;
pointers_allocated = 1;
}
for (i = 0; i < trigger->regex_count; i++)
{
/* if regex is not set (invalid), skip it */
if (!trigger->regex[i].regex)
continue;
ptr_key = (trigger->regex[i].variable) ?
trigger->regex[i].variable :
trigger_hook_regex_default_var[weechat_config_integer (trigger->options[TRIGGER_OPTION_HOOK])];
if (!ptr_key || !ptr_key[0])
{
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d: %s",
i + 1, _("no variable"));
}
continue;
}
ptr_value = weechat_hashtable_get (extra_vars, ptr_key);
if (!ptr_value)
{
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d (%s): %s",
i + 1, ptr_key, _("empty variable"));
}
continue;
}
weechat_hashtable_set (pointers, "regex", trigger->regex[i].regex);
weechat_hashtable_set (trigger_callback_hashtable_options_regex,
"regex_replace",
trigger->regex[i].replace_escaped);
value = weechat_string_eval_expression (
ptr_value,
pointers,
extra_vars,
trigger_callback_hashtable_options_regex);
if (value)
{
/* display debug info on trigger buffer */
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d %s(%s%s%s)%s: "
"%s\"%s%s%s\"",
i + 1,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
ptr_key,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
value,
weechat_color ("chat_delimiters"));
}
weechat_hashtable_set (extra_vars, ptr_key, value);
free (value);
}
}
if (pointers_allocated)
weechat_hashtable_free (pointers);
else
weechat_hashtable_remove (pointers, "regex");
}
int
xfer_chat_recv_cb (void *arg_xfer, int fd)
{
struct t_xfer *xfer;
static char buffer[4096 + 2];
char *buf2, *pos, *ptr_buf, *ptr_buf2, *next_ptr_buf;
char *ptr_buf_decoded, *ptr_buf_without_weechat_colors, *ptr_buf_color;
char str_tags[256], *str_color;
const char *pv_tags;
int num_read, length, ctcp_action;
/* make C compiler happy */
(void) fd;
xfer = (struct t_xfer *)arg_xfer;
num_read = recv (xfer->sock, buffer, sizeof (buffer) - 2, 0);
if (num_read > 0)
{
buffer[num_read] = '\0';
buf2 = NULL;
ptr_buf = buffer;
if (xfer->unterminated_message)
{
buf2 = malloc (strlen (xfer->unterminated_message) +
strlen (buffer) + 1);
if (buf2)
{
strcpy (buf2, xfer->unterminated_message);
strcat (buf2, buffer);
}
ptr_buf = buf2;
free (xfer->unterminated_message);
xfer->unterminated_message = NULL;
}
while (ptr_buf && ptr_buf[0])
{
next_ptr_buf = NULL;
pos = strstr (ptr_buf, "\n");
if (pos)
{
pos[0] = '\0';
next_ptr_buf = pos + 1;
}
else
{
xfer->unterminated_message = strdup (ptr_buf);
ptr_buf = NULL;
next_ptr_buf = NULL;
}
if (ptr_buf)
{
ctcp_action = 0;
length = strlen (ptr_buf);
if (ptr_buf[length - 1] == '\r')
{
ptr_buf[length - 1] = '\0';
length--;
}
if ((ptr_buf[0] == '\01')
&& (ptr_buf[length - 1] == '\01'))
{
ptr_buf[length - 1] = '\0';
ptr_buf++;
if (strncmp (ptr_buf, "ACTION ", 7) == 0)
{
ptr_buf += 7;
ctcp_action = 1;
}
}
ptr_buf_decoded = (xfer->charset_modifier) ?
weechat_hook_modifier_exec ("charset_decode",
xfer->charset_modifier,
ptr_buf) : NULL;
ptr_buf_without_weechat_colors = weechat_string_remove_color ((ptr_buf_decoded) ? ptr_buf_decoded : ptr_buf,
"?");
ptr_buf_color = weechat_hook_modifier_exec ("irc_color_decode",
"1",
(ptr_buf_without_weechat_colors) ?
ptr_buf_without_weechat_colors : ((ptr_buf_decoded) ? ptr_buf_decoded : ptr_buf));
ptr_buf2 = (ptr_buf_color) ?
ptr_buf_color : ((ptr_buf_without_weechat_colors) ?
ptr_buf_without_weechat_colors : ((ptr_buf_decoded) ? ptr_buf_decoded : ptr_buf));
pv_tags = weechat_config_string (xfer_config_look_pv_tags);
if (ctcp_action)
{
snprintf (str_tags, sizeof (str_tags),
"irc_privmsg,irc_action,%s%snick_%s,log1",
(pv_tags && pv_tags[0]) ? pv_tags : "",
(pv_tags && pv_tags[0]) ? "," : "",
xfer->remote_nick);
weechat_printf_tags (xfer->buffer,
str_tags,
"%s%s%s%s%s%s",
weechat_prefix ("action"),
weechat_color ((xfer->remote_nick_color) ?
xfer->remote_nick_color : "chat_nick_other"),
xfer->remote_nick,
weechat_color ("chat"),
(ptr_buf2[0]) ? " " : "",
ptr_buf2);
}
else
{
str_color = xfer_chat_color_for_tags (
(xfer->remote_nick_color) ?
xfer->remote_nick_color : weechat_config_color (weechat_config_get ("weechat.color.chat_nick_other")));
snprintf (str_tags, sizeof (str_tags),
"irc_privmsg,%s%sprefix_nick_%s,nick_%s,log1",
(pv_tags && pv_tags[0]) ? pv_tags : "",
(pv_tags && pv_tags[0]) ? "," : "",
(str_color) ? str_color : "default",
xfer->remote_nick);
if (str_color)
free (str_color);
weechat_printf_tags (xfer->buffer,
str_tags,
"%s%s\t%s",
weechat_color ((xfer->remote_nick_color) ?
xfer->remote_nick_color : "chat_nick_other"),
xfer->remote_nick,
ptr_buf2);
}
if (ptr_buf_decoded)
free (ptr_buf_decoded);
if (ptr_buf_without_weechat_colors)
free (ptr_buf_without_weechat_colors);
if (ptr_buf_color)
free (ptr_buf_color);
}
ptr_buf = next_ptr_buf;
}
if (buf2)
free (buf2);
}
else
{
xfer_close (xfer, XFER_STATUS_ABORTED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
}
return WEECHAT_RC_OK;
}
int
trigger_command_trigger (void *data, struct t_gui_buffer *buffer, int argc,
char **argv, char **argv_eol)
{
struct t_trigger *ptr_trigger, *ptr_trigger2;
struct t_trigger_regex *regex;
char *value, **sargv, **items, input[1024], str_pos[16];
int rc, i, type, count, index_option, enable, sargc, num_items, add_rc;
int regex_count, regex_rc;
/* make C compiler happy */
(void) data;
rc = WEECHAT_RC_OK;
sargv = NULL;
/* list all triggers */
if ((argc == 1)
|| ((argc == 2) && (weechat_strcasecmp (argv[1], "list") == 0)))
{
trigger_command_list (_("List of triggers:"), 0);
goto end;
}
/* full list of all triggers */
if ((argc == 2) && (weechat_strcasecmp (argv[1], "listfull") == 0))
{
trigger_command_list (_("List of triggers:"), 1);
goto end;
}
/* list of default triggers */
if ((argc == 2) && (weechat_strcasecmp (argv[1], "listdefault") == 0))
{
trigger_command_list_default (1);
goto end;
}
/* add a trigger */
if ((weechat_strcasecmp (argv[1], "add") == 0)
|| (weechat_strcasecmp (argv[1], "addoff") == 0)
|| (weechat_strcasecmp (argv[1], "addreplace") == 0))
{
sargv = weechat_string_split_shell (argv_eol[2], &sargc);
if (!sargv || (sargc < 2))
goto error;
if (!trigger_name_valid (sargv[0]))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid name for trigger"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);
goto end;
}
type = trigger_search_hook_type (sargv[1]);
if (type < 0)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid hook type \"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
sargv[1]);
goto end;
}
if ((sargc > 4) && sargv[4][0])
{
regex_count = 0;
regex = NULL;
regex_rc = trigger_regex_split (sargv[4], ®ex_count, ®ex);
trigger_regex_free (®ex_count, ®ex);
switch (regex_rc)
{
case 0: /* OK */
break;
case -1: /* format error */
weechat_printf (NULL,
_("%s%s: invalid format for regular "
"expression"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME);
goto end;
break;
case -2: /* regex compilation error */
weechat_printf (NULL,
_("%s%s: invalid regular expression "
"(compilation failed)"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME);
goto end;
break;
case -3: /* memory error */
weechat_printf (NULL,
_("%s%s: not enough memory"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME);
goto end;
break;
}
}
if ((sargc > 6) && sargv[6][0]
&& (trigger_search_return_code (sargv[6]) < 0))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid return code \"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
sargv[6]);
goto end;
}
ptr_trigger = trigger_search (sargv[0]);
if (ptr_trigger)
{
if (weechat_strcasecmp (argv[1], "addreplace") == 0)
{
if (ptr_trigger)
trigger_free (ptr_trigger);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" already exists "
"(choose another name or use option "
"\"addreplace\" to overwrite it)"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME, sargv[0]);
goto end;
}
}
ptr_trigger = trigger_alloc (sargv[0]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: failed to create trigger \"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
sargv[0]);
goto end;
}
ptr_trigger = trigger_new (
sargv[0], /* name */
(weechat_strcasecmp (argv[1], "addoff") == 0) ? "off" : "on",
sargv[1], /* hook */
(sargc > 2) ? sargv[2] : "", /* arguments */
(sargc > 3) ? sargv[3] : "", /* conditions */
(sargc > 4) ? sargv[4] : "", /* regex */
(sargc > 5) ? sargv[5] : "", /* command */
(sargc > 6) ? sargv[6] : ""); /* return code */
if (ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" created"), sargv[0]);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: failed to create trigger \"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
sargv[0]);
}
goto end;
}
/* add trigger command in input (to help trigger creation) */
if (weechat_strcasecmp (argv[1], "addinput") == 0)
{
type = TRIGGER_HOOK_SIGNAL;
if (argc >= 3)
{
type = trigger_search_hook_type (argv[2]);
if (type < 0)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid hook type \"%s\""),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME, argv[2]);
goto end;
}
}
items = weechat_string_split (trigger_hook_default_rc[type], ",", 0, 0,
&num_items);
snprintf (input, sizeof (input),
"/trigger add name %s \"%s\" \"%s\" \"%s\" \"%s\"%s%s%s",
trigger_hook_type_string[type],
trigger_hook_default_arguments[type],
TRIGGER_HOOK_DEFAULT_CONDITIONS,
TRIGGER_HOOK_DEFAULT_REGEX,
TRIGGER_HOOK_DEFAULT_COMMAND,
(items && (num_items > 0)) ? " \"" : "",
(items && (num_items > 0)) ? items[0] : "",
(items && (num_items > 0)) ? "\"" : "");
weechat_buffer_set (buffer, "input", input);
weechat_buffer_set (buffer, "input_pos", "13");
goto end;
}
/*
* get command to create a trigger, and according to option:
* - input: put the command in input
* - output: send the command to the buffer
* - recreate: same as input, but the trigger is first deleted
*/
if ((weechat_strcasecmp (argv[1], "input") == 0)
|| (weechat_strcasecmp (argv[1], "output") == 0)
|| (weechat_strcasecmp (argv[1], "recreate") == 0))
{
if (argc < 3)
goto error;
ptr_trigger = trigger_search (argv[2]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" not found"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[2]);
goto end;
}
add_rc = trigger_hook_default_rc[weechat_config_integer (ptr_trigger->options[TRIGGER_OPTION_HOOK])][0];
snprintf (input, sizeof (input),
"//trigger %s %s %s \"%s\" \"%s\" \"%s\" \"%s\"%s%s%s",
(weechat_strcasecmp (argv[1], "recreate") == 0) ? "addreplace" : "add",
ptr_trigger->name,
weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_HOOK]),
weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_ARGUMENTS]),
weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_CONDITIONS]),
weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_REGEX]),
weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_COMMAND]),
(add_rc) ? " \"" : "",
(add_rc) ? weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_RETURN_CODE]) : "",
(add_rc) ? "\"" : "");
if (weechat_strcasecmp (argv[1], "output") == 0)
{
weechat_command (buffer, input);
}
else
{
weechat_buffer_set (buffer, "input", input + 1);
snprintf (str_pos, sizeof (str_pos),
"%d", weechat_utf8_strlen (input + 1));
weechat_buffer_set (buffer, "input_pos", str_pos);
}
goto end;
}
/* set option in a trigger */
if (weechat_strcasecmp (argv[1], "set") == 0)
{
if (argc < 5)
goto error;
ptr_trigger = trigger_search (argv[2]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" not found"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[2]);
goto end;
}
if (weechat_strcasecmp (argv[3], "name") == 0)
{
trigger_command_rename (ptr_trigger, argv[4]);
goto end;
}
value = weechat_string_remove_quotes (argv_eol[4], "'\"");
if (value)
{
index_option = trigger_search_option (argv[3]);
if (index_option >= 0)
{
weechat_config_option_set (ptr_trigger->options[index_option],
value, 1);
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" updated"),
ptr_trigger->name);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger option \"%s\" not "
"found"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME, argv[3]);
}
free (value);
}
goto end;
}
/* rename a trigger */
if (weechat_strcasecmp (argv[1], "rename") == 0)
{
if (argc < 4)
goto error;
ptr_trigger = trigger_search (argv[2]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" not found"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[2]);
goto end;
}
trigger_command_rename (ptr_trigger, argv[3]);
goto end;
}
/* copy a trigger */
if (weechat_strcasecmp (argv[1], "copy") == 0)
{
if (argc < 4)
goto error;
ptr_trigger = trigger_search (argv[2]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" not found"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[2]);
goto end;
}
/* check that new name is valid */
if (!trigger_name_valid (argv[3]))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: invalid name for trigger"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);
goto end;
}
/* check that no trigger already exists with the new name */
if (trigger_search (argv[3]))
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" already "
"exists"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[3]);
goto end;
}
/* copy the trigger */
ptr_trigger2 = trigger_copy (ptr_trigger, argv[3]);
if (ptr_trigger2)
{
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" copied to \"%s\""),
ptr_trigger->name, ptr_trigger2->name);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: failed to copy trigger "
"\"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
ptr_trigger->name);
}
goto end;
}
/* enable/disable/toggle/restart trigger(s) */
if ((weechat_strcasecmp (argv[1], "enable") == 0)
|| (weechat_strcasecmp (argv[1], "disable") == 0)
|| (weechat_strcasecmp (argv[1], "toggle") == 0)
|| (weechat_strcasecmp (argv[1], "restart") == 0))
{
if (argc < 3)
{
if (weechat_strcasecmp (argv[1], "restart") == 0)
goto error;
if (weechat_strcasecmp (argv[1], "enable") == 0)
weechat_config_option_set (trigger_config_look_enabled, "1", 1);
else if (weechat_strcasecmp (argv[1], "disable") == 0)
weechat_config_option_set (trigger_config_look_enabled, "0", 1);
else if (weechat_strcasecmp (argv[1], "toggle") == 0)
{
weechat_config_option_set (trigger_config_look_enabled,
(trigger_enabled) ? "0" : "1",
1);
}
trigger_command_display_status ();
goto end;
}
enable = -1;
if (weechat_strcasecmp (argv[1], "enable") == 0)
enable = 1;
else if (weechat_strcasecmp (argv[1], "disable") == 0)
enable = 0;
else if (weechat_strcasecmp (argv[1], "restart") == 0)
enable = 2;
if (weechat_strcasecmp (argv[2], "-all") == 0)
{
for (ptr_trigger = triggers; ptr_trigger;
ptr_trigger = ptr_trigger->next_trigger)
{
trigger_command_set_enabled (ptr_trigger, enable, 0);
}
}
else
{
for (i = 2; i < argc; i++)
{
ptr_trigger = trigger_search (argv[i]);
if (ptr_trigger)
trigger_command_set_enabled (ptr_trigger, enable, 1);
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%sTrigger \"%s\" not found"),
weechat_prefix ("error"), argv[i]);
}
}
}
goto end;
}
/* delete trigger(s) */
if (weechat_strcasecmp (argv[1], "del") == 0)
{
if (argc < 3)
goto error;
if (weechat_strcasecmp (argv[2], "-all") == 0)
{
count = triggers_count;
trigger_free_all ();
if (count > 0)
weechat_printf_tags (NULL, "no_trigger",
_("%d triggers removed"), count);
}
else
{
for (i = 2; i < argc; i++)
{
ptr_trigger = trigger_search (argv[i]);
if (ptr_trigger)
{
trigger_free (ptr_trigger);
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" removed"), argv[i]);
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%sTrigger \"%s\" not found"),
weechat_prefix ("error"), argv[i]);
}
}
}
goto end;
}
/* show detailed info on a trigger */
if (weechat_strcasecmp (argv[1], "show") == 0)
{
if (argc < 3)
goto error;
ptr_trigger = trigger_search (argv[2]);
if (!ptr_trigger)
{
weechat_printf_tags (NULL, "no_trigger",
_("%s%s: trigger \"%s\" not found"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
argv[2]);
goto end;
}
weechat_printf_tags (NULL, "no_trigger", "");
weechat_printf_tags (NULL, "no_trigger", _("Trigger:"));
trigger_command_display_trigger (ptr_trigger, 2);
goto end;
}
/* restore default triggers */
if (weechat_strcasecmp (argv[1], "default") == 0)
{
if ((argc >= 3) && (weechat_strcasecmp (argv[2], "-yes") == 0))
{
trigger_free_all ();
trigger_create_default ();
trigger_command_list (_("Default triggers restored:"), 0);
}
else
{
weechat_printf (NULL,
_("%s%s: \"-yes\" argument is required for "
"restoring default triggers (security reason)"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);
}
goto end;
}
/* open the trigger monitor buffer */
if (weechat_strcasecmp (argv[1], "monitor") == 0)
{
trigger_buffer_open ((argc > 2) ? argv_eol[2] : NULL, 1);
goto end;
}
error:
rc = WEECHAT_RC_ERROR;
end:
if (sargv)
weechat_string_free_split (sargv);
return rc;
}
void
trigger_command_display_trigger_internal (const char *name,
int enabled,
const char *hook,
const char *arguments,
const char *conditions,
int hooks_count,
int hook_count_cb,
int hook_count_cmd,
int regex_count,
struct t_trigger_regex *regex,
int commands_count,
char **commands,
int return_code,
int verbose)
{
char str_conditions[64], str_regex[64], str_command[64], str_rc[64];
char spaces[256];
int i, length;
if (verbose >= 1)
{
weechat_printf_tags (
NULL, "no_trigger",
" %s%s%s: %s%s%s%s%s%s%s",
(enabled) ?
weechat_color (weechat_config_string (trigger_config_color_trigger)) :
weechat_color (weechat_config_string (trigger_config_color_trigger_disabled)),
name,
weechat_color ("reset"),
hook,
weechat_color ("chat_delimiters"),
(arguments && arguments[0]) ? "(" : "",
weechat_color ("reset"),
arguments,
weechat_color ("chat_delimiters"),
(arguments && arguments[0]) ? ")" : "");
length = weechat_strlen_screen (name) + 3;
if (length >= (int)sizeof (spaces))
length = sizeof (spaces) - 1;
memset (spaces, ' ', length);
spaces[length] = '\0';
if (verbose >= 2)
{
weechat_printf_tags (NULL, "no_trigger",
"%s hooks: %d", spaces, hooks_count);
weechat_printf_tags (NULL, "no_trigger",
"%s callback: %d",
spaces, hook_count_cb);
weechat_printf_tags (NULL, "no_trigger",
"%s commands: %d",
spaces, hook_count_cmd);
}
if (conditions && conditions[0])
{
weechat_printf_tags (NULL, "no_trigger",
"%s %s=? %s\"%s%s%s\"",
spaces,
weechat_color (weechat_config_string (trigger_config_color_flag_conditions)),
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
conditions,
weechat_color ("chat_delimiters"));
}
for (i = 0; i < regex_count; i++)
{
weechat_printf_tags (NULL, "no_trigger",
"%s %s~%d %s\"%s%s%s\" --> "
"\"%s%s%s\"%s%s%s%s",
spaces,
weechat_color (weechat_config_string (trigger_config_color_flag_regex)),
i + 1,
weechat_color ("chat_delimiters"),
weechat_color (weechat_config_string (trigger_config_color_regex)),
regex[i].str_regex,
weechat_color ("chat_delimiters"),
weechat_color (weechat_config_string (trigger_config_color_replace)),
regex[i].replace,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
(regex[i].variable) ? " (" : "",
(regex[i].variable) ? regex[i].variable : "",
(regex[i].variable) ? ")" : "");
}
if (commands)
{
for (i = 0; commands[i]; i++)
{
weechat_printf_tags (NULL, "no_trigger",
"%s %s/%d %s\"%s%s%s\"",
spaces,
weechat_color (weechat_config_string (trigger_config_color_flag_command)),
i + 1,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
commands[i],
weechat_color ("chat_delimiters"));
}
}
if ((return_code >= 0) && (return_code != TRIGGER_RC_OK))
{
weechat_printf_tags (NULL, "no_trigger",
"%s %s=> %s%s",
spaces,
weechat_color (weechat_config_string (trigger_config_color_flag_return_code)),
weechat_color ("reset"),
trigger_return_code_string[return_code]);
}
}
else
{
str_conditions[0] ='\0';
str_regex[0] = '\0';
str_command[0] = '\0';
str_rc[0] = '\0';
if (conditions && conditions[0])
{
snprintf (str_conditions, sizeof (str_conditions),
" %s=?%s",
weechat_color (weechat_config_string (trigger_config_color_flag_conditions)),
weechat_color ("reset"));
}
if (regex_count > 0)
{
snprintf (str_regex, sizeof (str_regex),
" %s~%d%s",
weechat_color (weechat_config_string (trigger_config_color_flag_regex)),
regex_count,
weechat_color ("reset"));
}
if (commands_count > 0)
{
snprintf (str_command, sizeof (str_command),
" %s/%d%s",
weechat_color (weechat_config_string (trigger_config_color_flag_command)),
commands_count,
weechat_color ("reset"));
}
if ((return_code >= 0) && (return_code != TRIGGER_RC_OK))
{
snprintf (str_rc, sizeof (str_rc),
" %s=>%s",
weechat_color (weechat_config_string (trigger_config_color_flag_return_code)),
weechat_color ("reset"));
}
weechat_printf_tags (
NULL, "no_trigger",
" %s%s%s: %s%s%s%s%s%s%s%s%s%s%s%s",
(enabled) ?
weechat_color (weechat_config_string (trigger_config_color_trigger)) :
weechat_color (weechat_config_string (trigger_config_color_trigger_disabled)),
name,
weechat_color ("reset"),
hook,
weechat_color ("chat_delimiters"),
(arguments && arguments[0]) ? "(" : "",
weechat_color ("reset"),
arguments,
weechat_color ("chat_delimiters"),
(arguments && arguments[0]) ? ")" : "",
weechat_color ("reset"),
str_conditions,
str_regex,
str_command,
str_rc);
}
}
void
trigger_callback_replace_regex (struct t_trigger *trigger,
struct t_hashtable *pointers,
struct t_hashtable *extra_vars,
int display_monitor)
{
char *value, *replace_eval;
const char *ptr_key, *ptr_value;
int i;
if (trigger->regex_count == 0)
return;
for (i = 0; i < trigger->regex_count; i++)
{
/* if regex is not set (invalid), skip it */
if (!trigger->regex[i].regex)
continue;
ptr_key = (trigger->regex[i].variable) ?
trigger->regex[i].variable :
trigger_hook_regex_default_var[weechat_config_integer (trigger->options[TRIGGER_OPTION_HOOK])];
if (!ptr_key || !ptr_key[0])
{
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d: %s",
i + 1, _("no variable"));
}
continue;
}
ptr_value = weechat_hashtable_get (extra_vars, ptr_key);
if (!ptr_value)
{
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d (%s): %s",
i + 1, ptr_key, _("empty variable"));
}
continue;
}
replace_eval = weechat_string_eval_expression (
trigger->regex[i].replace_escaped,
pointers,
extra_vars,
NULL);
if (replace_eval)
{
value = weechat_string_replace_regex (ptr_value,
trigger->regex[i].regex,
replace_eval,
'$',
NULL, NULL);
if (value)
{
/* display debug info on trigger buffer */
if (trigger_buffer && display_monitor)
{
weechat_printf_tags (trigger_buffer, "no_trigger",
"\t regex %d %s(%s%s%s)%s: "
"%s\"%s%s%s\"",
i + 1,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
ptr_key,
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
weechat_color ("chat_delimiters"),
weechat_color ("reset"),
value,
weechat_color ("chat_delimiters"));
}
weechat_hashtable_set (extra_vars, ptr_key, value);
free (value);
}
free (replace_eval);
}
}
}
