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; }