void
irc_notify_end ()
{
if (irc_notify_timer_ison)
weechat_unhook (irc_notify_timer_ison);
if (irc_notify_timer_whois)
weechat_unhook (irc_notify_timer_whois);
if (irc_notify_hsignal)
weechat_unhook (irc_notify_hsignal);
}
void
relay_weechat_unhook_signals (struct t_relay_client *client)
{
if (RELAY_WEECHAT_DATA(client, hook_signal_buffer))
{
weechat_unhook (RELAY_WEECHAT_DATA(client, hook_signal_buffer));
RELAY_WEECHAT_DATA(client, hook_signal_buffer) = NULL;
}
if (RELAY_WEECHAT_DATA(client, hook_signal_nicklist))
{
weechat_unhook (RELAY_WEECHAT_DATA(client, hook_signal_nicklist));
RELAY_WEECHAT_DATA(client, hook_signal_nicklist) = NULL;
}
}
void
alias_free (struct t_alias *alias)
{
struct t_alias *new_alias_list;
/* remove alias from list */
if (last_alias == alias)
last_alias = alias->prev_alias;
if (alias->prev_alias)
{
(alias->prev_alias)->next_alias = alias->next_alias;
new_alias_list = alias_list;
}
else
new_alias_list = alias->next_alias;
if (alias->next_alias)
(alias->next_alias)->prev_alias = alias->prev_alias;
/* free data */
if (alias->hook)
weechat_unhook (alias->hook);
if (alias->name)
free (alias->name);
if (alias->command)
free (alias->command);
if (alias->completion)
free (alias->completion);
free (alias);
alias_list = new_alias_list;
}
void
relay_server_close_socket (struct t_relay_server *server)
{
if (server->hook_fd)
{
weechat_unhook (server->hook_fd);
server->hook_fd = NULL;
}
if (server->sock >= 0)
{
close (server->sock);
server->sock = -1;
if (server->unix_socket)
unlink (server->path);
if (!relay_signal_upgrade_received)
{
weechat_printf (NULL,
_("%s: socket closed for %s (%s: %s)"),
RELAY_PLUGIN_NAME,
server->protocol_string,
(server->unix_socket) ? _("path") : _("port"),
server->path);
}
}
}
int
weechat_plugin_end (struct t_weechat_plugin *plugin)
{
/* make C compiler happy */
(void) plugin;
if (relay_hook_timer)
weechat_unhook (relay_hook_timer);
relay_config_write ();
if (relay_signal_upgrade_received)
relay_upgrade_save ();
else
{
relay_raw_message_free_all ();
relay_server_free_all ();
relay_client_disconnect_all ();
if (relay_buffer)
weechat_buffer_close (relay_buffer);
relay_client_free_all ();
}
relay_network_end ();
relay_config_free ();
return WEECHAT_RC_OK;
}
void
relay_server_close_socket (struct t_relay_server *server)
{
if (server->hook_fd)
{
weechat_unhook (server->hook_fd);
server->hook_fd = NULL;
}
if (server->sock >= 0)
{
close (server->sock);
server->sock = -1;
if (!relay_signal_upgrade_received)
{
weechat_printf (NULL,
_("%s: socket closed for %s%s%s (port %d)"),
RELAY_PLUGIN_NAME,
relay_protocol_string[server->protocol],
(server->protocol_args) ? "." : "",
(server->protocol_args) ? server->protocol_args : "",
server->port);
}
}
}
static void
_wec_disconnect(void)
{
if ( _wec_context.connect_hook != NULL )
weechat_unhook(_wec_context.connect_hook);
gint error = 0;
if ( eventc_light_connection_is_connected(_wec_context.client, &error) )
{
weechat_unhook(_wec_context.fd_hook);
eventc_light_connection_close(_wec_context.client);
}
_wec_context.connect_hook = NULL;
_wec_context.fd = 0;
_wec_context.fd_hook = NULL;
}
void
relay_weechat_free (struct t_relay_client *client)
{
if (client->protocol_data)
{
if (RELAY_WEECHAT_DATA(client, buffers_sync))
weechat_hashtable_free (RELAY_WEECHAT_DATA(client, buffers_sync));
if (RELAY_WEECHAT_DATA(client, hook_signal_buffer))
weechat_unhook (RELAY_WEECHAT_DATA(client, hook_signal_buffer));
if (RELAY_WEECHAT_DATA(client, hook_signal_nicklist))
weechat_unhook (RELAY_WEECHAT_DATA(client, hook_signal_nicklist));
if (RELAY_WEECHAT_DATA(client, buffers_nicklist))
weechat_hashtable_free (RELAY_WEECHAT_DATA(client, buffers_nicklist));
free (client->protocol_data);
client->protocol_data = NULL;
}
}
void
irc_notify_hook_timer_whois ()
{
if (irc_notify_timer_whois)
weechat_unhook (irc_notify_timer_whois);
irc_notify_timer_whois = weechat_hook_timer (
60 * 1000 * weechat_config_integer (irc_config_network_notify_check_whois),
0, 0, &irc_notify_timer_whois_cb, NULL, NULL);
}
void
irc_notify_hook_timer_ison ()
{
if (irc_notify_timer_ison)
weechat_unhook (irc_notify_timer_ison);
irc_notify_timer_ison = weechat_hook_timer (
60 * 1000 * weechat_config_integer (irc_config_network_notify_check_ison),
0, 0, &irc_notify_timer_ison_cb, NULL, NULL);
}
void
relay_client_free (struct t_relay_client *client)
{
struct t_relay_client *new_relay_clients;
if (!client)
return;
/* remove client from list */
if (last_relay_client == client)
last_relay_client = client->prev_client;
if (client->prev_client)
{
(client->prev_client)->next_client = client->next_client;
new_relay_clients = relay_clients;
}
else
new_relay_clients = client->next_client;
if (client->next_client)
(client->next_client)->prev_client = client->prev_client;
/* free data */
if (client->address)
free (client->address);
if (client->protocol_args)
free (client->protocol_args);
if (client->hook_fd)
weechat_unhook (client->hook_fd);
if (client->protocol_data)
{
switch (client->protocol)
{
case RELAY_PROTOCOL_WEECHAT:
relay_weechat_free (client);
break;
case RELAY_PROTOCOL_IRC:
relay_irc_free (client);
break;
case RELAY_NUM_PROTOCOLS:
break;
}
}
free (client);
relay_clients = new_relay_clients;
relay_client_count--;
if (relay_buffer_selected_line >= relay_client_count)
{
relay_buffer_selected_line = (relay_client_count == 0) ?
0 : relay_client_count - 1;
}
}
void
alias_update_completion (struct t_alias *alias, const char *completion)
{
/* update completion in alias */
if (alias->completion)
free (alias->completion);
alias->completion = (completion) ? strdup (completion) : NULL;
/* unhook and hook again command, with new completion */
weechat_unhook (alias->hook);
alias->hook = NULL;
alias_hook_command (alias);
}
static void
cksum_xfer_free(cksum_xfer_t *xfer)
{
if (xfer) {
if (xfer->local_filename) free (xfer->local_filename);
if (xfer->crc32) free (xfer->crc32);
if (xfer->filename) free (xfer->filename);
if (xfer->timer) {
weechat_unhook(xfer->timer);
xfer->timer = NULL;
}
free (xfer);
}
}
void
rmodifier_free (struct t_rmodifier *rmodifier)
{
struct t_rmodifier *new_rmodifier_list;
int i;
/* remove rmodifier from list */
if (last_rmodifier == rmodifier)
last_rmodifier = rmodifier->prev_rmodifier;
if (rmodifier->prev_rmodifier)
{
(rmodifier->prev_rmodifier)->next_rmodifier = rmodifier->next_rmodifier;
new_rmodifier_list = rmodifier_list;
}
else
new_rmodifier_list = rmodifier->next_rmodifier;
if (rmodifier->next_rmodifier)
(rmodifier->next_rmodifier)->prev_rmodifier = rmodifier->prev_rmodifier;
/* free data */
if (rmodifier->name)
free (rmodifier->name);
if (rmodifier->modifiers)
free (rmodifier->modifiers);
if (rmodifier->hooks)
{
for (i = 0; i < rmodifier->hooks_count; i++)
{
weechat_unhook (rmodifier->hooks[i]);
}
free (rmodifier->hooks);
}
if (rmodifier->str_regex)
free (rmodifier->str_regex);
if (rmodifier->regex)
{
regfree (rmodifier->regex);
free (rmodifier->regex);
}
if (rmodifier->groups)
free (rmodifier->groups);
free (rmodifier);
rmodifier_count--;
rmodifier_list = new_rmodifier_list;
}
void
buflist_config_free_signals_refresh ()
{
int i;
if (!buflist_config_signals_refresh)
return;
for (i = 0; i < buflist_config_num_signals_refresh; i++)
{
weechat_unhook (buflist_config_signals_refresh[i]);
}
free (buflist_config_signals_refresh);
buflist_config_signals_refresh = NULL;
buflist_config_num_signals_refresh = 0;
}
int
weechat_plugin_end (struct t_weechat_plugin *plugin)
{
/* make C compiler happy */
(void) plugin;
if (logger_timer)
{
weechat_unhook (logger_timer);
logger_timer = NULL;
}
logger_config_write ();
logger_stop_all (1);
logger_config_free ();
return WEECHAT_RC_OK;
}
void
exec_free (struct t_exec_cmd *exec_cmd)
{
int i;
if (!exec_cmd)
return;
/* remove command from commands list */
if (exec_cmd->prev_cmd)
(exec_cmd->prev_cmd)->next_cmd = exec_cmd->next_cmd;
if (exec_cmd->next_cmd)
(exec_cmd->next_cmd)->prev_cmd = exec_cmd->prev_cmd;
if (exec_cmds == exec_cmd)
exec_cmds = exec_cmd->next_cmd;
if (last_exec_cmd == exec_cmd)
last_exec_cmd = exec_cmd->prev_cmd;
/* free data */
if (exec_cmd->hook)
weechat_unhook (exec_cmd->hook);
if (exec_cmd->name)
free (exec_cmd->name);
if (exec_cmd->command)
free (exec_cmd->command);
if (exec_cmd->buffer_full_name)
free (exec_cmd->buffer_full_name);
for (i = 0; i < 2; i++)
{
if (exec_cmd->output[i])
free (exec_cmd->output[i]);
}
if (exec_cmd->pipe_command)
free (exec_cmd->pipe_command);
if (exec_cmd->hsignal)
free (exec_cmd->hsignal);
free (exec_cmd);
exec_cmds_count--;
}
void
logger_config_flush_delay_change (const void *pointer, void *data,
struct t_config_option *option)
{
/* make C compiler happy */
(void) pointer;
(void) data;
(void) option;
if (logger_config_loading)
return;
if (logger_timer)
{
if (weechat_logger_plugin->debug)
{
weechat_printf_date_tags (
NULL, 0, "no_log",
"%s: stopping timer", LOGGER_PLUGIN_NAME);
}
weechat_unhook (logger_timer);
logger_timer = NULL;
}
if (weechat_config_integer (logger_config_file_flush_delay) > 0)
{
if (weechat_logger_plugin->debug)
{
weechat_printf_date_tags (
NULL, 0, "no_log",
"%s: starting timer (interval: %d seconds)",
LOGGER_PLUGIN_NAME,
weechat_config_integer (logger_config_file_flush_delay));
}
logger_timer = weechat_hook_timer (weechat_config_integer (logger_config_file_flush_delay) * 1000,
0, 0,
&logger_timer_cb, NULL, NULL);
}
}
void
trigger_unhook (struct t_trigger *trigger)
{
int i;
if (trigger->hooks)
{
for (i = 0; i < trigger->hooks_count; i++)
{
if (trigger->hooks[i])
weechat_unhook (trigger->hooks[i]);
}
free (trigger->hooks);
trigger->hooks = NULL;
trigger->hooks_count = 0;
}
trigger->hook_count_cb = 0;
trigger->hook_count_cmd = 0;
if (trigger->hook_print_buffers)
{
free (trigger->hook_print_buffers);
trigger->hook_print_buffers = NULL;
}
}
int
relay_weechat_protocol_hsignal_nicklist_cb (const void *pointer, void *data,
const char *signal,
struct t_hashtable *hashtable)
{
struct t_relay_client *ptr_client;
struct t_gui_nick_group *parent_group, *group;
struct t_gui_nick *nick;
struct t_gui_buffer *ptr_buffer;
struct t_relay_weechat_nicklist *ptr_nicklist;
char diff;
/* make C compiler happy */
(void) data;
ptr_client = (struct t_relay_client *)pointer;
if (!ptr_client || !relay_client_valid (ptr_client))
return WEECHAT_RC_OK;
/* check if buffer is synchronized with flag "nicklist" */
ptr_buffer = weechat_hashtable_get (hashtable, "buffer");
if (!relay_weechat_protocol_is_sync (ptr_client, ptr_buffer,
RELAY_WEECHAT_PROTOCOL_SYNC_NICKLIST))
return WEECHAT_RC_OK;
parent_group = weechat_hashtable_get (hashtable, "parent_group");
group = weechat_hashtable_get (hashtable, "group");
nick = weechat_hashtable_get (hashtable, "nick");
/* if there is no parent group (for example "root" group), ignore the signal */
if (!parent_group)
return WEECHAT_RC_OK;
ptr_nicklist = weechat_hashtable_get (RELAY_WEECHAT_DATA(ptr_client,
buffers_nicklist),
ptr_buffer);
if (!ptr_nicklist)
{
ptr_nicklist = relay_weechat_nicklist_new ();
if (!ptr_nicklist)
return WEECHAT_RC_OK;
ptr_nicklist->nicklist_count = weechat_buffer_get_integer (ptr_buffer,
"nicklist_count");
weechat_hashtable_set (RELAY_WEECHAT_DATA(ptr_client, buffers_nicklist),
ptr_buffer,
ptr_nicklist);
}
/* set diff type */
diff = RELAY_WEECHAT_NICKLIST_DIFF_UNKNOWN;
if ((strcmp (signal, "nicklist_group_added") == 0)
|| (strcmp (signal, "nicklist_nick_added") == 0))
{
diff = RELAY_WEECHAT_NICKLIST_DIFF_ADDED;
}
else if ((strcmp (signal, "nicklist_group_removing") == 0)
|| (strcmp (signal, "nicklist_nick_removing") == 0))
{
diff = RELAY_WEECHAT_NICKLIST_DIFF_REMOVED;
}
else if ((strcmp (signal, "nicklist_group_changed") == 0)
|| (strcmp (signal, "nicklist_nick_changed") == 0))
{
diff = RELAY_WEECHAT_NICKLIST_DIFF_CHANGED;
}
if (diff != RELAY_WEECHAT_NICKLIST_DIFF_UNKNOWN)
{
/*
* add items if nicklist was not empty or very small (otherwise we will
* send full nicklist)
*/
if (ptr_nicklist->nicklist_count > 1)
{
/* add nicklist item for parent group and group/nick */
relay_weechat_nicklist_add_item (ptr_nicklist,
RELAY_WEECHAT_NICKLIST_DIFF_PARENT,
parent_group, NULL);
relay_weechat_nicklist_add_item (ptr_nicklist, diff, group, nick);
}
/* add timer to send nicklist */
if (RELAY_WEECHAT_DATA(ptr_client, hook_timer_nicklist))
{
weechat_unhook (RELAY_WEECHAT_DATA(ptr_client, hook_timer_nicklist));
RELAY_WEECHAT_DATA(ptr_client, hook_timer_nicklist) = NULL;
}
relay_weechat_hook_timer_nicklist (ptr_client);
}
return WEECHAT_RC_OK;
}
int
xfer_network_fd_cb (const void *pointer, void *data, int fd)
{
struct t_xfer *xfer;
int sock, flags, error;
struct sockaddr_storage addr;
socklen_t length;
char str_address[NI_MAXHOST];
/* make C compiler happy */
(void) data;
(void) fd;
length = sizeof (addr);
memset (&addr, 0, length);
xfer = (struct t_xfer *)pointer;
if (xfer->status == XFER_STATUS_CONNECTING)
{
if (xfer->type == XFER_TYPE_FILE_SEND)
{
xfer->last_activity = time (NULL);
sock = accept (xfer->sock,
(struct sockaddr *) &addr, &length);
error = errno;
weechat_unhook (xfer->hook_fd);
xfer->hook_fd = NULL;
close (xfer->sock);
xfer->sock = -1;
if (sock < 0)
{
weechat_printf (NULL,
_("%s%s: unable to create socket for sending "
"file: error %d %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
error, strerror (error));
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->sock = sock;
flags = fcntl (xfer->sock, F_GETFL);
if (flags == -1)
flags = 0;
if (fcntl (xfer->sock, F_SETFL, flags | O_NONBLOCK) == -1)
{
weechat_printf (NULL,
_("%s%s: unable to set option \"nonblock\" "
"for socket: error %d %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
errno, strerror (errno));
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
error = getnameinfo ((struct sockaddr *)&addr, length, str_address,
sizeof (str_address), NULL, 0, NI_NUMERICHOST);
if (error != 0)
{
snprintf (str_address, sizeof (str_address),
"error: %s", gai_strerror (error));
}
xfer_set_remote_address (xfer, (struct sockaddr *)&addr, length,
str_address);
xfer->status = XFER_STATUS_ACTIVE;
xfer->start_transfer = time (NULL);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
xfer_network_send_file_fork (xfer);
}
}
if (xfer->status == XFER_STATUS_WAITING)
{
if (xfer->type == XFER_TYPE_CHAT_SEND)
{
length = sizeof (addr);
sock = accept (xfer->sock, (struct sockaddr *) &addr, &length);
error = errno;
weechat_unhook (xfer->hook_fd);
xfer->hook_fd = NULL;
close (xfer->sock);
xfer->sock = -1;
if (sock < 0)
{
weechat_printf (NULL,
_("%s%s: unable to create socket for sending "
"file: error %d %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
error, strerror (error));
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->sock = sock;
flags = fcntl (xfer->sock, F_GETFL);
if (flags == -1)
flags = 0;
if (fcntl (xfer->sock, F_SETFL, flags | O_NONBLOCK) == -1)
{
weechat_printf (NULL,
_("%s%s: unable to set option \"nonblock\" "
"for socket: error %d %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
errno, strerror (errno));
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
error = getnameinfo ((struct sockaddr *)&addr, length, str_address,
sizeof (str_address), NULL, 0, NI_NUMERICHOST);
if (error != 0)
{
snprintf (str_address, sizeof (str_address),
"error: %s", gai_strerror (error));
}
xfer_set_remote_address (xfer, (struct sockaddr *)&addr, length,
str_address);
xfer->status = XFER_STATUS_ACTIVE;
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
xfer->hook_fd = weechat_hook_fd (xfer->sock,
1, 0, 0,
&xfer_chat_recv_cb,
xfer, NULL);
xfer_chat_open_buffer (xfer);
}
}
return WEECHAT_RC_OK;
}
int
xfer_network_fd_cb (void *arg_xfer, int fd)
{
struct t_xfer *xfer;
int sock;
struct sockaddr_in addr;
socklen_t length;
/* make C compiler happy */
(void) fd;
xfer = (struct t_xfer *)arg_xfer;
if (xfer->status == XFER_STATUS_CONNECTING)
{
if (xfer->type == XFER_TYPE_FILE_SEND)
{
xfer->last_activity = time (NULL);
length = sizeof (addr);
sock = accept (xfer->sock,
(struct sockaddr *) &addr, &length);
weechat_unhook (xfer->hook_fd);
xfer->hook_fd = NULL;
close (xfer->sock);
xfer->sock = -1;
if (sock < 0)
{
weechat_printf (NULL,
_("%s%s: unable to create socket for sending "
"file"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->sock = sock;
if (fcntl (xfer->sock, F_SETFL, O_NONBLOCK) == -1)
{
weechat_printf (NULL,
_("%s%s: unable to set option \"nonblock\" "
"for socket"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->address = ntohl (addr.sin_addr.s_addr);
xfer->status = XFER_STATUS_ACTIVE;
xfer->start_transfer = time (NULL);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
xfer_network_send_file_fork (xfer);
}
/*
if (xfer->type == XFER_TYPE_FILE_RECV)
{
if (xfer->child_read != -1)
irc_dcc_file_child_read (dcc);
}
*/
}
if (xfer->status == XFER_STATUS_WAITING)
{
if (xfer->type == XFER_TYPE_CHAT_SEND)
{
length = sizeof (addr);
sock = accept (xfer->sock, (struct sockaddr *) &addr, &length);
weechat_unhook (xfer->hook_fd);
xfer->hook_fd = NULL;
close (xfer->sock);
xfer->sock = -1;
if (sock < 0)
{
weechat_printf (NULL,
_("%s%s: unable to create socket for sending "
"file"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->sock = sock;
if (fcntl (xfer->sock, F_SETFL, O_NONBLOCK) == -1)
{
weechat_printf (NULL,
_("%s%s: unable to set option \"nonblock\" "
"for socket"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->address = ntohl (addr.sin_addr.s_addr);
xfer->status = XFER_STATUS_ACTIVE;
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
xfer->hook_fd = weechat_hook_fd (xfer->sock,
1, 0, 0,
&xfer_chat_recv_cb,
xfer);
xfer_chat_open_buffer (xfer);
}
}
/*
if (xfer->status == XFER_STATUS_ACTIVE)
{
if (XFER_IS_CHAT(dcc->type))
{
irc_dcc_chat_recv (dcc);
}
else
irc_dcc_file_child_read (dcc);
}
*/
return WEECHAT_RC_OK;
}
int
xfer_network_connect_chat_recv_cb (const void *pointer, void *data,
int status, int gnutls_rc,
int sock, const char *error,
const char *ip_address)
{
struct t_xfer *xfer;
int flags;
/* make C compiler happy */
(void) data;
(void) gnutls_rc;
(void) ip_address;
xfer = (struct t_xfer*)pointer;
weechat_unhook (xfer->hook_connect);
xfer->hook_connect = NULL;
/* connection OK? */
if (status == WEECHAT_HOOK_CONNECT_OK)
{
xfer->sock = sock;
flags = fcntl (xfer->sock, F_GETFL);
if (flags == -1)
flags = 0;
if (fcntl (xfer->sock, F_SETFL, flags | O_NONBLOCK) == -1)
{
weechat_printf (NULL,
_("%s%s: unable to set option \"nonblock\" "
"for socket: error %d %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
errno, strerror (errno));
close (xfer->sock);
xfer->sock = -1;
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
xfer->hook_fd = weechat_hook_fd (xfer->sock,
1, 0, 0,
&xfer_chat_recv_cb,
xfer, NULL);
xfer_chat_open_buffer (xfer);
xfer->status = XFER_STATUS_ACTIVE;
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
/* connection error */
switch (status)
{
case WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND:
weechat_printf (NULL,
(xfer->proxy && xfer->proxy[0]) ?
_("%s%s: proxy address \"%s\" not found") :
_("%s%s: address \"%s\" not found"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
xfer->remote_address_str);
break;
case WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND:
weechat_printf (NULL,
(xfer->proxy && xfer->proxy[0]) ?
_("%s%s: proxy IP address not found") :
_("%s%s: IP address not found"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
case WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED:
weechat_printf (NULL,
(xfer->proxy && xfer->proxy[0]) ?
_("%s%s: proxy connection refused") :
_("%s%s: connection refused"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
case WEECHAT_HOOK_CONNECT_PROXY_ERROR:
weechat_printf (NULL,
_("%s%s: proxy fails to establish connection to "
"server (check username/password if used and if "
"server address/port is allowed by proxy)"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
case WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR:
weechat_printf (NULL,
_("%s%s: unable to set local hostname/IP"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
case WEECHAT_HOOK_CONNECT_MEMORY_ERROR:
weechat_printf (NULL,
_("%s%s: not enough memory (%s)"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
(error) ? error : "-");
break;
case WEECHAT_HOOK_CONNECT_TIMEOUT:
weechat_printf (NULL,
_("%s%s: timeout"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
case WEECHAT_HOOK_CONNECT_SOCKET_ERROR:
weechat_printf (NULL,
_("%s%s: unable to create socket"),
weechat_prefix ("error"), XFER_PLUGIN_NAME);
break;
default:
weechat_printf (NULL,
_("%s%s: unable to connect: unexpected error (%d)"),
weechat_prefix ("error"), XFER_PLUGIN_NAME,
status);
break;
}
if (error && error[0])
{
weechat_printf (NULL,
_("%s%s: error: %s"),
weechat_prefix ("error"), XFER_PLUGIN_NAME, error);
}
xfer_close (xfer, XFER_STATUS_FAILED);
xfer_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
return WEECHAT_RC_OK;
}
void
relay_client_set_status (struct t_relay_client *client,
enum t_relay_status status)
{
client->status = status;
if (RELAY_CLIENT_HAS_ENDED(client))
{
client->end_time = time (NULL);
if (client->hook_fd)
{
weechat_unhook (client->hook_fd);
client->hook_fd = NULL;
}
switch (client->protocol)
{
case RELAY_PROTOCOL_WEECHAT:
relay_weechat_close_connection (client);
break;
case RELAY_PROTOCOL_IRC:
relay_irc_close_connection (client);
break;
case RELAY_NUM_PROTOCOLS:
break;
}
switch (client->status)
{
case RELAY_STATUS_AUTH_FAILED:
weechat_printf (NULL,
_("%s%s: authentication failed with client %s%s%s (%s%s%s)"),
weechat_prefix ("error"),
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_HOST,
client->address,
RELAY_COLOR_CHAT,
relay_protocol_string[client->protocol],
(client->protocol_args) ? "." : "",
(client->protocol_args) ? client->protocol_args : "");
break;
case RELAY_STATUS_DISCONNECTED:
weechat_printf (NULL,
_("%s: disconnected from client %s%s%s (%s%s%s)"),
RELAY_PLUGIN_NAME,
RELAY_COLOR_CHAT_HOST,
client->address,
RELAY_COLOR_CHAT,
relay_protocol_string[client->protocol],
(client->protocol_args) ? "." : "",
(client->protocol_args) ? client->protocol_args : "");
break;
default:
break;
}
if (client->sock >= 0)
{
close (client->sock);
client->sock = -1;
}
}
relay_buffer_refresh (WEECHAT_HOTLIST_MESSAGE);
}
