void lllp_quit_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) {
GtkListStore *store_library = GTK_LIST_STORE(pstore_library);
gsize i;
GtkTreeIter iter;
gboolean valid;
GSocketConnection *connection;
GSocketAddress *remote_socket_addr;
GInetAddress *remote_addr;
gchar *remote_addr_char;
gchar *tempchar;
connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL);
remote_socket_addr = g_socket_connection_get_remote_address(connection, NULL);
remote_addr = g_inet_socket_address_get_address((GInetSocketAddress *)(remote_socket_addr));
remote_addr_char = g_inet_address_to_string(remote_addr);
if(connection != NULL) {
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter);
while(valid == TRUE) {
gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, INET_ADDRESS, &tempchar, -1);
if(g_strcmp0(tempchar, remote_addr_char) == 0)
gtk_list_store_remove(store_library, &iter);
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter);
}
printf("LLLP %s DISCONNECTED\n", remote_addr_char);
}
g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_quit_cb, store_library);
}
void lllp_connected_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) {
GtkListStore *store_library = GTK_LIST_STORE(pstore_library);
GSocketConnection *connection;
GSocketAddress *address;
gchar *address_char;
GInputStream *stream;
GFile *output_file;
GOutputStream *file_stream;
gsize count;
gboolean valid = FALSE;
connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL);
address = g_socket_connection_get_remote_address(connection, NULL);
address_char = g_inet_address_to_string(g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address)));
printf("%s\n", address_char);
output_file = g_file_new_for_path(address_char);
g_file_delete(output_file, NULL, NULL);
file_stream = (GOutputStream*)g_file_replace(output_file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL);
stream = g_io_stream_get_input_stream(G_IO_STREAM(connection));
g_output_stream_splice(file_stream, stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE & G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL);
g_output_stream_close(file_stream, NULL, NULL);
convert_library_to_list_store(store_library, address_char);
printf("%s CONNECTED\n", address_char);
g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_connected_cb, store_library);
}
void
socket_listen(char *suffix)
{
GSocketService *sock;
GSocketAddress *sa;
GError *err = NULL;
char *name, *path;
name = g_strdup_printf("%s-%s", __NAME__, suffix);
path = g_build_filename(g_get_user_runtime_dir(), name, NULL);
g_free(name);
unlink(path);
sa = g_unix_socket_address_new(path);
g_free(path);
sock = g_threaded_socket_service_new(-1);
if (!g_socket_listener_add_address(G_SOCKET_LISTENER(sock), sa,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT,
NULL, NULL, &err))
{
fprintf(stderr, "Failed to set up socket: '%s'\n", err->message);
exit(EXIT_FAILURE);
}
g_signal_connect(G_OBJECT(sock), "run", G_CALLBACK(sock_incoming), NULL);
g_socket_service_start(sock);
}
static void
identd_start_server (void)
{
GError *error = NULL;
int enabled, port = 113;
if (hextor_get_prefs (ph, "identd", NULL, &enabled) == 3)
{
if (!enabled)
return;
}
if (hextor_get_prefs (ph, "identd_port", NULL, &port) == 2 && (port <= 0 || port > G_MAXUINT16))
{
port = 113;
}
service = g_socket_service_new ();
g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), port, NULL, &error);
if (error)
{
hextor_printf (ph, _("*\tError starting identd server: %s"), error->message);
g_object_unref (service);
service = NULL;
return;
}
/*hextor_printf (ph, "*\tIdentd listening on port: %d", port); */
g_signal_connect (G_OBJECT (service), "incoming", G_CALLBACK(identd_incoming_cb), NULL);
g_socket_service_start (service);
}
GLibJsonRpcServer *glib_jsonrpc_server_new(int port)
{
GLibJsonRpcServerPrivate *jsonrpc_server = g_new0(GLibJsonRpcServerPrivate, 1);
GError *error = NULL;
jsonrpc_server->service = g_threaded_socket_service_new (10);
jsonrpc_server->async_busy = FALSE;
jsonrpc_server->allow_non_loopback_connections = FALSE;
if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (jsonrpc_server->service),
port,
NULL,
&error))
{
// Silently ignore failed servers and return a NULL server.
// g_printerr ("%s\n", error->message);
g_error_free(error);
g_free(jsonrpc_server);
return NULL;
}
g_signal_connect (jsonrpc_server->service, "run", G_CALLBACK (handler), jsonrpc_server);
jsonrpc_server->command_hash = g_hash_table_new(g_str_hash,
g_str_equal);
return (GLibJsonRpcServer*)jsonrpc_server;
}
void owr_image_server_add_image_renderer(OwrImageServer *image_server,
OwrImageRenderer *image_renderer, const gchar *tag)
{
OwrImageServerPrivate *priv;
g_return_if_fail(OWR_IS_IMAGE_SERVER(image_server));
g_return_if_fail(OWR_IS_IMAGE_RENDERER(image_renderer));
g_return_if_fail(tag && tag[0]);
priv = image_server->priv;
g_mutex_lock(&priv->image_renderers_mutex);
if (!g_hash_table_contains(priv->image_renderers, tag)) {
g_hash_table_insert(priv->image_renderers, g_strdup(tag), image_renderer);
g_object_ref(image_renderer);
} else
g_warning("Image renderer not added, an image renderer is already added for this tag");
g_mutex_unlock(&priv->image_renderers_mutex);
if (!priv->socket_service_is_started) {
g_socket_listener_add_address(G_SOCKET_LISTENER(priv->socket_service),
g_inet_socket_address_new(g_inet_address_new_from_string("127.0.0.1"),
(guint16)priv->port), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP,
NULL, NULL, NULL);
g_socket_service_start(priv->socket_service);
priv->socket_service_is_started = TRUE;
}
}
gboolean
cockpit_web_server_add_socket (CockpitWebServer *self,
GSocket *socket,
GError **error)
{
return g_socket_listener_add_socket (G_SOCKET_LISTENER (self->socket_service), socket, NULL, error);
}
static void
test_happy_eyeballs_cancel_delayed (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
GCancellable *cancel;
gboolean got_completed_event = FALSE;
/* This just tests that cancellation works as expected, still emits the completed signal,
* and never returns a connection */
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
client = g_socket_client_new ();
cancel = g_cancellable_new ();
g_socket_client_connect_to_host_async (client, "localhost", port, cancel, on_connected_cancelled, loop);
g_timeout_add (1, (GSourceFunc) on_timer, cancel);
g_signal_connect (client, "event", G_CALLBACK (on_event), &got_completed_event);
g_main_loop_run (loop);
g_assert_true (got_completed_event);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
g_object_unref (cancel);
}
static void
test_happy_eyeballs_cancel_instant (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
GCancellable *cancel;
gboolean got_completed_event = FALSE;
/* This tests the same things as above, test_happy_eyeballs_cancel_delayed(), but
* with different timing since it sends an already cancelled cancellable */
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
client = g_socket_client_new ();
cancel = g_cancellable_new ();
g_cancellable_cancel (cancel);
g_socket_client_connect_to_host_async (client, "localhost", port, cancel, on_connected_cancelled, loop);
g_signal_connect (client, "event", G_CALLBACK (on_event), &got_completed_event);
g_main_loop_run (loop);
g_assert_true (got_completed_event);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
g_object_unref (cancel);
}
static void
test_happy_eyeballs (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
/* All of the magic here actually happens in slow-connect-preload.c
* which as you would guess is preloaded. So this is just making a
* normal connection that happens to take 600ms each time. This will
* trigger the logic to make multiple parallel connections.
*/
client = g_socket_client_new ();
g_socket_client_connect_to_host_async (client, "localhost", port, NULL, on_connected, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
}
static gboolean net_createTCPSocket(struct node *n, guint classid)
{
guint port = 2300+n->classes[classid];
GError * err = NULL;
GInetAddress *addr = n->netadr;
syslog(LOG_DEBUG,"net_createSockets: Creating tcp socket listener "
"on port %u\n", port);
GSocketAddress *sa = g_inet_socket_address_new(addr,port);
GSocketService *gss = g_socket_service_new();
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), sa,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &err)
== FALSE ){
syslog(LOG_WARNING, "net_createSockets: Error while creating"
"socket listener: %s\n", err->message);
g_error_free(err);
g_object_unref(gss);
return FALSE;
}
n->tcpsockets[classid].n = n;
n->tcpsockets[classid].socketservice = gss;
n->tcpsockets[classid].socketaddress = sa;
n->tcpsockets[classid].classid = classid;
g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener),
&(n->tcpsockets[classid]));
g_socket_service_start(gss);
return TRUE;
}
int
main (int argc, char *argv[])
{
GSocketService *service;
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new (" - Test GSocket server stuff");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
service = g_threaded_socket_service_new (10);
if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service),
port,
NULL,
&error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
g_print ("Echo service listening on port %d\n", port);
g_signal_connect (service, "run", G_CALLBACK (handler), NULL);
g_main_loop_run (g_main_loop_new (NULL, FALSE));
g_assert_not_reached ();
}
static void
create_tube_socket_connected_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GSocketListener *listener = G_SOCKET_LISTENER (source_object);
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->connection = g_socket_listener_accept_finish (listener, res, NULL,
&error);
if (data->connection != NULL)
{
/* Transfer ownership of unix path */
g_object_set_data_full (G_OBJECT (data->connection), "unix-path",
data->unix_path, (GDestroyNotify) unix_path_destroy);
data->unix_path = NULL;
}
create_tube_complete (simple, error);
g_clear_error (&error);
g_object_unref (simple);
}
static void
do_accept (GSocketService *service)
{
g_socket_listener_accept_async (G_SOCKET_LISTENER (service),
service->priv->cancellable,
g_socket_service_ready, NULL);
service->priv->outstanding_accept = TRUE;
}
static void
_j4status_io_add_systemd(J4statusIOContext *self)
{
#ifdef ENABLE_SYSTEMD
gint fds = sd_listen_fds(TRUE);
if ( fds < 0 )
{
g_warning("Failed to acquire systemd sockets: %s", g_strerror(-fds));
return;
}
if ( fds == 0 )
return;
gboolean socket_added = FALSE;
_j4status_io_add_server(self);
GError *error = NULL;
gint fd;
for ( fd = SD_LISTEN_FDS_START ; fd < SD_LISTEN_FDS_START + fds ; ++fd )
{
gint r;
r = sd_is_socket(fd, AF_UNSPEC, SOCK_STREAM, 1);
if ( r < 0 )
{
g_warning("Failed to verify systemd socket type: %s", g_strerror(-r));
continue;
}
if ( r == 0 )
continue;
GSocket *socket;
socket = g_socket_new_from_fd(fd, &error);
if ( socket == NULL )
{
g_warning("Failed to take a socket from systemd: %s", error->message);
g_clear_error(&error);
continue;
}
if ( ! g_socket_listener_add_socket(G_SOCKET_LISTENER(self->server), socket, NULL, &error) )
{
g_warning("Failed to add systemd socket to server: %s", error->message);
g_clear_error(&error);
continue;
}
socket_added = TRUE;
}
if ( ! socket_added )
{
g_object_unref(self->server);
self->server = NULL;
}
#endif /* ENABLE_SYSTEMD */
}
gboolean xr_server_bind(xr_server* server, const char* bind_addr, GError** err)
{
GError* local_err = NULL;
char* addr = NULL;
int port = 0;
xr_trace(XR_DEBUG_SERVER_TRACE, "(server=%p, bind_addr=%s, err=%p)", server, bind_addr, err);
g_return_val_if_fail(server != NULL, FALSE);
g_return_val_if_fail(bind_addr != NULL, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
g_return_val_if_fail(_parse_addr(bind_addr, &addr, &port), FALSE);
if (addr[0] == '*')
{
g_socket_listener_add_inet_port(G_SOCKET_LISTENER(server->service), (guint16)port, NULL, &local_err);
}
else
{
// build address
GInetAddress* iaddr = g_inet_address_new_from_string(addr);
if (!iaddr)
{
g_error_new(XR_SERVER_ERROR, XR_SERVER_ERROR_FAILED, "Invalid address: %s", bind_addr);
g_free(addr);
xr_server_stop(server);
return FALSE;
}
GSocketAddress* isaddr = g_inet_socket_address_new(iaddr, (guint16)port);
g_socket_listener_add_address(G_SOCKET_LISTENER(server->service), isaddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &local_err);
}
g_free(addr);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Port listen failed: ");
xr_server_stop(server);
return FALSE;
}
return TRUE;
}
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);
}
void
spice_foreign_menu_listener_accept_async (GObject *listener,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(G_IS_OBJECT(listener));
#ifdef G_OS_WIN32
spice_named_pipe_listener_accept_async (SPICE_NAMED_PIPE_LISTENER (listener), cancellable, callback, user_data);
#else
g_socket_listener_accept_async (G_SOCKET_LISTENER (listener), cancellable, callback, user_data);
#endif
}
static gboolean
initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
DasomServer *server = DASOM_SERVER (initable);
GSocketAddress *address;
GError *local_error = NULL;
server->listener = G_SOCKET_LISTENER (g_socket_service_new ());
/* server->listener = G_SOCKET_LISTENER (g_threaded_socket_service_new (-1)); */
if (g_unix_socket_address_abstract_names_supported ())
address = g_unix_socket_address_new_with_type (server->address, -1,
G_UNIX_SOCKET_ADDRESS_ABSTRACT);
else
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Abstract UNIX domain socket names are not supported.");
return FALSE;
}
g_socket_listener_add_address (server->listener, address,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT,
NULL, NULL, &local_error);
g_object_unref (address);
if (local_error)
{
g_propagate_error (error, local_error);
return FALSE;
}
server->is_using_listener = TRUE;
server->run_signal_handler_id =
g_signal_connect (G_SOCKET_SERVICE (server->listener), "incoming",
(GCallback) on_new_connection, server);
/*
server->run_signal_handler_id = g_signal_connect (G_SOCKET_SERVICE (server->listener),
"run",
G_CALLBACK (on_run),
server);
*/
return TRUE;
}
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);
}
void dirserver_init(gchar* baseaddress)
{
syslog(LOG_DEBUG,"dirserver_init: starting directory server");
services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
dirserversocket = multicast_createSocket("directoryserver", 2323, &sa);
if( socket != NULL){
syslog(LOG_DEBUG,"dirserver_init: socket open");
GSource *source = g_socket_create_source(dirserversocket,
G_IO_IN, NULL);
ub_assert(source != NULL);
g_source_set_callback(source, (GSourceFunc)dirserver_read,
NULL, NULL);
g_source_attach(source, g_main_context_default());
}else{
syslog(LOG_WARNING,
"directory-server.c: warning: could not create socket");
}
GError * e = NULL;
GInetAddress *net_base = g_inet_address_new_from_string(baseaddress);
if( net_base == NULL ){
syslog(LOG_ERR, "dirserver_init: Could not parse base address");
return;
}
//set up http tcp listener
GSocketAddress *httpsa = g_inet_socket_address_new(net_base,8080);
syslog(LOG_DEBUG,"dirserver_init: Creating tcp socket on port 8080\n");
GSocketService *gss = g_socket_service_new();
//TODO: save a reference to the gss somewhere
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), httpsa,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e)
== FALSE ){
syslog(LOG_WARNING,
"dirserver_init: error while creating socket listener: %s\n",e->message);
g_error_free(e);
}
g_signal_connect(gss, "incoming", G_CALLBACK(dirserver_tcp_listener),NULL);
g_socket_service_start(gss);
g_timeout_add_seconds(1,dirserver_tick,NULL);
}
static void
g_socket_listener_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GSocketListener *listener = G_SOCKET_LISTENER (object);
switch (prop_id)
{
case PROP_LISTEN_BACKLOG:
g_value_set_int (value, listener->priv->listen_backlog);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
gint net_init(gchar* interface, gchar* baseaddress, gchar *multicastbase)
{
GError * e = NULL;
interface = NULL; //prevent warning
net_base = g_inet_address_new_from_string(baseaddress);
if( net_base == NULL ){
syslog(LOG_ERR, "net_init: Could not parse base address");
return -1;
}
struct node n;
n.netadr = net_base;
n.ubnetd = NULL;
syslog(LOG_DEBUG,"creating base address...\n");
interface_createAddress(&n);
usleep(3000*1000);
syslog(LOG_DEBUG,"done\n");
net_multicastbase = g_inet_address_new_from_string(multicastbase);
if( net_multicastbase == NULL ){
syslog(LOG_ERR, "net_init: Could not parse multicast base address");
return -1;
}
address6_init(net_base, net_multicastbase);
tcp_init();
GSocketAddress * sa = g_inet_socket_address_new(net_base,2323);
//set up data tcp listener
syslog(LOG_DEBUG,"net_init: Creating tcp socket on port 2323\n");
GSocketService *gss = g_socket_service_new();
//TODO: save a reference to the gss somewhere
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), sa,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &e)
== FALSE ){
syslog(LOG_WARNING, "net_init: error while creating socket listener: %s\n",
e->message);
g_error_free(e);
}
g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener),NULL);
g_socket_service_start(gss);
g_object_unref(sa);
return 0;
}
void net_createSockets(struct node *n)
{
GInetAddress *addr = n->netadr;
gchar *tmp = g_inet_address_to_string(addr);
syslog(LOG_DEBUG,"net_createSockets: Creating sockets on ip: %s\n",tmp);
g_free(tmp);
guint i;
for(i=0; i<sizeof(n->classes); i++){
if( n->classes[i] != 0 ){
if( !(net_createUDPSocket(n, i) &&
net_createTCPSocket(n, i)) )
return;
}
}
syslog(LOG_DEBUG,"net_createSockets: Creating tcp management socket listener on port 2324\n");
GError * err = NULL;
GSocketAddress * samgt = g_inet_socket_address_new(addr,2324);
GSocketService *gss = g_socket_service_new();
if( g_socket_listener_add_address(G_SOCKET_LISTENER(gss), samgt,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &err)
== FALSE ){
syslog(LOG_WARNING, "net_createSockets: Error while creating socket listener: %s\n", err->message);
g_error_free(err);
g_object_unref(gss);
return;
}
n->mgtsocket.n = n;
n->mgtsocket.socketservice = gss;
n->mgtsocket.socketaddress = samgt;
g_signal_connect(gss, "incoming", G_CALLBACK(tcp_listener),
&(n->mgtsocket));
g_socket_service_start(gss);
syslog(LOG_DEBUG,"net_createSockets: activating network for this node\n");
avahi_registerServices(n);
n->netup = TRUE;
}
/**
* Register the flare service port
*/
void create_service(gchar *address, uint16_t port, GCallback *callback, gulong *handler_id)
{
GSocketService *service = g_socket_service_new();
GInetAddress *inet_address = g_inet_address_new_from_string(address);
GSocketAddress *socket_address = g_inet_socket_address_new(inet_address, port);
g_socket_listener_add_address(
G_SOCKET_LISTENER(service),
socket_address,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
NULL, NULL, NULL);
g_object_unref(socket_address);
g_object_unref(inet_address);
*handler_id = g_signal_connect(service, "incoming", G_CALLBACK(callback), NULL);
g_socket_service_start(service);
g_assert(g_socket_service_is_active(service));
}
GIOStream*
spice_foreign_menu_listener_accept_finish (GObject *listener,
GAsyncResult *result,
GObject **source_object,
GError **error)
{
g_return_val_if_fail(G_IS_OBJECT(listener), NULL);
#ifdef G_OS_WIN32
SpiceNamedPipeConnection *np;
np = spice_named_pipe_listener_accept_finish (SPICE_NAMED_PIPE_LISTENER (listener), result, source_object, error);
if (np)
return G_IO_STREAM (np);
#else
GSocketConnection *socket;
socket = g_socket_listener_accept_finish (G_SOCKET_LISTENER (listener), result, source_object, error);
if (socket)
return G_IO_STREAM (socket);
#endif
return NULL;
}
static GList *
_eventd_evp_add_socket(GList *used_sockets, EventdPluginContext *context, const gchar * const *binds)
{
GList *sockets;
sockets = libeventd_core_get_sockets(context->core, context->core_interface, binds);
GList *socket_;
for ( socket_ = sockets ; socket_ != NULL ; socket_ = g_list_next(socket_) )
{
GError *error = NULL;
if ( ! g_socket_listener_add_socket(G_SOCKET_LISTENER(context->service), socket_->data, NULL, &error) )
{
g_warning("Unable to add socket: %s", error->message);
g_clear_error(&error);
}
else
used_sockets = g_list_prepend(used_sockets, g_object_ref(socket_->data));
}
g_list_free_full(sockets, g_object_unref);
return used_sockets;
}
void cortrol_service_init()
{
GError * error = NULL;
control_service_data.cmd_buf = NULL;
/* create the new socketservice */
control_service_data.service = g_socket_service_new ();
GInetAddress *address = g_inet_address_new_from_string(inet_ntoa(local_ip));
GSocketAddress *socket_address = g_inet_socket_address_new(address, CONTROL_PORT);
g_socket_listener_add_address(G_SOCKET_LISTENER(control_service_data.service), socket_address, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL, NULL, NULL);
/* connect to the port */
/*g_socket_listener_add_inet_port ((GSocketListener*)control_service_data.service,
CONTROL_PORT,
NULL,
&error);*/
/* don't forget to check for errors */
if (error != NULL)
{
g_error ("%s", error->message);
}
/* listen to the 'incoming' signal */
g_signal_connect (control_service_data.service,
"incoming",
G_CALLBACK (incoming_callback),
NULL);
/* start the socket service */
g_socket_service_start (control_service_data.service);
/* enter mainloop */
g_print ("Waiting for client! %s\n", inet_ntoa(local_ip));
}
