/**
* @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;
}
int main (int argc, char **argv) {
gtk_init_check(&argc, &argv);
GMainLoop *loop;
loop = g_main_loop_new(NULL, TRUE);
GtkListStore *store_library = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT);
GSocketListener *listener;
GSocketListener *listener_next_song;
GSocketListener *listener_quit;
gsize i;
listener = g_socket_listener_new();
listener_next_song = g_socket_listener_new();
listener_quit = g_socket_listener_new();
g_socket_listener_add_inet_port(listener_next_song, 12512, NULL, NULL);
g_socket_listener_add_inet_port(listener, 1292, NULL, NULL);
g_socket_listener_add_inet_port(listener_quit, 11912, NULL, NULL);
g_socket_listener_accept_async(listener, NULL, lllp_connected_cb, store_library);
g_socket_listener_accept_async(listener_next_song, NULL, lllp_next_song_cb, store_library);
g_socket_listener_accept_async(listener_quit, NULL, lllp_quit_cb, store_library);
// g_timeout_add(4000, test, lllp_array);
gtk_main();
return 0;
}
void GIOServiceServer::listen() throw(CommunicationModuleException){
assert(listener == nullptr);
listener = g_socket_listener_new();
if(listener == nullptr ){
throw CommunicationModuleException("Could not instantiate listener");
}
SocketType type;
GSocketAddress * gsocketAddr = getSocket(address, type);
GError * error = NULL;
int ret = g_socket_listener_add_address(listener, gsocketAddr, type == SocketType::IPC ? (GSocketType) SocketType::TCP : (GSocketType) type, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, & error);
g_object_unref(gsocketAddr);
if (! ret){
CommunicationModuleException e = CommunicationModuleException(error->message);
g_error_free(error);
throw e;
}
if(error != NULL){
g_error_free(error);
}
addAcceptorThread();
}
static void
test_event_signal (void)
{
gboolean success = FALSE;
GInetAddress *iaddr;
GSocketAddress *saddr;
GSocketListener *listener;
GError *error = NULL;
iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
saddr = g_inet_socket_address_new (iaddr, 0);
g_object_unref (iaddr);
listener = g_socket_listener_new ();
g_signal_connect (listener, "event", G_CALLBACK (event_cb), &success);
g_socket_listener_add_address (listener,
saddr,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
NULL,
NULL,
&error);
g_assert_no_error (error);
g_assert_true (success);
g_object_unref (saddr);
g_object_unref (listener);
}
GObject*
spice_foreign_menu_listener_new (const gchar *address, GError **error)
{
GObject *listener = NULL;
gchar *addr = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
addr = g_strdup (address);
#ifdef G_OS_WIN32
if (addr == NULL)
addr = g_strdup (g_getenv ("SPICE_FOREIGN_MENU_NAMEDPIPE"));
if (addr == NULL)
addr = g_strdup_printf ("\\\\.\\pipe\\SpiceForeignMenu-%" G_GUINT64_FORMAT, (guint64)GetCurrentProcessId ());
#else
if (addr == NULL)
addr = g_strdup (g_getenv ("SPICE_FOREIGN_MENU_SOCKET"));
if (addr == NULL)
addr = g_strdup_printf ("/tmp/SpiceForeignMenu-%" G_GUINT64_FORMAT ".uds", (guint64)getpid ());
#endif
if (addr == NULL) {
g_set_error (error,
SPICE_FOREIGN_MENU_LISTENER_ERROR,
SPICE_FOREIGN_MENU_LISTENER_ERROR_VALUE,
#ifdef G_OS_WIN32
"Missing namedpipe address"
#else
"Missing socket address"
#endif
);
goto end;
}
g_unlink (addr);
#ifdef G_OS_WIN32
{
SpiceNamedPipe *np;
listener = G_OBJECT (spice_named_pipe_listener_new ());
np = spice_win32_user_pipe_new (addr, error);
if (!np) {
g_object_unref (listener);
listener = NULL;
goto end;
}
spice_named_pipe_listener_add_named_pipe (SPICE_NAMED_PIPE_LISTENER (listener), np);
}
#else
{
listener = G_OBJECT (g_socket_listener_new ());
if (!g_socket_listener_add_address (G_SOCKET_LISTENER (listener),
G_SOCKET_ADDRESS (g_unix_socket_address_new (addr)),
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT,
NULL,
NULL,
error))
g_warning ("failed to add address");
}
#endif
end:
g_free (addr);
return listener;
}
static void
create_channel_cb (GObject *acr,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GSocketListener *listener = NULL;
gchar *dir;
GSocket *socket = NULL;
GSocketAddress *socket_address = NULL;
GValue *address;
GHashTable *parameters;
GError *error = NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
if (g_cancellable_is_cancelled (data->op_cancellable))
{
g_object_unref (simple);
return;
}
data->channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (acr), res, NULL, &error);
if (data->channel == NULL)
goto OUT;
data->invalidated_id = g_signal_connect (data->channel, "invalidated",
G_CALLBACK (create_tube_channel_invalidated_cb), simple);
/* We are client side, but we have to offer a socket... So we offer an unix
* socket on which the service side can connect. We also create an IPv4 socket
* on which the ssh client can connect. When both sockets are connected,
* we can forward all communications between them. */
listener = g_socket_listener_new ();
/* Create temporary file for our unix socket */
dir = g_build_filename (g_get_tmp_dir (), "telepathy-ssh-XXXXXX", NULL);
dir = mkdtemp (dir);
data->unix_path = g_build_filename (dir, "unix-socket", NULL);
g_free (dir);
/* Create the unix socket, and listen for connection on it */
socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT, &error);
if (socket == NULL)
goto OUT;
socket_address = g_unix_socket_address_new (data->unix_path);
if (!g_socket_bind (socket, socket_address, FALSE, &error))
goto OUT;
if (!g_socket_listen (socket, &error))
goto OUT;
if (!g_socket_listener_add_socket (listener, socket, NULL, &error))
goto OUT;
g_socket_listener_accept_async (listener, data->op_cancellable,
create_tube_socket_connected_cb, g_object_ref (simple));
/* Offer the socket */
address = tp_address_variant_from_g_socket_address (socket_address,
TP_SOCKET_ADDRESS_TYPE_UNIX, &error);
if (address == NULL)
goto OUT;
parameters = g_hash_table_new (NULL, NULL);
data->offer_call = tp_cli_channel_type_stream_tube_call_offer (data->channel,
-1,
TP_SOCKET_ADDRESS_TYPE_UNIX, address,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST, parameters,
create_tube_offer_cb, g_object_ref (simple), g_object_unref, NULL);
tp_g_value_slice_free (address);
g_hash_table_unref (parameters);
OUT:
if (error != NULL)
create_tube_complete (simple, error);
tp_clear_object (&listener);
tp_clear_object (&socket);
tp_clear_object (&socket_address);
g_clear_error (&error);
g_object_unref (simple);
}
