int
irc_input_send_cb (const void *pointer, void *data,
const char *signal,
const char *type_data, void *signal_data)
{
const char *ptr_string, *ptr_message;
char *pos_semicol1, *pos_semicol2, *pos_semicol3, *pos_semicol4;
char *server, *channel, *options, *tags, *data_with_colors, **list_options;
int i, num_options, flags, force_user_message;
struct t_irc_server *ptr_server;
struct t_irc_channel *ptr_channel;
struct t_gui_buffer *ptr_buffer;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) signal;
(void) type_data;
ptr_string = (const char *)signal_data;
server = NULL;
channel = NULL;
options = NULL;
flags = IRC_SERVER_SEND_OUTQ_PRIO_HIGH;
force_user_message = 0;
tags = NULL;
ptr_message = NULL;
ptr_server = NULL;
ptr_channel = NULL;
pos_semicol1 = strchr (ptr_string, ';');
if (pos_semicol1)
{
if (pos_semicol1 > ptr_string + 1)
{
server = weechat_strndup (ptr_string, pos_semicol1 - ptr_string);
}
pos_semicol2 = strchr (pos_semicol1 + 1, ';');
if (pos_semicol2)
{
if (pos_semicol2 > pos_semicol1 + 1)
{
channel = weechat_strndup (pos_semicol1 + 1,
pos_semicol2 - pos_semicol1 - 1);
}
pos_semicol3 = strchr (pos_semicol2 + 1, ';');
if (pos_semicol3)
{
if (pos_semicol3 > pos_semicol2 + 1)
{
options = weechat_strndup (pos_semicol2 + 1,
pos_semicol3 - pos_semicol2 - 1);
}
pos_semicol4 = strchr (pos_semicol3 + 1, ';');
if (pos_semicol4)
{
if (pos_semicol4 > pos_semicol3 + 1)
{
tags = weechat_strndup (pos_semicol3 + 1,
pos_semicol4 - pos_semicol3 - 1);
}
ptr_message = pos_semicol4 + 1;
}
}
}
}
if (options && options[0])
{
list_options = weechat_string_split (options, ",", 0, 0, &num_options);
if (list_options)
{
for (i = 0; i < num_options; i++)
{
if (strcmp (list_options[i], "priority_high") == 0)
flags = IRC_SERVER_SEND_OUTQ_PRIO_HIGH;
else if (strcmp (list_options[i], "priority_low") == 0)
flags = IRC_SERVER_SEND_OUTQ_PRIO_LOW;
else if (strcmp (list_options[i], "user_message") == 0)
force_user_message = 1;
}
weechat_string_free_split (list_options);
}
}
if (server && ptr_message)
{
ptr_server = irc_server_search (server);
if (ptr_server)
{
ptr_buffer = ptr_server->buffer;
if (channel)
{
ptr_channel = irc_channel_search (ptr_server, channel);
if (ptr_channel)
ptr_buffer = ptr_channel->buffer;
}
/* set tags to use by default */
irc_server_set_send_default_tags (tags);
/* send text to buffer, or execute command */
if (force_user_message
|| weechat_string_input_for_buffer (ptr_message))
{
/* text as input */
irc_input_data (ptr_buffer, ptr_message, flags, 1);
}
else
{
/* command */
data_with_colors = irc_color_encode (
ptr_message,
weechat_config_boolean (irc_config_network_colors_send));
weechat_command (
ptr_buffer,
(data_with_colors) ? data_with_colors : ptr_message);
if (data_with_colors)
free (data_with_colors);
}
/* reset tags to use by default */
irc_server_set_send_default_tags (NULL);
}
}
if (server)
free (server);
if (channel)
free (channel);
if (options)
free (options);
if (tags)
free (tags);
return WEECHAT_RC_OK;
}
int
irc_message_split_join (struct t_hashtable *hashtable,
const char *tags, const char *host,
const char *arguments)
{
int number, channels_count, keys_count, length, length_no_channel;
int length_to_add, index_channel;
char **channels, **keys, *pos, *str;
char msg_to_send[2048], keys_to_add[2048];
number = 1;
channels = NULL;
channels_count = 0;
keys = NULL;
keys_count = 0;
pos = strchr (arguments, ' ');
if (pos)
{
str = weechat_strndup (arguments, pos - arguments);
if (!str)
return 0;
channels = weechat_string_split (str, ",", 0, 0, &channels_count);
free (str);
while (pos[0] == ' ')
{
pos++;
}
if (pos[0])
keys = weechat_string_split (pos, ",", 0, 0, &keys_count);
}
else
{
channels = weechat_string_split (arguments, ",", 0, 0, &channels_count);
}
snprintf (msg_to_send, sizeof (msg_to_send), "%s%sJOIN",
(host) ? host : "",
(host) ? " " : "");
length = strlen (msg_to_send);
length_no_channel = length;
keys_to_add[0] = '\0';
index_channel = 0;
while (index_channel < channels_count)
{
length_to_add = 1 + strlen (channels[index_channel]);
if (index_channel < keys_count)
length_to_add += 1 + strlen (keys[index_channel]);
if ((length + length_to_add < 510) || (length == length_no_channel))
{
if (length + length_to_add < (int)sizeof (msg_to_send))
{
strcat (msg_to_send, (length == length_no_channel) ? " " : ",");
strcat (msg_to_send, channels[index_channel]);
}
if (index_channel < keys_count)
{
if (strlen (keys_to_add) + 1 +
strlen (keys[index_channel]) < (int)sizeof (keys_to_add))
{
strcat (keys_to_add, (keys_to_add[0]) ? "," : " ");
strcat (keys_to_add, keys[index_channel]);
}
}
length += length_to_add;
index_channel++;
}
else
{
strcat (msg_to_send, keys_to_add);
irc_message_split_add (hashtable, number,
tags,
msg_to_send,
msg_to_send + length_no_channel + 1);
number++;
snprintf (msg_to_send, sizeof (msg_to_send), "%s%sJOIN",
(host) ? host : "",
(host) ? " " : "");
length = strlen (msg_to_send);
keys_to_add[0] = '\0';
}
}
if (length > length_no_channel)
{
strcat (msg_to_send, keys_to_add);
irc_message_split_add (hashtable, number,
tags,
msg_to_send,
msg_to_send + length_no_channel + 1);
}
if (channels)
weechat_string_free_split (channels);
if (keys)
weechat_string_free_split (keys);
return 1;
}
struct t_hashtable *
irc_message_split (struct t_irc_server *server, const char *message)
{
struct t_hashtable *hashtable;
char **argv, **argv_eol, *tags, *host, *command, *arguments, target[512];
char *pos, monitor_action[3];
int split_ok, argc, index_args, max_length_nick, max_length_host;
split_ok = 0;
tags = NULL;
host = NULL;
command = NULL;
arguments = NULL;
index_args = 0;
argv = NULL;
argv_eol = NULL;
/* debug message */
if (weechat_irc_plugin->debug >= 2)
weechat_printf (NULL, "irc_message_split: message='%s'", message);
hashtable = weechat_hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING,
NULL,
NULL);
if (!hashtable)
return NULL;
if (!message || !message[0])
goto end;
if (message[0] == '@')
{
pos = strchr (message, ' ');
if (pos)
{
tags = weechat_strndup (message, pos - message + 1);
message = pos + 1;
}
}
argv = weechat_string_split (message, " ", 0, 0, &argc);
argv_eol = weechat_string_split (message, " ", 2, 0, NULL);
if (argc < 2)
goto end;
if (argv[0][0] == ':')
{
if (argc < 3)
goto end;
host = argv[0];
command = argv[1];
arguments = argv_eol[2];
index_args = 2;
}
else
{
command = argv[0];
arguments = argv_eol[1];
index_args = 1;
}
max_length_nick = (server && (server->nick_max_length > 0)) ?
server->nick_max_length : 16;
max_length_host = 1 + /* ":" */
max_length_nick + /* nick */
1 + /* "!" */
63 + /* host */
1; /* " " */
if ((weechat_strcasecmp (command, "ison") == 0)
|| (weechat_strcasecmp (command, "wallops") == 0))
{
/*
* ISON :nick1 nick2 nick3
* WALLOPS :some text here
*/
split_ok = irc_message_split_string (
hashtable, tags, host, command, NULL, ":",
(argv_eol[index_args][0] == ':') ?
argv_eol[index_args] + 1 : argv_eol[index_args],
NULL, ' ', max_length_host);
}
else if (weechat_strcasecmp (command, "monitor") == 0)
{
/*
* MONITOR + nick1,nick2,nick3
* MONITOR - nick1,nick2,nick3
*/
if (((argv_eol[index_args][0] == '+') || (argv_eol[index_args][0] == '-'))
&& (argv_eol[index_args][1] == ' '))
{
snprintf (monitor_action, sizeof (monitor_action),
"%c ", argv_eol[index_args][0]);
split_ok = irc_message_split_string (
hashtable, tags, host, command, NULL, monitor_action,
argv_eol[index_args] + 2, NULL, ',', max_length_host);
}
else
{
split_ok = irc_message_split_string (
hashtable, tags, host, command, NULL, ":",
(argv_eol[index_args][0] == ':') ?
argv_eol[index_args] + 1 : argv_eol[index_args],
NULL, ',', max_length_host);
}
}
else if (weechat_strcasecmp (command, "join") == 0)
{
/* JOIN #channel1,#channel2,#channel3 key1,key2 */
if (strlen (message) > 510)
{
/* split join if it's more than 510 bytes */
split_ok = irc_message_split_join (hashtable, tags, host,
arguments);
}
}
else if ((weechat_strcasecmp (command, "privmsg") == 0)
|| (weechat_strcasecmp (command, "notice") == 0))
{
/*
* PRIVMSG target :some text here
* NOTICE target :some text here
*/
if (index_args + 1 <= argc - 1)
{
split_ok = irc_message_split_privmsg_notice (
hashtable, tags, host, command, argv[index_args],
(argv_eol[index_args + 1][0] == ':') ?
argv_eol[index_args + 1] + 1 : argv_eol[index_args + 1],
max_length_host);
}
}
else if (weechat_strcasecmp (command, "005") == 0)
{
/* :server 005 nick MODES=4 CHANLIMIT=#:20 NICKLEN=16 USERLEN=10 ... */
if (index_args + 1 <= argc - 1)
{
split_ok = irc_message_split_005 (
hashtable, tags, host, command, argv[index_args],
(argv_eol[index_args + 1][0] == ':') ?
argv_eol[index_args + 1] + 1 : argv_eol[index_args + 1]);
}
}
else if (weechat_strcasecmp (command, "353") == 0)
{
/*
* list of users on channel:
* :server 353 mynick = #channel :mynick nick1 @nick2 +nick3
*/
if (index_args + 2 <= argc - 1)
{
if (irc_channel_is_channel (server, argv[index_args + 1]))
{
snprintf (target, sizeof (target), "%s %s",
argv[index_args], argv[index_args + 1]);
split_ok = irc_message_split_string (
hashtable, tags, host, command, target, ":",
(argv_eol[index_args + 2][0] == ':') ?
argv_eol[index_args + 2] + 1 : argv_eol[index_args + 2],
NULL, ' ', -1);
}
else
{
if (index_args + 3 <= argc - 1)
{
snprintf (target, sizeof (target), "%s %s %s",
argv[index_args], argv[index_args + 1],
argv[index_args + 2]);
split_ok = irc_message_split_string (
hashtable, tags, host, command, target, ":",
(argv_eol[index_args + 3][0] == ':') ?
argv_eol[index_args + 3] + 1 : argv_eol[index_args + 3],
NULL, ' ', -1);
}
}
}
}
end:
if (!split_ok
|| (weechat_hashtable_get_integer (hashtable, "items_count") == 0))
{
irc_message_split_add (hashtable, 1, tags, message, arguments);
}
if (tags)
free (tags);
if (argv)
weechat_string_free_split (argv);
if (argv_eol)
weechat_string_free_split (argv_eol);
return hashtable;
}
char *
weechat_aspell_bar_item_suggest (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window,
struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
const char *ptr_suggestions, *pos;
char **suggestions, *suggestions2;
int i, num_suggestions, length;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!aspell_enabled)
return NULL;
if (!buffer)
return NULL;
ptr_suggestions = weechat_buffer_get_string (buffer,
"localvar_aspell_suggest");
if (!ptr_suggestions)
return NULL;
pos = strchr (ptr_suggestions, ':');
if (pos)
pos++;
else
pos = ptr_suggestions;
suggestions = weechat_string_split (pos, "/", 0, 0, &num_suggestions);
if (suggestions)
{
length = 64 + 1;
for (i = 0; i < num_suggestions; i++)
{
length += strlen (suggestions[i]) + 64;
}
suggestions2 = malloc (length);
if (suggestions2)
{
suggestions2[0] = '\0';
strcat (suggestions2,
weechat_color (weechat_config_string (weechat_aspell_config_color_suggestions)));
for (i = 0; i < num_suggestions; i++)
{
if (i > 0)
{
strcat (suggestions2, weechat_color ("bar_delim"));
strcat (suggestions2, "/");
strcat (suggestions2,
weechat_color (weechat_config_string (weechat_aspell_config_color_suggestions)));
}
strcat (suggestions2, suggestions[i]);
}
weechat_string_free_split (suggestions);
return suggestions2;
}
weechat_string_free_split (suggestions);
}
return strdup (pos);
}
struct t_aspell_speller_buffer *
weechat_aspell_speller_buffer_new (struct t_gui_buffer *buffer)
{
const char *buffer_dicts;
char **dicts;
int num_dicts, i;
struct t_aspell_speller_buffer *new_speller_buffer;
#ifdef USE_ENCHANT
EnchantDict *ptr_speller;
#else
AspellSpeller *ptr_speller;
#endif /* USE_ENCHANT */
if (!buffer)
return NULL;
weechat_hashtable_remove (weechat_aspell_speller_buffer, buffer);
new_speller_buffer = malloc (sizeof (*new_speller_buffer));
if (!new_speller_buffer)
return NULL;
new_speller_buffer->spellers = NULL;
new_speller_buffer->modifier_string = NULL;
new_speller_buffer->input_pos = -1;
new_speller_buffer->modifier_result = NULL;
buffer_dicts = weechat_aspell_get_dict (buffer);
if (buffer_dicts)
{
dicts = weechat_string_split (buffer_dicts, ",", 0, 0, &num_dicts);
if (dicts && (num_dicts > 0))
{
new_speller_buffer->spellers =
#ifdef USE_ENCHANT
malloc ((num_dicts + 1) * sizeof (EnchantDict *));
#else
malloc ((num_dicts + 1) * sizeof (AspellSpeller *));
#endif /* USE_ENCHANT */
if (new_speller_buffer->spellers)
{
for (i = 0; i < num_dicts; i++)
{
ptr_speller = weechat_hashtable_get (weechat_aspell_spellers,
dicts[i]);
if (!ptr_speller)
ptr_speller = weechat_aspell_speller_new (dicts[i]);
new_speller_buffer->spellers[i] = ptr_speller;
}
new_speller_buffer->spellers[num_dicts] = NULL;
}
}
if (dicts)
weechat_string_free_split (dicts);
}
weechat_hashtable_set (weechat_aspell_speller_buffer,
buffer,
new_speller_buffer);
weechat_bar_item_update ("aspell_dict");
return new_speller_buffer;
}
int
irc_redirect_message (struct t_irc_server *server, const char *message,
const char *command, const char *arguments)
{
struct t_irc_redirect *ptr_redirect, *ptr_next_redirect;
int rc, match_stop, arguments_argc;
char **arguments_argv;
if (!server || !server->redirects || !message || !command)
return 0;
rc = 0;
if (arguments && arguments[0])
{
arguments_argv = weechat_string_split (arguments, " ", 0, 0,
&arguments_argc);
}
else
{
arguments_argv = NULL;
arguments_argc = 0;
}
ptr_redirect = server->redirects;
while (ptr_redirect)
{
ptr_next_redirect = ptr_redirect->next_redirect;
if (ptr_redirect->start_time > 0)
{
if (ptr_redirect->cmd_stop_received)
{
if (ptr_redirect->cmd_extra
&& irc_redirect_message_match_hash (ptr_redirect,
command,
arguments_argv,
arguments_argc,
ptr_redirect->cmd_extra))
{
irc_redirect_message_add (ptr_redirect, message, command);
irc_redirect_stop (ptr_redirect, NULL);
rc = 1;
goto end;
}
irc_redirect_stop (ptr_redirect, NULL);
}
else
{
/* message matches a start command? */
if (ptr_redirect->cmd_start
&& !ptr_redirect->cmd_start_received
&& irc_redirect_message_match_hash (ptr_redirect,
command,
arguments_argv,
arguments_argc,
ptr_redirect->cmd_start))
{
/*
* message is a start command for redirection, then add
* message to output for redirection and mark start
* command as "received" for this redirect
*/
irc_redirect_message_add (ptr_redirect, message, command);
ptr_redirect->cmd_start_received = 1;
rc = 1;
goto end;
}
/*
* if matching stop command, or start command received, we are
* in redirection: add message to output and close redirection
* if matching stop command
*/
match_stop = irc_redirect_message_match_hash (ptr_redirect,
command,
arguments_argv,
arguments_argc,
ptr_redirect->cmd_stop);
if (match_stop || ptr_redirect->cmd_start_received)
{
/*
* add message to output if matching stop of if command
* is numeric
*/
irc_redirect_message_add (ptr_redirect, message, command);
if (match_stop)
{
ptr_redirect->cmd_stop_received = 1;
if (ptr_redirect->cmd_extra)
{
if (irc_redirect_message_match_hash (ptr_redirect,
command,
arguments_argv,
arguments_argc,
ptr_redirect->cmd_extra))
{
/*
* this command is a stop and extra command,
* then remove redirect
*/
irc_redirect_stop (ptr_redirect, NULL);
}
}
else
{
/*
* no extra command after stop, then remove
* redirect
*/
irc_redirect_stop (ptr_redirect, NULL);
}
}
rc = 1;
goto end;
}
}
}
ptr_redirect = ptr_next_redirect;
}
end:
if (arguments_argv)
weechat_string_free_split (arguments_argv);
return rc;
}
int
irc_mode_channel_set (struct t_irc_server *server,
struct t_irc_channel *channel,
const char *modes)
{
char *pos_args, *str_modes, set_flag, **argv, *pos, *ptr_arg, chanmode_type;
int argc, current_arg, update_channel_modes, channel_modes_updated;
int smart_filter;
struct t_irc_nick *ptr_nick;
if (!server || !channel || !modes)
return 0;
channel_modes_updated = 0;
argc = 0;
argv = NULL;
pos_args = strchr (modes, ' ');
if (pos_args)
{
str_modes = weechat_strndup (modes, pos_args - modes);
if (!str_modes)
return 0;
pos_args++;
while (pos_args[0] == ' ')
pos_args++;
argv = weechat_string_split (pos_args, " ", 0, 0, &argc);
}
else
{
str_modes = strdup (modes);
if (!str_modes)
return 0;
}
current_arg = 0;
smart_filter = (weechat_config_boolean (irc_config_look_smart_filter)
&& weechat_config_string (irc_config_look_smart_filter_mode)
&& weechat_config_string (irc_config_look_smart_filter_mode)[0]) ? 1 : 0;
if (str_modes && str_modes[0])
{
set_flag = '+';
pos = str_modes;
while (pos && pos[0])
{
switch (pos[0])
{
case ':':
case ' ':
break;
case '+':
set_flag = '+';
break;
case '-':
set_flag = '-';
break;
default:
update_channel_modes = 1;
chanmode_type = irc_mode_get_chanmode_type (server, pos[0]);
ptr_arg = NULL;
switch (chanmode_type)
{
case 'A': /* always argument */
update_channel_modes = 0;
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'B': /* always argument */
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'C': /* argument if set */
ptr_arg = ((set_flag == '+') && (current_arg < argc)) ?
argv[current_arg] : NULL;
break;
case 'D': /* no argument */
break;
}
if (ptr_arg)
current_arg++;
if (smart_filter
&& !irc_mode_smart_filtered (server, pos[0]))
{
smart_filter = 0;
}
if (pos[0] == 'k')
{
/* channel key */
if (set_flag == '-')
{
if (channel->key)
{
free (channel->key);
channel->key = NULL;
}
}
else if ((set_flag == '+')
&& ptr_arg && (strcmp (ptr_arg, "*") != 0))
{
/* replace key for +k, but ignore "*" as new key */
if (channel->key)
free (channel->key);
channel->key = strdup (ptr_arg);
}
}
else if (pos[0] == 'l')
{
/* channel limit */
if (set_flag == '-')
channel->limit = 0;
if ((set_flag == '+') && ptr_arg)
{
channel->limit = atoi (ptr_arg);
}
}
else if ((chanmode_type != 'A')
&& (irc_server_get_prefix_mode_index (server,
pos[0]) >= 0))
{
/* mode for nick */
update_channel_modes = 0;
if (ptr_arg)
{
ptr_nick = irc_nick_search (server, channel,
ptr_arg);
if (ptr_nick)
{
irc_nick_set_mode (server, channel, ptr_nick,
(set_flag == '+'), pos[0]);
if (smart_filter
&& irc_channel_nick_speaking_time_search (server,
channel,
ptr_nick->name,
1))
{
smart_filter = 0;
}
}
}
}
if (update_channel_modes)
{
irc_mode_channel_update (server, channel, set_flag,
pos[0], ptr_arg);
channel_modes_updated = 1;
}
break;
}
pos++;
}
}
if (str_modes)
free (str_modes);
if (argv)
weechat_string_free_split (argv);
if (channel_modes_updated)
weechat_bar_item_update ("buffer_modes");
return smart_filter;
}
void
buflist_config_hook_signals_refresh ()
{
char **all_signals, **signals;
const char *ptr_signals_refresh;
struct t_arraylist *signals_list;
int count, list_size, i;
all_signals = weechat_string_dyn_alloc (256);
if (!all_signals)
return;
ptr_signals_refresh = weechat_config_string (
buflist_config_look_signals_refresh);
weechat_string_dyn_concat (all_signals, BUFLIST_CONFIG_SIGNALS_REFRESH);
if (ptr_signals_refresh && ptr_signals_refresh[0])
{
weechat_string_dyn_concat (all_signals, ",");
weechat_string_dyn_concat (all_signals, ptr_signals_refresh);
}
if (weechat_config_boolean (buflist_config_look_nick_prefix))
{
weechat_string_dyn_concat (all_signals, ",");
weechat_string_dyn_concat (
all_signals,
BUFLIST_CONFIG_SIGNALS_REFRESH_NICK_PREFIX);
}
signals = weechat_string_split (*all_signals, ",",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0, &count);
if (signals)
{
signals_list = weechat_arraylist_new (
32, 1, 0,
&buflist_config_compare_signals,
NULL, NULL, NULL);
if (signals_list)
{
for (i = 0; i < count; i++)
{
weechat_arraylist_add (signals_list, signals[i]);
}
list_size = weechat_arraylist_size (signals_list);
buflist_config_signals_refresh = malloc (
list_size * sizeof (*buflist_config_signals_refresh));
if (buflist_config_signals_refresh)
{
buflist_config_num_signals_refresh = list_size;
for (i = 0; i < list_size; i++)
{
buflist_config_signals_refresh[i] = weechat_hook_signal (
weechat_arraylist_get (signals_list, i),
&buflist_config_signal_buffer_cb, NULL, NULL);
}
if (weechat_buflist_plugin->debug >= 1)
{
weechat_printf (NULL, _("%s: %d signals hooked"),
BUFLIST_PLUGIN_NAME, list_size);
}
}
weechat_arraylist_free (signals_list);
}
weechat_string_free_split (signals);
}
weechat_string_dyn_free (all_signals, 1);
}
void
trigger_hook (struct t_trigger *trigger)
{
char **argv, **argv_eol, *tags, *message, *error1, *error2, *error3;
int i, argc, strip_colors;
long interval, align_second, max_calls;
trigger_unhook (trigger);
argv = weechat_string_split (weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),
";", 0, 0, &argc);
argv_eol = weechat_string_split (weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),
";", 1, 0, NULL);
switch (weechat_config_integer (trigger->options[TRIGGER_OPTION_HOOK]))
{
case TRIGGER_HOOK_SIGNAL:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_signal (
argv[i],
&trigger_callback_signal_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_HSIGNAL:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_hsignal (
argv[i],
&trigger_callback_hsignal_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_MODIFIER:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_modifier (
argv[i],
&trigger_callback_modifier_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_PRINT:
tags = NULL;
message = NULL;
strip_colors = 0;
if (argv && (argc >= 1))
{
if (strcmp (argv[0], "*") != 0)
trigger->hook_print_buffers = strdup (argv[0]);
if ((argc >= 2) && (strcmp (argv[1], "*") != 0))
tags = argv[1];
if ((argc >= 3) && (strcmp (argv[2], "*") != 0))
message = argv[2];
if (argc >= 4)
strip_colors = (strcmp (argv[3], "0") != 0) ? 1 : 0;
}
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_print (
NULL,
tags,
message,
strip_colors,
&trigger_callback_print_cb,
trigger);
}
break;
case TRIGGER_HOOK_COMMAND:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_command (
argv[0], /* command */
(argc > 1) ? argv[1] : "", /* description */
(argc > 2) ? argv[2] : "", /* arguments */
(argc > 3) ? argv[3] : "", /* description of args */
(argc > 4) ? argv[4] : "", /* completion */
&trigger_callback_command_cb,
trigger);
}
}
break;
case TRIGGER_HOOK_COMMAND_RUN:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_command_run (
argv[i],
&trigger_callback_command_run_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_TIMER:
if (argv && (argc >= 1))
{
error1 = NULL;
error2 = NULL;
error3 = NULL;
interval = strtol (argv[0], &error1, 10);
align_second = strtol ((argc >= 2) ? argv[1] : "0", &error2, 10);
max_calls = strtol ((argc >= 3) ? argv[2] : "0", &error3, 10);
if (error1 && !error1[0]
&& error2 && !error2[0]
&& error3 && !error3[0]
&& (interval > 0)
&& (align_second >= 0)
&& (max_calls >= 0))
{
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_timer (
interval,
(int)align_second,
(int)max_calls,
&trigger_callback_timer_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_CONFIG:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_config (
argv[i],
&trigger_callback_config_cb,
trigger);
}
}
}
break;
case TRIGGER_HOOK_FOCUS:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_focus (
argv[i],
&trigger_callback_focus_cb,
trigger);
}
}
}
break;
}
if (!trigger->hooks)
{
weechat_printf (NULL,
_("%s%s: unable to create hook for trigger \"%s\" "
"(bad arguments)"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
trigger->name);
}
if (argv)
weechat_string_free_split (argv);
if (argv_eol)
weechat_string_free_split (argv_eol);
}
void
relay_weechat_protocol_recv (struct t_relay_client *client, const char *data)
{
char *pos, *id, *command, **argv, **argv_eol;
int i, argc, return_code;
struct t_relay_weechat_protocol_cb protocol_cb[] =
{ { "init", &relay_weechat_protocol_cb_init },
{ "hdata", &relay_weechat_protocol_cb_hdata },
{ "info", &relay_weechat_protocol_cb_info },
{ "infolist", &relay_weechat_protocol_cb_infolist },
{ "nicklist", &relay_weechat_protocol_cb_nicklist },
{ "input", &relay_weechat_protocol_cb_input },
{ "sync", &relay_weechat_protocol_cb_sync },
{ "desync", &relay_weechat_protocol_cb_desync },
{ "test", &relay_weechat_protocol_cb_test },
{ "ping", &relay_weechat_protocol_cb_ping },
{ "quit", &relay_weechat_protocol_cb_quit },
{ NULL, NULL }
};
if (!data || !data[0] || RELAY_CLIENT_HAS_ENDED(client))
return;
/* display debug message */
if (weechat_relay_plugin->debug >= 2)
{
weechat_printf (NULL, "%s: recv from client %s%s%s: \"%s\"",
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT,
data);
}
/* extract id */
id = NULL;
if (data[0] == '(')
{
pos = strchr (data, ')');
if (pos)
{
id = weechat_strndup (data + 1, pos - data - 1);
data = pos + 1;
while (data[0] == ' ')
{
data++;
}
}
}
/* search end of data */
pos = strchr (data, ' ');
if (pos)
command = weechat_strndup (data, pos - data);
else
command = strdup (data);
if (!command)
{
if (id)
free (id);
return;
}
argc = 0;
argv = NULL;
argv_eol = NULL;
if (pos)
{
while (pos[0] == ' ')
{
pos++;
}
argv = weechat_string_split (pos, " ", 0, 0, &argc);
argv_eol = weechat_string_split (pos, " ", 1, 0, NULL);
}
for (i = 0; protocol_cb[i].name; i++)
{
if (strcmp (protocol_cb[i].name, command) == 0)
{
if ((strcmp (protocol_cb[i].name, "init") != 0)
&& (!RELAY_WEECHAT_DATA(client, password_ok)))
{
/*
* command is not "init" and password is not set?
* then close connection!
*/
relay_client_set_status (client,
RELAY_STATUS_DISCONNECTED);
}
else
{
return_code = (int) (protocol_cb[i].cmd_function) (client,
id,
protocol_cb[i].name,
argc,
argv,
argv_eol);
if ((weechat_relay_plugin->debug >= 1)
&& (return_code == WEECHAT_RC_ERROR))
{
weechat_printf (NULL,
_("%s%s: failed to execute command \"%s\" "
"for client %s%s%s"),
weechat_prefix ("error"),
RELAY_PLUGIN_NAME,
command,
RELAY_COLOR_CHAT_CLIENT,
client->desc,
RELAY_COLOR_CHAT);
}
}
break;
}
}
if (id)
free (id);
if (argv)
weechat_string_free_split (argv);
if (argv_eol)
weechat_string_free_split (argv_eol);
}
char *
alias_replace_args (const char *alias_args, const char *user_args)
{
char **argv, *res;
const char *start, *pos;
int n, m, argc, length_res, args_count, offset;
argv = weechat_string_split (user_args, " ", 0, 0, &argc);
res = NULL;
length_res = 0;
args_count = 0;
start = alias_args;
pos = start;
while (pos && pos[0])
{
offset = 0;
if ((pos[0] == '\\') && (pos[1] == '$'))
{
offset = 2;
alias_string_add_word_range (&res, &length_res, start, pos);
alias_string_add_word (&res, &length_res, "$");
}
else
{
if (pos[0] == '$')
{
if (pos[1] == '*')
{
/* replace with all arguments */
args_count++;
offset = 2;
if (pos > start)
alias_string_add_word_range (&res, &length_res, start, pos);
alias_string_add_word (&res, &length_res, user_args);
}
else if (pos[1] == '~')
{
/* replace with last argument */
args_count++;
offset = 2;
if (pos > start)
alias_string_add_word_range (&res, &length_res, start, pos);
if (argc > 0)
alias_string_add_word (&res, &length_res, argv[argc - 1]);
}
else if ((pos[1] == '-') && ALIAS_IS_ARG_NUMBER(pos[2]))
{
/* replace with arguments 1 to m */
args_count++;
offset = 3;
if (pos > start)
alias_string_add_word_range (&res, &length_res, start, pos);
if (pos[2] - '1' < argc)
m = pos[2] - '1';
else
m = argc - 1;
alias_string_add_arguments (&res, &length_res, argv, 0, m);
}
else if (ALIAS_IS_ARG_NUMBER(pos[1]))
{
args_count++;
n = pos[1] - '1';
if (pos > start)
alias_string_add_word_range (&res, &length_res, start, pos);
if (pos[2] != '-')
{
/* replace with argument n */
offset = 2;
if (n < argc)
alias_string_add_word (&res, &length_res, argv[n]);
}
else
{
if (ALIAS_IS_ARG_NUMBER(pos[3]))
{
/* replace with arguments n to m */
offset = 4;
if (pos[3] - '1' < argc)
m = pos[3] - '1';
else
m = argc - 1;
}
else
{
/* replace with arguments n to last */
offset = 3;
m = argc - 1;
}
if (n < argc)
{
alias_string_add_arguments (&res, &length_res,
argv, n, m);
}
}
}
}
}
if (offset != 0)
{
pos += offset;
start = pos;
}
else
pos++;
}
if (pos > start)
alias_string_add_word (&res, &length_res, start);
if (argv)
weechat_string_free_split (argv);
return res;
}
void
relay_weechat_msg_add_infolist (struct t_relay_weechat_msg *msg,
const char *name,
void *pointer,
const char *arguments)
{
struct t_infolist *ptr_infolist;
const char *fields;
char **list_fields;
void *buf_ptr;
int num_fields, i, buf_size;
int pos_count_items, count_items, pos_count_vars, count_vars;
uint32_t count32;
ptr_infolist = weechat_infolist_get (name, pointer, arguments);
if (!ptr_infolist)
return;
/* start infolist in message */
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_INFOLIST);
relay_weechat_msg_add_string (msg, name);
/* count of items will be set later, with number of items in infolist */
pos_count_items = msg->data_size;
count_items = 0;
relay_weechat_msg_add_int (msg, 0);
while (weechat_infolist_next (ptr_infolist))
{
fields = weechat_infolist_fields (ptr_infolist);
if (fields)
{
list_fields = weechat_string_split (fields, ",", 0, 0, &num_fields);
if (list_fields)
{
count_items++;
pos_count_vars = msg->data_size;
count_vars = 0;
relay_weechat_msg_add_int (msg, 0);
for (i = 0; i < num_fields; i++)
{
if (strlen (list_fields[i]) > 2)
{
count_vars++;
relay_weechat_msg_add_string (msg, list_fields[i] + 2);
switch (list_fields[i][0])
{
case 'i':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_INT);
relay_weechat_msg_add_int (msg,
weechat_infolist_integer (ptr_infolist,
list_fields[i] + 2));
break;
case 's':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_STRING);
relay_weechat_msg_add_string (msg,
weechat_infolist_string (ptr_infolist,
list_fields[i] + 2));
break;
case 'p':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_POINTER);
relay_weechat_msg_add_pointer (msg,
weechat_infolist_pointer (ptr_infolist,
list_fields[i] + 2));
break;
case 'b':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_BUFFER);
buf_ptr = weechat_infolist_buffer (ptr_infolist,
list_fields[i] + 2,
&buf_size);
relay_weechat_msg_add_buffer (msg, buf_ptr, buf_size);
break;
case 't':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_TIME);
relay_weechat_msg_add_time (msg,
weechat_infolist_time (ptr_infolist,
list_fields[i] + 2));
break;
}
}
}
/* set count of variables in item */
count32 = htonl ((uint32_t)count_vars);
relay_weechat_msg_set_bytes (msg, pos_count_vars, &count32, 4);
weechat_string_free_split (list_fields);
}
}
}
/* set count of items */
count32 = htonl ((uint32_t)count_items);
relay_weechat_msg_set_bytes (msg, pos_count_items, &count32, 4);
weechat_infolist_free (ptr_infolist);
}
void
relay_weechat_msg_add_hdata (struct t_relay_weechat_msg *msg,
const char *path, const char *keys)
{
struct t_hdata *ptr_hdata_head, *ptr_hdata;
char *hdata_head, *pos, **list_keys, *keys_types, **list_path;
char *path_returned;
const char *hdata_name, *array_size;
void *pointer, **path_pointers;
long unsigned int value;
int num_keys, num_path, i, type, pos_count, count, rc;
uint32_t count32;
hdata_head = NULL;
list_keys = NULL;
num_keys = 0;
keys_types = NULL;
list_path = NULL;
num_path = 0;
path_returned = NULL;
/* extract hdata name (head) from path */
pos = strchr (path, ':');
if (!pos)
goto end;
hdata_head = weechat_strndup (path, pos - path);
if (!hdata_head)
goto end;
ptr_hdata_head = weechat_hdata_get (hdata_head);
if (!ptr_hdata_head)
goto end;
/* split path */
list_path = weechat_string_split (pos + 1, "/", 0, 0, &num_path);
if (!list_path)
goto end;
/* extract pointer from first path (direct pointer or list name) */
pointer = NULL;
pos = strchr (list_path[0], '(');
if (pos)
pos[0] = '\0';
if (strncmp (list_path[0], "0x", 2) == 0)
{
rc = sscanf (list_path[0], "%lx", &value);
if ((rc != EOF) && (rc != 0))
pointer = (void *)value;
}
else
pointer = weechat_hdata_get_list (ptr_hdata_head, list_path[0]);
if (pos)
pos[0] = '(';
if (!pointer)
goto end;
/*
* build string with path where:
* - counters are removed
* - variable names are replaced by hdata name
*/
path_returned = malloc (strlen (path) * 2);
if (!path_returned)
goto end;
ptr_hdata = ptr_hdata_head;
strcpy (path_returned, hdata_head);
hdata_name = hdata_head;
for (i = 1; i < num_path; i++)
{
pos = strchr (list_path[i], '(');
if (pos)
pos[0] = '\0';
hdata_name = weechat_hdata_get_var_hdata (ptr_hdata, list_path[i]);
if (!hdata_name)
goto end;
ptr_hdata = weechat_hdata_get (hdata_name);
if (!ptr_hdata)
goto end;
strcat (path_returned, "/");
strcat (path_returned, hdata_name);
if (pos)
pos[0] = '(';
}
/* split keys */
if (!keys)
keys = weechat_hdata_get_string (ptr_hdata, "var_keys");
list_keys = weechat_string_split (keys, ",", 0, 0, &num_keys);
if (!list_keys)
goto end;
/* build string with list of keys with types: "key1:type1,key2:type2,..." */
keys_types = malloc (strlen (keys) + (num_keys * 8) + 1);
if (!keys_types)
goto end;
keys_types[0] = '\0';
for (i = 0; i < num_keys; i++)
{
type = weechat_hdata_get_var_type (ptr_hdata, list_keys[i]);
if ((type >= 0) && (type != WEECHAT_HDATA_OTHER))
{
if (keys_types[0])
strcat (keys_types, ",");
strcat (keys_types, list_keys[i]);
strcat (keys_types, ":");
array_size = weechat_hdata_get_var_array_size_string (ptr_hdata,
NULL,
list_keys[i]);
if (array_size)
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_ARRAY);
else
{
switch (type)
{
case WEECHAT_HDATA_CHAR:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_CHAR);
break;
case WEECHAT_HDATA_INTEGER:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_INT);
break;
case WEECHAT_HDATA_LONG:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_LONG);
break;
case WEECHAT_HDATA_STRING:
case WEECHAT_HDATA_SHARED_STRING:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_STRING);
break;
case WEECHAT_HDATA_POINTER:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_POINTER);
break;
case WEECHAT_HDATA_TIME:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_TIME);
break;
case WEECHAT_HDATA_HASHTABLE:
strcat (keys_types, RELAY_WEECHAT_MSG_OBJ_HASHTABLE);
break;
}
}
}
}
if (!keys_types[0])
goto end;
/* start hdata in message */
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_HDATA);
relay_weechat_msg_add_string (msg, path_returned);
relay_weechat_msg_add_string (msg, keys_types);
/* "count" will be set later, with number of objects in hdata */
pos_count = msg->data_size;
count = 0;
relay_weechat_msg_add_int (msg, 0);
path_pointers = malloc (sizeof (*path_pointers) * num_path);
if (path_pointers)
{
count = relay_weechat_msg_add_hdata_path (msg,
list_path,
0,
path_pointers,
ptr_hdata_head,
pointer,
list_keys);
free (path_pointers);
}
count32 = htonl ((uint32_t)count);
relay_weechat_msg_set_bytes (msg, pos_count, &count32, 4);
end:
if (list_keys)
weechat_string_free_split (list_keys);
if (keys_types)
free (keys_types);
if (list_path)
weechat_string_free_split (list_path);
if (path_returned)
free (path_returned);
if (hdata_head)
free (hdata_head);
}
int
fset_completion_option_cb (const void *pointer, void *data,
const char *completion_item,
struct t_gui_buffer *buffer,
struct t_gui_completion *completion)
{
struct t_config_file *ptr_config;
struct t_config_section *ptr_section;
struct t_config_option *ptr_option;
char **words;
int config_section_added, num_words, i;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) completion_item;
(void) buffer;
ptr_config = weechat_hdata_get_list (fset_hdata_config_file,
"config_files");
while (ptr_config)
{
ptr_section = weechat_hdata_pointer (fset_hdata_config_file,
ptr_config, "sections");
while (ptr_section)
{
config_section_added = 0;
ptr_option = weechat_hdata_pointer (fset_hdata_config_section,
ptr_section, "options");
while (ptr_option)
{
if (!config_section_added)
{
weechat_hook_completion_list_add (
completion,
weechat_config_option_get_string (ptr_option,
"config_name"),
0, WEECHAT_LIST_POS_SORT);
weechat_hook_completion_list_add (
completion,
weechat_config_option_get_string (ptr_option,
"section_name"),
0, WEECHAT_LIST_POS_SORT);
config_section_added = 1;
}
weechat_hook_completion_list_add (
completion,
weechat_config_option_get_string (ptr_option, "name"),
0,
WEECHAT_LIST_POS_SORT);
words = weechat_string_split (
weechat_config_option_get_string (ptr_option, "name"),
"_",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0,
&num_words);
if (words && (num_words > 1))
{
for (i = 0; i < num_words; i++)
{
weechat_hook_completion_list_add (
completion, words[i], 0, WEECHAT_LIST_POS_SORT);
}
}
if (words)
weechat_string_free_split (words);
ptr_option = weechat_hdata_move (fset_hdata_config_option,
ptr_option, 1);
}
ptr_section = weechat_hdata_move (fset_hdata_config_section,
ptr_section, 1);
}
ptr_config = weechat_hdata_move (fset_hdata_config_file,
ptr_config, 1);
}
return WEECHAT_RC_OK;
}
int
irc_upgrade_read_cb (const void *pointer, void *data,
struct t_upgrade_file *upgrade_file,
int object_id,
struct t_infolist *infolist)
{
int flags, sock, size, i, index, nicks_count, num_items;
long number;
time_t join_time;
char *buf, option_name[64], **nicks, *nick_join, *pos, *error;
char **items;
const char *buffer_name, *str, *nick;
struct t_irc_nick *ptr_nick;
struct t_irc_redirect *ptr_redirect;
struct t_irc_notify *ptr_notify;
struct t_gui_buffer *ptr_buffer;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) upgrade_file;
weechat_infolist_reset_item_cursor (infolist);
while (weechat_infolist_next (infolist))
{
switch (object_id)
{
case IRC_UPGRADE_TYPE_SERVER:
irc_upgrade_current_server = irc_server_search (weechat_infolist_string (infolist, "name"));
if (irc_upgrade_current_server)
{
irc_upgrade_current_server->temp_server =
weechat_infolist_integer (infolist, "temp_server");
irc_upgrade_current_server->buffer = NULL;
buffer_name = weechat_infolist_string (infolist, "buffer_name");
if (buffer_name && buffer_name[0])
{
ptr_buffer = weechat_buffer_search (IRC_PLUGIN_NAME,
buffer_name);
if (ptr_buffer)
irc_upgrade_current_server->buffer = ptr_buffer;
}
irc_upgrade_current_server->index_current_address =
weechat_infolist_integer (infolist, "index_current_address");
str = weechat_infolist_string (infolist, "current_address");
if (str)
{
irc_upgrade_current_server->current_address = strdup (str);
irc_upgrade_current_server->current_port = weechat_infolist_integer (infolist, "current_port");
}
else
{
if (irc_upgrade_current_server->index_current_address < irc_upgrade_current_server->addresses_count)
{
irc_upgrade_current_server->current_address =
strdup (irc_upgrade_current_server->addresses_array[irc_upgrade_current_server->index_current_address]);
irc_upgrade_current_server->current_port =
irc_upgrade_current_server->ports_array[irc_upgrade_current_server->index_current_address];
}
}
str = weechat_infolist_string (infolist, "current_ip");
if (str)
irc_upgrade_current_server->current_ip = strdup (str);
sock = weechat_infolist_integer (infolist, "sock");
if (sock >= 0)
{
irc_upgrade_current_server->sock = sock;
irc_upgrade_current_server->hook_fd = weechat_hook_fd (
irc_upgrade_current_server->sock,
1, 0, 0,
&irc_server_recv_cb,
irc_upgrade_current_server,
NULL);
}
irc_upgrade_current_server->is_connected = weechat_infolist_integer (infolist, "is_connected");
irc_upgrade_current_server->ssl_connected = weechat_infolist_integer (infolist, "ssl_connected");
irc_upgrade_current_server->disconnected = weechat_infolist_integer (infolist, "disconnected");
str = weechat_infolist_string (infolist, "unterminated_message");
if (str)
irc_upgrade_current_server->unterminated_message = strdup (str);
str = weechat_infolist_string (infolist, "nick");
if (str)
irc_server_set_nick (irc_upgrade_current_server, str);
str = weechat_infolist_string (infolist, "nick_modes");
if (str)
irc_upgrade_current_server->nick_modes = strdup (str);
irc_upgrade_current_server->cap_away_notify = weechat_infolist_integer (infolist, "cap_away_notify");
irc_upgrade_current_server->cap_account_notify = weechat_infolist_integer (infolist, "cap_account_notify");
irc_upgrade_current_server->cap_extended_join = weechat_infolist_integer (infolist, "cap_extended_join");
str = weechat_infolist_string (infolist, "isupport");
if (str)
irc_upgrade_current_server->isupport = strdup (str);
/*
* "prefix" is not any more in this infolist (since
* WeeChat 0.3.4), but we read it to keep compatibility
* with old WeeChat versions, on /upgrade)
*/
str = weechat_infolist_string (infolist, "prefix");
if (str)
irc_server_set_prefix_modes_chars (irc_upgrade_current_server, str);
/* "prefix_modes" is new in WeeChat 0.3.4 */
str = weechat_infolist_string (infolist, "prefix_modes");
if (str)
{
if (irc_upgrade_current_server->prefix_modes)
free (irc_upgrade_current_server->prefix_modes);
irc_upgrade_current_server->prefix_modes = strdup (str);
}
/* "prefix_chars" is new in WeeChat 0.3.4 */
str = weechat_infolist_string (infolist, "prefix_chars");
if (str)
{
if (irc_upgrade_current_server->prefix_chars)
free (irc_upgrade_current_server->prefix_chars);
irc_upgrade_current_server->prefix_chars = strdup (str);
}
irc_upgrade_current_server->nick_max_length = weechat_infolist_integer (infolist, "nick_max_length");
irc_upgrade_current_server->casemapping = weechat_infolist_integer (infolist, "casemapping");
str = weechat_infolist_string (infolist, "chantypes");
if (str)
irc_upgrade_current_server->chantypes = strdup (str);
str = weechat_infolist_string (infolist, "chanmodes");
if (str)
irc_upgrade_current_server->chanmodes = strdup (str);
else
{
str = irc_server_get_isupport_value (irc_upgrade_current_server,
"CHANMODES");
if (str)
irc_upgrade_current_server->chanmodes = strdup (str);
}
/* "monitor" is new in WeeChat 0.4.3 */
if (weechat_infolist_search_var (infolist, "monitor"))
{
irc_upgrade_current_server->monitor = weechat_infolist_integer (infolist, "monitor");
}
else
{
/* WeeChat <= 0.4.2 */
str = irc_server_get_isupport_value (irc_upgrade_current_server,
"MONITOR");
if (str)
{
error = NULL;
number = strtol (str, &error, 10);
if (error && !error[0])
irc_upgrade_current_server->monitor = (int)number;
}
}
irc_upgrade_current_server->reconnect_delay = weechat_infolist_integer (infolist, "reconnect_delay");
irc_upgrade_current_server->reconnect_start = weechat_infolist_time (infolist, "reconnect_start");
irc_upgrade_current_server->command_time = weechat_infolist_time (infolist, "command_time");
irc_upgrade_current_server->reconnect_join = weechat_infolist_integer (infolist, "reconnect_join");
irc_upgrade_current_server->disable_autojoin = weechat_infolist_integer (infolist, "disable_autojoin");
irc_upgrade_current_server->is_away = weechat_infolist_integer (infolist, "is_away");
str = weechat_infolist_string (infolist, "away_message");
if (str)
irc_upgrade_current_server->away_message = strdup (str);
irc_upgrade_current_server->away_time = weechat_infolist_time (infolist, "away_time");
irc_upgrade_current_server->lag = weechat_infolist_integer (infolist, "lag");
irc_upgrade_current_server->lag_displayed = weechat_infolist_integer (infolist, "lag_displayed");
buf = weechat_infolist_buffer (infolist, "lag_check_time", &size);
if (buf)
memcpy (&(irc_upgrade_current_server->lag_check_time), buf, size);
irc_upgrade_current_server->lag_next_check = weechat_infolist_time (infolist, "lag_next_check");
irc_upgrade_current_server->lag_last_refresh = weechat_infolist_time (infolist, "lag_last_refresh");
irc_upgrade_current_server->last_user_message = weechat_infolist_time (infolist, "last_user_message");
irc_upgrade_current_server->last_away_check = weechat_infolist_time (infolist, "last_away_check");
irc_upgrade_current_server->last_data_purge = weechat_infolist_time (infolist, "last_data_purge");
}
break;
case IRC_UPGRADE_TYPE_CHANNEL:
if (irc_upgrade_current_server)
{
irc_upgrade_current_channel = irc_channel_new (irc_upgrade_current_server,
weechat_infolist_integer (infolist, "type"),
weechat_infolist_string (infolist, "name"),
0, 0);
if (irc_upgrade_current_channel)
{
str = weechat_infolist_string (infolist, "topic");
if (str)
irc_channel_set_topic (irc_upgrade_current_channel, str);
str = weechat_infolist_string (infolist, "modes");
if (str)
irc_upgrade_current_channel->modes = strdup (str);
irc_upgrade_current_channel->limit = weechat_infolist_integer (infolist, "limit");
str = weechat_infolist_string (infolist, "key");
if (str)
irc_upgrade_current_channel->key = strdup (str);
str = weechat_infolist_string (infolist, "join_msg_received");
if (str)
{
items = weechat_string_split (str, ",", 0, 0,
&num_items);
if (items)
{
for (i = 0; i < num_items; i++)
{
weechat_hashtable_set (irc_upgrade_current_channel->join_msg_received,
items[i], "1");
}
weechat_string_free_split (items);
}
}
irc_upgrade_current_channel->checking_whox = weechat_infolist_integer (infolist, "checking_whox");
str = weechat_infolist_string (infolist, "away_message");
if (str)
irc_upgrade_current_channel->away_message = strdup (str);
irc_upgrade_current_channel->has_quit_server = weechat_infolist_integer (infolist, "has_quit_server");
irc_upgrade_current_channel->cycle = weechat_infolist_integer (infolist, "cycle");
irc_upgrade_current_channel->part = weechat_infolist_integer (infolist, "part");
irc_upgrade_current_channel->nick_completion_reset = weechat_infolist_integer (infolist, "nick_completion_reset");
for (i = 0; i < 2; i++)
{
index = 0;
while (1)
{
snprintf (option_name, sizeof (option_name),
"nick_speaking%d_%05d", i, index);
nick = weechat_infolist_string (infolist, option_name);
if (!nick)
break;
irc_channel_nick_speaking_add (irc_upgrade_current_channel,
nick,
i);
index++;
}
}
index = 0;
while (1)
{
snprintf (option_name, sizeof (option_name),
"nick_speaking_time_nick_%05d", index);
nick = weechat_infolist_string (infolist, option_name);
if (!nick)
break;
snprintf (option_name, sizeof (option_name),
"nick_speaking_time_time_%05d", index);
irc_channel_nick_speaking_time_add (irc_upgrade_current_server,
irc_upgrade_current_channel,
nick,
weechat_infolist_time (infolist,
option_name));
index++;
}
str = weechat_infolist_string (infolist, "join_smart_filtered");
if (str)
{
nicks = weechat_string_split (str, ",", 0, 0,
&nicks_count);
if (nicks)
{
for (i = 0; i < nicks_count; i++)
{
pos = strchr (nicks[i], ':');
if (pos)
{
nick_join = weechat_strndup (nicks[i],
pos - nicks[i]);
if (nick_join)
{
error = NULL;
number = strtol (pos + 1, &error, 10);
if (error && !error[0])
{
join_time = (time_t)number;
irc_channel_join_smart_filtered_add (irc_upgrade_current_channel,
nick_join,
join_time);
}
free (nick_join);
}
}
}
weechat_string_free_split (nicks);
}
}
}
}
break;
case IRC_UPGRADE_TYPE_NICK:
if (irc_upgrade_current_server && irc_upgrade_current_channel)
{
ptr_nick = irc_nick_new (irc_upgrade_current_server,
irc_upgrade_current_channel,
weechat_infolist_string (infolist, "name"),
weechat_infolist_string (infolist, "host"),
weechat_infolist_string (infolist, "prefixes"),
weechat_infolist_integer (infolist, "away"),
weechat_infolist_string (infolist, "account"),
weechat_infolist_string (infolist, "realname"));
if (ptr_nick)
{
/*
* "flags" is not any more in this infolist (since
* WeeChat 0.3.4), but we read it to keep compatibility
* with old WeeChat versions, on /upgrade)
* We try to restore prefixes with old flags, but
* this is approximation, it's not sure we will
* restore good prefixes here (a /names on channel
* will fix problem if prefixes are wrong).
* Flags were defined in irc-nick.h:
* #define IRC_NICK_CHANOWNER 1
* #define IRC_NICK_CHANADMIN 2
* #define IRC_NICK_CHANADMIN2 4
* #define IRC_NICK_OP 8
* #define IRC_NICK_HALFOP 16
* #define IRC_NICK_VOICE 32
* #define IRC_NICK_AWAY 64
* #define IRC_NICK_CHANUSER 128
*/
flags = weechat_infolist_integer (infolist, "flags");
if (flags > 0)
{
/* channel owner */
if (flags & 1)
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'q');
}
/* channel admin */
if ((flags & 2) || (flags & 4))
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'a');
}
/* op */
if (flags & 8)
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'o');
}
/* half-op */
if (flags & 16)
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'h');
}
/* voice */
if (flags & 32)
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'v');
}
/* away */
if (flags & 64)
{
irc_nick_set_away (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1);
}
/* channel user */
if (flags & 128)
{
irc_nick_set_mode (irc_upgrade_current_server,
irc_upgrade_current_channel,
ptr_nick, 1, 'u');
}
}
}
}
break;
case IRC_UPGRADE_TYPE_REDIRECT:
if (irc_upgrade_current_server)
{
ptr_redirect = irc_redirect_new_with_commands (
irc_upgrade_current_server,
weechat_infolist_string (infolist, "pattern"),
weechat_infolist_string (infolist, "signal"),
weechat_infolist_integer (infolist, "count"),
weechat_infolist_string (infolist, "string"),
weechat_infolist_integer (infolist, "timeout"),
weechat_infolist_string (infolist, "cmd_start"),
weechat_infolist_string (infolist, "cmd_stop"),
weechat_infolist_string (infolist, "cmd_extra"),
weechat_infolist_string (infolist, "cmd_filter"));
if (ptr_redirect)
{
ptr_redirect->current_count = weechat_infolist_integer (infolist, "current_count");
str = weechat_infolist_string (infolist, "command");
if (str)
ptr_redirect->command = strdup (str);
ptr_redirect->assigned_to_command = weechat_infolist_integer (infolist, "assigned_to_command");
ptr_redirect->start_time = weechat_infolist_time (infolist, "start_time");
ptr_redirect->cmd_start_received = weechat_infolist_integer (infolist, "cmd_start_received");
ptr_redirect->cmd_stop_received = weechat_infolist_integer (infolist, "cmd_stop_received");
str = weechat_infolist_string (infolist, "output");
if (str)
ptr_redirect->output = strdup (str);
ptr_redirect->output_size = weechat_infolist_integer (infolist, "output_size");
}
}
break;
case IRC_UPGRADE_TYPE_REDIRECT_PATTERN:
irc_redirect_pattern_new (
weechat_infolist_string (infolist, "name"),
weechat_infolist_integer (infolist, "temp_pattern"),
weechat_infolist_integer (infolist, "timeout"),
weechat_infolist_string (infolist, "cmd_start"),
weechat_infolist_string (infolist, "cmd_stop"),
weechat_infolist_string (infolist, "cmd_extra"));
break;
case IRC_UPGRADE_TYPE_NOTIFY:
if (irc_upgrade_current_server)
{
ptr_notify = irc_notify_search (irc_upgrade_current_server,
weechat_infolist_string (infolist, "nick"));
if (ptr_notify)
{
ptr_notify->is_on_server = weechat_infolist_integer (infolist, "is_on_server");
str = weechat_infolist_string (infolist, "away_message");
if (str)
ptr_notify->away_message = strdup (str);
}
}
break;
case IRC_UPGRADE_TYPE_RAW_MESSAGE:
irc_raw_message_add_to_list (weechat_infolist_time (infolist, "date"),
weechat_infolist_string (infolist, "prefix"),
weechat_infolist_string (infolist, "message"));
break;
}
}
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, j, 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)
{
if (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
goto end;
}
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 (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
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;
}
if (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
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, argv[1], 0);
}
}
else
{
for (i = 2; i < argc; i++)
{
ptr_trigger = trigger_search (argv[i]);
if (ptr_trigger)
trigger_command_set_enabled (ptr_trigger, enable, argv[1],
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;
ptr_trigger = triggers;
while (ptr_trigger)
{
ptr_trigger2 = ptr_trigger->next_trigger;
if (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
}
else
{
trigger_free (ptr_trigger);
}
ptr_trigger = ptr_trigger2;
}
count = count - triggers_count;
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)
{
if (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
}
else
{
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 trigger(s) */
if (weechat_strcasecmp (argv[1], "restore") == 0)
{
if (argc < 3)
goto error;
for (i = 2; i < argc; i++)
{
for (j = 0; trigger_config_default_list[j][0]; j++)
{
if (weechat_strcasecmp (trigger_config_default_list[j][0],
argv[i]) == 0)
{
break;
}
}
if (trigger_config_default_list[j][0])
{
ptr_trigger = trigger_search (argv[i]);
if (ptr_trigger && ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
}
else
{
if (ptr_trigger)
trigger_free (ptr_trigger);
trigger_new (
trigger_config_default_list[j][0], /* name */
trigger_config_default_list[j][1], /* enabled */
trigger_config_default_list[j][2], /* hook */
trigger_config_default_list[j][3], /* arguments */
trigger_config_default_list[j][4], /* conditions */
trigger_config_default_list[j][5], /* regex */
trigger_config_default_list[j][6], /* command */
trigger_config_default_list[j][7]); /* return code */
weechat_printf_tags (NULL, "no_trigger",
_("Trigger \"%s\" restored"),
argv[i]);
}
}
else
{
weechat_printf_tags (NULL, "no_trigger",
_("%sDefault trigger \"%s\" not found"),
weechat_prefix ("error"), argv[i]);
}
}
goto end;
}
/* delete all triggers and restore default ones */
if (weechat_strcasecmp (argv[1], "default") == 0)
{
if ((argc >= 3) && (weechat_strcasecmp (argv[2], "-yes") == 0))
{
ptr_trigger = triggers;
while (ptr_trigger)
{
ptr_trigger2 = ptr_trigger->next_trigger;
if (ptr_trigger->hook_running)
{
trigger_command_error_running (ptr_trigger, argv[1]);
}
else
{
trigger_free (ptr_trigger);
}
ptr_trigger = ptr_trigger2;
}
if (triggers_count == 0)
{
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);
if (rc == WEECHAT_RC_ERROR)
WEECHAT_COMMAND_ERROR;
return rc;
}
struct t_irc_redirect *
irc_redirect_new_with_commands (struct t_irc_server *server,
const char *pattern, const char *signal,
int count, const char *string, int timeout,
const char *cmd_start,
const char *cmd_stop,
const char *cmd_extra,
const char *cmd_filter)
{
struct t_irc_redirect *new_redirect;
char **items[4], *pos, *error;
int i, j, num_items[4];
long value;
struct t_hashtable *hash_cmd[4];
new_redirect = malloc (sizeof (*new_redirect));
if (!new_redirect)
return NULL;
/* create hashtables with commands */
for (i = 0; i < 4; i++)
{
hash_cmd[i] = NULL;
items[i] = NULL;
}
if (cmd_start)
items[0] = weechat_string_split (cmd_start, ",", 0, 0, &num_items[0]);
if (cmd_stop)
items[1] = weechat_string_split (cmd_stop, ",", 0, 0, &num_items[1]);
if (cmd_extra)
items[2] = weechat_string_split (cmd_extra, ",", 0, 0, &num_items[2]);
if (cmd_filter)
items[3] = weechat_string_split (cmd_filter, ",", 0, 0, &num_items[3]);
for (i = 0; i < 4; i++)
{
if (items[i])
{
hash_cmd[i] = weechat_hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_INTEGER,
NULL, NULL);
for (j = 0; j < num_items[i]; j++)
{
if (i < 3)
{
value = -1;
pos = strchr (items[i][j], ':');
if (pos)
{
pos[0] = '\0';
value = strtol (pos + 1, &error, 10);
if (!error || error[0])
value = -1;
}
weechat_string_toupper (items[i][j]);
weechat_hashtable_set (hash_cmd[i], items[i][j], &value);
}
else
{
weechat_hashtable_set (hash_cmd[i], items[i][j], NULL);
}
}
weechat_string_free_split (items[i]);
}
}
/* initialize new redirect */
new_redirect->server = server;
new_redirect->pattern = strdup (pattern);
new_redirect->signal = strdup (signal);
new_redirect->count = (count >= 1) ? count : 1;
new_redirect->current_count = 1;
new_redirect->string = (string) ? strdup (string) : NULL;
new_redirect->timeout = timeout;
new_redirect->command = NULL;
new_redirect->assigned_to_command = 0;
new_redirect->start_time = 0;
new_redirect->cmd_start = hash_cmd[0];
new_redirect->cmd_stop = hash_cmd[1];
new_redirect->cmd_extra = hash_cmd[2];
new_redirect->cmd_start_received = 0;
new_redirect->cmd_stop_received = 0;
new_redirect->cmd_filter = hash_cmd[3];
new_redirect->output = NULL;
new_redirect->output_size = 0;
/* add redirect to end of list */
new_redirect->prev_redirect = server->last_redirect;
if (server->redirects)
(server->last_redirect)->next_redirect = new_redirect;
else
server->redirects = new_redirect;
server->last_redirect = new_redirect;
new_redirect->next_redirect = NULL;
return new_redirect;
}
char *
irc_color_decode_ansi_cb (void *data, const char *text)
{
struct t_irc_color_ansi_state *ansi_state;
char *text2, **items, *output, str_color[128];
int i, length, num_items, value, color;
ansi_state = (struct t_irc_color_ansi_state *)data;
/* if we don't keep colors of if text is empty, just return empty string */
if (!ansi_state->keep_colors || !text || !text[0])
return strdup ("");
/* only sequences ending with 'm' are used, the others are discarded */
length = strlen (text);
if (text[length - 1] != 'm')
return strdup ("");
/* sequence "\33[m" resets color */
if (length < 4)
return strdup (weechat_color ("reset"));
text2 = NULL;
items = NULL;
output = NULL;
/* extract text between "\33[" and "m" */
text2 = weechat_strndup (text + 2, length - 3);
if (!text2)
goto end;
items = weechat_string_split (text2, ";", 0, 0, &num_items);
if (!items)
goto end;
output = malloc ((32 * num_items) + 1);
if (!output)
goto end;
output[0] = '\0';
for (i = 0; i < num_items; i++)
{
value = atoi (items[i]);
switch (value)
{
case 0: /* reset */
strcat (output, IRC_COLOR_RESET_STR);
ansi_state->bold = 0;
ansi_state->underline = 0;
ansi_state->italic = 0;
break;
case 1: /* bold */
if (!ansi_state->bold)
{
strcat (output, IRC_COLOR_BOLD_STR);
ansi_state->bold = 1;
}
break;
case 2: /* remove bold */
case 21:
case 22:
if (ansi_state->bold)
{
strcat (output, IRC_COLOR_BOLD_STR);
ansi_state->bold = 0;
}
break;
case 3: /* italic */
if (!ansi_state->italic)
{
strcat (output, IRC_COLOR_ITALIC_STR);
ansi_state->italic = 1;
}
break;
case 4: /* underline */
if (!ansi_state->underline)
{
strcat (output, IRC_COLOR_UNDERLINE_STR);
ansi_state->underline = 1;
}
break;
case 23: /* remove italic */
if (ansi_state->italic)
{
strcat (output, IRC_COLOR_ITALIC_STR);
ansi_state->italic = 0;
}
break;
case 24: /* remove underline */
if (ansi_state->underline)
{
strcat (output, IRC_COLOR_UNDERLINE_STR);
ansi_state->underline = 0;
}
break;
case 30: /* text color */
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
snprintf (str_color, sizeof (str_color),
"%c%02d",
IRC_COLOR_COLOR_CHAR,
irc_color_term2irc[value - 30]);
strcat (output, str_color);
break;
case 38: /* text color */
if (i + 1 < num_items)
{
switch (atoi (items[i + 1]))
{
case 2: /* RGB color */
if (i + 4 < num_items)
{
color = irc_color_convert_rgb2irc (
(atoi (items[i + 2]) << 16) |
(atoi (items[i + 3]) << 8) |
atoi (items[i + 4]));
if (color >= 0)
{
snprintf (str_color, sizeof (str_color),
"%c%02d",
IRC_COLOR_COLOR_CHAR,
color);
strcat (output, str_color);
}
i += 4;
}
break;
case 5: /* terminal color (0-255) */
if (i + 2 < num_items)
{
color = irc_color_convert_term2irc (atoi (items[i + 2]));
if (color >= 0)
{
snprintf (str_color, sizeof (str_color),
"%c%02d",
IRC_COLOR_COLOR_CHAR,
color);
strcat (output, str_color);
}
i += 2;
}
break;
}
}
break;
case 39: /* default text color */
snprintf (str_color, sizeof (str_color),
"%c15",
IRC_COLOR_COLOR_CHAR);
strcat (output, str_color);
break;
case 40: /* background color */
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
snprintf (str_color, sizeof (str_color),
"%c,%02d",
IRC_COLOR_COLOR_CHAR,
irc_color_term2irc[value - 40]);
strcat (output, str_color);
break;
case 48: /* background color */
if (i + 1 < num_items)
{
switch (atoi (items[i + 1]))
{
case 2: /* RGB color */
if (i + 4 < num_items)
{
color = irc_color_convert_rgb2irc (
(atoi (items[i + 2]) << 16) |
(atoi (items[i + 3]) << 8) |
atoi (items[i + 4]));
if (color >= 0)
{
snprintf (str_color, sizeof (str_color),
"%c,%02d",
IRC_COLOR_COLOR_CHAR,
color);
strcat (output, str_color);
}
i += 4;
}
break;
case 5: /* terminal color (0-255) */
if (i + 2 < num_items)
{
color = irc_color_convert_term2irc (atoi (items[i + 2]));
if (color >= 0)
{
snprintf (str_color, sizeof (str_color),
"%c,%02d",
IRC_COLOR_COLOR_CHAR,
color);
strcat (output, str_color);
}
i += 2;
}
break;
}
}
break;
case 49: /* default background color */
snprintf (str_color, sizeof (str_color),
"%c,01",
IRC_COLOR_COLOR_CHAR);
strcat (output, str_color);
break;
case 90: /* text color (bright) */
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
snprintf (str_color, sizeof (str_color),
"%c%02d",
IRC_COLOR_COLOR_CHAR,
irc_color_term2irc[value - 90 + 8]);
strcat (output, str_color);
break;
case 100: /* background color (bright) */
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
snprintf (str_color, sizeof (str_color),
"%c,%02d",
IRC_COLOR_COLOR_CHAR,
irc_color_term2irc[value - 100 + 8]);
strcat (output, str_color);
break;
}
}
end:
if (items)
weechat_string_free_split (items);
if (text2)
free (text2);
return (output) ? output : strdup ("");
}
void
irc_mode_channel_update (struct t_irc_server *server,
struct t_irc_channel *channel,
char set_flag,
char chanmode,
const char *argument)
{
char *pos_args, *str_modes, **argv, *pos, *ptr_arg;
char *new_modes, *new_args, str_mode[2], *str_temp;
int argc, current_arg, chanmode_found, length;
if (!channel->modes)
channel->modes = strdup ("+");
if (!channel->modes)
return;
argc = 0;
argv = NULL;
pos_args = strchr (channel->modes, ' ');
if (pos_args)
{
str_modes = weechat_strndup (channel->modes, pos_args - channel->modes);
if (!str_modes)
return;
pos_args++;
while (pos_args[0] == ' ')
pos_args++;
argv = weechat_string_split (pos_args, " ", 0, 0, &argc);
}
else
{
str_modes = strdup (channel->modes);
if (!str_modes)
return;
}
new_modes = malloc (strlen (channel->modes) + 1 + 1);
new_args = malloc (((pos_args) ? strlen (pos_args) : 0)
+ ((argument) ? 1 + strlen (argument) : 0) + 1);
if (new_modes && new_args)
{
new_modes[0] = '\0';
new_args[0] = '\0';
/* loop on current modes and build "new_modes" + "new_args" */
current_arg = 0;
chanmode_found = 0;
pos = str_modes;
while (pos && pos[0])
{
if ((pos[0] == '+') || (pos[0] == '-'))
{
str_mode[0] = pos[0];
str_mode[1] = '\0';
strcat (new_modes, str_mode);
}
else
{
ptr_arg = NULL;
switch (irc_mode_get_chanmode_type (server, pos[0]))
{
case 'A': /* always argument */
case 'B': /* always argument */
case 'C': /* argument if set */
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'D': /* no argument */
break;
}
if (ptr_arg)
current_arg++;
if (pos[0] == chanmode)
{
chanmode_found = 1;
if (set_flag == '+')
{
str_mode[0] = pos[0];
str_mode[1] = '\0';
strcat (new_modes, str_mode);
if (argument)
{
if (new_args[0])
strcat (new_args, " ");
strcat (new_args, argument);
}
}
}
else
{
str_mode[0] = pos[0];
str_mode[1] = '\0';
strcat (new_modes, str_mode);
if (ptr_arg)
{
if (new_args[0])
strcat (new_args, " ");
strcat (new_args, ptr_arg);
}
}
}
pos++;
}
if (!chanmode_found)
{
/*
* chanmode was not in channel modes: if set_flag is '+', add
* it to channel modes
*/
if (set_flag == '+')
{
if (argument)
{
/* add mode with argument at the end of modes */
str_mode[0] = chanmode;
str_mode[1] = '\0';
strcat (new_modes, str_mode);
if (new_args[0])
strcat (new_args, " ");
strcat (new_args, argument);
}
else
{
/* add mode without argument at the beginning of modes */
pos = new_modes;
while (pos[0] == '+')
pos++;
memmove (pos + 1, pos, strlen (pos) + 1);
pos[0] = chanmode;
}
}
}
if (new_args[0])
{
length = strlen (new_modes) + 1 + strlen (new_args) + 1;
str_temp = malloc (length);
if (str_temp)
{
snprintf (str_temp, length, "%s %s", new_modes, new_args);
if (channel->modes)
free (channel->modes);
channel->modes = str_temp;
}
}
else
{
if (channel->modes)
free (channel->modes);
channel->modes = strdup (new_modes);
}
}
if (new_modes)
free (new_modes);
if (new_args)
free (new_args);
if (str_modes)
free (str_modes);
if (argv)
weechat_string_free_split (argv);
}
struct t_infolist *
irc_info_get_infolist_cb (void *data, const char *infolist_name,
void *pointer, const char *arguments)
{
struct t_infolist *ptr_infolist;
struct t_irc_server *ptr_server;
struct t_irc_channel *ptr_channel;
struct t_irc_nick *ptr_nick;
struct t_irc_ignore *ptr_ignore;
char **argv;
int argc;
/* make C compiler happy */
(void) data;
if (!infolist_name || !infolist_name[0])
return NULL;
if (weechat_strcasecmp (infolist_name, "irc_server") == 0)
{
if (pointer && !irc_server_valid (pointer))
return NULL;
ptr_infolist = weechat_infolist_new ();
if (ptr_infolist)
{
if (pointer)
{
/* build list with only one server */
if (!irc_server_add_to_infolist (ptr_infolist, pointer))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
return ptr_infolist;
}
else
{
/* build list with all servers matching arguments */
for (ptr_server = irc_servers; ptr_server;
ptr_server = ptr_server->next_server)
{
if (!arguments || !arguments[0]
|| weechat_string_match (ptr_server->name, arguments, 0))
{
if (!irc_server_add_to_infolist (ptr_infolist, ptr_server))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
}
}
return ptr_infolist;
}
}
}
else if (weechat_strcasecmp (infolist_name, "irc_channel") == 0)
{
if (arguments && arguments[0])
{
ptr_server = irc_server_search (arguments);
if (ptr_server)
{
if (pointer && !irc_channel_valid (ptr_server, pointer))
return NULL;
ptr_infolist = weechat_infolist_new ();
if (ptr_infolist)
{
if (pointer)
{
/* build list with only one channel */
if (!irc_channel_add_to_infolist (ptr_infolist, pointer))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
return ptr_infolist;
}
else
{
/* build list with all channels of server */
for (ptr_channel = ptr_server->channels; ptr_channel;
ptr_channel = ptr_channel->next_channel)
{
if (!irc_channel_add_to_infolist (ptr_infolist,
ptr_channel))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
}
return ptr_infolist;
}
}
}
}
}
else if (weechat_strcasecmp (infolist_name, "irc_nick") == 0)
{
if (arguments && arguments[0])
{
ptr_server = NULL;
ptr_channel = NULL;
argv = weechat_string_split (arguments, ",", 0, 0, &argc);
if (argv)
{
if (argc >= 2)
{
ptr_server = irc_server_search (argv[0]);
if (!ptr_server)
{
weechat_string_free_split (argv);
return NULL;
}
ptr_channel = irc_channel_search (ptr_server, argv[1]);
if (!ptr_channel)
{
weechat_string_free_split (argv);
return NULL;
}
if (!pointer && (argc >= 3))
{
pointer = irc_nick_search (ptr_channel, argv[2]);
if (!pointer)
{
weechat_string_free_split (argv);
return NULL;
}
}
}
weechat_string_free_split (argv);
if (ptr_server && ptr_channel)
{
if (pointer && !irc_nick_valid (ptr_channel, pointer))
return NULL;
ptr_infolist = weechat_infolist_new ();
if (ptr_infolist)
{
if (pointer)
{
/* build list with only one nick */
if (!irc_nick_add_to_infolist (ptr_infolist, pointer))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
return ptr_infolist;
}
else
{
/* build list with all nicks of channel */
for (ptr_nick = ptr_channel->nicks; ptr_nick;
ptr_nick = ptr_nick->next_nick)
{
if (!irc_nick_add_to_infolist (ptr_infolist,
ptr_nick))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
}
return ptr_infolist;
}
}
}
}
}
}
else if (weechat_strcasecmp (infolist_name, "irc_ignore") == 0)
{
if (pointer && !irc_ignore_valid (pointer))
return NULL;
ptr_infolist = weechat_infolist_new ();
if (ptr_infolist)
{
if (pointer)
{
/* build list with only one ignore */
if (!irc_ignore_add_to_infolist (ptr_infolist, pointer))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
return ptr_infolist;
}
else
{
/* build list with all ignore */
for (ptr_ignore = irc_ignore_list; ptr_ignore;
ptr_ignore = ptr_ignore->next_ignore)
{
if (!irc_ignore_add_to_infolist (ptr_infolist, ptr_ignore))
{
weechat_infolist_free (ptr_infolist);
return NULL;
}
}
return ptr_infolist;
}
}
}
return NULL;
}
char *
trigger_callback_modifier_cb (void *data, const char *modifier,
const char *modifier_data, const char *string)
{
struct t_gui_buffer *buffer;
const char *ptr_string;
char *string_modified, *pos, *pos2, *plugin_name, *buffer_name;
char *buffer_full_name, *str_tags, **tags, *prefix, *string_no_color;
int length, num_tags;
TRIGGER_CALLBACK_CB_INIT(NULL);
buffer = NULL;
tags = NULL;
num_tags = 0;
string_no_color = NULL;
/* split IRC message (if string is an IRC message) */
if ((strncmp (modifier, "irc_in_", 7) == 0)
|| (strncmp (modifier, "irc_in2_", 8) == 0)
|| (strncmp (modifier, "irc_out1_", 9) == 0)
|| (strncmp (modifier, "irc_out_", 8) == 0))
{
extra_vars = trigger_callback_irc_message_parse (string,
modifier_data);
if (extra_vars)
weechat_hashtable_set (extra_vars, "server", modifier_data);
}
TRIGGER_CALLBACK_CB_NEW_POINTERS;
if (!extra_vars)
{
TRIGGER_CALLBACK_CB_NEW_EXTRA_VARS;
}
/* add data in hashtable used for conditions/replace/command */
weechat_hashtable_set (extra_vars, "tg_modifier", modifier);
weechat_hashtable_set (extra_vars, "tg_modifier_data", modifier_data);
weechat_hashtable_set (extra_vars, "tg_string", string);
string_no_color = weechat_string_remove_color (string, NULL);
if (string_no_color)
{
weechat_hashtable_set (extra_vars,
"tg_string_nocolor", string_no_color);
}
/* add special variables for a WeeChat message */
if (strcmp (modifier, "weechat_print") == 0)
{
/* set "tg_prefix" and "tg_message" */
pos = strchr (string, '\t');
if (pos)
{
if (pos > string)
{
prefix = weechat_strndup (string, pos - string);
if (prefix)
{
weechat_hashtable_set (extra_vars, "tg_prefix", prefix);
free (prefix);
}
}
pos++;
if (pos[0] == '\t')
pos++;
weechat_hashtable_set (extra_vars, "tg_message", pos);
}
else
weechat_hashtable_set (extra_vars, "tg_message", string);
/* set "tg_prefix_nocolor" and "tg_message_nocolor" */
if (string_no_color)
{
pos = strchr (string_no_color, '\t');
if (pos)
{
if (pos > string_no_color)
{
prefix = weechat_strndup (string_no_color,
pos - string_no_color);
if (prefix)
{
weechat_hashtable_set (extra_vars,
"tg_prefix_nocolor", prefix);
free (prefix);
}
}
pos++;
if (pos[0] == '\t')
pos++;
weechat_hashtable_set (extra_vars, "tg_message_nocolor", pos);
}
else
{
weechat_hashtable_set (extra_vars,
"tg_message_nocolor", string_no_color);
}
}
/*
* extract buffer/tags from modifier data
* (format: "plugin;buffer_name;tags")
*/
pos = strchr (modifier_data, ';');
if (pos)
{
plugin_name = weechat_strndup (modifier_data, pos - modifier_data);
if (plugin_name)
{
weechat_hashtable_set (extra_vars, "tg_plugin", plugin_name);
pos++;
pos2 = strchr (pos, ';');
if (pos2)
{
buffer_name = weechat_strndup (pos, pos2 - pos);
if (buffer_name)
{
buffer = weechat_buffer_search (plugin_name,
buffer_name);
length = strlen (plugin_name) + 1 + strlen (buffer_name) + 1;
buffer_full_name = malloc (length);
if (buffer_full_name)
{
snprintf (buffer_full_name, length,
"%s.%s", plugin_name, buffer_name);
weechat_hashtable_set (extra_vars, "tg_buffer",
buffer_full_name);
free (buffer_full_name);
}
free (buffer_name);
}
pos2++;
if (pos2[0])
{
tags = weechat_string_split (pos2, ",", 0, 0, &num_tags);
length = 1 + strlen (pos2) + 1 + 1;
str_tags = malloc (length);
if (str_tags)
{
snprintf (str_tags, length, ",%s,", pos2);
weechat_hashtable_set (extra_vars, "tg_tags",
str_tags);
free (str_tags);
}
}
}
free (plugin_name);
}
}
weechat_hashtable_set (pointers, "buffer", buffer);
}
if (tags)
{
if (!trigger_callback_set_tags (buffer, (const char **)tags, num_tags,
extra_vars))
{
goto end;
}
}
/* execute the trigger (conditions, regex, command) */
trigger_callback_execute (trigger, buffer, pointers, extra_vars);
end:
ptr_string = weechat_hashtable_get (extra_vars, "tg_string");
string_modified = (ptr_string && (strcmp (ptr_string, string) != 0)) ?
strdup (ptr_string) : NULL;
if (tags)
weechat_string_free_split (tags);
if (string_no_color)
free (string_no_color);
TRIGGER_CALLBACK_CB_END(string_modified);
}
int
irc_notify_hsignal_cb (const void *pointer, void *data, const char *signal,
struct t_hashtable *hashtable)
{
const char *error, *server, *pattern, *command, *output;
char **messages, **nicks_sent, **nicks_recv, *irc_cmd, *arguments;
char *ptr_args, *pos;
int i, j, num_messages, num_nicks_sent, num_nicks_recv, nick_was_sent;
int away_message_updated, no_such_nick;
struct t_irc_server *ptr_server;
struct t_irc_notify *ptr_notify;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) signal;
error = weechat_hashtable_get (hashtable, "error");
server = weechat_hashtable_get (hashtable, "server");
pattern = weechat_hashtable_get (hashtable, "pattern");
command = weechat_hashtable_get (hashtable, "command");
output = weechat_hashtable_get (hashtable, "output");
/* if there is an error on redirection, just ignore result */
if (error && error[0])
return WEECHAT_RC_OK;
/* missing things in redirection */
if (!server || !pattern || !command || !output)
return WEECHAT_RC_OK;
/* search server */
ptr_server = irc_server_search (server);
if (!ptr_server)
return WEECHAT_RC_OK;
/* search for start of arguments in command sent to server */
ptr_args = strchr (command, ' ');
if (!ptr_args)
return WEECHAT_RC_OK;
ptr_args++;
while ((ptr_args[0] == ' ') || (ptr_args[0] == ':'))
{
ptr_args++;
}
if (!ptr_args[0])
return WEECHAT_RC_OK;
/* read output of command */
if (strcmp (pattern, "ison") == 0)
{
/* redirection of command "ison" */
messages = weechat_string_split (
output,
"\n",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0,
&num_messages);
if (messages)
{
nicks_sent = weechat_string_split (
ptr_args,
" ",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0,
&num_nicks_sent);
if (!nicks_sent)
return WEECHAT_RC_OK;
for (ptr_notify = ptr_server->notify_list;
ptr_notify;
ptr_notify = ptr_notify->next_notify)
{
ptr_notify->ison_received = 0;
}
for (i = 0; i < num_messages; i++)
{
irc_message_parse (ptr_server, messages[i], NULL, NULL, NULL,
NULL, NULL, NULL, &arguments, NULL, NULL,
NULL, NULL, NULL);
if (arguments)
{
pos = strchr (arguments, ' ');
if (pos)
{
pos++;
while ((pos[0] == ' ') || (pos[0] == ':'))
{
pos++;
}
if (pos[0])
{
nicks_recv = weechat_string_split (
pos,
" ",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0,
&num_nicks_recv);
if (nicks_recv)
{
for (j = 0; j < num_nicks_recv; j++)
{
for (ptr_notify = ptr_server->notify_list;
ptr_notify;
ptr_notify = ptr_notify->next_notify)
{
if (irc_server_strcasecmp (ptr_server,
ptr_notify->nick,
nicks_recv[j]) == 0)
{
irc_notify_set_is_on_server (ptr_notify,
NULL,
1);
ptr_notify->ison_received = 1;
}
}
}
weechat_string_free_split (nicks_recv);
}
}
}
free (arguments);
}
}
for (ptr_notify = ptr_server->notify_list;
ptr_notify;
ptr_notify = ptr_notify->next_notify)
{
if (!ptr_notify->ison_received)
{
nick_was_sent = 0;
for (j = 0; j < num_nicks_sent; j++)
{
if (irc_server_strcasecmp (ptr_server,
nicks_sent[j],
ptr_notify->nick) == 0)
{
nick_was_sent = 1;
break;
}
}
if (nick_was_sent)
{
irc_notify_set_is_on_server (ptr_notify, NULL, 0);
}
}
}
weechat_string_free_split (messages);
}
}
else if (strcmp (pattern, "whois") == 0)
{
/* redirection of command "whois" */
ptr_notify = irc_notify_search (ptr_server, ptr_args);
if (ptr_notify)
{
away_message_updated = 0;
no_such_nick = 0;
messages = weechat_string_split (
output,
"\n",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0,
&num_messages);
if (messages)
{
for (i = 0; i < num_messages; i++)
{
irc_message_parse (ptr_server, messages[i], NULL, NULL,
NULL, NULL, &irc_cmd, NULL, &arguments,
NULL, NULL, NULL, NULL, NULL);
if (irc_cmd && arguments)
{
if (strcmp (irc_cmd, "401") == 0)
{
/* no such nick/channel */
no_such_nick = 1;
}
else if (strcmp (irc_cmd, "301") == 0)
{
/* away message */
pos = strchr (arguments, ':');
if (pos)
{
pos++;
/* nick is away */
irc_notify_set_away_message (ptr_notify, pos);
away_message_updated = 1;
}
}
}
if (irc_cmd)
free (irc_cmd);
if (arguments)
free (arguments);
}
}
if (!away_message_updated && !no_such_nick)
{
/* nick is back */
irc_notify_set_away_message (ptr_notify, NULL);
}
}
}
return WEECHAT_RC_OK;
}