int
irc_input_data (struct t_gui_buffer *buffer, const char *input_data, int flags)
{
const char *ptr_data;
char *data_with_colors, *msg;
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (buffer == irc_raw_buffer)
{
if (weechat_strcasecmp (input_data, "q") == 0)
weechat_buffer_close (buffer);
}
else
{
/*
* if send unknown commands is enabled and that input data is a
* command, then send this command to IRC server
*/
if (weechat_config_boolean (irc_config_network_send_unknown_commands)
&& !weechat_string_input_for_buffer (input_data))
{
if (ptr_server)
{
irc_server_sendf (ptr_server, flags, NULL,
"%s", weechat_utf8_next_char (input_data));
}
return WEECHAT_RC_OK;
}
if (ptr_channel)
{
ptr_data = weechat_string_input_for_buffer (input_data);
if (!ptr_data)
ptr_data = input_data;
data_with_colors = irc_color_encode (
ptr_data,
weechat_config_boolean (irc_config_network_colors_send));
msg = strdup ((data_with_colors) ? data_with_colors : ptr_data);
if (msg)
{
irc_input_send_user_message (buffer, flags, NULL, msg);
free (msg);
}
if (data_with_colors)
free (data_with_colors);
}
else
{
weechat_printf (buffer,
_("%s%s: this buffer is not a channel!"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
}
}
return WEECHAT_RC_OK;
}
int
irc_input_data_cb (void *data, struct t_gui_buffer *buffer,
const char *input_data)
{
const char *ptr_data;
char *data_with_colors, *msg;
/* make C compiler happy */
(void) data;
IRC_GET_SERVER_CHANNEL(buffer);
/* if send unknown commands is enabled and that input data is a command,
then send this command to IRC server */
if (weechat_config_boolean (irc_config_network_send_unknown_commands)
&& (input_data[0] == '/') && (input_data[1] != '/'))
{
if (ptr_server)
irc_server_sendf (ptr_server, 1, input_data + 1);
return WEECHAT_RC_OK;
}
if (ptr_channel)
{
ptr_data = ((input_data[0] == '/') && (input_data[1] == '/')) ?
input_data + 1 : input_data;
data_with_colors = irc_color_encode (ptr_data,
weechat_config_boolean (irc_config_network_colors_send));
msg = strdup ((data_with_colors) ? data_with_colors : ptr_data);
if (msg)
{
irc_input_send_user_message (buffer, msg);
free (msg);
}
if (data_with_colors)
free (data_with_colors);
}
else
{
weechat_printf (buffer,
_("%s%s: this buffer is not a channel!"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
}
return WEECHAT_RC_OK;
}
void
irc_input_user_message_display (struct t_gui_buffer *buffer, const char *text)
{
struct t_irc_nick *ptr_nick;
char *text_decoded;
text_decoded = irc_color_decode (text,
weechat_config_boolean (irc_config_network_colors_send));
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (ptr_channel)
{
ptr_nick = NULL;
if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL)
{
ptr_nick = irc_nick_search (ptr_server, ptr_channel,
ptr_server->nick);
}
weechat_printf_tags (buffer,
irc_protocol_tags ("privmsg",
"notify_none,no_highlight",
(ptr_nick) ? ptr_nick->name : ptr_server->nick),
"%s%s",
irc_nick_as_prefix (ptr_server,
(ptr_nick) ? ptr_nick : NULL,
(ptr_nick) ? NULL : ptr_server->nick,
IRC_COLOR_CHAT_NICK_SELF),
(text_decoded) ? text_decoded : text);
}
if (text_decoded)
free (text_decoded);
}
char *
irc_bar_item_buffer_title (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window,
struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
const char *title;
char *title_color;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!buffer)
return NULL;
title = weechat_buffer_get_string (buffer, "title");
if (!title)
return NULL;
title_color = irc_color_decode (title,
(weechat_config_boolean (irc_config_look_topic_strip_colors)) ?
0 : 1);
return (title_color) ? title_color : strdup (title);
}
void
logger_stop (struct t_logger_buffer *logger_buffer, int write_info_line)
{
time_t seconds;
struct tm *date_tmp;
char buf_time[256];
if (!logger_buffer)
return;
if (logger_buffer->log_enabled && logger_buffer->log_file)
{
if (write_info_line && weechat_config_boolean (logger_config_file_info_lines))
{
buf_time[0] = '\0';
seconds = time (NULL);
date_tmp = localtime (&seconds);
if (date_tmp)
{
strftime (buf_time, sizeof (buf_time) - 1,
weechat_config_string (logger_config_file_time_format),
date_tmp);
}
logger_write_line (logger_buffer,
_("%s\t**** End of log ****"),
buf_time);
}
fclose (logger_buffer->log_file);
logger_buffer->log_file = NULL;
}
logger_buffer_free (logger_buffer);
}
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
buflist_config_change_enabled (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
buflist_config_free_signals_refresh ();
if (weechat_config_boolean (buflist_config_look_enabled))
{
/* buflist enabled */
buflist_config_hook_signals_refresh ();
weechat_command (NULL, "/mute /bar show buflist");
buflist_bar_item_update (0);
}
else
{
/* buflist disabled */
weechat_command (NULL, "/mute /bar hide buflist");
buflist_bar_item_update (1);
}
}
void
irc_ctcp_display_request (struct t_irc_server *server,
const char *command,
struct t_irc_channel *channel,
const char *nick, const char *ctcp,
const char *arguments,
const char *reply)
{
/* CTCP blocked and user doesn't want to see message? then just return */
if (reply && !reply[0]
&& !weechat_config_boolean (irc_config_look_display_ctcp_blocked))
return;
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server, nick,
NULL, "ctcp",
(channel) ? channel->buffer : NULL),
irc_protocol_tags (command, "irc_ctcp", NULL),
_("%sCTCP requested by %s%s%s: %s%s%s%s%s%s"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_NICK,
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
ctcp,
IRC_COLOR_RESET,
(arguments) ? " " : "",
(arguments) ? arguments : "",
(reply && !reply[0]) ? _(" (blocked)") : "");
}
int
xfer_file_resume (struct t_xfer *xfer, const char *filename)
{
struct stat st;
if (!weechat_config_boolean (xfer_config_file_auto_resume))
return 0;
if (access (filename, W_OK) == 0)
{
if (stat (filename, &st) != -1)
{
if ((unsigned long long) st.st_size < xfer->size)
{
xfer->start_resume = (unsigned long long) st.st_size;
xfer->pos = xfer->start_resume;
xfer->last_check_pos = xfer->start_resume;
return 1;
}
}
}
/* not resumable */
return 0;
}
char *
irc_bar_item_buffer_modes (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window,
struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
char modes[128], *modes_without_args;
const char *pos_space, *pos_key;
int part_from_channel;
struct t_irc_server *server;
struct t_irc_channel *channel;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!buffer)
return NULL;
modes[0] = '\0';
irc_buffer_get_server_and_channel (buffer, &server, &channel);
if (!channel)
return NULL;
part_from_channel = ((channel->type == IRC_CHANNEL_TYPE_CHANNEL)
&& !channel->nicks);
if (!part_from_channel
&& channel->modes && channel->modes[0]
&& (strcmp (channel->modes, "+") != 0))
{
modes_without_args = NULL;
if (weechat_config_boolean (irc_config_look_item_channel_modes_hide_key))
{
pos_space = strchr(channel->modes, ' ');
if (pos_space)
{
pos_key = strchr(channel->modes, 'k');
if (pos_key && (pos_key < pos_space))
{
modes_without_args = weechat_strndup (channel->modes,
pos_space - channel->modes);
}
}
}
snprintf (modes, sizeof (modes),
"%s%s",
IRC_COLOR_ITEM_CHANNEL_MODES,
(modes_without_args) ? modes_without_args : channel->modes);
if (modes_without_args)
free (modes_without_args);
return strdup (modes);
}
return NULL;
}
void
trigger_command_set_enabled (struct t_trigger *trigger,
int enable, const char *enable_string,
int display_error)
{
if (trigger->hook_running)
{
trigger_command_error_running (trigger, enable_string);
return;
}
if (enable == 2)
{
if (weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]))
{
trigger_hook (trigger);
weechat_printf_date_tags (NULL, 0, "no_trigger",
_("Trigger \"%s\" restarted"),
trigger->name);
}
else if (display_error)
{
weechat_printf_date_tags (NULL, 0, "no_trigger",
_("%s%s: a disabled trigger can not be "
"restarted"),
weechat_prefix ("error"),
TRIGGER_PLUGIN_NAME);
}
}
else
{
if (enable < 0)
{
enable = weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]) ?
0 : 1;
}
weechat_config_option_set (trigger->options[TRIGGER_OPTION_ENABLED],
(enable) ? "on" : "off", 1);
weechat_printf_date_tags (NULL, 0, "no_trigger",
(enable) ?
_("Trigger \"%s\" enabled") :
_("Trigger \"%s\" disabled"),
trigger->name);
}
}
void
irc_ctcp_reply_to_nick (struct t_irc_server *server,
const char *command,
struct t_irc_channel *channel,
const char *nick, const char *ctcp,
const char *arguments)
{
struct t_hashtable *hashtable;
int number;
char hash_key[32];
const char *str_args;
hashtable = irc_server_sendf (server,
IRC_SERVER_SEND_OUTQ_PRIO_LOW | IRC_SERVER_SEND_RETURN_HASHTABLE,
NULL,
"NOTICE %s :\01%s%s%s\01",
nick, ctcp,
(arguments) ? " " : "",
(arguments) ? arguments : "");
if (hashtable)
{
if (weechat_config_boolean (irc_config_look_display_ctcp_reply))
{
number = 1;
while (1)
{
snprintf (hash_key, sizeof (hash_key), "args%d", number);
str_args = weechat_hashtable_get (hashtable, hash_key);
if (!str_args)
break;
weechat_printf_tags (irc_msgbuffer_get_target_buffer (server,
nick,
NULL,
"ctcp",
(channel) ? channel->buffer : NULL),
irc_protocol_tags (command,
"irc_ctcp,irc_ctcp_reply,"
"notify_none,no_highlight",
NULL),
_("%sCTCP reply to %s%s%s: %s%s%s%s%s"),
weechat_prefix ("network"),
irc_nick_color_for_message (server, NULL,
nick),
nick,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_CHANNEL,
ctcp,
(str_args[0]) ? IRC_COLOR_RESET : "",
(str_args[0]) ? " " : "",
str_args);
number++;
}
}
weechat_hashtable_free (hashtable);
}
}
void
trigger_config_change_enabled (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
trigger_enabled = weechat_config_boolean (option);
}
void
weechat_aspell_config_change_enabled (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
aspell_enabled = weechat_config_boolean (option);
/* refresh input and aspell suggestions */
weechat_bar_item_update ("input_text");
weechat_bar_item_update ("aspell_suggest");
}
void
fifo_config_change_file_enabled (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
fifo_remove ();
if (weechat_config_boolean (fifo_config_file_enabled))
fifo_create ();
}
int
weechat_perl_eval (struct t_gui_buffer *buffer, int send_to_buffer_as_input,
int exec_commands, const char *code)
{
void *func_argv[1], *result;
if (!perl_script_eval)
{
perl_quiet = 1;
perl_script_eval = weechat_perl_load (WEECHAT_SCRIPT_EVAL_NAME,
PERL_EVAL_SCRIPT);
perl_quiet = 0;
if (!perl_script_eval)
return 0;
}
weechat_perl_output_flush ();
perl_eval_mode = 1;
perl_eval_send_input = send_to_buffer_as_input;
perl_eval_exec_commands = exec_commands;
perl_eval_buffer = buffer;
func_argv[0] = (char *)code;
result = weechat_perl_exec (perl_script_eval,
WEECHAT_SCRIPT_EXEC_IGNORE,
"script_perl_eval",
"s", func_argv);
/* result is ignored */
if (result)
free (result);
weechat_perl_output_flush ();
perl_eval_mode = 0;
perl_eval_send_input = 0;
perl_eval_exec_commands = 0;
perl_eval_buffer = NULL;
if (!weechat_config_boolean (perl_config_look_eval_keep_context))
{
perl_quiet = 1;
weechat_perl_unload (perl_script_eval);
perl_quiet = 0;
perl_script_eval = NULL;
}
return 1;
}
char *
irc_bar_item_away (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window, struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
struct t_irc_server *server;
char *buf, *message;
int length;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!buffer)
return NULL;
buf = NULL;
irc_buffer_get_server_and_channel (buffer, &server, NULL);
if (server && server->is_away)
{
if (weechat_config_boolean (irc_config_look_item_away_message)
&& server->away_message && server->away_message[0])
{
message = strdup (server->away_message);
}
else
{
message = strdup (_("away"));
}
if (message)
{
length = strlen (message) + 64 + 1;
buf = malloc (length);
if (buf)
{
snprintf (buf, length, "%s%s",
IRC_COLOR_ITEM_AWAY,
message);
}
free (message);
}
}
return buf;
}
void
logger_start_buffer (struct t_gui_buffer *buffer, int write_info_line)
{
struct t_logger_buffer *ptr_logger_buffer;
int log_level, log_enabled;
if (!buffer)
return;
log_level = logger_get_level_for_buffer (buffer);
log_enabled = weechat_config_boolean (logger_config_file_auto_log)
&& (log_level > 0);
ptr_logger_buffer = logger_buffer_search_buffer (buffer);
/* logging is disabled for buffer */
if (!log_enabled)
{
/* stop logger if it is active */
if (ptr_logger_buffer)
logger_stop (ptr_logger_buffer, 1);
}
else
{
/* logging is enabled for buffer */
if (ptr_logger_buffer)
ptr_logger_buffer->log_level = log_level;
else
{
ptr_logger_buffer = logger_buffer_add (buffer, log_level);
if (ptr_logger_buffer)
{
if (ptr_logger_buffer->log_filename)
{
if (ptr_logger_buffer->log_file)
{
fclose (ptr_logger_buffer->log_file);
ptr_logger_buffer->log_file = NULL;
}
}
}
}
if (ptr_logger_buffer)
ptr_logger_buffer->write_start_info_line = write_info_line;
}
}
void
trigger_command_display_trigger (struct t_trigger *trigger, int verbose)
{
trigger_command_display_trigger_internal (
trigger->name,
weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]),
weechat_config_string (trigger->options[TRIGGER_OPTION_HOOK]),
weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),
weechat_config_string (trigger->options[TRIGGER_OPTION_CONDITIONS]),
trigger->hooks_count,
trigger->hook_count_cb,
trigger->hook_count_cmd,
trigger->regex_count,
trigger->regex,
trigger->commands_count,
trigger->commands,
weechat_config_integer (trigger->options[TRIGGER_OPTION_RETURN_CODE]),
verbose);
}
void
trigger_config_change_trigger_enabled (const void *pointer, void *data,
struct t_config_option *option)
{
struct t_trigger *ptr_trigger;
/* make C compiler happy */
(void) pointer;
(void) data;
ptr_trigger = trigger_search_with_option (option);
if (!ptr_trigger)
return;
if (weechat_config_boolean (option))
trigger_hook (ptr_trigger);
else
trigger_unhook (ptr_trigger);
}
struct t_trigger *
trigger_new_with_options (const char *name, struct t_config_option **options)
{
struct t_trigger *new_trigger;
int i;
new_trigger = trigger_alloc (name);
if (!new_trigger)
return NULL;
for (i = 0; i < TRIGGER_NUM_OPTIONS; i++)
{
new_trigger->options[i] = options[i];
}
trigger_add (new_trigger, &triggers, &last_trigger);
triggers_count++;
if (trigger_regex_split (weechat_config_string (new_trigger->options[TRIGGER_OPTION_REGEX]),
&new_trigger->regex_count,
&new_trigger->regex) < 0)
{
weechat_printf (NULL,
_("%s%s: invalid regular expression in trigger "
"\"%s\""),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
name);
}
trigger_split_command (weechat_config_string (new_trigger->options[TRIGGER_OPTION_COMMAND]),
&new_trigger->commands_count,
&new_trigger->commands);
if (weechat_config_boolean (new_trigger->options[TRIGGER_OPTION_ENABLED]))
trigger_hook (new_trigger);
return new_trigger;
}
void
irc_input_user_message_display (struct t_gui_buffer *buffer, int action,
const char *text)
{
struct t_irc_nick *ptr_nick;
char *pos, *text2, *text_decoded, str_tags[256], *str_color;
const char *ptr_text;
/* if message is an action, force "action" to 1 and extract message */
if (strncmp (text, "\01ACTION ", 8) == 0)
{
action = 1;
pos = strrchr (text + 8, '\01');
if (pos)
text2 = weechat_strndup (text + 8, pos - text - 8);
else
text2 = strdup (text + 8);
}
else
text2 = strdup (text);
text_decoded = irc_color_decode (
(text2) ? text2 : text,
weechat_config_boolean (irc_config_network_colors_send));
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (ptr_channel)
{
ptr_nick = NULL;
if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL)
{
ptr_nick = irc_nick_search (ptr_server, ptr_channel,
ptr_server->nick);
}
if (action)
{
snprintf (str_tags, sizeof (str_tags),
"irc_action,self_msg,notify_none,no_highlight");
}
else
{
str_color = irc_color_for_tags (
weechat_config_color (
weechat_config_get ("weechat.color.chat_nick_self")));
snprintf (str_tags, sizeof (str_tags),
"notify_none,self_msg,no_highlight,prefix_nick_%s",
(str_color) ? str_color : "default");
if (str_color)
free (str_color);
}
ptr_text = (text_decoded) ? text_decoded : ((text2) ? text2 : text);
if (action)
{
weechat_printf_date_tags (
buffer,
0,
irc_protocol_tags (
"privmsg", str_tags,
(ptr_nick) ? ptr_nick->name : ptr_server->nick,
NULL),
"%s%s%s%s%s %s",
weechat_prefix ("action"),
irc_nick_mode_for_display (ptr_server, ptr_nick, 0),
IRC_COLOR_CHAT_NICK_SELF,
ptr_server->nick,
IRC_COLOR_RESET,
ptr_text);
}
else
{
weechat_printf_date_tags (
buffer,
0,
irc_protocol_tags (
"privmsg", str_tags,
(ptr_nick) ? ptr_nick->name : ptr_server->nick,
NULL),
"%s%s",
irc_nick_as_prefix (
ptr_server,
(ptr_nick) ? ptr_nick : NULL,
(ptr_nick) ? NULL : ptr_server->nick,
IRC_COLOR_CHAT_NICK_SELF),
ptr_text);
}
}
if (text2)
free (text2);
if (text_decoded)
free (text_decoded);
}
void
trigger_hook (struct t_trigger *trigger)
{
char **argv, **argv_eol, *tags, *message, *error1, *error2, *error3;
int i, argc, strip_colors;
long interval, align_second, max_calls;
if (!weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]))
return;
trigger_unhook (trigger);
argv = weechat_string_split (weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),
";", 0, 0, &argc);
argv_eol = weechat_string_split (weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),
";", 1, 0, NULL);
switch (weechat_config_integer (trigger->options[TRIGGER_OPTION_HOOK]))
{
case TRIGGER_HOOK_SIGNAL:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_signal (
argv[i],
&trigger_callback_signal_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_HSIGNAL:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_hsignal (
argv[i],
&trigger_callback_hsignal_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_MODIFIER:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_modifier (
argv[i],
&trigger_callback_modifier_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_PRINT:
tags = NULL;
message = NULL;
strip_colors = 0;
if (argv && (argc >= 1))
{
if (strcmp (argv[0], "*") != 0)
trigger->hook_print_buffers = strdup (argv[0]);
if ((argc >= 2) && (strcmp (argv[1], "*") != 0))
tags = argv[1];
if ((argc >= 3) && (strcmp (argv[2], "*") != 0))
message = argv[2];
if (argc >= 4)
strip_colors = (strcmp (argv[3], "0") != 0) ? 1 : 0;
}
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_print (
NULL,
tags,
message,
strip_colors,
&trigger_callback_print_cb,
trigger, NULL);
}
break;
case TRIGGER_HOOK_COMMAND:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_command (
argv[0], /* command */
(argc > 1) ? argv[1] : "", /* description */
(argc > 2) ? argv[2] : "", /* arguments */
(argc > 3) ? argv[3] : "", /* description of args */
(argc > 4) ? argv[4] : "", /* completion */
&trigger_callback_command_cb,
trigger, NULL);
}
}
break;
case TRIGGER_HOOK_COMMAND_RUN:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_command_run (
argv[i],
&trigger_callback_command_run_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_TIMER:
if (argv && (argc >= 1))
{
error1 = NULL;
error2 = NULL;
error3 = NULL;
interval = strtol (argv[0], &error1, 10);
align_second = strtol ((argc >= 2) ? argv[1] : "0", &error2, 10);
max_calls = strtol ((argc >= 3) ? argv[2] : "0", &error3, 10);
if (error1 && !error1[0]
&& error2 && !error2[0]
&& error3 && !error3[0]
&& (interval > 0)
&& (align_second >= 0)
&& (max_calls >= 0))
{
trigger->hooks = malloc (sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = 1;
trigger->hooks[0] = weechat_hook_timer (
interval,
(int)align_second,
(int)max_calls,
&trigger_callback_timer_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_CONFIG:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_config (
argv[i],
&trigger_callback_config_cb,
trigger, NULL);
}
}
}
break;
case TRIGGER_HOOK_FOCUS:
if (argv && (argc >= 1))
{
trigger->hooks = malloc (argc * sizeof (trigger->hooks[0]));
if (trigger->hooks)
{
trigger->hooks_count = argc;
for (i = 0; i < argc; i++)
{
trigger->hooks[i] = weechat_hook_focus (
argv[i],
&trigger_callback_focus_cb,
trigger, NULL);
}
}
}
break;
}
if (!trigger->hooks)
{
weechat_printf (NULL,
_("%s%s: unable to create hook for trigger \"%s\" "
"(bad arguments)"),
weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,
trigger->name);
}
if (argv)
weechat_string_free_split (argv);
if (argv_eol)
weechat_string_free_split (argv_eol);
}
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_write_line (struct t_logger_buffer *logger_buffer,
const char *format, ...)
{
char *message, buf_time[256], buf_beginning[1024];
const char *charset;
time_t seconds;
struct tm *date_tmp;
int log_level;
charset = weechat_info_get ("charset_terminal", "");
if (!logger_buffer->log_file)
{
log_level = logger_get_level_for_buffer (logger_buffer->buffer);
if (log_level == 0)
{
logger_buffer_free (logger_buffer);
return;
}
if (!logger_create_directory ())
{
weechat_printf_tags (NULL,
"no_log",
_("%s%s: unable to create directory for logs "
"(\"%s\")"),
weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
weechat_config_string (logger_config_file_path));
logger_buffer_free (logger_buffer);
return;
}
if (!logger_buffer->log_filename)
logger_set_log_filename (logger_buffer);
if (!logger_buffer->log_filename)
{
logger_buffer_free (logger_buffer);
return;
}
logger_buffer->log_file =
fopen (logger_buffer->log_filename, "a");
if (!logger_buffer->log_file)
{
weechat_printf_tags (
NULL,
"no_log",
_("%s%s: unable to write log file \"%s\": %s"),
weechat_prefix ("error"), LOGGER_PLUGIN_NAME,
logger_buffer->log_filename, strerror (errno));
logger_buffer_free (logger_buffer);
return;
}
if (weechat_config_boolean (logger_config_file_info_lines)
&& logger_buffer->write_start_info_line)
{
buf_time[0] = '\0';
seconds = time (NULL);
date_tmp = localtime (&seconds);
if (date_tmp)
{
strftime (buf_time, sizeof (buf_time) - 1,
weechat_config_string (logger_config_file_time_format),
date_tmp);
}
snprintf (buf_beginning, sizeof (buf_beginning),
_("%s\t**** Beginning of log ****"),
buf_time);
message = (charset) ?
weechat_iconv_from_internal (charset, buf_beginning) : NULL;
fprintf (logger_buffer->log_file,
"%s\n", (message) ? message : buf_beginning);
if (message)
free (message);
logger_buffer->flush_needed = 1;
}
logger_buffer->write_start_info_line = 0;
}
weechat_va_format (format);
if (vbuffer)
{
message = (charset) ?
weechat_iconv_from_internal (charset, vbuffer) : NULL;
fprintf (logger_buffer->log_file,
"%s\n", (message) ? message : vbuffer);
if (message)
free (message);
logger_buffer->flush_needed = 1;
if (!logger_timer)
{
fflush (logger_buffer->log_file);
logger_buffer->flush_needed = 0;
}
free (vbuffer);
}
}
char *
logger_get_mask_expanded (struct t_gui_buffer *buffer, const char *mask)
{
char *mask2, *mask_decoded, *mask_decoded2, *mask_decoded3, *mask_decoded4;
char *mask_decoded5;
const char *dir_separator;
int length;
time_t seconds;
struct tm *date_tmp;
mask2 = NULL;
mask_decoded = NULL;
mask_decoded2 = NULL;
mask_decoded3 = NULL;
mask_decoded4 = NULL;
mask_decoded5 = NULL;
dir_separator = weechat_info_get ("dir_separator", "");
if (!dir_separator)
return NULL;
/*
* we first replace directory separator (commonly '/') by \01 because
* buffer mask can contain this char, and will be replaced by replacement
* char ('_' by default)
*/
mask2 = weechat_string_replace (mask, dir_separator, "\01");
if (!mask2)
goto end;
mask_decoded = weechat_buffer_string_replace_local_var (buffer, mask2);
if (!mask_decoded)
goto end;
mask_decoded2 = weechat_string_replace (mask_decoded,
dir_separator,
weechat_config_string (logger_config_file_replacement_char));
if (!mask_decoded2)
goto end;
#ifdef __CYGWIN__
mask_decoded3 = weechat_string_replace (mask_decoded2, "\\",
weechat_config_string (logger_config_file_replacement_char));
#else
mask_decoded3 = strdup (mask_decoded2);
#endif /* __CYGWIN__ */
if (!mask_decoded3)
goto end;
/* restore directory separator */
mask_decoded4 = weechat_string_replace (mask_decoded3,
"\01", dir_separator);
if (!mask_decoded4)
goto end;
/* replace date/time specifiers in mask */
length = strlen (mask_decoded4) + 256 + 1;
mask_decoded5 = malloc (length);
if (!mask_decoded5)
goto end;
seconds = time (NULL);
date_tmp = localtime (&seconds);
mask_decoded5[0] = '\0';
strftime (mask_decoded5, length - 1, mask_decoded4, date_tmp);
/* convert to lower case? */
if (weechat_config_boolean (logger_config_file_name_lower_case))
weechat_string_tolower (mask_decoded5);
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: buffer = \"%s\", mask = \"%s\", "
"decoded mask = \"%s\"",
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"),
mask, mask_decoded5);
}
end:
if (mask2)
free (mask2);
if (mask_decoded)
free (mask_decoded);
if (mask_decoded2)
free (mask_decoded2);
if (mask_decoded3)
free (mask_decoded3);
if (mask_decoded4)
free (mask_decoded4);
return mask_decoded5;
}
int
irc_mode_channel_set (struct t_irc_server *server,
struct t_irc_channel *channel,
const char *host,
const char *modes,
const char *modes_arguments)
{
const char *pos, *ptr_arg;
char set_flag, **argv, chanmode_type;
int argc, current_arg, update_channel_modes, channel_modes_updated;
int smart_filter, end_modes;
struct t_irc_nick *ptr_nick;
struct t_irc_modelist *ptr_modelist;
struct t_irc_modelist_item *ptr_item;
if (!server || !channel || !modes)
return 0;
channel_modes_updated = 0;
argc = 0;
argv = NULL;
if (modes_arguments)
{
argv = weechat_string_split (modes_arguments, " ",
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0, &argc);
}
current_arg = 0;
smart_filter = (weechat_config_boolean (irc_config_look_smart_filter)
&& weechat_config_string (irc_config_look_smart_filter_mode)
&& weechat_config_string (irc_config_look_smart_filter_mode)[0]) ? 1 : 0;
end_modes = 0;
set_flag = '+';
pos = modes;
while (pos[0])
{
switch (pos[0])
{
case ':':
break;
case ' ':
end_modes = 1;
break;
case '+':
set_flag = '+';
break;
case '-':
set_flag = '-';
break;
default:
update_channel_modes = 1;
chanmode_type = irc_mode_get_chanmode_type (server, pos[0]);
ptr_arg = NULL;
switch (chanmode_type)
{
case 'A': /* always argument */
update_channel_modes = 0;
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'B': /* always argument */
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'C': /* argument if set */
ptr_arg = ((set_flag == '+') && (current_arg < argc)) ?
argv[current_arg] : NULL;
break;
case 'D': /* no argument */
break;
}
if (ptr_arg)
{
if (ptr_arg[0] == ':')
ptr_arg++;
current_arg++;
}
if (smart_filter
&& !irc_mode_smart_filtered (server, pos[0]))
{
smart_filter = 0;
}
if (pos[0] == 'k')
{
/* channel key */
if (set_flag == '-')
{
if (channel->key)
{
free (channel->key);
channel->key = NULL;
}
}
else if ((set_flag == '+')
&& ptr_arg && (strcmp (ptr_arg, "*") != 0))
{
/* replace key for +k, but ignore "*" as new key */
if (channel->key)
free (channel->key);
channel->key = strdup (ptr_arg);
}
}
else if (pos[0] == 'l')
{
/* channel limit */
if (set_flag == '-')
channel->limit = 0;
if ((set_flag == '+') && ptr_arg)
{
channel->limit = atoi (ptr_arg);
}
}
else if ((chanmode_type != 'A')
&& (irc_server_get_prefix_mode_index (server,
pos[0]) >= 0))
{
/* mode for nick */
update_channel_modes = 0;
if (ptr_arg)
{
ptr_nick = irc_nick_search (server, channel,
ptr_arg);
if (ptr_nick)
{
irc_nick_set_mode (server, channel, ptr_nick,
(set_flag == '+'), pos[0]);
/*
* disable smart filtering if mode is sent
* to me, or based on the nick speaking time
*/
if (smart_filter
&& ((irc_server_strcasecmp (server,
ptr_nick->name,
server->nick) == 0)
|| irc_channel_nick_speaking_time_search (server,
channel,
ptr_nick->name,
1)))
{
smart_filter = 0;
}
}
}
}
else if (chanmode_type == 'A')
{
/* modelist modes */
if (ptr_arg)
{
ptr_modelist = irc_modelist_search (channel, pos[0]);
if (ptr_modelist)
{
if (set_flag == '+')
{
irc_modelist_item_new (ptr_modelist, ptr_arg,
host, time (NULL));
}
else if (set_flag == '-')
{
ptr_item = irc_modelist_item_search_mask (
ptr_modelist, ptr_arg);
if (ptr_item)
irc_modelist_item_free (ptr_modelist, ptr_item);
}
}
}
}
if (update_channel_modes)
{
irc_mode_channel_update (server, channel, set_flag,
pos[0], ptr_arg);
channel_modes_updated = 1;
}
break;
}
if (end_modes)
break;
pos++;
}
if (argv)
weechat_string_free_split (argv);
if (channel_modes_updated)
weechat_bar_item_update ("buffer_modes");
return smart_filter;
}
int
irc_input_send_cb (const void *pointer, void *data,
const char *signal,
const char *type_data, void *signal_data)
{
const char *ptr_string, *ptr_message;
char *pos_semicol1, *pos_semicol2, *pos_semicol3, *pos_semicol4;
char *server, *channel, *options, *tags, *data_with_colors, **list_options;
int i, num_options, flags, force_user_message;
struct t_irc_server *ptr_server;
struct t_irc_channel *ptr_channel;
struct t_gui_buffer *ptr_buffer;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) signal;
(void) type_data;
ptr_string = (const char *)signal_data;
server = NULL;
channel = NULL;
options = NULL;
flags = IRC_SERVER_SEND_OUTQ_PRIO_HIGH;
force_user_message = 0;
tags = NULL;
ptr_message = NULL;
ptr_server = NULL;
ptr_channel = NULL;
pos_semicol1 = strchr (ptr_string, ';');
if (pos_semicol1)
{
if (pos_semicol1 > ptr_string + 1)
{
server = weechat_strndup (ptr_string, pos_semicol1 - ptr_string);
}
pos_semicol2 = strchr (pos_semicol1 + 1, ';');
if (pos_semicol2)
{
if (pos_semicol2 > pos_semicol1 + 1)
{
channel = weechat_strndup (pos_semicol1 + 1,
pos_semicol2 - pos_semicol1 - 1);
}
pos_semicol3 = strchr (pos_semicol2 + 1, ';');
if (pos_semicol3)
{
if (pos_semicol3 > pos_semicol2 + 1)
{
options = weechat_strndup (pos_semicol2 + 1,
pos_semicol3 - pos_semicol2 - 1);
}
pos_semicol4 = strchr (pos_semicol3 + 1, ';');
if (pos_semicol4)
{
if (pos_semicol4 > pos_semicol3 + 1)
{
tags = weechat_strndup (pos_semicol3 + 1,
pos_semicol4 - pos_semicol3 - 1);
}
ptr_message = pos_semicol4 + 1;
}
}
}
}
if (options && options[0])
{
list_options = weechat_string_split (options, ",", 0, 0, &num_options);
if (list_options)
{
for (i = 0; i < num_options; i++)
{
if (strcmp (list_options[i], "priority_high") == 0)
flags = IRC_SERVER_SEND_OUTQ_PRIO_HIGH;
else if (strcmp (list_options[i], "priority_low") == 0)
flags = IRC_SERVER_SEND_OUTQ_PRIO_LOW;
else if (strcmp (list_options[i], "user_message") == 0)
force_user_message = 1;
}
weechat_string_free_split (list_options);
}
}
if (server && ptr_message)
{
ptr_server = irc_server_search (server);
if (ptr_server)
{
ptr_buffer = ptr_server->buffer;
if (channel)
{
ptr_channel = irc_channel_search (ptr_server, channel);
if (ptr_channel)
ptr_buffer = ptr_channel->buffer;
}
/* set tags to use by default */
irc_server_set_send_default_tags (tags);
/* send text to buffer, or execute command */
if (force_user_message
|| weechat_string_input_for_buffer (ptr_message))
{
/* text as input */
irc_input_data (ptr_buffer, ptr_message, flags, 1);
}
else
{
/* command */
data_with_colors = irc_color_encode (
ptr_message,
weechat_config_boolean (irc_config_network_colors_send));
weechat_command (
ptr_buffer,
(data_with_colors) ? data_with_colors : ptr_message);
if (data_with_colors)
free (data_with_colors);
}
/* reset tags to use by default */
irc_server_set_send_default_tags (NULL);
}
}
if (server)
free (server);
if (channel)
free (channel);
if (options)
free (options);
if (tags)
free (tags);
return WEECHAT_RC_OK;
}
void
xfer_file_find_filename (struct t_xfer *xfer)
{
const char *dir_separator;
char *path, *filename2;
int length;
if (!XFER_IS_FILE(xfer->type))
return;
path = weechat_string_eval_path_home (
weechat_config_string (xfer_config_file_download_path),
NULL, NULL, NULL);
if (!path)
return;
xfer->local_filename = malloc (strlen (path) +
strlen (xfer->remote_nick) +
strlen (xfer->filename) + 4);
if (!xfer->local_filename)
{
free (path);
return;
}
strcpy (xfer->local_filename, path);
dir_separator = weechat_info_get("dir_separator", "");
if (dir_separator
&& (xfer->local_filename[strlen (xfer->local_filename) - 1] != dir_separator[0]))
strcat (xfer->local_filename, dir_separator);
if (weechat_config_boolean (xfer_config_file_use_nick_in_filename))
{
strcat (xfer->local_filename, xfer->remote_nick);
strcat (xfer->local_filename, ".");
}
strcat (xfer->local_filename, xfer->filename);
free (path);
/* file already exists? */
if (access (xfer->local_filename, F_OK) == 0)
{
if (xfer_file_resume (xfer, xfer->local_filename))
return;
/* if auto rename is not set, then abort xfer */
if (!xfer_config_file_auto_rename)
{
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return;
}
length = strlen (xfer->local_filename) + 16;
filename2 = malloc (length);
if (!filename2)
{
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return;
}
xfer->filename_suffix = 0;
do
{
xfer->filename_suffix++;
snprintf (filename2, length, "%s.%d",
xfer->local_filename,
xfer->filename_suffix);
if (access (filename2, F_OK) == 0)
{
if (xfer_file_resume (xfer, filename2))
break;
}
else
break;
}
while (1);
free (xfer->local_filename);
xfer->local_filename = strdup (filename2);
free (filename2);
}
}
int
irc_mode_channel_set (struct t_irc_server *server,
struct t_irc_channel *channel,
const char *modes)
{
char *pos_args, *str_modes, set_flag, **argv, *pos, *ptr_arg, chanmode_type;
int argc, current_arg, update_channel_modes, channel_modes_updated;
int smart_filter;
struct t_irc_nick *ptr_nick;
if (!server || !channel || !modes)
return 0;
channel_modes_updated = 0;
argc = 0;
argv = NULL;
pos_args = strchr (modes, ' ');
if (pos_args)
{
str_modes = weechat_strndup (modes, pos_args - modes);
if (!str_modes)
return 0;
pos_args++;
while (pos_args[0] == ' ')
pos_args++;
argv = weechat_string_split (pos_args, " ", 0, 0, &argc);
}
else
{
str_modes = strdup (modes);
if (!str_modes)
return 0;
}
current_arg = 0;
smart_filter = (weechat_config_boolean (irc_config_look_smart_filter)
&& weechat_config_string (irc_config_look_smart_filter_mode)
&& weechat_config_string (irc_config_look_smart_filter_mode)[0]) ? 1 : 0;
if (str_modes && str_modes[0])
{
set_flag = '+';
pos = str_modes;
while (pos && pos[0])
{
switch (pos[0])
{
case ':':
case ' ':
break;
case '+':
set_flag = '+';
break;
case '-':
set_flag = '-';
break;
default:
update_channel_modes = 1;
chanmode_type = irc_mode_get_chanmode_type (server, pos[0]);
ptr_arg = NULL;
switch (chanmode_type)
{
case 'A': /* always argument */
update_channel_modes = 0;
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'B': /* always argument */
ptr_arg = (current_arg < argc) ?
argv[current_arg] : NULL;
break;
case 'C': /* argument if set */
ptr_arg = ((set_flag == '+') && (current_arg < argc)) ?
argv[current_arg] : NULL;
break;
case 'D': /* no argument */
break;
}
if (ptr_arg)
current_arg++;
if (smart_filter
&& !irc_mode_smart_filtered (server, pos[0]))
{
smart_filter = 0;
}
if (pos[0] == 'k')
{
/* channel key */
if (set_flag == '-')
{
if (channel->key)
{
free (channel->key);
channel->key = NULL;
}
}
else if ((set_flag == '+')
&& ptr_arg && (strcmp (ptr_arg, "*") != 0))
{
/* replace key for +k, but ignore "*" as new key */
if (channel->key)
free (channel->key);
channel->key = strdup (ptr_arg);
}
}
else if (pos[0] == 'l')
{
/* channel limit */
if (set_flag == '-')
channel->limit = 0;
if ((set_flag == '+') && ptr_arg)
{
channel->limit = atoi (ptr_arg);
}
}
else if ((chanmode_type != 'A')
&& (irc_server_get_prefix_mode_index (server,
pos[0]) >= 0))
{
/* mode for nick */
update_channel_modes = 0;
if (ptr_arg)
{
ptr_nick = irc_nick_search (server, channel,
ptr_arg);
if (ptr_nick)
{
irc_nick_set_mode (server, channel, ptr_nick,
(set_flag == '+'), pos[0]);
if (smart_filter
&& irc_channel_nick_speaking_time_search (server,
channel,
ptr_nick->name,
1))
{
smart_filter = 0;
}
}
}
}
if (update_channel_modes)
{
irc_mode_channel_update (server, channel, set_flag,
pos[0], ptr_arg);
channel_modes_updated = 1;
}
break;
}
pos++;
}
}
if (str_modes)
free (str_modes);
if (argv)
weechat_string_free_split (argv);
if (channel_modes_updated)
weechat_bar_item_update ("buffer_modes");
return smart_filter;
}
