static void
infinoted_plugin_document_stream_close_stream(
InfinotedPluginDocumentStreamStream* stream)
{
stream->plugin->streams = g_slist_remove(stream->plugin->streams, stream);
if(stream->proxy != NULL || stream->subscribe_request != NULL)
infinoted_plugin_document_stream_stop(stream, FALSE);
if(stream->navigate_handle != NULL)
{
infinoted_plugin_util_navigate_cancel(stream->navigate_handle);
stream->navigate_handle = NULL;
}
infinoted_plugin_document_stream_queue_finalize(&stream->send_queue);
infinoted_plugin_document_stream_queue_finalize(&stream->recv_queue);
inf_io_remove_watch(
infinoted_plugin_manager_get_io(stream->plugin->manager),
stream->watch
);
g_free(stream->username);
stream->username = NULL;
close(stream->socket);
stream->socket = -1;
if(stream->status == INFINOTED_PLUGIN_DOCUMENT_STREAM_NORMAL)
g_slice_free(InfinotedPluginDocumentStreamStream, stream);
else if(stream->status == INFINOTED_PLUGIN_DOCUMENT_STREAM_RECEIVING)
stream->status = INFINOTED_PLUGIN_DOCUMENT_STREAM_CLOSED;
}
static void
infinoted_plugin_document_stream_deinitialize(gpointer plugin_info)
{
InfinotedPluginDocumentStream* plugin;
plugin = (InfinotedPluginDocumentStream*)plugin_info;
while(plugin->streams != NULL)
{
infinoted_plugin_document_stream_close_stream(
(InfinotedPluginDocumentStreamStream*)plugin->streams->data
);
}
inf_signal_handlers_disconnect_by_func(
G_OBJECT(infinoted_plugin_manager_get_directory(plugin->manager)),
G_CALLBACK(infinoted_plugin_document_stream_node_removed_cb),
plugin
);
if(plugin->watch != NULL)
{
inf_io_remove_watch(
infinoted_plugin_manager_get_io(plugin->manager),
plugin->watch
);
}
if(plugin->socket != -1)
{
close(plugin->socket);
}
}
/**
* infinoted_signal_unregister:
* @sig: A #InfinotedSignal.
*
* Unregisters signal handlers registered with infinoted_signal_register().
*/
void
infinoted_signal_unregister(InfinotedSignal* sig)
{
#ifdef G_OS_WIN32
SetConsoleCtrlHandler(infinoted_signal_console_handler, FALSE);
#endif
#ifdef LIBINFINITY_HAVE_LIBDAEMON
if(sig->run)
{
inf_io_remove_watch(INF_IO(sig->run->io), sig->watch);
sig->watch = NULL;
daemon_signal_done();
}
#else
signal(SIGINT, sig->previous_sigint_handler);
signal(SIGTERM, sig->previous_sigterm_handler);
#ifndef G_OS_WIN32
signal(SIGQUIT, sig->previous_sigquit_handler);
signal(SIGHUP, sig->previous_sighup_handler);
#endif /* !G_OS_WIN32 */
_infinoted_signal_server = NULL;
#endif /* !LIBINFINITY_HAVE_LIBDAEMON */
g_slice_free(InfinotedSignal, sig);
}
static void
infinoted_signal_sig_func(InfNativeSocket* fd,
InfIoEvent event,
gpointer user_data)
{
InfinotedSignal* sig;
int occured;
GError* error;
sig = (InfinotedSignal*)user_data;
if(event & INF_IO_ERROR)
{
inf_io_remove_watch(INF_IO(sig->run->io), sig->watch);
daemon_signal_done();
sig->run = NULL;
sig->signal_fd = 0;
sig->watch = NULL;
infinoted_log_error(
sig->run->startup->log,
_("Error on signal handler connection; signal "
"handlers have been removed from now on")
);
}
else if(event & INF_IO_INCOMING)
{
occured = daemon_signal_next();
if(occured == SIGINT || occured == SIGTERM || occured == SIGQUIT)
{
printf("\n");
inf_standalone_io_loop_quit(sig->run->io);
}
else if(occured == SIGHUP)
{
error = NULL;
if(!infinoted_config_reload(sig->run, &error))
{
infinoted_log_error(
sig->run->startup->log,
_("Configuration reload failed: %s"), error->message
);
g_error_free(error);
}
else
{
infinoted_log_info(
sig->run->startup->log,
_("Configuration reloaded")
);
}
}
}
}
/* Handles when an error occurred during connection. Returns FALSE when the
* error was fatal. In this case, it has already emitted the "error" signal.
* Returns TRUE, if another connection attempt is made. */
static gboolean
inf_tcp_connection_connection_error(InfTcpConnection* connection,
const GError* error)
{
InfTcpConnectionPrivate* priv;
priv = INF_TCP_CONNECTION_PRIVATE(connection);
if(priv->socket != INVALID_SOCKET)
{
closesocket(priv->socket);
priv->socket = INVALID_SOCKET;
}
if(priv->watch != NULL)
{
priv->events = 0;
inf_io_remove_watch(priv->io, priv->watch);
priv->watch = NULL;
}
if(priv->resolver != NULL)
{
/* Try next address, if there is one */
if(priv->resolver_index <
inf_name_resolver_get_n_addresses(priv->resolver))
{
++priv->resolver_index;
if(inf_tcp_connection_open_with_resolver(connection, NULL) == TRUE)
return TRUE;
}
/* No new addresses available */
priv->resolver_index = 0;
}
g_signal_emit(
G_OBJECT(connection),
tcp_connection_signals[ERROR_],
0,
error
);
return FALSE;
}
/**
* inf_tcp_connection_close:
* @connection: A #InfTcpConnection.
*
* Closes a TCP connection that is either open or currently connecting.
**/
void
inf_tcp_connection_close(InfTcpConnection* connection)
{
InfTcpConnectionPrivate* priv;
g_return_if_fail(INF_IS_TCP_CONNECTION(connection));
priv = INF_TCP_CONNECTION_PRIVATE(connection);
g_return_if_fail(priv->status != INF_TCP_CONNECTION_CLOSED);
priv->events = 0;
if(priv->watch != NULL)
{
inf_io_remove_watch(priv->io, priv->watch);
priv->watch = NULL;
}
priv->front_pos = 0;
priv->back_pos = 0;
priv->status = INF_TCP_CONNECTION_CLOSED;
g_object_notify(G_OBJECT(connection), "status");
}
static void
inf_tcp_connection_error(InfTcpConnection* connection,
GError* error)
{
InfTcpConnectionPrivate* priv;
priv = INF_TCP_CONNECTION_PRIVATE(connection);
/* Normally, it would be enough to check one of both conditions, but socket
* may be already set with status still being CLOSED during
* inf_tcp_connection_open(). */
if(priv->watch != NULL)
{
priv->events = 0;
inf_io_remove_watch(priv->io, priv->watch);
priv->watch = NULL;
}
if(priv->status != INF_TCP_CONNECTION_CLOSED)
{
priv->status = INF_TCP_CONNECTION_CLOSED;
g_object_notify(G_OBJECT(connection), "status");
}
}