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