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)); }