void
script_action_install (int quiet)
{
struct t_script_repo *ptr_script_to_install;
char *filename, *url;
struct t_hashtable *options;
while (1)
{
ptr_script_to_install = script_action_get_next_script_to_install ();
/* no more script to install? just exit function */
if (!ptr_script_to_install)
return;
/*
* script to install and plugin is loaded: exit loop and go on with
* install
*/
if (script_plugin_loaded[ptr_script_to_install->language])
break;
/* plugin not loaded for language of script: display error */
dogechat_printf (NULL,
_("%s: script \"%s\" can not be installed because "
"plugin \"%s\" is not loaded"),
SCRIPT_PLUGIN_NAME,
ptr_script_to_install->name_with_extension,
script_language[ptr_script_to_install->language]);
}
filename = script_config_get_script_download_filename (ptr_script_to_install,
NULL);
if (filename)
{
options = dogechat_hashtable_new (32,
DOGECHAT_HASHTABLE_STRING,
DOGECHAT_HASHTABLE_STRING,
NULL,
NULL);
if (options)
{
url = script_build_download_url (ptr_script_to_install->url);
if (url)
{
if (!dogechat_config_boolean (script_config_look_quiet_actions))
{
dogechat_printf (NULL,
_("%s: downloading script \"%s\"..."),
SCRIPT_PLUGIN_NAME,
ptr_script_to_install->name_with_extension);
}
dogechat_hashtable_set (options, "file_out", filename);
dogechat_hook_process_hashtable (
url,
options,
dogechat_config_integer (script_config_scripts_download_timeout) * 1000,
&script_action_install_process_cb,
(quiet) ? (void *)1 : (void *)0);
free (url);
}
dogechat_hashtable_free (options);
}
free (filename);
}
}
void
script_action_show (const char *name, int quiet)
{
struct t_script_repo *ptr_script;
char *filename, *url;
struct t_hashtable *options;
if (name)
{
ptr_script = script_repo_search_by_name_ext (name);
if (ptr_script)
{
script_buffer_show_detail_script (ptr_script);
if (dogechat_config_boolean (script_config_look_display_source))
{
dogechat_printf_y (script_buffer,
script_buffer_detail_script_last_line++,
_("Source code:"));
dogechat_printf_y (script_buffer,
script_buffer_detail_script_last_line++,
"%s----------------------------------------"
"----------------------------------------",
dogechat_color ("lightcyan"));
dogechat_printf_y (script_buffer,
script_buffer_detail_script_last_line,
_("Downloading script..."));
dogechat_printf_y (script_buffer,
script_buffer_detail_script_last_line + 1,
"%s----------------------------------------"
"----------------------------------------",
dogechat_color ("lightcyan"));
filename = script_config_get_script_download_filename (ptr_script,
".repository");
if (filename)
{
options = dogechat_hashtable_new (32,
DOGECHAT_HASHTABLE_STRING,
DOGECHAT_HASHTABLE_STRING,
NULL,
NULL);
if (options)
{
url = script_build_download_url (ptr_script->url);
if (url)
{
dogechat_hashtable_set (options, "file_out", filename);
dogechat_hook_process_hashtable (
url,
options,
dogechat_config_integer (script_config_scripts_download_timeout) * 1000,
&script_action_show_source_process_cb,
NULL);
free (url);
}
dogechat_hashtable_free (options);
}
free (filename);
}
}
}
else
{
if (!quiet)
{
dogechat_printf (NULL,
_("%s: script \"%s\" not found"),
SCRIPT_PLUGIN_NAME, name);
}
}
}
else
script_buffer_show_detail_script (NULL);
}
void
exec_end_command (struct t_exec_cmd *exec_cmd, int return_code)
{
struct t_gui_buffer *ptr_buffer;
struct t_hashtable *hashtable;
char str_number[32], *output;
int i, buffer_type;
if (exec_cmd->hsignal)
{
hashtable = dogechat_hashtable_new (32,
DOGECHAT_HASHTABLE_STRING,
DOGECHAT_HASHTABLE_STRING,
NULL,
NULL);
if (hashtable)
{
dogechat_hashtable_set (hashtable, "command", exec_cmd->command);
snprintf (str_number, sizeof (str_number), "%d", exec_cmd->number);
dogechat_hashtable_set (hashtable, "number", str_number);
dogechat_hashtable_set (hashtable, "name", exec_cmd->name);
output = exec_decode_color (exec_cmd, exec_cmd->output[EXEC_STDOUT]);
dogechat_hashtable_set (hashtable, "out", output);
if (output)
free (output);
output = exec_decode_color (exec_cmd, exec_cmd->output[EXEC_STDERR]);
dogechat_hashtable_set (hashtable, "err", output);
if (output)
free (output);
snprintf (str_number, sizeof (str_number), "%d", return_code);
dogechat_hashtable_set (hashtable, "rc", str_number);
dogechat_hook_hsignal_send (exec_cmd->hsignal, hashtable);
dogechat_hashtable_free (hashtable);
}
}
else
{
ptr_buffer = dogechat_buffer_search ("==", exec_cmd->buffer_full_name);
/* display the last line of output (if not ending with '\n') */
exec_display_line (exec_cmd, ptr_buffer, EXEC_STDOUT,
exec_cmd->output[EXEC_STDOUT]);
exec_display_line (exec_cmd, ptr_buffer, EXEC_STDERR,
exec_cmd->output[EXEC_STDERR]);
/*
* display return code (only if command is not detached, if output is
* NOT sent to buffer, and if command is not piped)
*/
if (exec_cmd->display_rc
&& !exec_cmd->detached && !exec_cmd->output_to_buffer
&& !exec_cmd->pipe_command)
{
buffer_type = dogechat_buffer_get_integer (ptr_buffer, "type");
if (return_code >= 0)
{
if (buffer_type == 1)
{
dogechat_printf_y (ptr_buffer, -1,
("%s: end of command %d (\"%s\"), "
"return code: %d"),
EXEC_PLUGIN_NAME, exec_cmd->number,
exec_cmd->command, return_code);
}
else
{
dogechat_printf_tags (ptr_buffer, "exec_rc",
_("%s: end of command %d (\"%s\"), "
"return code: %d"),
EXEC_PLUGIN_NAME, exec_cmd->number,
exec_cmd->command, return_code);
}
}
else
{
if (buffer_type == 1)
{
dogechat_printf_y (ptr_buffer, -1,
_("%s: unexpected end of command %d "
"(\"%s\")"),
EXEC_PLUGIN_NAME, exec_cmd->number,
exec_cmd->command);
}
else
{
dogechat_printf_tags (ptr_buffer, "exec_rc",
_("%s: unexpected end of command %d "
"(\"%s\")"),
EXEC_PLUGIN_NAME, exec_cmd->number,
exec_cmd->command);
}
}
}
}
/* (re)set some variables after the end of command */
exec_cmd->hook = NULL;
exec_cmd->pid = 0;
exec_cmd->end_time = time (NULL);
exec_cmd->return_code = return_code;
for (i = 0; i < 2; i++)
{
if (exec_cmd->output[i])
{
free (exec_cmd->output[i]);
exec_cmd->output[i] = NULL;
}
exec_cmd->output_size[i] = 0;
}
/* schedule a timer to remove the executed command */
if (dogechat_config_integer (exec_config_command_purge_delay) >= 0)
{
dogechat_hook_timer (1 + (1000 * dogechat_config_integer (exec_config_command_purge_delay)),
0, 1,
&exec_timer_delete_cb, exec_cmd);
}
}
int
relay_server_create_socket (struct t_relay_server *server)
{
int domain, set, max_clients, addr_size;
struct sockaddr_in server_addr;
struct sockaddr_in6 server_addr6;
const char *bind_address;
void *ptr_addr;
bind_address = dogechat_config_string (relay_config_network_bind_address);
if (server->ipv6)
{
domain = AF_INET6;
memset (&server_addr6, 0, sizeof (struct sockaddr_in6));
server_addr6.sin6_family = domain;
server_addr6.sin6_port = htons (server->port);
server_addr6.sin6_addr = in6addr_any;
if (bind_address && bind_address[0])
{
if (!inet_pton (domain, bind_address, &server_addr6.sin6_addr))
{
dogechat_printf (NULL,
/* TRANSLATORS: second "%s" is "IPv4" or "IPv6" */
_("%s%s: invalid bind address \"%s\" for %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
bind_address, "IPv6");
return 0;
}
}
ptr_addr = &server_addr6;
addr_size = sizeof (struct sockaddr_in6);
}
else
{
domain = AF_INET;
memset (&server_addr, 0, sizeof (struct sockaddr_in));
server_addr.sin_family = domain;
server_addr.sin_port = htons (server->port);
server_addr.sin_addr.s_addr = INADDR_ANY;
if (bind_address && bind_address[0])
{
if (!inet_pton (domain, bind_address, &server_addr.sin_addr))
{
dogechat_printf (NULL,
/* TRANSLATORS: second "%s" is "IPv4" or "IPv6" */
_("%s%s: invalid bind address \"%s\" for %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
bind_address, "IPv4");
return 0;
}
}
ptr_addr = &server_addr;
addr_size = sizeof (struct sockaddr_in);
}
/* create socket */
server->sock = socket (domain, SOCK_STREAM, 0);
if (server->sock < 0)
{
dogechat_printf (NULL,
_("%s%s: cannot create socket: error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
errno, strerror (errno));
if (errno == EAFNOSUPPORT)
{
dogechat_printf (NULL,
_("%s%s: try /set relay.network.ipv6 off"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME);
}
return 0;
}
#ifdef IPV6_V6ONLY
/* set option IPV6_V6ONLY to 0 or 1 */
if (server->ipv6)
{
set = (server->ipv4) ? 0 : 1;
if (setsockopt (server->sock, IPPROTO_IPV6, IPV6_V6ONLY,
(void *) &set, sizeof (set)) < 0)
{
dogechat_printf (NULL,
_("%s%s: cannot set socket option \"%s\" "
"to %d: error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
"IPV6_V6ONLY", set, errno, strerror (errno));
close (server->sock);
server->sock = -1;
return 0;
}
}
#endif /* IPV6_V6ONLY */
/* set option SO_REUSEADDR to 1 */
set = 1;
if (setsockopt (server->sock, SOL_SOCKET, SO_REUSEADDR,
(void *) &set, sizeof (set)) < 0)
{
dogechat_printf (NULL,
_("%s%s: cannot set socket option \"%s\" to %d: "
"error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
"SO_REUSEADDR", set, errno, strerror (errno));
close (server->sock);
server->sock = -1;
return 0;
}
/* set option SO_KEEPALIVE to 1 */
set = 1;
if (setsockopt (server->sock, SOL_SOCKET, SO_KEEPALIVE,
(void *) &set, sizeof (set)) < 0)
{
dogechat_printf (NULL,
_("%s%s: cannot set socket option \"%s\" to %d: "
"error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
"SO_KEEPALIVE", set, errno, strerror (errno));
close (server->sock);
server->sock = -1;
return 0;
}
/* bind */
if (bind (server->sock, (struct sockaddr *)ptr_addr, addr_size) < 0)
{
dogechat_printf (NULL,
_("%s%s: cannot \"bind\" on port %d (%s): error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
server->port, server->protocol_string,
errno, strerror (errno));
close (server->sock);
server->sock = -1;
return 0;
}
max_clients = dogechat_config_integer (relay_config_network_max_clients);
if (listen (server->sock, max_clients) != 0)
{
dogechat_printf (NULL,
_("%s%s: cannot \"listen\" on port %d (%s): error %d %s"),
dogechat_prefix ("error"), RELAY_PLUGIN_NAME,
server->port, server->protocol_string,
errno, strerror (errno));
close (server->sock);
server->sock = -1;
return 0;
}
dogechat_printf (NULL,
_("%s: listening on port %d (relay: %s, %s, max %d clients)"),
RELAY_PLUGIN_NAME,
server->port,
server->protocol_string,
((server->ipv4 && server->ipv6) ? "IPv4+6" : ((server->ipv6) ? "IPv6" : "IPv4")),
max_clients);
server->hook_fd = dogechat_hook_fd (server->sock,
1, 0, 0,
&relay_server_sock_cb,
server);
server->start_time = time (NULL);
return 1;
}
int
xfer_network_connect (struct t_xfer *xfer)
{
int flags;
if (xfer->type == XFER_TYPE_CHAT_SEND)
xfer->status = XFER_STATUS_WAITING;
else
xfer->status = XFER_STATUS_CONNECTING;
if (XFER_IS_SEND(xfer->type))
{
/* create socket */
if (xfer->sock < 0)
{
xfer->sock = socket (xfer->local_address->sa_family, SOCK_STREAM,
0);
if (xfer->sock < 0)
return 0;
}
/* listen to socket */
flags = fcntl (xfer->sock, F_GETFL);
if (flags == -1)
flags = 0;
if (fcntl (xfer->sock, F_SETFL, flags | O_NONBLOCK) == -1)
return 0;
if (listen (xfer->sock, 1) == -1)
return 0;
if (fcntl (xfer->sock, F_SETFL, flags) == -1)
return 0;
xfer->hook_fd = dogechat_hook_fd (xfer->sock,
1, 0, 0,
&xfer_network_fd_cb,
xfer);
/* add timeout */
if (dogechat_config_integer (xfer_config_network_timeout) > 0)
{
xfer->hook_timer = dogechat_hook_timer (dogechat_config_integer (xfer_config_network_timeout) * 1000,
0, 1,
&xfer_network_timer_cb,
xfer);
}
}
/* for chat receiving, connect to listening host */
if (xfer->type == XFER_TYPE_CHAT_RECV)
{
xfer->hook_connect = dogechat_hook_connect (xfer->proxy,
xfer->remote_address_str,
xfer->port, 1, 0, NULL, NULL,
0, "NONE", NULL,
&xfer_network_connect_chat_recv_cb,
xfer);
}
/* for file receiving, connection is made in child process (blocking) */
return 1;
}
