/**
* @brief Function that will listen for new connections to the server sockets.
*
* This creates a g_socket_listener and will loop waiting for new connections until
* the scheduler is closed.
*
* @param scheduler Relevant scheduler structure
* @return (void*)0 on failure, (void*)1 on success
*/
void* interface_listen_thread(scheduler_t* scheduler)
{
GSocketListener* server_socket;
GSocketConnection* new_connection;
GError* error = NULL;
/* validate new thread */
if(scheduler->i_terminate || !scheduler->i_created)
{
ERROR("Could not create server socket thread\n");
return (void*)0;
}
/* create the server socket to listen for connections on */
server_socket = g_socket_listener_new();
if(server_socket == NULL)
FATAL("could not create the server socket");
g_socket_listener_add_inet_port(server_socket, scheduler->i_port, NULL, &error);
if(error)
FATAL("[port:%d]: %s", scheduler->i_port, error->message);
scheduler->cancel = g_cancellable_new();
V_INTERFACE("INTERFACE: listening port is %d\n", scheduler->i_port);
/* wait for new connections */
for(;;)
{
new_connection = g_socket_listener_accept(server_socket, NULL,
scheduler->cancel, &error);
if(scheduler->i_terminate)
break;
V_INTERFACE("INTERFACE: new interface connection\n");
if(error)
FATAL("INTERFACE closing for %s", error->message);
interface_conn_init(new_connection, scheduler->workers);
}
V_INTERFACE("INTERFACE: socket listening thread closing\n");
g_socket_listener_close(server_socket);
g_object_unref(server_socket);
return (void*)1;
}
static void net_removeTCPSocketListener(struct node *n, guint classid)
{
g_socket_service_stop(n->tcpsockets[classid].socketservice);
g_socket_listener_close(
G_SOCKET_LISTENER(n->tcpsockets[classid].socketservice));
g_object_unref(n->tcpsockets[classid].socketservice);
//FIXME: unref address results in segfault?
//g_object_unref(sa);
}
static void
_eventd_evp_stop(EventdPluginContext *service)
{
#ifdef ENABLE_AVAHI
eventd_evp_avahi_stop(service->avahi);
#endif /* ENABLE_AVAHI */
g_slist_free_full(service->clients, _eventd_service_client_disconnect);
g_socket_service_stop(service->service);
g_socket_listener_close(G_SOCKET_LISTENER(service->service));
g_object_unref(service->service);
}
static void
g_socket_listener_finalize (GObject *object)
{
GSocketListener *listener = G_SOCKET_LISTENER (object);
if (listener->priv->main_context)
g_main_context_unref (listener->priv->main_context);
if (!listener->priv->closed)
g_socket_listener_close (listener);
g_ptr_array_free (listener->priv->sockets, TRUE);
G_OBJECT_CLASS (g_socket_listener_parent_class)
->finalize (object);
}
void net_removeSockets(struct node *n)
{
avahi_removeServices(n);
syslog(LOG_DEBUG,"net_removeSockets: Closing sockets of node %s\n",n->id);
guint i;
for(i=0; i<sizeof(n->classes); i++){
if( n->classes[i] != 0 ){
net_removeUDPSocket(n, i);
net_removeTCPSocketListener(n, i);
}
}
g_socket_service_stop(n->mgtsocket.socketservice);
g_socket_listener_close(G_SOCKET_LISTENER(n->mgtsocket.socketservice));
g_object_unref(n->mgtsocket.socketservice);
}
/* note that address_entry has already been validated =>
* both host and port (guaranteed to be a number in [0, 65535]) are set (family is optional)
*/
static gboolean
try_tcp (GDBusServer *server,
const gchar *address_entry,
GHashTable *key_value_pairs,
gboolean do_nonce,
GError **error)
{
gboolean ret;
const gchar *host;
const gchar *port;
gint port_num;
GResolver *resolver;
GList *resolved_addresses;
GList *l;
ret = FALSE;
resolver = NULL;
resolved_addresses = NULL;
host = g_hash_table_lookup (key_value_pairs, "host");
port = g_hash_table_lookup (key_value_pairs, "port");
/* family = g_hash_table_lookup (key_value_pairs, "family"); */
if (g_hash_table_lookup (key_value_pairs, "noncefile") != NULL)
{
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Cannot specify nonce file when creating a server"));
goto out;
}
if (host == NULL)
host = "localhost";
if (port == NULL)
port = "0";
port_num = strtol (port, NULL, 10);
resolver = g_resolver_get_default ();
resolved_addresses = g_resolver_lookup_by_name (resolver,
host,
NULL,
error);
if (resolved_addresses == NULL)
goto out;
/* TODO: handle family */
for (l = resolved_addresses; l != NULL; l = l->next)
{
GInetAddress *address = G_INET_ADDRESS (l->data);
GSocketAddress *socket_address;
GSocketAddress *effective_address;
socket_address = g_inet_socket_address_new (address, port_num);
if (!g_socket_listener_add_address (server->listener,
socket_address,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
NULL, /* GObject *source_object */
&effective_address,
error))
{
g_object_unref (socket_address);
goto out;
}
if (port_num == 0)
/* make sure we allocate the same port number for other listeners */
port_num = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (effective_address));
g_object_unref (effective_address);
g_object_unref (socket_address);
}
if (do_nonce)
{
gint fd;
guint n;
gsize bytes_written;
gsize bytes_remaining;
char *file_escaped;
server->nonce = g_new0 (guchar, 16);
for (n = 0; n < 16; n++)
server->nonce[n] = g_random_int_range (0, 256);
fd = g_file_open_tmp ("gdbus-nonce-file-XXXXXX",
&server->nonce_file,
error);
if (fd == -1)
{
g_socket_listener_close (server->listener);
goto out;
}
again:
bytes_written = 0;
bytes_remaining = 16;
while (bytes_remaining > 0)
{
gssize ret;
ret = write (fd, server->nonce + bytes_written, bytes_remaining);
if (ret == -1)
{
if (errno == EINTR)
goto again;
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
_("Error writing nonce file at '%s': %s"),
server->nonce_file,
strerror (errno));
goto out;
}
bytes_written += ret;
bytes_remaining -= ret;
}
if (!g_close (fd, error))
goto out;
file_escaped = g_uri_escape_string (server->nonce_file, "/\\", FALSE);
server->client_address = g_strdup_printf ("nonce-tcp:host=%s,port=%d,noncefile=%s",
host,
port_num,
file_escaped);
g_free (file_escaped);
}
else
{
server->client_address = g_strdup_printf ("tcp:host=%s,port=%d", host, port_num);
}
server->is_using_listener = TRUE;
ret = TRUE;
out:
g_list_free_full (resolved_addresses, g_object_unref);
g_object_unref (resolver);
return ret;
}
