void script_buffer_set_keys () { char *keys[][2] = { { "meta-A", "toggleautoload" }, { "meta-l", "load" }, { "meta-u", "unload" }, { "meta-L", "reload" }, { "meta-i", "install" }, { "meta-r", "remove" }, { "meta-h", "hold" }, { "meta-v", "show" }, { "meta-d", "showdiff" }, { NULL, NULL } }; char str_key[64], str_command[64]; int i; weechat_buffer_set (script_buffer, "key_bind_meta2-A", "/script up"); weechat_buffer_set (script_buffer, "key_bind_meta2-B", "/script down"); for (i = 0; keys[i][0]; i++) { if (weechat_config_boolean (script_config_look_use_keys)) { snprintf (str_key, sizeof (str_key), "key_bind_%s", keys[i][0]); snprintf (str_command, sizeof (str_command), "/script %s", keys[i][1]); weechat_buffer_set (script_buffer, str_key, str_command); } else { snprintf (str_key, sizeof (str_key), "key_unbind_%s", keys[i][0]); weechat_buffer_set (script_buffer, str_key, ""); } } }
void script_buffer_refresh (int clear) { struct t_script_repo *ptr_script; int line; char str_title[1024]; if (!script_buffer) return; if (clear) { weechat_buffer_clear (script_buffer); script_buffer_selected_line = (script_repo_count_displayed > 0) ? 0 : -1; } if (script_buffer_detail_script) { snprintf (str_title, sizeof (str_title), "%s", _("Alt+key/input: v=back to list d=jump to diff")); } else { snprintf (str_title, sizeof (str_title), _("%d/%d scripts (filter: %s) | Sort: %s | " "Alt+key/input: i=install, r=remove, l=load, L=reload, " "u=unload, A=autoload, h=(un)hold, v=view script | " "Input: q=close, $=refresh, s:x,y=sort, words=filter, " "*=reset filter | Mouse: left=select, right=install/remove"), script_repo_count_displayed, script_repo_count, (script_repo_filter) ? script_repo_filter : "*", weechat_config_string (script_config_look_sort)); } weechat_buffer_set (script_buffer, "title", str_title); if (script_buffer_detail_script) { /* detail on a script */ script_buffer_display_detail_script (script_buffer_detail_script); } else { /* list of scripts */ line = 0; for (ptr_script = scripts_repo; ptr_script; ptr_script = ptr_script->next_script) { if (ptr_script->displayed) { script_buffer_display_line_script (line, ptr_script); line++; } } } }
void irc_raw_open (int switch_to_buffer) { struct t_irc_raw_message *ptr_raw_message; if (!irc_raw_buffer) { irc_raw_buffer = weechat_buffer_search (IRC_PLUGIN_NAME, IRC_RAW_BUFFER_NAME); if (!irc_raw_buffer) { irc_raw_buffer = weechat_buffer_new (IRC_RAW_BUFFER_NAME, NULL, NULL, &irc_buffer_close_cb, NULL); /* failed to create buffer ? then return */ if (!irc_raw_buffer) return; weechat_buffer_set (irc_raw_buffer, "title", _("IRC raw messages")); weechat_buffer_set (irc_raw_buffer, "short_name", IRC_RAW_BUFFER_NAME); weechat_buffer_set (irc_raw_buffer, "localvar_set_type", "debug"); weechat_buffer_set (irc_raw_buffer, "localvar_set_server", IRC_RAW_BUFFER_NAME); weechat_buffer_set (irc_raw_buffer, "localvar_set_channel", IRC_RAW_BUFFER_NAME); weechat_buffer_set (irc_raw_buffer, "localvar_set_no_log", "1"); /* disable all highlights on this debug buffer */ weechat_buffer_set (irc_raw_buffer, "highlight_words", "-"); if (switch_to_buffer) weechat_buffer_set (irc_raw_buffer, "display", "1"); /* print messages in list */ for (ptr_raw_message = irc_raw_messages; ptr_raw_message; ptr_raw_message = ptr_raw_message->next_message) { irc_raw_message_print (ptr_raw_message); } } } else { if (switch_to_buffer) weechat_buffer_set (irc_raw_buffer, "display", "1"); } }
struct t_gui_buffer * exec_buffer_new (const char *name, int free_content, int clear_buffer, int switch_to_buffer) { struct t_gui_buffer *new_buffer; int buffer_type; new_buffer = weechat_buffer_search (EXEC_PLUGIN_NAME, name); if (new_buffer) { buffer_type = weechat_buffer_get_integer (new_buffer, "type"); if (((buffer_type == 0) && free_content) || ((buffer_type == 1) && !free_content)) { /* change the type of buffer */ weechat_buffer_set (new_buffer, "type", (free_content) ? "free" : "formatted"); } goto end; } new_buffer = weechat_buffer_new (name, &exec_buffer_input_cb, NULL, NULL, &exec_buffer_close_cb, NULL, NULL); /* failed to create buffer ? then return */ if (!new_buffer) return NULL; if (free_content) weechat_buffer_set (new_buffer, "type", "free"); weechat_buffer_set (new_buffer, "clear", "1"); weechat_buffer_set (new_buffer, "title", _("Executed commands")); weechat_buffer_set (new_buffer, "localvar_set_type", "exec"); weechat_buffer_set (new_buffer, "localvar_set_no_log", "1"); weechat_buffer_set (new_buffer, "time_for_each_line", "0"); weechat_buffer_set (new_buffer, "input_get_unknown_commands", "0"); end: if (clear_buffer) weechat_buffer_clear (new_buffer); if (switch_to_buffer) weechat_buffer_set (new_buffer, "display", "1"); return new_buffer; }
void relay_buffer_open () { if (!relay_buffer) { relay_buffer = weechat_buffer_new (RELAY_BUFFER_NAME, &relay_buffer_input_cb, NULL, NULL, &relay_buffer_close_cb, NULL, NULL); /* failed to create buffer ? then exit */ if (!relay_buffer) return; weechat_buffer_set (relay_buffer, "type", "free"); weechat_buffer_set (relay_buffer, "title", _("List of clients for relay")); weechat_buffer_set (relay_buffer, "key_bind_meta2-A", "/relay up"); weechat_buffer_set (relay_buffer, "key_bind_meta2-B", "/relay down"); weechat_buffer_set (relay_buffer, "localvar_set_type", "relay"); } }
void xfer_buffer_open () { if (!xfer_buffer) { xfer_buffer = weechat_buffer_new (XFER_BUFFER_NAME, &xfer_buffer_input_cb, NULL, NULL, &xfer_buffer_close_cb, NULL, NULL); /* failed to create buffer ? then exit */ if (!xfer_buffer) return; weechat_buffer_set (xfer_buffer, "type", "free"); weechat_buffer_set (xfer_buffer, "title", _("Xfer list")); weechat_buffer_set (xfer_buffer, "key_bind_meta2-A", "/xfer up"); weechat_buffer_set (xfer_buffer, "key_bind_meta2-B", "/xfer down"); weechat_buffer_set (xfer_buffer, "localvar_set_type", "xfer"); } }
/** * Enable or disable logging for a WeeChat buffer. */ int twc_set_buffer_logging(struct t_gui_buffer *buffer, bool logging) { if (!buffer) return WEECHAT_RC_ERROR; char const *signal; if (logging) { weechat_buffer_set(buffer, "localvar_del_no_log", ""); signal = "logger_start"; } else { weechat_buffer_set(buffer, "localvar_set_no_log", "1"); signal = "logger_stop"; } return weechat_hook_signal_send(signal, WEECHAT_HOOK_SIGNAL_POINTER, buffer); }
struct t_gui_buffer * exec_buffer_new (const char *name, int switch_to_buffer) { struct t_gui_buffer *new_buffer; new_buffer = weechat_buffer_search (EXEC_PLUGIN_NAME, name); if (new_buffer) goto end; new_buffer = weechat_buffer_new (name, &exec_buffer_input_cb, NULL, &exec_buffer_close_cb, NULL); /* failed to create buffer ? then return */ if (!new_buffer) return NULL; weechat_buffer_set (new_buffer, "title", _("Executed commands")); weechat_buffer_set (new_buffer, "localvar_set_type", "exec"); weechat_buffer_set (new_buffer, "localvar_set_no_log", "1"); weechat_buffer_set (new_buffer, "time_for_each_line", "0"); weechat_buffer_set (new_buffer, "input_get_unknown_commands", "0"); end: if (switch_to_buffer) weechat_buffer_set (new_buffer, "display", "1"); return new_buffer; }
void script_buffer_open () { if (!script_buffer) { script_buffer = weechat_buffer_new (SCRIPT_BUFFER_NAME, &script_buffer_input_cb, NULL, &script_buffer_close_cb, NULL); /* failed to create buffer ? then exit */ if (!script_buffer) return; weechat_buffer_set (script_buffer, "type", "free"); weechat_buffer_set (script_buffer, "title", _("Scripts")); script_buffer_set_keys (); weechat_buffer_set (script_buffer, "localvar_set_type", "script"); script_buffer_selected_line = 0; script_buffer_detail_script = NULL; } }
void silc_channel_message(SilcClient client, SilcClientConnection conn, SilcClientEntry sender, SilcChannelEntry channel, SilcMessagePayload payload, SilcChannelPrivateKey key, SilcMessageFlags flags, const unsigned char *message, SilcUInt32 message_len) { struct t_gui_buffer *channel_buffer = channel->context; if (channel_buffer == NULL) { weechat_log_printf("BUG: received message on channel we don't know about! channel: %s, server: %s, message: %s, sender: %s", channel->channel_name, channel->server, message, sender->nickname); } else { weechat_printf(channel_buffer, "%s\t%s", sender->nickname, message); weechat_buffer_set(channel_buffer, "hotlist", WEECHAT_HOTLIST_MESSAGE); weechat_log_printf("TODO - handle message flags: %d", flags); } }
void relay_raw_open (int switch_to_buffer) { struct t_relay_raw_message *ptr_raw_message; if (!relay_raw_buffer) { relay_raw_buffer = weechat_buffer_search (RELAY_PLUGIN_NAME, RELAY_RAW_BUFFER_NAME); if (!relay_raw_buffer) { relay_raw_buffer = weechat_buffer_new (RELAY_RAW_BUFFER_NAME, &relay_buffer_input_cb, NULL, &relay_buffer_close_cb, NULL); /* failed to create buffer ? then return */ if (!relay_raw_buffer) return; weechat_buffer_set (relay_raw_buffer, "title", _("Relay raw messages")); if (!weechat_buffer_get_integer (relay_raw_buffer, "short_name_is_set")) { weechat_buffer_set (relay_raw_buffer, "short_name", RELAY_RAW_BUFFER_NAME); } weechat_buffer_set (relay_raw_buffer, "localvar_set_type", "debug"); weechat_buffer_set (relay_raw_buffer, "localvar_set_server", RELAY_RAW_BUFFER_NAME); weechat_buffer_set (relay_raw_buffer, "localvar_set_channel", RELAY_RAW_BUFFER_NAME); weechat_buffer_set (relay_raw_buffer, "localvar_set_no_log", "1"); /* disable all highlights on this buffer */ weechat_buffer_set (relay_raw_buffer, "highlight_words", "-"); /* print messages in list */ for (ptr_raw_message = relay_raw_messages; ptr_raw_message; ptr_raw_message = ptr_raw_message->next_message) { relay_raw_message_print (ptr_raw_message); } } } if (relay_raw_buffer && switch_to_buffer) weechat_buffer_set (relay_raw_buffer, "display", "1"); }
int relay_command_relay (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { /* make C compiler happy */ (void) data; (void) buffer; (void) argv_eol; if ((argc > 1) && (weechat_strcasecmp (argv[1], "list") == 0)) { relay_command_client_list (0); return WEECHAT_RC_OK; } if ((argc > 1) && (weechat_strcasecmp (argv[1], "listfull") == 0)) { relay_command_client_list (1); return WEECHAT_RC_OK; } if (!relay_buffer) relay_buffer_open (); if (relay_buffer) { weechat_buffer_set (relay_buffer, "display", "1"); if (argc > 1) { if (strcmp (argv[1], "up") == 0) { if (relay_buffer_selected_line > 0) relay_buffer_selected_line--; } else if (strcmp (argv[1], "down") == 0) { if (relay_buffer_selected_line < relay_client_count - 1) relay_buffer_selected_line++; } } } relay_buffer_refresh (NULL); return WEECHAT_RC_OK; }
void silc_private_message(SilcClient client, SilcClientConnection conn, SilcClientEntry sender, SilcMessagePayload payload, SilcMessageFlags flags, const unsigned char *message, SilcUInt32 message_len) { struct SilcClientContext *clientCtx; struct t_gui_buffer *query_buffer = sender->context; if (query_buffer == NULL) { clientCtx = malloc(sizeof(struct SilcClientContext)); query_buffer = weechat_buffer_new(sender->nickname, &silc_plugin_query_input, clientCtx, NULL, NULL); clientCtx->query_buffer = query_buffer; clientCtx->client_entry = sender; clientCtx->connection = conn; sender->context = query_buffer; } weechat_printf(query_buffer, "%s\t%s", sender->nickname, message); weechat_buffer_set(query_buffer, "hotlist", WEECHAT_HOTLIST_HIGHLIGHT); }
void xfer_chat_open_buffer (struct t_xfer *xfer) { char *name; int length, buffer_created; buffer_created = 0; length = strlen (xfer->plugin_name) + 8 + strlen (xfer->plugin_id) + 1 + strlen (xfer->remote_nick) + 1; name = malloc (length); if (name) { snprintf (name, length, "%s_dcc.%s.%s", xfer->plugin_name, xfer->plugin_id, xfer->remote_nick); xfer->buffer = weechat_buffer_search (XFER_PLUGIN_NAME, name); if (!xfer->buffer) { xfer->buffer = weechat_buffer_new (name, &xfer_chat_buffer_input_cb, NULL, &xfer_chat_buffer_close_cb, NULL); buffer_created = 1; /* failed to create buffer ? then return */ if (!xfer->buffer) return; } if (buffer_created) { weechat_buffer_set (xfer->buffer, "title", _("xfer chat")); if (!weechat_buffer_get_integer (xfer->buffer, "short_name_is_set")) { weechat_buffer_set (xfer->buffer, "short_name", xfer->remote_nick); } weechat_buffer_set (xfer->buffer, "localvar_set_type", "private"); weechat_buffer_set (xfer->buffer, "localvar_set_nick", xfer->local_nick); weechat_buffer_set (xfer->buffer, "localvar_set_channel", xfer->remote_nick); weechat_buffer_set (xfer->buffer, "highlight_words_add", "$nick"); } weechat_printf (xfer->buffer, _("%s%s: connected to %s (%s) via xfer chat"), weechat_prefix ("network"), XFER_PLUGIN_NAME, xfer->remote_nick, xfer->remote_address_str); free (name); } }
void silc_command_reply(SilcClient client, SilcClientConnection conn, SilcCommand command, SilcStatus status, SilcStatus error, va_list ap) { // "infrastructure" struct t_gui_buffer *channelbuffer, *serverbuffer; SilcConnectionContext ctx = conn->context; //SilcPluginChannelList channel; struct SilcChannelContext *chanCtx; // possible args char *str, *topic, *cipher, *hmac; SilcChannelEntry channel_entry; SilcUInt32 mode, userlimit; SilcHashTableList *userlist; SilcPublicKey key; SilcDList pubkeys; size_t strsize; // needed for the nicklist SilcClientEntry user_client; SilcChannelUser user; struct t_gui_nick *nick = NULL; switch (command) { case SILC_COMMAND_JOIN: str = va_arg(ap, char *); channel_entry = va_arg(ap, SilcChannelEntry); mode = va_arg(ap, SilcUInt32); userlist = va_arg(ap, SilcHashTableList *); topic = va_arg(ap, char *); cipher = va_arg(ap, char *); hmac = va_arg(ap, char *); key = va_arg(ap, SilcPublicKey); pubkeys = va_arg(ap, SilcDList); userlimit = va_arg(ap, SilcUInt32); chanCtx = malloc(sizeof(struct SilcChannelContext)); chanCtx->channel_name = str; chanCtx->channel_entry = channel_entry; chanCtx->connection = conn; strsize = strlen(channel_entry->channel_name) + strlen(channel_entry->server) + 1; str = malloc(strsize+1); snprintf(str, strsize, "%s.%s", channel_entry->channel_name, channel_entry->server); // create a regular chat buffer and set some senible values channelbuffer = weechat_buffer_new(str, &silc_plugin_channel_input, chanCtx, NULL, NULL); weechat_buffer_set(channelbuffer, "name", str); weechat_buffer_set(channelbuffer, "short_name", channel_entry->channel_name); weechat_buffer_set(channelbuffer, "title", topic); weechat_buffer_set(channelbuffer, "hotlist", WEECHAT_HOTLIST_LOW); weechat_buffer_set(channelbuffer, "nicklist", "1"); chanCtx->channel_buffer = channelbuffer; channel_entry->context = channelbuffer; serverbuffer = ctx->server_buffer; add_channel(channel_entry->channel_name, find_server_for_buffer(serverbuffer), channel_entry, NULL, channelbuffer); // fill the nicklist with users currently on the channel while (silc_hash_table_get(userlist, (void **)&user_client, (void **)&user)) { nick = silc_nicklist_add(user); } break; default: weechat_log_printf("unhandled command reply for %d", command); break; } }
void xfer_buffer_refresh (const char *hotlist) { struct t_xfer *ptr_xfer, *xfer_selected; char str_color[256], suffix[32], status[64], date[128], eta[128]; char str_ip[128], str_hash[128]; char *progress_bar, *str_pos, *str_total, *str_bytes_per_sec; int i, length, line, progress_bar_size, num_bars; unsigned long long pos, pct_complete; struct tm *date_tmp; if (xfer_buffer) { weechat_buffer_clear (xfer_buffer); line = 0; xfer_selected = xfer_search_by_number (xfer_buffer_selected_line); weechat_printf_y (xfer_buffer, 0, "%s%s%s%s%s%s%s%s", weechat_color ("green"), _("Actions (letter+enter):"), weechat_color ("lightgreen"), /* accept */ (xfer_selected && XFER_IS_RECV(xfer_selected->type) && (xfer_selected->status == XFER_STATUS_WAITING)) ? _(" [A] Accept") : "", /* cancel */ (xfer_selected && !XFER_HAS_ENDED(xfer_selected->status)) ? _(" [C] Cancel") : "", /* remove */ (xfer_selected && XFER_HAS_ENDED(xfer_selected->status)) ? _(" [R] Remove") : "", /* purge old */ _(" [P] Purge finished"), /* quit */ _(" [Q] Close this buffer")); for (ptr_xfer = xfer_list; ptr_xfer; ptr_xfer = ptr_xfer->next_xfer) { suffix[0] = '\0'; if (ptr_xfer->filename_suffix >= 0) { snprintf (suffix, sizeof (suffix), " (.%d)", ptr_xfer->filename_suffix); } snprintf (str_color, sizeof (str_color), "%s,%s", (line == xfer_buffer_selected_line) ? weechat_config_string (xfer_config_color_text_selected) : weechat_config_string (xfer_config_color_text), weechat_config_string (xfer_config_color_text_bg)); str_ip[0] = '\0'; if (ptr_xfer->remote_address_str) { snprintf (str_ip, sizeof (str_ip), " (%s)", ptr_xfer->remote_address_str); } str_hash[0] = '\0'; if (ptr_xfer->hash_target && ptr_xfer->hash_handle && (ptr_xfer->hash_status != XFER_HASH_STATUS_UNKNOWN) && ((ptr_xfer->status == XFER_STATUS_ACTIVE) || (ptr_xfer->status == XFER_STATUS_DONE) || (ptr_xfer->status == XFER_STATUS_HASHING))) { snprintf (str_hash, sizeof (str_hash), " (%s)", _(xfer_hash_status_string[ptr_xfer->hash_status])); } /* display first line with remote nick, filename and plugin name/id */ weechat_printf_y (xfer_buffer, (line * 2) + 2, "%s%s%-24s %s%s%s%s (%s.%s)%s%s", weechat_color (str_color), (line == xfer_buffer_selected_line) ? "*** " : " ", ptr_xfer->remote_nick, (XFER_IS_FILE(ptr_xfer->type)) ? "\"" : "", (XFER_IS_FILE(ptr_xfer->type)) ? ptr_xfer->filename : _("xfer chat"), (XFER_IS_FILE(ptr_xfer->type)) ? "\"" : "", suffix, ptr_xfer->plugin_name, ptr_xfer->plugin_id, str_ip, str_hash); snprintf (status, sizeof (status), "%s", _(xfer_status_string[ptr_xfer->status])); length = weechat_utf8_strlen_screen (status); if (length < 20) { for (i = 0; i < 20 - length; i++) { strcat (status, " "); } } if (XFER_IS_CHAT(ptr_xfer->type)) { /* display second line for chat with status and date */ date[0] = '\0'; date_tmp = localtime (&(ptr_xfer->start_time)); if (date_tmp) { if (strftime (date, sizeof (date), "%a, %d %b %Y %H:%M:%S", date_tmp) == 0) date[0] = '\0'; } weechat_printf_y (xfer_buffer, (line * 2) + 3, "%s%s%s %s%s%s%s%s", weechat_color (str_color), (line == xfer_buffer_selected_line) ? "*** " : " ", (XFER_IS_SEND(ptr_xfer->type)) ? "<<--" : "-->>", weechat_color (weechat_config_string (xfer_config_color_status[ptr_xfer->status])), status, weechat_color ("reset"), weechat_color (str_color), date); } else { /* build progress bar */ pos = (ptr_xfer->pos <= ptr_xfer->size) ? ptr_xfer->pos : ptr_xfer->size; progress_bar = NULL; progress_bar_size = weechat_config_integer (xfer_config_look_progress_bar_size); if (progress_bar_size > 0) { progress_bar = malloc (1 + progress_bar_size + 1 + 1 + 1); strcpy (progress_bar, "["); if (ptr_xfer->size == 0) { if (ptr_xfer->status == XFER_STATUS_DONE) num_bars = progress_bar_size; else num_bars = 0; } else num_bars = (int)(((float)(pos)/(float)(ptr_xfer->size)) * (float)progress_bar_size); for (i = 0; i < num_bars - 1; i++) { strcat (progress_bar, "="); } if (num_bars > 0) strcat (progress_bar, ">"); for (i = 0; i < progress_bar_size - num_bars; i++) { strcat (progress_bar, " "); } strcat (progress_bar, "] "); } /* computes percentage */ if (ptr_xfer->size == 0) { if (ptr_xfer->status == XFER_STATUS_DONE) pct_complete = 100; else pct_complete = 0; } else pct_complete = (unsigned long long)(((float)(pos)/(float)(ptr_xfer->size)) * 100); /* position, total and bytes per second */ str_pos = weechat_string_format_size (pos); str_total = weechat_string_format_size (ptr_xfer->size); str_bytes_per_sec = weechat_string_format_size (ptr_xfer->bytes_per_sec); /* ETA */ eta[0] = '\0'; if (ptr_xfer->status == XFER_STATUS_ACTIVE) { snprintf (eta, sizeof (eta), "%s: %.2llu:%.2llu:%.2llu - ", _("ETA"), ptr_xfer->eta / 3600, (ptr_xfer->eta / 60) % 60, ptr_xfer->eta % 60); } /* display second line for file with status, progress bar and estimated time */ weechat_printf_y (xfer_buffer, (line * 2) + 3, "%s%s%s %s%s%s%s%3llu%% %s / %s (%s%s/s)", weechat_color (str_color), (line == xfer_buffer_selected_line) ? "*** " : " ", (XFER_IS_SEND(ptr_xfer->type)) ? "<<--" : "-->>", weechat_color (weechat_config_string (xfer_config_color_status[ptr_xfer->status])), status, weechat_color (str_color), (progress_bar) ? progress_bar : "", pct_complete, (str_pos) ? str_pos : "?", (str_total) ? str_total : "?", eta, str_bytes_per_sec); if (progress_bar) free (progress_bar); if (str_pos) free (str_pos); if (str_total) free (str_total); if (str_bytes_per_sec) free (str_bytes_per_sec); } line++; } weechat_buffer_set (xfer_buffer, "hotlist", hotlist); } }
int trigger_command_trigger (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { struct t_trigger *ptr_trigger, *ptr_trigger2; struct t_trigger_regex *regex; char *value, **sargv, **items, input[1024], str_pos[16]; int rc, i, type, count, index_option, enable, sargc, num_items, add_rc; int regex_count, regex_rc; /* make C compiler happy */ (void) data; rc = WEECHAT_RC_OK; sargv = NULL; /* list all triggers */ if ((argc == 1) || ((argc == 2) && (weechat_strcasecmp (argv[1], "list") == 0))) { trigger_command_list (_("List of triggers:"), 0); goto end; } /* full list of all triggers */ if ((argc == 2) && (weechat_strcasecmp (argv[1], "listfull") == 0)) { trigger_command_list (_("List of triggers:"), 1); goto end; } /* list of default triggers */ if ((argc == 2) && (weechat_strcasecmp (argv[1], "listdefault") == 0)) { trigger_command_list_default (1); goto end; } /* add a trigger */ if ((weechat_strcasecmp (argv[1], "add") == 0) || (weechat_strcasecmp (argv[1], "addoff") == 0) || (weechat_strcasecmp (argv[1], "addreplace") == 0)) { sargv = weechat_string_split_shell (argv_eol[2], &sargc); if (!sargv || (sargc < 2)) goto error; if (!trigger_name_valid (sargv[0])) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: invalid name for trigger"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); goto end; } type = trigger_search_hook_type (sargv[1]); if (type < 0) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: invalid hook type \"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, sargv[1]); goto end; } if ((sargc > 4) && sargv[4][0]) { regex_count = 0; regex = NULL; regex_rc = trigger_regex_split (sargv[4], ®ex_count, ®ex); trigger_regex_free (®ex_count, ®ex); switch (regex_rc) { case 0: /* OK */ break; case -1: /* format error */ weechat_printf (NULL, _("%s%s: invalid format for regular " "expression"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); goto end; break; case -2: /* regex compilation error */ weechat_printf (NULL, _("%s%s: invalid regular expression " "(compilation failed)"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); goto end; break; case -3: /* memory error */ weechat_printf (NULL, _("%s%s: not enough memory"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); goto end; break; } } if ((sargc > 6) && sargv[6][0] && (trigger_search_return_code (sargv[6]) < 0)) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: invalid return code \"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, sargv[6]); goto end; } ptr_trigger = trigger_search (sargv[0]); if (ptr_trigger) { if (weechat_strcasecmp (argv[1], "addreplace") == 0) { if (ptr_trigger) trigger_free (ptr_trigger); } else { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" already exists " "(choose another name or use option " "\"addreplace\" to overwrite it)"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, sargv[0]); goto end; } } ptr_trigger = trigger_alloc (sargv[0]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: failed to create trigger \"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, sargv[0]); goto end; } ptr_trigger = trigger_new ( sargv[0], /* name */ (weechat_strcasecmp (argv[1], "addoff") == 0) ? "off" : "on", sargv[1], /* hook */ (sargc > 2) ? sargv[2] : "", /* arguments */ (sargc > 3) ? sargv[3] : "", /* conditions */ (sargc > 4) ? sargv[4] : "", /* regex */ (sargc > 5) ? sargv[5] : "", /* command */ (sargc > 6) ? sargv[6] : ""); /* return code */ if (ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("Trigger \"%s\" created"), sargv[0]); } else { weechat_printf_tags (NULL, "no_trigger", _("%s%s: failed to create trigger \"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, sargv[0]); } goto end; } /* add trigger command in input (to help trigger creation) */ if (weechat_strcasecmp (argv[1], "addinput") == 0) { type = TRIGGER_HOOK_SIGNAL; if (argc >= 3) { type = trigger_search_hook_type (argv[2]); if (type < 0) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: invalid hook type \"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } } items = weechat_string_split (trigger_hook_default_rc[type], ",", 0, 0, &num_items); snprintf (input, sizeof (input), "/trigger add name %s \"%s\" \"%s\" \"%s\" \"%s\"%s%s%s", trigger_hook_type_string[type], trigger_hook_default_arguments[type], TRIGGER_HOOK_DEFAULT_CONDITIONS, TRIGGER_HOOK_DEFAULT_REGEX, TRIGGER_HOOK_DEFAULT_COMMAND, (items && (num_items > 0)) ? " \"" : "", (items && (num_items > 0)) ? items[0] : "", (items && (num_items > 0)) ? "\"" : ""); weechat_buffer_set (buffer, "input", input); weechat_buffer_set (buffer, "input_pos", "13"); goto end; } /* * get command to create a trigger, and according to option: * - input: put the command in input * - output: send the command to the buffer * - recreate: same as input, but the trigger is first deleted */ if ((weechat_strcasecmp (argv[1], "input") == 0) || (weechat_strcasecmp (argv[1], "output") == 0) || (weechat_strcasecmp (argv[1], "recreate") == 0)) { if (argc < 3) goto error; ptr_trigger = trigger_search (argv[2]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" not found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } add_rc = trigger_hook_default_rc[weechat_config_integer (ptr_trigger->options[TRIGGER_OPTION_HOOK])][0]; snprintf (input, sizeof (input), "//trigger %s %s %s \"%s\" \"%s\" \"%s\" \"%s\"%s%s%s", (weechat_strcasecmp (argv[1], "recreate") == 0) ? "addreplace" : "add", ptr_trigger->name, weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_HOOK]), weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_ARGUMENTS]), weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_CONDITIONS]), weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_REGEX]), weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_COMMAND]), (add_rc) ? " \"" : "", (add_rc) ? weechat_config_string (ptr_trigger->options[TRIGGER_OPTION_RETURN_CODE]) : "", (add_rc) ? "\"" : ""); if (weechat_strcasecmp (argv[1], "output") == 0) { weechat_command (buffer, input); } else { weechat_buffer_set (buffer, "input", input + 1); snprintf (str_pos, sizeof (str_pos), "%d", weechat_utf8_strlen (input + 1)); weechat_buffer_set (buffer, "input_pos", str_pos); } goto end; } /* set option in a trigger */ if (weechat_strcasecmp (argv[1], "set") == 0) { if (argc < 5) goto error; ptr_trigger = trigger_search (argv[2]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" not found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } if (weechat_strcasecmp (argv[3], "name") == 0) { trigger_command_rename (ptr_trigger, argv[4]); goto end; } value = weechat_string_remove_quotes (argv_eol[4], "'\""); if (value) { index_option = trigger_search_option (argv[3]); if (index_option >= 0) { weechat_config_option_set (ptr_trigger->options[index_option], value, 1); weechat_printf_tags (NULL, "no_trigger", _("Trigger \"%s\" updated"), ptr_trigger->name); } else { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger option \"%s\" not " "found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[3]); } free (value); } goto end; } /* rename a trigger */ if (weechat_strcasecmp (argv[1], "rename") == 0) { if (argc < 4) goto error; ptr_trigger = trigger_search (argv[2]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" not found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } trigger_command_rename (ptr_trigger, argv[3]); goto end; } /* copy a trigger */ if (weechat_strcasecmp (argv[1], "copy") == 0) { if (argc < 4) goto error; ptr_trigger = trigger_search (argv[2]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" not found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } /* check that new name is valid */ if (!trigger_name_valid (argv[3])) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: invalid name for trigger"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); goto end; } /* check that no trigger already exists with the new name */ if (trigger_search (argv[3])) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" already " "exists"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[3]); goto end; } /* copy the trigger */ ptr_trigger2 = trigger_copy (ptr_trigger, argv[3]); if (ptr_trigger2) { weechat_printf_tags (NULL, "no_trigger", _("Trigger \"%s\" copied to \"%s\""), ptr_trigger->name, ptr_trigger2->name); } else { weechat_printf_tags (NULL, "no_trigger", _("%s%s: failed to copy trigger " "\"%s\""), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, ptr_trigger->name); } goto end; } /* enable/disable/toggle/restart trigger(s) */ if ((weechat_strcasecmp (argv[1], "enable") == 0) || (weechat_strcasecmp (argv[1], "disable") == 0) || (weechat_strcasecmp (argv[1], "toggle") == 0) || (weechat_strcasecmp (argv[1], "restart") == 0)) { if (argc < 3) { if (weechat_strcasecmp (argv[1], "restart") == 0) goto error; if (weechat_strcasecmp (argv[1], "enable") == 0) weechat_config_option_set (trigger_config_look_enabled, "1", 1); else if (weechat_strcasecmp (argv[1], "disable") == 0) weechat_config_option_set (trigger_config_look_enabled, "0", 1); else if (weechat_strcasecmp (argv[1], "toggle") == 0) { weechat_config_option_set (trigger_config_look_enabled, (trigger_enabled) ? "0" : "1", 1); } trigger_command_display_status (); goto end; } enable = -1; if (weechat_strcasecmp (argv[1], "enable") == 0) enable = 1; else if (weechat_strcasecmp (argv[1], "disable") == 0) enable = 0; else if (weechat_strcasecmp (argv[1], "restart") == 0) enable = 2; if (weechat_strcasecmp (argv[2], "-all") == 0) { for (ptr_trigger = triggers; ptr_trigger; ptr_trigger = ptr_trigger->next_trigger) { trigger_command_set_enabled (ptr_trigger, enable, 0); } } else { for (i = 2; i < argc; i++) { ptr_trigger = trigger_search (argv[i]); if (ptr_trigger) trigger_command_set_enabled (ptr_trigger, enable, 1); else { weechat_printf_tags (NULL, "no_trigger", _("%sTrigger \"%s\" not found"), weechat_prefix ("error"), argv[i]); } } } goto end; } /* delete trigger(s) */ if (weechat_strcasecmp (argv[1], "del") == 0) { if (argc < 3) goto error; if (weechat_strcasecmp (argv[2], "-all") == 0) { count = triggers_count; trigger_free_all (); if (count > 0) weechat_printf_tags (NULL, "no_trigger", _("%d triggers removed"), count); } else { for (i = 2; i < argc; i++) { ptr_trigger = trigger_search (argv[i]); if (ptr_trigger) { trigger_free (ptr_trigger); weechat_printf_tags (NULL, "no_trigger", _("Trigger \"%s\" removed"), argv[i]); } else { weechat_printf_tags (NULL, "no_trigger", _("%sTrigger \"%s\" not found"), weechat_prefix ("error"), argv[i]); } } } goto end; } /* show detailed info on a trigger */ if (weechat_strcasecmp (argv[1], "show") == 0) { if (argc < 3) goto error; ptr_trigger = trigger_search (argv[2]); if (!ptr_trigger) { weechat_printf_tags (NULL, "no_trigger", _("%s%s: trigger \"%s\" not found"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME, argv[2]); goto end; } weechat_printf_tags (NULL, "no_trigger", ""); weechat_printf_tags (NULL, "no_trigger", _("Trigger:")); trigger_command_display_trigger (ptr_trigger, 2); goto end; } /* restore default triggers */ if (weechat_strcasecmp (argv[1], "default") == 0) { if ((argc >= 3) && (weechat_strcasecmp (argv[2], "-yes") == 0)) { trigger_free_all (); trigger_create_default (); trigger_command_list (_("Default triggers restored:"), 0); } else { weechat_printf (NULL, _("%s%s: \"-yes\" argument is required for " "restoring default triggers (security reason)"), weechat_prefix ("error"), TRIGGER_PLUGIN_NAME); } goto end; } /* open the trigger monitor buffer */ if (weechat_strcasecmp (argv[1], "monitor") == 0) { trigger_buffer_open ((argc > 2) ? argv_eol[2] : NULL, 1); goto end; } error: rc = WEECHAT_RC_ERROR; end: if (sargv) weechat_string_free_split (sargv); return rc; }
char * weechat_aspell_modifier_cb (void *data, const char *modifier, const char *modifier_data, const char *string) { long unsigned int value; struct t_gui_buffer *buffer; struct t_aspell_speller_buffer *ptr_speller_buffer; char *result, *ptr_string, *pos_space, *ptr_end, *ptr_end_valid, save_end; char *word_for_suggestions, *old_suggestions, *suggestions; char *word_and_suggestions; const char *color_normal, *color_error, *ptr_suggestions; int utf8_char_int, char_size; int length, index_result, length_word, word_ok; int length_color_normal, length_color_error, rc; int input_pos, current_pos, word_start_pos, word_end_pos, word_end_pos_valid; /* make C compiler happy */ (void) data; (void) modifier; if (!aspell_enabled) return NULL; if (!string) return NULL; rc = sscanf (modifier_data, "%lx", &value); if ((rc == EOF) || (rc == 0)) return NULL; buffer = (struct t_gui_buffer *)value; /* check text during search only if option is enabled */ if (weechat_buffer_get_integer (buffer, "text_search") && !weechat_config_boolean (weechat_aspell_config_check_during_search)) return NULL; /* get structure with speller info for buffer */ ptr_speller_buffer = weechat_hashtable_get (weechat_aspell_speller_buffer, buffer); if (!ptr_speller_buffer) { ptr_speller_buffer = weechat_aspell_speller_buffer_new (buffer); if (!ptr_speller_buffer) return NULL; } if (!ptr_speller_buffer->spellers) return NULL; /* * for performance: return last string built if input string is the * same (and cursor position is the same, if suggestions are enabled) */ input_pos = weechat_buffer_get_integer (buffer, "input_pos"); if (ptr_speller_buffer->modifier_string && (strcmp (string, ptr_speller_buffer->modifier_string) == 0) && ((weechat_config_integer (weechat_aspell_config_check_suggestions) < 0) || (input_pos == ptr_speller_buffer->input_pos))) { return (ptr_speller_buffer->modifier_result) ? strdup (ptr_speller_buffer->modifier_result) : NULL; } /* free last modifier string and result */ if (ptr_speller_buffer->modifier_string) { free (ptr_speller_buffer->modifier_string); ptr_speller_buffer->modifier_string = NULL; } if (ptr_speller_buffer->modifier_result) { free (ptr_speller_buffer->modifier_result); ptr_speller_buffer->modifier_result = NULL; } word_for_suggestions = NULL; /* save last modifier string received */ ptr_speller_buffer->modifier_string = strdup (string); ptr_speller_buffer->input_pos = input_pos; color_normal = weechat_color ("bar_fg"); length_color_normal = strlen (color_normal); color_error = weechat_color (weechat_config_string (weechat_aspell_config_color_misspelled)); length_color_error = strlen (color_error); length = strlen (string); result = malloc (length + (length * length_color_error) + 1); if (result) { result[0] = '\0'; ptr_string = ptr_speller_buffer->modifier_string; index_result = 0; /* check if string is a command */ if (!weechat_string_input_for_buffer (ptr_string)) { char_size = weechat_utf8_char_size (ptr_string); ptr_string += char_size; pos_space = ptr_string; while (pos_space && pos_space[0] && (pos_space[0] != ' ')) { pos_space = weechat_utf8_next_char (pos_space); } if (!pos_space || !pos_space[0]) { free (result); return NULL; } pos_space[0] = '\0'; /* exit if command is not authorized for spell checking */ if (!weechat_aspell_command_authorized (ptr_string)) { free (result); return NULL; } memcpy (result + index_result, ptr_speller_buffer->modifier_string, char_size); index_result += char_size; strcpy (result + index_result, ptr_string); index_result += strlen (ptr_string); pos_space[0] = ' '; ptr_string = pos_space; } current_pos = 0; while (ptr_string[0]) { /* find start of word: it must start with an alphanumeric char */ utf8_char_int = weechat_utf8_char_int (ptr_string); while ((!iswalnum (utf8_char_int)) || iswspace (utf8_char_int)) { char_size = weechat_utf8_char_size (ptr_string); memcpy (result + index_result, ptr_string, char_size); index_result += char_size; ptr_string += char_size; current_pos++; if (!ptr_string[0]) break; utf8_char_int = weechat_utf8_char_int (ptr_string); } if (!ptr_string[0]) break; word_start_pos = current_pos; word_end_pos = current_pos; word_end_pos_valid = current_pos; /* find end of word: ' and - allowed in word, but not at the end */ ptr_end_valid = ptr_string; ptr_end = weechat_utf8_next_char (ptr_string); utf8_char_int = weechat_utf8_char_int (ptr_end); while (iswalnum (utf8_char_int) || (utf8_char_int == '\'') || (utf8_char_int == '-')) { word_end_pos++; if (iswalnum (utf8_char_int)) { /* pointer to last alphanumeric char in the word */ ptr_end_valid = ptr_end; word_end_pos_valid = word_end_pos; } ptr_end = weechat_utf8_next_char (ptr_end); if (!ptr_end[0]) break; utf8_char_int = weechat_utf8_char_int (ptr_end); } ptr_end = weechat_utf8_next_char (ptr_end_valid); word_end_pos = word_end_pos_valid; word_ok = 0; if (weechat_aspell_string_is_url (ptr_string)) { /* * word is an URL, then it is OK, and search for next space * (will be end of word) */ word_ok = 1; if (ptr_end[0]) { utf8_char_int = weechat_utf8_char_int (ptr_end); while (!iswspace (utf8_char_int)) { ptr_end = weechat_utf8_next_char (ptr_end); if (!ptr_end[0]) break; utf8_char_int = weechat_utf8_char_int (ptr_end); } } } save_end = ptr_end[0]; ptr_end[0] = '\0'; length_word = ptr_end - ptr_string; if (!word_ok) { if ((save_end != '\0') || (weechat_config_integer (weechat_aspell_config_check_real_time))) { word_ok = weechat_aspell_check_word (buffer, ptr_speller_buffer, ptr_string); if (!word_ok && (input_pos >= word_start_pos)) { /* * if word is misspelled and that cursor is after * the beginning of this word, save the word (we will * look for suggestions after this loop) */ if (word_for_suggestions) free (word_for_suggestions); word_for_suggestions = strdup (ptr_string); } } else word_ok = 1; } /* add error color */ if (!word_ok) { strcpy (result + index_result, color_error); index_result += length_color_error; } /* add word */ strcpy (result + index_result, ptr_string); index_result += length_word; /* add normal color (after misspelled word) */ if (!word_ok) { strcpy (result + index_result, color_normal); index_result += length_color_normal; } if (save_end == '\0') break; ptr_end[0] = save_end; ptr_string = ptr_end; current_pos = word_end_pos + 1; } result[index_result] = '\0'; } /* save old suggestions in buffer */ ptr_suggestions = weechat_buffer_get_string (buffer, "localvar_aspell_suggest"); old_suggestions = (ptr_suggestions) ? strdup (ptr_suggestions) : NULL; /* if there is a misspelled word, get suggestions and set them in buffer */ if (word_for_suggestions) { suggestions = weechat_aspell_get_suggestions (ptr_speller_buffer, word_for_suggestions); if (suggestions) { length = strlen (word_for_suggestions) + 1 /* ":" */ + strlen (suggestions) + 1; word_and_suggestions = malloc (length); if (word_and_suggestions) { snprintf (word_and_suggestions, length, "%s:%s", word_for_suggestions, suggestions); weechat_buffer_set (buffer, "localvar_set_aspell_suggest", word_and_suggestions); free (word_and_suggestions); } else { weechat_buffer_set (buffer, "localvar_del_aspell_suggest", ""); } free (suggestions); } else { weechat_buffer_set (buffer, "localvar_del_aspell_suggest", ""); } free (word_for_suggestions); } else { weechat_buffer_set (buffer, "localvar_del_aspell_suggest", ""); } /* * if suggestions have changed, update the bar item * and send signal "aspell_suggest" */ ptr_suggestions = weechat_buffer_get_string (buffer, "localvar_aspell_suggest"); if ((old_suggestions && !ptr_suggestions) || (!old_suggestions && ptr_suggestions) || (old_suggestions && ptr_suggestions && (strcmp (old_suggestions, ptr_suggestions) != 0))) { weechat_bar_item_update ("aspell_suggest"); weechat_hook_signal_send ("aspell_suggest", WEECHAT_HOOK_SIGNAL_POINTER, buffer); } if (old_suggestions) free (old_suggestions); if (!result) return NULL; ptr_speller_buffer->modifier_result = strdup (result); return result; }
void logger_backlog (struct t_gui_buffer *buffer, const char *filename, int lines) { const char *charset; struct t_logger_line *last_lines, *ptr_lines; char *pos_message, *pos_tab, *error, *message; time_t datetime, time_now; struct tm tm_line; int num_lines; charset = weechat_info_get ("charset_terminal", ""); weechat_buffer_set (buffer, "print_hooks_enabled", "0"); num_lines = 0; last_lines = logger_tail_file (filename, lines); ptr_lines = last_lines; while (ptr_lines) { datetime = 0; pos_message = strchr (ptr_lines->data, '\t'); if (pos_message) { /* initialize structure, because strptime does not do it */ memset (&tm_line, 0, sizeof (struct tm)); /* * we get current time to initialize daylight saving time in * structure tm_line, otherwise printed time will be shifted * and will not use DST used on machine */ time_now = time (NULL); localtime_r (&time_now, &tm_line); pos_message[0] = '\0'; error = strptime (ptr_lines->data, weechat_config_string (logger_config_file_time_format), &tm_line); if (error && !error[0] && (tm_line.tm_year > 0)) datetime = mktime (&tm_line); pos_message[0] = '\t'; } pos_message = (pos_message && (datetime != 0)) ? pos_message + 1 : ptr_lines->data; message = (charset) ? weechat_iconv_to_internal (charset, pos_message) : strdup (pos_message); if (message) { pos_tab = strchr (message, '\t'); if (pos_tab) pos_tab[0] = '\0'; weechat_printf_date_tags (buffer, datetime, "no_highlight,notify_none,logger_backlog", "%s%s%s%s%s", weechat_color (weechat_config_string (logger_config_color_backlog_line)), message, (pos_tab) ? "\t" : "", (pos_tab) ? weechat_color (weechat_config_string (logger_config_color_backlog_line)) : "", (pos_tab) ? pos_tab + 1 : ""); if (pos_tab) pos_tab[0] = '\t'; free (message); } num_lines++; ptr_lines = ptr_lines->next_line; } if (last_lines) logger_tail_free (last_lines); if (num_lines > 0) { weechat_printf_date_tags (buffer, datetime, "no_highlight,notify_none,logger_backlog_end", _("%s===\t%s========== End of backlog (%d lines) =========="), weechat_color (weechat_config_string (logger_config_color_backlog_end)), weechat_color (weechat_config_string (logger_config_color_backlog_end)), num_lines); weechat_buffer_set (buffer, "unread", ""); } weechat_buffer_set (buffer, "print_hooks_enabled", "1"); }
int exec_command_run (struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol, int start_arg) { char str_buffer[512]; struct t_exec_cmd *new_exec_cmd; struct t_exec_cmd_options cmd_options; struct t_hashtable *process_options; struct t_infolist *ptr_infolist; struct t_gui_buffer *ptr_new_buffer; /* parse command options */ cmd_options.command_index = -1; cmd_options.use_shell = 0; cmd_options.detached = 0; cmd_options.pipe_stdin = 0; cmd_options.timeout = 0; cmd_options.ptr_buffer_name = NULL; cmd_options.ptr_buffer = buffer; cmd_options.output_to_buffer = 0; cmd_options.new_buffer = 0; cmd_options.new_buffer_clear = 0; cmd_options.switch_to_buffer = 1; cmd_options.line_numbers = -1; cmd_options.flush = 1; cmd_options.color = EXEC_COLOR_AUTO; cmd_options.display_rc = 1; cmd_options.ptr_command_name = NULL; cmd_options.pipe_command = NULL; cmd_options.hsignal = NULL; /* parse default options */ if (!exec_command_parse_options (&cmd_options, exec_config_cmd_num_options, exec_config_cmd_options, 0, 0)) { weechat_printf (NULL, _("%s%s: invalid options in option " "exec.command.default_options"), weechat_prefix ("error"), EXEC_PLUGIN_NAME); return WEECHAT_RC_ERROR; } if (!exec_command_parse_options (&cmd_options, argc, argv, start_arg, 1)) return WEECHAT_RC_ERROR; /* options "-bg" and "-o"/"-n" are incompatible */ if (cmd_options.detached && (cmd_options.output_to_buffer || cmd_options.new_buffer)) return WEECHAT_RC_ERROR; /* options "-pipe" and "-bg"/"-o"/"-n" are incompatible */ if (cmd_options.pipe_command && (cmd_options.detached || cmd_options.output_to_buffer || cmd_options.new_buffer)) return WEECHAT_RC_ERROR; /* command not found? */ if (cmd_options.command_index < 0) return WEECHAT_RC_ERROR; new_exec_cmd = exec_add (); if (!new_exec_cmd) return WEECHAT_RC_ERROR; /* create hashtable for weechat_hook_process_hashtable() */ process_options = weechat_hashtable_new (32, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING, NULL, NULL); if (!process_options) { exec_free (new_exec_cmd); return WEECHAT_RC_ERROR; } /* automatically disable shell if we are downloading an URL */ if (strncmp (argv_eol[cmd_options.command_index], "url:", 4) == 0) cmd_options.use_shell = 0; if (cmd_options.use_shell) { /* command will be: sh -c "command arguments..." */ weechat_hashtable_set (process_options, "arg1", "-c"); weechat_hashtable_set (process_options, "arg2", argv_eol[cmd_options.command_index]); } if (cmd_options.pipe_stdin) weechat_hashtable_set (process_options, "stdin", "1"); if (cmd_options.detached) weechat_hashtable_set (process_options, "detached", "1"); if (cmd_options.flush) weechat_hashtable_set (process_options, "buffer_flush", "1"); /* set variables in new command (before running the command) */ new_exec_cmd->name = (cmd_options.ptr_command_name) ? strdup (cmd_options.ptr_command_name) : NULL; new_exec_cmd->command = strdup (argv_eol[cmd_options.command_index]); new_exec_cmd->detached = cmd_options.detached; if (!cmd_options.detached && !cmd_options.pipe_command && !cmd_options.hsignal) { if (cmd_options.ptr_buffer_name && !cmd_options.ptr_buffer) { /* output in a new buffer using given name */ new_exec_cmd->output_to_buffer = 0; snprintf (str_buffer, sizeof (str_buffer), "exec.%s", cmd_options.ptr_buffer_name); ptr_new_buffer = exec_buffer_new (str_buffer, (cmd_options.new_buffer == 2), cmd_options.new_buffer_clear, cmd_options.switch_to_buffer); if (ptr_new_buffer) { new_exec_cmd->buffer_full_name = strdup (weechat_buffer_get_string (ptr_new_buffer, "full_name")); } } else if (cmd_options.new_buffer) { /* output in a new buffer using automatic name */ if (new_exec_cmd->name) { snprintf (str_buffer, sizeof (str_buffer), "exec.%s", new_exec_cmd->name); } else { snprintf (str_buffer, sizeof (str_buffer), "exec.%d", new_exec_cmd->number); } ptr_new_buffer = exec_buffer_new (str_buffer, (cmd_options.new_buffer == 2), cmd_options.new_buffer_clear, cmd_options.switch_to_buffer); if (ptr_new_buffer) { new_exec_cmd->buffer_full_name = strdup (weechat_buffer_get_string (ptr_new_buffer, "full_name")); } } else if (cmd_options.ptr_buffer) { new_exec_cmd->buffer_full_name = strdup (weechat_buffer_get_string (cmd_options.ptr_buffer, "full_name")); if (cmd_options.switch_to_buffer) weechat_buffer_set (cmd_options.ptr_buffer, "display", "1"); } if (cmd_options.ptr_buffer && (strcmp (weechat_buffer_get_string (cmd_options.ptr_buffer, "plugin"), EXEC_PLUGIN_NAME) == 0)) { cmd_options.output_to_buffer = 0; cmd_options.new_buffer = 1; } } new_exec_cmd->output_to_buffer = cmd_options.output_to_buffer; new_exec_cmd->line_numbers = (cmd_options.line_numbers < 0) ? cmd_options.new_buffer : cmd_options.line_numbers; new_exec_cmd->color = cmd_options.color; new_exec_cmd->display_rc = cmd_options.display_rc; new_exec_cmd->pipe_command = cmd_options.pipe_command; new_exec_cmd->hsignal = cmd_options.hsignal; /* execute the command */ if (weechat_exec_plugin->debug >= 1) { weechat_printf (NULL, "%s: executing command: \"%s%s%s\"", EXEC_PLUGIN_NAME, (cmd_options.use_shell) ? "" : "sh -c '", argv_eol[cmd_options.command_index], (cmd_options.use_shell) ? "" : "'"); } new_exec_cmd->hook = weechat_hook_process_hashtable ( (cmd_options.use_shell) ? "sh" : argv_eol[cmd_options.command_index], process_options, cmd_options.timeout * 1000, &exec_process_cb, new_exec_cmd); if (new_exec_cmd->hook) { /* get PID of command */ ptr_infolist = weechat_infolist_get ("hook", new_exec_cmd->hook, NULL); if (ptr_infolist) { if (weechat_infolist_next (ptr_infolist)) { new_exec_cmd->pid = weechat_infolist_integer (ptr_infolist, "child_pid"); } weechat_infolist_free (ptr_infolist); } } else { exec_free (new_exec_cmd); weechat_printf (NULL, _("%s%s: failed to run command \"%s\""), weechat_prefix ("error"), EXEC_PLUGIN_NAME, argv_eol[cmd_options.command_index]); } weechat_hashtable_free (process_options); return WEECHAT_RC_OK; }
int relay_command_relay (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { struct t_relay_server *ptr_server; struct t_config_option *ptr_option; int port; /* make C compiler happy */ (void) data; (void) buffer; if (argc > 1) { if (weechat_strcasecmp (argv[1], "list") == 0) { relay_command_client_list (0); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "listfull") == 0) { relay_command_client_list (1); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "listrelay") == 0) { relay_command_server_list (); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "add") == 0) { if (argc >= 4) { if (relay_config_create_option_port (NULL, relay_config_file, relay_config_section_port, argv[2], argv_eol[3]) != WEECHAT_CONFIG_OPTION_SET_ERROR) { weechat_printf (NULL, _("%s: relay \"%s\" (port %s) added"), RELAY_PLUGIN_NAME, argv[2], argv_eol[3]); } } else { weechat_printf (NULL, _("%s%s: missing arguments for \"%s\" " "command"), weechat_prefix ("error"), RELAY_PLUGIN_NAME, "relay add"); } return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "del") == 0) { if (argc >= 3) { ptr_server = relay_server_search (argv_eol[2]); if (ptr_server) { port = ptr_server->port; relay_server_free (ptr_server); ptr_option = weechat_config_search_option (relay_config_file, relay_config_section_port, argv_eol[2]); if (ptr_option) weechat_config_option_free (ptr_option); weechat_printf (NULL, _("%s: relay \"%s\" (port %d) removed"), RELAY_PLUGIN_NAME, argv[2], port); } else { weechat_printf (NULL, _("%s%s: relay \"%s\" not found"), weechat_prefix ("error"), RELAY_PLUGIN_NAME, argv_eol[2]); } } else { weechat_printf (NULL, _("%s%s: missing arguments for \"%s\" " "command"), weechat_prefix ("error"), RELAY_PLUGIN_NAME, "relay del"); } return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "raw") == 0) { relay_raw_open (1); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "sslcertkey") == 0) { relay_network_set_ssl_cert_key (1); return WEECHAT_RC_OK; } } if (!relay_buffer) relay_buffer_open (); if (relay_buffer) { weechat_buffer_set (relay_buffer, "display", "1"); if (argc > 1) { if (strcmp (argv[1], "up") == 0) { if (relay_buffer_selected_line > 0) relay_buffer_selected_line--; } else if (strcmp (argv[1], "down") == 0) { if (relay_buffer_selected_line < relay_client_count - 1) relay_buffer_selected_line++; } } } relay_buffer_refresh (NULL); return WEECHAT_RC_OK; }
void relay_buffer_refresh (const char *hotlist) { struct t_relay_client *ptr_client, *client_selected; char str_color[256], str_status[64], str_date_start[128], str_date_end[128]; char *str_recv, *str_sent; int i, length, line; struct tm *date_tmp; if (relay_buffer) { weechat_buffer_clear (relay_buffer); line = 0; client_selected = relay_client_search_by_number (relay_buffer_selected_line); weechat_printf_y (relay_buffer, 0, "%s%s%s%s%s%s%s", weechat_color("green"), _("Actions (letter+enter):"), weechat_color("lightgreen"), /* disconnect */ (client_selected && !RELAY_CLIENT_HAS_ENDED(client_selected)) ? _(" [D] Disconnect") : "", /* remove */ (client_selected && RELAY_CLIENT_HAS_ENDED(client_selected)) ? _(" [R] Remove") : "", /* purge old */ _(" [P] Purge finished"), /* quit */ _(" [Q] Close this buffer")); for (ptr_client = relay_clients; ptr_client; ptr_client = ptr_client->next_client) { snprintf (str_color, sizeof (str_color), "%s,%s", (line == relay_buffer_selected_line) ? weechat_config_string (relay_config_color_text_selected) : weechat_config_string (relay_config_color_text), weechat_config_string (relay_config_color_text_bg)); snprintf (str_status, sizeof (str_status), "%s", _(relay_client_status_string[ptr_client->status])); length = weechat_utf8_strlen_screen (str_status); if (length < 20) { for (i = 0; i < 20 - length; i++) { strcat (str_status, " "); } } str_date_start[0] = '\0'; date_tmp = localtime (&(ptr_client->start_time)); if (date_tmp) { strftime (str_date_start, sizeof (str_date_start), "%a, %d %b %Y %H:%M:%S", date_tmp); } str_date_end[0] = '-'; str_date_end[1] = '\0'; if (ptr_client->end_time > 0) { date_tmp = localtime (&(ptr_client->end_time)); if (date_tmp) { strftime (str_date_end, sizeof (str_date_end), "%a, %d %b %Y %H:%M:%S", date_tmp); } } str_recv = weechat_string_format_size (ptr_client->bytes_recv); str_sent = weechat_string_format_size (ptr_client->bytes_sent); /* first line with status, description and bytes recv/sent */ weechat_printf_y (relay_buffer, (line * 2) + 2, _("%s%s[%s%s%s%s] %s, received: %s, sent: %s"), weechat_color(str_color), (line == relay_buffer_selected_line) ? "*** " : " ", weechat_color(weechat_config_string (relay_config_color_status[ptr_client->status])), str_status, weechat_color ("reset"), weechat_color (str_color), ptr_client->desc, (str_recv) ? str_recv : "?", (str_sent) ? str_sent : "?"); /* second line with start/end time */ weechat_printf_y (relay_buffer, (line * 2) + 3, _("%s%-26s started on: %s, ended on: %s"), weechat_color(str_color), " ", str_date_start, str_date_end); if (str_recv) free (str_recv); if (str_sent) free (str_sent); line++; } if (hotlist) weechat_buffer_set (relay_buffer, "hotlist", hotlist); } }
int script_command_script (void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) { char *error; long value; int line; /* make C compiler happy */ (void) data; if (argc == 1) { script_action_schedule ("buffer", 1, 0); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "go") == 0) { if ((argc > 2) && script_buffer && !script_buffer_detail_script) { error = NULL; value = strtol (argv[2], &error, 10); if (error && !error[0]) { script_buffer_set_current_line (value); } } return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "search") == 0) { if (scripts_repo) script_repo_filter_scripts ((argc > 2) ? argv_eol[2] : NULL); else script_repo_set_filter ((argc > 2) ? argv_eol[2] : NULL); script_action_schedule ("buffer", 1, 0); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "list") == 0) { script_action_schedule (argv_eol[1], 1, 0); return WEECHAT_RC_OK; } if ((weechat_strcasecmp (argv[1], "load") == 0) || (weechat_strcasecmp (argv[1], "unload") == 0) || (weechat_strcasecmp (argv[1], "reload") == 0)) { script_command_action (buffer, argv[1], (argc > 2) ? argv_eol[2] : NULL, 0); return WEECHAT_RC_OK; } if ((weechat_strcasecmp (argv[1], "install") == 0) || (weechat_strcasecmp (argv[1], "remove") == 0) || (weechat_strcasecmp (argv[1], "installremove") == 0) || (weechat_strcasecmp (argv[1], "hold") == 0) || (weechat_strcasecmp (argv[1], "show") == 0) || (weechat_strcasecmp (argv[1], "showdiff") == 0)) { script_command_action (buffer, argv[1], (argc > 2) ? argv_eol[2] : NULL, 1); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "upgrade") == 0) { script_action_schedule ("upgrade", 1, 0); return WEECHAT_RC_OK; } if (weechat_strcasecmp (argv[1], "update") == 0) { script_repo_file_update (0); return WEECHAT_RC_OK; } if (!script_buffer) script_buffer_open (); if (script_buffer) { weechat_buffer_set (script_buffer, "display", "1"); if (argc > 1) { if (!script_buffer_detail_script && (script_buffer_selected_line >= 0) && (script_repo_count_displayed > 0)) { if (strcmp (argv[1], "up") == 0) { value = 1; if (argc > 2) { error = NULL; value = strtol (argv[2], &error, 10); if (!error || error[0]) value = 1; } line = script_buffer_selected_line - value; if (line < 0) line = 0; if (line != script_buffer_selected_line) { script_buffer_set_current_line (line); script_buffer_check_line_outside_window (); } return WEECHAT_RC_OK; } else if (strcmp (argv[1], "down") == 0) { value = 1; if (argc > 2) { error = NULL; value = strtol (argv[2], &error, 10); if (!error || error[0]) value = 1; } line = script_buffer_selected_line + value; if (line >= script_repo_count_displayed) line = script_repo_count_displayed - 1; if (line != script_buffer_selected_line) { script_buffer_set_current_line (line); script_buffer_check_line_outside_window (); } return WEECHAT_RC_OK; } } } } script_buffer_refresh (0); return WEECHAT_RC_OK; }