void relay_upgrade_set_buffer_callbacks () { struct t_infolist *infolist; struct t_gui_buffer *ptr_buffer; infolist = weechat_infolist_get ("buffer", NULL, NULL); if (infolist) { while (weechat_infolist_next (infolist)) { if (weechat_infolist_pointer (infolist, "plugin") == weechat_relay_plugin) { ptr_buffer = weechat_infolist_pointer (infolist, "pointer"); weechat_buffer_set_pointer (ptr_buffer, "close_callback", &relay_buffer_close_cb); weechat_buffer_set_pointer (ptr_buffer, "input_callback", &relay_buffer_input_cb); if (strcmp (weechat_infolist_string (infolist, "name"), RELAY_BUFFER_NAME) == 0) { relay_buffer = ptr_buffer; } if (strcmp (weechat_infolist_string (infolist, "name"), RELAY_RAW_BUFFER_NAME) == 0) { relay_raw_buffer = ptr_buffer; } } } weechat_infolist_free (infolist); } }
AspellSpeller * weechat_aspell_speller_new (const char *lang) { AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } /* create a speller instance for the newly created cell */ config = new_aspell_config(); aspell_config_replace (config, "lang", lang); /* apply all options on speller */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); /* free configuration */ delete_aspell_config (config); return new_speller; }
void logger_list () { struct t_infolist *ptr_infolist; struct t_logger_buffer *ptr_logger_buffer; struct t_gui_buffer *ptr_buffer; char status[128]; weechat_printf (NULL, ""); weechat_printf (NULL, _("Logging on buffers:")); ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL); if (ptr_infolist) { while (weechat_infolist_next (ptr_infolist)) { ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer"); if (ptr_buffer) { ptr_logger_buffer = logger_buffer_search_buffer (ptr_buffer); if (ptr_logger_buffer) { snprintf (status, sizeof (status), _("logging (level: %d)"), ptr_logger_buffer->log_level); } else { snprintf (status, sizeof (status), "%s", _("not logging")); } weechat_printf (NULL, " %s[%s%d%s]%s (%s) %s%s%s: %s%s%s%s", weechat_color("chat_delimiters"), weechat_color("chat"), weechat_infolist_integer (ptr_infolist, "number"), weechat_color("chat_delimiters"), weechat_color("chat"), weechat_infolist_string (ptr_infolist, "plugin_name"), weechat_color("chat_buffer"), weechat_infolist_string (ptr_infolist, "name"), weechat_color("chat"), status, (ptr_logger_buffer) ? " (" : "", (ptr_logger_buffer) ? ((ptr_logger_buffer->log_filename) ? ptr_logger_buffer->log_filename : _("log not started")) : "", (ptr_logger_buffer) ? ")" : ""); } } weechat_infolist_free (ptr_infolist); } }
void exec_buffer_set_callbacks () { struct t_infolist *ptr_infolist; struct t_gui_buffer *ptr_buffer; const char *plugin_name; ptr_infolist = weechat_infolist_get ("buffer", NULL, ""); if (ptr_infolist) { while (weechat_infolist_next (ptr_infolist)) { ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer"); plugin_name = weechat_infolist_string (ptr_infolist, "plugin_name"); if (ptr_buffer && plugin_name && (strcmp (plugin_name, EXEC_PLUGIN_NAME) == 0)) { weechat_buffer_set_pointer (ptr_buffer, "close_callback", &exec_buffer_close_cb); weechat_buffer_set_pointer (ptr_buffer, "input_callback", &exec_buffer_input_cb); } } weechat_infolist_free (ptr_infolist); } }
void irc_upgrade_set_buffer_callbacks () { struct t_infolist *infolist; struct t_gui_buffer *ptr_buffer; const char *type; infolist = weechat_infolist_get ("buffer", NULL, NULL); if (infolist) { while (weechat_infolist_next (infolist)) { if (weechat_infolist_pointer (infolist, "plugin") == weechat_irc_plugin) { ptr_buffer = weechat_infolist_pointer (infolist, "pointer"); weechat_buffer_set_pointer (ptr_buffer, "close_callback", &irc_buffer_close_cb); weechat_buffer_set_pointer (ptr_buffer, "input_callback", &irc_input_data_cb); type = weechat_buffer_get_string (ptr_buffer, "localvar_type"); if (type && (strcmp (type, "channel") == 0)) { weechat_buffer_set_pointer (ptr_buffer, "nickcmp_callback", &irc_buffer_nickcmp_cb); } if (strcmp (weechat_infolist_string (infolist, "name"), IRC_RAW_BUFFER_NAME) == 0) { irc_raw_buffer = ptr_buffer; } } } weechat_infolist_free (infolist); } }
int relay_upgrade_read_cb (const void *pointer, void *data, struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist) { const char *str; struct t_relay_server *ptr_server; /* 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 RELAY_UPGRADE_TYPE_SERVER: str = weechat_infolist_string (infolist, "protocol_string"); if (str) { ptr_server = relay_server_search (str); if (ptr_server) { ptr_server->last_client_disconnect = weechat_infolist_time (infolist, "last_client_disconnect"); } } break; case RELAY_UPGRADE_TYPE_CLIENT: relay_client_new_with_infolist (infolist); break; case RELAY_UPGRADE_TYPE_RAW_MESSAGE: relay_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; }
void relay_weechat_alloc_with_infolist (struct t_relay_client *client, struct t_infolist *infolist) { struct t_relay_weechat_data *weechat_data; int index, value; char name[64]; const char *key; client->protocol_data = malloc (sizeof (*weechat_data)); if (client->protocol_data) { /* general stuff */ RELAY_WEECHAT_DATA(client, password_ok) = weechat_infolist_integer (infolist, "password_ok"); RELAY_WEECHAT_DATA(client, compression) = weechat_infolist_integer (infolist, "compression"); /* sync of buffers */ RELAY_WEECHAT_DATA(client, buffers_sync) = weechat_hashtable_new (32, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_INTEGER, NULL, NULL); index = 0; while (1) { snprintf (name, sizeof (name), "buffers_sync_name_%05d", index); key = weechat_infolist_string (infolist, name); if (!key) break; snprintf (name, sizeof (name), "buffers_sync_value_%05d", index); value = weechat_infolist_integer (infolist, name); weechat_hashtable_set (RELAY_WEECHAT_DATA(client, buffers_sync), key, &value); index++; } RELAY_WEECHAT_DATA(client, hook_signal_buffer) = NULL; RELAY_WEECHAT_DATA(client, hook_hsignal_nicklist) = NULL; RELAY_WEECHAT_DATA(client, hook_signal_upgrade) = NULL; RELAY_WEECHAT_DATA(client, buffers_nicklist) = weechat_hashtable_new (32, WEECHAT_HASHTABLE_POINTER, WEECHAT_HASHTABLE_POINTER, NULL, NULL); weechat_hashtable_set_pointer (RELAY_WEECHAT_DATA(client, buffers_nicklist), "callback_free_value", &relay_weechat_free_buffers_nicklist); RELAY_WEECHAT_DATA(client, hook_timer_nicklist) = NULL; relay_weechat_hook_signals (client); } }
int relay_completion_protocol_name_cb (void *data, const char *completion_item, struct t_gui_buffer *buffer, struct t_gui_completion *completion) { struct t_infolist *infolist; char protocol_name[512]; /* make C compiler happy */ (void) data; (void) buffer; (void) completion_item; infolist = weechat_infolist_get("irc_server", NULL, NULL); if (infolist) { while (weechat_infolist_next (infolist)) { snprintf (protocol_name, sizeof (protocol_name), "irc.%s", weechat_infolist_string (infolist, "name")); weechat_hook_completion_list_add (completion, protocol_name, 0, WEECHAT_LIST_POS_SORT); snprintf (protocol_name, sizeof (protocol_name), "ssl.irc.%s", weechat_infolist_string (infolist, "name")); weechat_hook_completion_list_add (completion, protocol_name, 0, WEECHAT_LIST_POS_SORT); } weechat_infolist_free (infolist); } weechat_hook_completion_list_add (completion, "weechat", 0, WEECHAT_LIST_POS_SORT); weechat_hook_completion_list_add (completion, "ssl.weechat", 0, WEECHAT_LIST_POS_SORT); return WEECHAT_RC_OK; }
void weechat_aspell_speller_remove_unused () { struct t_hashtable *used_spellers; struct t_infolist *infolist; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: removing unused spellers", ASPELL_PLUGIN_NAME); } /* create a hashtable that will contain all used spellers */ used_spellers = weechat_hashtable_new (32, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); if (!used_spellers) return; /* collect used spellers and store them in hashtable "used_spellers" */ weechat_aspell_speller_add_dicts_to_hash (used_spellers, weechat_config_string (weechat_aspell_config_check_default_dict)); infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*"); if (infolist) { while (weechat_infolist_next (infolist)) { weechat_aspell_speller_add_dicts_to_hash (used_spellers, weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } /* * look at current spellers, and remove spellers that are not in hashtable * "used_spellers" */ weechat_hashtable_map (weechat_aspell_spellers, &weechat_aspell_speller_remove_unused_cb, used_spellers); weechat_hashtable_free (used_spellers); }
int weechat_aspell_command_cb (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { char *dicts; const char *default_dict; struct t_infolist *infolist; int number; /* make C compiler happy */ (void) data; if (argc == 1) { /* display aspell status */ weechat_printf (NULL, ""); weechat_printf (NULL, /* TRANSLATORS: second "%s" is "aspell" or "enchant" */ _("%s (using %s)"), (aspell_enabled) ? _("Spell checking is enabled") : _("Spell checking is disabled"), #ifdef USE_ENCHANT "enchant" #else "aspell" #endif ); default_dict = weechat_config_string (weechat_aspell_config_check_default_dict); weechat_printf (NULL, _("Default dictionary: %s"), (default_dict && default_dict[0]) ? default_dict : _("(not set)")); number = 0; infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*"); if (infolist) { while (weechat_infolist_next (infolist)) { if (number == 0) weechat_printf (NULL, _("Specific dictionaries on buffers:")); number++; weechat_printf (NULL, " %s: %s", weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } return WEECHAT_RC_OK; } /* enable aspell */ if (weechat_strcasecmp (argv[1], "enable") == 0) { weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1); weechat_printf (NULL, _("Aspell enabled")); return WEECHAT_RC_OK; } /* disable aspell */ if (weechat_strcasecmp (argv[1], "disable") == 0) { weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1); weechat_printf (NULL, _("Aspell disabled")); return WEECHAT_RC_OK; } /* toggle aspell */ if (weechat_strcasecmp (argv[1], "toggle") == 0) { if (aspell_enabled) { weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1); weechat_printf (NULL, _("Aspell disabled")); } else { weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1); weechat_printf (NULL, _("Aspell enabled")); } return WEECHAT_RC_OK; } /* list of dictionaries */ if (weechat_strcasecmp (argv[1], "listdict") == 0) { weechat_aspell_command_speller_list_dicts (); return WEECHAT_RC_OK; } /* set dictionary for current buffer */ if (weechat_strcasecmp (argv[1], "setdict") == 0) { if (argc < 3) return WEECHAT_RC_ERROR; dicts = weechat_string_replace (argv_eol[2], " ", ""); weechat_aspell_command_set_dict (buffer, (dicts) ? dicts : argv[2]); if (dicts) free (dicts); return WEECHAT_RC_OK; } /* delete dictionary used on current buffer */ if (weechat_strcasecmp (argv[1], "deldict") == 0) { weechat_aspell_command_set_dict (buffer, NULL); return WEECHAT_RC_OK; } /* add word to personal dictionary */ if (weechat_strcasecmp (argv[1], "addword") == 0) { if (argc < 3) return WEECHAT_RC_ERROR; if (argc > 3) { /* use a given dict */ weechat_aspell_command_add_word (buffer, argv[2], argv_eol[3]); } else { /* use default dict */ weechat_aspell_command_add_word (buffer, NULL, argv_eol[2]); } return WEECHAT_RC_OK; } return WEECHAT_RC_ERROR; }
struct t_weelist * script_buffer_get_script_usage (struct t_script_repo *script) { struct t_weelist *list; char hdata_name[128], str_option[256], str_info[1024]; int config_files; const char *ptr_name_hdata_callback, *type; struct t_hdata *ptr_hdata_script, *ptr_hdata_callback; struct t_hdata *ptr_hdata_config_file, *ptr_hdata_bar_item; void *ptr_script, *ptr_callback; struct t_config_file *ptr_config_file; struct t_hook *ptr_hook; struct t_gui_bar_item *ptr_bar_item; struct t_infolist *infolist; config_files = 0; snprintf (hdata_name, sizeof (hdata_name), "%s_script", script_language[script->language]); ptr_hdata_script = weechat_hdata_get (hdata_name); if (!ptr_hdata_script) return NULL; ptr_script = script_buffer_get_script_pointer (script, ptr_hdata_script); if (!ptr_script) return NULL; ptr_name_hdata_callback = weechat_hdata_get_var_hdata (ptr_hdata_script, "callbacks"); if (!ptr_name_hdata_callback) return NULL; ptr_hdata_callback = weechat_hdata_get (ptr_name_hdata_callback); if (!ptr_hdata_callback) return NULL; list = weechat_list_new (); ptr_hdata_config_file = weechat_hdata_get ("config_file"); ptr_hdata_bar_item = weechat_hdata_get ("bar_item"); ptr_callback = weechat_hdata_pointer (ptr_hdata_script, ptr_script, "callbacks"); while (ptr_callback) { str_info[0] = '\0'; ptr_config_file = weechat_hdata_pointer (ptr_hdata_callback, ptr_callback, "config_file"); ptr_hook = weechat_hdata_pointer (ptr_hdata_callback, ptr_callback, "hook"); ptr_bar_item = weechat_hdata_pointer (ptr_hdata_callback, ptr_callback, "bar_item"); if (ptr_config_file) { snprintf (str_info, sizeof (str_info), _("configuration file \"%s\" (options %s.*)"), weechat_hdata_string (ptr_hdata_config_file, ptr_config_file, "filename"), weechat_hdata_string (ptr_hdata_config_file, ptr_config_file, "name")); config_files++; } else if (ptr_hook) { infolist = weechat_infolist_get ("hook", ptr_hook, NULL); if (infolist) { if (weechat_infolist_next (infolist)) { type = weechat_infolist_string (infolist, "type"); if (type) { if (strcmp (type, "command") == 0) { snprintf (str_info, sizeof (str_info), _("command /%s"), weechat_infolist_string (infolist, "command")); } else if (strcmp (type, "completion") == 0) { snprintf (str_info, sizeof (str_info), _("completion %%(%s)"), weechat_infolist_string (infolist, "completion_item")); } else if (strcmp (type, "info") == 0) { snprintf (str_info, sizeof (str_info), "info \"%s\"", weechat_infolist_string (infolist, "info_name")); } else if (strcmp (type, "info_hashtable") == 0) { snprintf (str_info, sizeof (str_info), "info_hashtable \"%s\"", weechat_infolist_string (infolist, "info_name")); } else if (strcmp (type, "infolist") == 0) { snprintf (str_info, sizeof (str_info), "infolist \"%s\"", weechat_infolist_string (infolist, "infolist_name")); } } } weechat_infolist_free (infolist); } } else if (ptr_bar_item) { snprintf (str_info, sizeof (str_info), _("bar item \"%s\""), weechat_hdata_string (ptr_hdata_bar_item, ptr_bar_item, "name")); } if (str_info[0]) { weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } ptr_callback = weechat_hdata_move (ptr_hdata_callback, ptr_callback, 1); } snprintf (str_option, sizeof (str_option), "plugins.var.%s.%s.*", script_language[script->language], weechat_hdata_string (ptr_hdata_script, ptr_script, "name")); infolist = weechat_infolist_get ("option", NULL, str_option); if (infolist) { if (weechat_infolist_next (infolist)) { snprintf (str_info, sizeof (str_info), _("options %s%s%s"), str_option, (config_files > 0) ? " " : "", (config_files > 0) ? _("(old options?)") : ""); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } weechat_infolist_free (infolist); } return list; }
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); }
int irc_upgrade_read_cb (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) 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); } 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); 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"); 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_away = weechat_infolist_integer (infolist, "checking_away"); 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")); 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; }
void relay_weechat_alloc_with_infolist (struct t_relay_client *client, struct t_infolist *infolist) { struct t_relay_weechat_data *weechat_data; int index, rc, value_int; char name[64]; const char *key, *value; client->protocol_data = malloc (sizeof (*weechat_data)); if (client->protocol_data) { /* general stuff */ RELAY_WEECHAT_DATA(client, password_ok) = weechat_infolist_integer (infolist, "password_ok"); RELAY_WEECHAT_DATA(client, compression) = weechat_infolist_integer (infolist, "compression"); /* sync of buffers */ RELAY_WEECHAT_DATA(client, buffers_sync) = weechat_hashtable_new (16, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); index = 0; while (1) { snprintf (name, sizeof (name), "buffers_sync_name_%05d", index); key = weechat_infolist_string (infolist, name); if (!key) break; snprintf (name, sizeof (name), "buffers_sync_value_%05d", index); value = weechat_infolist_string (infolist, name); rc = sscanf (value, "%d", &value_int); if ((rc == EOF) || (rc == 0)) value_int = 0; weechat_hashtable_set (RELAY_WEECHAT_DATA(client, buffers_sync), key, &value_int); index++; } RELAY_WEECHAT_DATA(client, hook_signal_buffer) = NULL; RELAY_WEECHAT_DATA(client, hook_signal_nicklist) = NULL; RELAY_WEECHAT_DATA(client, buffers_nicklist) = weechat_hashtable_new (16, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); index = 0; while (1) { snprintf (name, sizeof (name), "buffers_nicklist_name_%05d", index); key = weechat_infolist_string (infolist, name); if (!key) break; snprintf (name, sizeof (name), "buffers_nicklist_value_%05d", index); value = weechat_infolist_string (infolist, name); weechat_hashtable_set (RELAY_WEECHAT_DATA(client, buffers_sync), key, value); index++; } RELAY_WEECHAT_DATA(client, hook_timer_nicklist) = NULL; if (weechat_hashtable_get_integer (RELAY_WEECHAT_DATA(client, buffers_sync), "items_count") > 0) relay_weechat_hook_signals (client); if (weechat_hashtable_get_integer (RELAY_WEECHAT_DATA(client, buffers_sync), "items_count") > 0) relay_weechat_hook_timer_nicklist (client); } }
struct t_weelist * script_buffer_get_script_usage (struct t_script_repo *script) { struct t_weelist *list; char hdata_name[128], str_option[256], str_info[1024]; int config_files; struct t_hdata *hdata_script, *hdata_config, *hdata_bar_item; void *ptr_script, *callback_pointer; struct t_config_file *ptr_config; struct t_gui_bar_item *ptr_bar_item; struct t_infolist *infolist; config_files = 0; snprintf (hdata_name, sizeof (hdata_name), "%s_script", script_language[script->language]); hdata_script = weechat_hdata_get (hdata_name); if (!hdata_script) return NULL; ptr_script = script_buffer_get_script_pointer (script, hdata_script); if (!ptr_script) return NULL; list = weechat_list_new (); /* get configuration files created by the script */ hdata_config = weechat_hdata_get ("config_file"); ptr_config = weechat_hdata_get_list (hdata_config, "config_files"); while (ptr_config) { callback_pointer = weechat_hdata_pointer ( hdata_config, ptr_config, "callback_reload_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), _("configuration file \"%s\" (options %s.*)"), weechat_hdata_string (hdata_config, ptr_config, "filename"), weechat_hdata_string (hdata_config, ptr_config, "name")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); config_files++; } ptr_config = weechat_hdata_move (hdata_config, ptr_config, 1); } /* get the commands created by the script */ infolist = weechat_infolist_get ("hook", NULL, "command"); if (infolist) { while (weechat_infolist_next (infolist)) { callback_pointer = weechat_infolist_pointer (infolist, "callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), _("command /%s"), weechat_infolist_string (infolist, "command")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } } weechat_infolist_free (infolist); } /* get the completions created by the script */ infolist = weechat_infolist_get ("hook", NULL, "completion"); if (infolist) { while (weechat_infolist_next (infolist)) { callback_pointer = weechat_infolist_pointer (infolist, "callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), _("completion %%(%s)"), weechat_infolist_string (infolist, "completion_item")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } } weechat_infolist_free (infolist); } /* get the infos created by the script */ infolist = weechat_infolist_get ("hook", NULL, "info"); if (infolist) { while (weechat_infolist_next (infolist)) { callback_pointer = weechat_infolist_pointer (infolist, "callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), "info \"%s\"", weechat_infolist_string (infolist, "info_name")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } } weechat_infolist_free (infolist); } /* get the infos (hashtable) created by the script */ infolist = weechat_infolist_get ("hook", NULL, "info_hashtable"); if (infolist) { while (weechat_infolist_next (infolist)) { callback_pointer = weechat_infolist_pointer (infolist, "callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), "info_hashtable \"%s\"", weechat_infolist_string (infolist, "info_name")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } } weechat_infolist_free (infolist); } /* get the infolists created by the script */ infolist = weechat_infolist_get ("hook", NULL, "infolist"); if (infolist) { while (weechat_infolist_next (infolist)) { callback_pointer = weechat_infolist_pointer (infolist, "callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), "infolist \"%s\"", weechat_infolist_string (infolist, "infolist_name")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } } weechat_infolist_free (infolist); } /* get the bar items created by the script */ hdata_bar_item = weechat_hdata_get ("bar_item"); ptr_bar_item = weechat_hdata_get_list (hdata_bar_item, "gui_bar_items"); while (ptr_bar_item) { callback_pointer = weechat_hdata_pointer (hdata_bar_item, ptr_bar_item, "build_callback_pointer"); if (callback_pointer == ptr_script) { snprintf (str_info, sizeof (str_info), _("bar item \"%s\""), weechat_hdata_string (hdata_bar_item, ptr_bar_item, "name")); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } ptr_bar_item = weechat_hdata_move (hdata_bar_item, ptr_bar_item, 1); } /* get the script options (in plugins.var) */ snprintf (str_option, sizeof (str_option), "plugins.var.%s.%s.*", script_language[script->language], weechat_hdata_string (hdata_script, ptr_script, "name")); infolist = weechat_infolist_get ("option", NULL, str_option); if (infolist) { if (weechat_infolist_next (infolist)) { snprintf (str_info, sizeof (str_info), _("options %s%s%s"), str_option, (config_files > 0) ? " " : "", (config_files > 0) ? _("(old options?)") : ""); weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL); } weechat_infolist_free (infolist); } return list; }
AspellSpeller * #endif /* USE_ENCHANT */ weechat_aspell_speller_new (const char *lang) { #ifdef USE_ENCHANT EnchantDict *new_speller; #else AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; #endif /* USE_ENCHANT */ struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } #ifdef USE_ENCHANT new_speller = enchant_broker_request_dict (broker, lang); if (!new_speller) { weechat_printf (NULL, _("%s%s: error: unable to create speller for lang \"%s\""), weechat_prefix ("error"), ASPELL_PLUGIN_NAME, lang); return NULL; } #else /* create a speller instance for the newly created cell */ config = new_aspell_config (); aspell_config_replace (config, "lang", lang); #endif /* USE_ENCHANT */ /* apply all options */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { #ifdef USE_ENCHANT /* TODO: set option with enchant */ #else aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); #endif /* USE_ENCHANT */ } weechat_infolist_free (infolist); } #ifndef USE_ENCHANT ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); #endif /* USE_ENCHANT */ weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); #ifndef USE_ENCHANT /* free configuration */ delete_aspell_config (config); #endif /* USE_ENCHANT */ return new_speller; }
int weechat_aspell_command_cb (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { char *dicts; const char *default_dict; struct t_infolist *infolist; int number; /* make C compiler happy */ (void) data; if (argc == 1) { /* display aspell status */ weechat_printf (NULL, ""); weechat_printf (NULL, "%s", (aspell_enabled) ? _("Aspell is enabled") : _("Aspell is disabled")); default_dict = weechat_config_string (weechat_aspell_config_check_default_dict); weechat_printf (NULL, _("Default dictionary: %s"), (default_dict && default_dict[0]) ? default_dict : _("(not set)")); number = 0; infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*"); if (infolist) { while (weechat_infolist_next (infolist)) { if (number == 0) weechat_printf (NULL, _("Specific dictionaries on buffers:")); number++; weechat_printf (NULL, " %s: %s", weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } return WEECHAT_RC_OK; } /* enable aspell */ if (weechat_strcasecmp (argv[1], "enable") == 0) { weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1); weechat_printf (NULL, _("Aspell enabled")); return WEECHAT_RC_OK; } /* disable aspell */ if (weechat_strcasecmp (argv[1], "disable") == 0) { weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1); weechat_printf (NULL, _("Aspell disabled")); return WEECHAT_RC_OK; } /* toggle aspell */ if (weechat_strcasecmp (argv[1], "toggle") == 0) { if (aspell_enabled) { weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1); weechat_printf (NULL, _("Aspell disabled")); } else { weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1); weechat_printf (NULL, _("Aspell enabled")); } return WEECHAT_RC_OK; } /* list of dictionaries */ if (weechat_strcasecmp (argv[1], "listdict") == 0) { weechat_aspell_speller_list_dicts (); return WEECHAT_RC_OK; } /* set dictionary for current buffer */ if (weechat_strcasecmp (argv[1], "setdict") == 0) { if (argc > 2) { dicts = weechat_string_replace (argv_eol[2], " ", ""); weechat_aspell_set_dict (buffer, (dicts) ? dicts : argv[2]); if (dicts) free (dicts); } return WEECHAT_RC_OK; } /* delete dictionary used on current buffer */ if (weechat_strcasecmp (argv[1], "deldict") == 0) { weechat_aspell_set_dict (buffer, NULL); return WEECHAT_RC_OK; } /* add word to personal dictionary */ if (weechat_strcasecmp (argv[1], "addword") == 0) { if (argc > 3) weechat_aspell_add_word (argv[2], argv_eol[3]); else { if (!weechat_aspell_spellers) { weechat_printf (NULL, _("%s%s: no dictionary on this buffer for " "adding word"), weechat_prefix ("error"), ASPELL_PLUGIN_NAME); } else if (weechat_aspell_spellers->next_speller) { weechat_printf (NULL, _("%s%s: many dictionaries are defined for " "this buffer, please specify dictionary"), weechat_prefix ("error"), ASPELL_PLUGIN_NAME); } else weechat_aspell_add_word (weechat_aspell_spellers->lang, argv_eol[2]); } return WEECHAT_RC_OK; } return WEECHAT_RC_ERROR; }