GDBusConnection * _g_bus_get_priv (GBusType bus_type, GCancellable *cancellable, GError **error) { gchar *address; GDBusConnection *ret; ret = NULL; address = g_dbus_address_get_for_bus_sync (bus_type, cancellable, error); if (address == NULL) goto out; ret = g_dbus_connection_new_for_address_sync (address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, /* GDBusAuthObserver */ cancellable, error); g_free (address); out: return ret; }
static gpointer test_auth_client_thread_func (gpointer user_data) { TestAuthData *data = user_data; GDBusConnection *c = NULL; GError *error = NULL; GDBusAuthObserver *auth_observer = NULL; auth_observer = g_dbus_auth_observer_new (); g_signal_connect (auth_observer, "allow-mechanism", G_CALLBACK (server_on_allow_mechanism), (gpointer) data->allowed_client_mechanism); c = g_dbus_connection_new_for_address_sync (data->address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, auth_observer, NULL, /* GCancellable */ &error); g_assert_no_error (error); g_assert (c != NULL); g_clear_object (&c); g_clear_object (&auth_observer); return NULL; }
GDBusConnection * _get_root_socket_bus_connection ( GError **error) { gchar address[128]; g_snprintf (address, 127, TLM_DBUS_ROOT_SOCKET_ADDRESS); return g_dbus_connection_new_for_address_sync (address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, error); }
static gboolean photos_thumbnailer_dbus_register (GApplication *application, GDBusConnection *connection, const gchar *object_path, GError **error) { PhotosThumbnailer *self = PHOTOS_THUMBNAILER (application); g_autoptr (GDBusAuthObserver) observer = NULL; gboolean ret_val = FALSE; g_return_val_if_fail (self->skeleton == NULL, FALSE); if (!G_APPLICATION_CLASS (photos_thumbnailer_parent_class)->dbus_register (application, connection, object_path, error)) goto out; observer = g_dbus_auth_observer_new (); g_signal_connect_swapped (observer, "authorize-authenticated-peer", G_CALLBACK (photos_thumbnailer_authorize_authenticated_peer), self); self->connection = g_dbus_connection_new_for_address_sync (self->address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, observer, NULL, error); if (self->connection == NULL) goto out; self->skeleton = photos_thumbnailer_dbus_skeleton_new (); g_signal_connect_swapped (self->skeleton, "handle-cancel", G_CALLBACK (photos_thumbnailer_handle_cancel), self); g_signal_connect_swapped (self->skeleton, "handle-generate-thumbnail", G_CALLBACK (photos_thumbnailer_handle_generate_thumbnail), self); if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->skeleton), self->connection, THUMBNAILER_PATH, error)) { g_clear_object (&self->skeleton); goto out; } ret_val = TRUE; out: return ret_val; }
void connect() { GError *error = NULL; m_conn = g_dbus_connection_new_for_address_sync( SERVER_ADDR, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); if (m_conn == NULL) { g_error("g_dbus_connection_new_for_address_sync() failed: %s", error->message); exit(-1); } }
GDBusConnection* WebKitTestBus::getOrCreateConnection() { if (m_connection) return m_connection.get(); g_assert(!m_address.isNull()); m_connection = adoptGRef(g_dbus_connection_new_for_address_sync(m_address.data(), static_cast<GDBusConnectionFlags>(G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION), 0, 0, 0)); return m_connection.get(); }
static int wrtc_setup(wrtc_t *wrtc) { static srs_client_ops_t ops = { .notify_focus = focus_cb, .notify_command = command_cb }; srs_context_t *srs = wrtc->srs; char *cmds[] = { (char *)wrtc->config.play, (char *)wrtc->config.stop, (char *)wrtc->config.pause, (char *)wrtc->config.next, (char *)wrtc->config.prev }; int ncmd = (int)MRP_ARRAY_SIZE(cmds); const char *name = "wrt-media-client"; const char *appcls = "player"; const char *id = "wrt-media-client"; if (!strcmp(wrtc->config.bus, "session")) wrtc->gdbus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL); else if (!strcmp(wrtc->config.bus, "system")) wrtc->gdbus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL); else { int flags = G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION; wrtc->gdbus = g_dbus_connection_new_for_address_sync(wrtc->config.bus, flags, NULL, NULL, NULL); } if (wrtc->gdbus == NULL) return FALSE; wrtc->gnrq = g_bus_own_name(G_BUS_TYPE_SESSION, "org.tizen.srs", 0, NULL, name_acquired_cb, name_lost_cb, wrtc, NULL); wrtc->c = client_create(srs, SRS_CLIENT_TYPE_BUILTIN, name, appcls, cmds, ncmd, id, &ops, wrtc); if (wrtc->c == NULL) { wrtc_cleanup(wrtc); return FALSE; } client_request_focus(wrtc->c, SRS_VOICE_FOCUS_SHARED); return TRUE; }
/* Connect to the transaction bus address and return a proxy for the transaction * object. */ RPMOSTreeTransaction * rpmostree_transaction_connect (const char *transaction_address, GCancellable *cancellable, GError **error) { g_autoptr(GDBusConnection) peer_connection = g_dbus_connection_new_for_address_sync (transaction_address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, cancellable, error); if (peer_connection == NULL) return NULL; return rpmostree_transaction_proxy_new_sync (peer_connection, G_DBUS_PROXY_FLAGS_NONE, NULL, "/", cancellable, error); }
GDBusConnection * _get_bus_connection ( const gchar *seat_id, GError **error) { uid_t ui_user_id = getuid (); if (ui_user_id == 0) { return _get_root_socket_bus_connection (error); } /* get dbus connection for specific user only */ gchar address[128]; g_snprintf (address, 127, "unix:path=%s/%s-%d", TLM_DBUS_SOCKET_PATH, seat_id, ui_user_id); return g_dbus_connection_new_for_address_sync (address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, error); }
int main (int argc, char *argv[]) { GDBusConnection *connection; GError *error = NULL; nm_g_type_init (); connection = g_dbus_connection_new_for_address_sync ("unix:path=" NMRUNDIR "/private-dhcp", G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); if (!connection) { g_dbus_error_strip_remote_error (error); g_printerr ("Error: could not connect to NetworkManager D-Bus socket: %s\n", error->message); g_error_free (error); fatal_error (); } if (!g_dbus_connection_emit_signal (connection, NULL, "/", NM_DHCP_CLIENT_DBUS_IFACE, "Event", build_signal_parameters (), &error)) { g_dbus_error_strip_remote_error (error); g_printerr ("Error: Could not send DHCP Event signal: %s\n", error->message); g_error_free (error); fatal_error (); } if (!g_dbus_connection_flush_sync (connection, NULL, &error)) { g_dbus_error_strip_remote_error (error); g_printerr ("Error: Could not flush D-Bus connection: %s\n", error->message); g_error_free (error); fatal_error (); } g_object_unref (connection); return 0; }
/* * Raise G_IO_ERROR_NOT_SUPPORTED if the requested user is impossible. */ GDBusConnection * test_try_connect_gdbus_as_user (const char *address, TestUser user, GError **error) { GDBusConnection *conn; if (user != TEST_USER_ME && !become_other_user (user, error)) return NULL; conn = g_dbus_connection_new_for_address_sync (address, (G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION | G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT), NULL, NULL, error); if (user != TEST_USER_ME) back_to_root (); return conn; }
gint gtk_module_init (gint argc, gchar *argv[]) { GDBusConnection *dbus; gchar *address; const gchar *socket; GError *error = NULL; ENTRY; if (!(socket = g_getenv("GDKEVENT_SOCKET"))) { CRITICAL(Gdk, "Failed to load gdkevent socket."); RETURN(-1); } address = g_strdup_printf("unix:path=%s", socket); dbus = g_dbus_connection_new_for_address_sync(address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); g_free(address); if (!dbus) { CRITICAL(Gdk, "Failed to load IPC socket: %s", error->message); g_error_free(error); RETURN(-1); } connection = dbus; gdk_event_handler_set(gdkevent_dispatcher, dbus, gdkevent_module_unloaded); g_get_current_time(&last_time); poll_func = g_main_context_get_poll_func(g_main_context_default()); g_main_context_set_poll_func(g_main_context_default(), gdkevent_poll); RETURN(0); }
int main (int argc, char *argv[]) { GOptionContext *opt_context; GError *error; GDBusConnectionFlags connection_flags; GIOChannel *io_channel; GDBusProxyFlags proxy_flags; GDBusMessage *message; GVariant *value; gchar *client_ident; gchar *input; gchar *response; gsize *len; gint ret,ret_loc; ret = 1; g_type_init (); error = NULL; object_path = NULL; opt_context = g_option_context_new ("ksr-chat-client() usage:"); g_option_context_set_summary (opt_context, "To connect to server under tcp:host=0.0.0.0 as \"maryl\" and start chatting, use:\n" " \"ksr-chat-client -n maryl -a tcp:host=0.0.0.0"); g_option_context_add_main_entries (opt_context, opt_entries, NULL); if (!g_option_context_parse (opt_context, &argc, &argv, &error)) { g_printerr ("Error parsing options: %s\n", error->message); g_error_free (error); goto out; } if (!input_is_valid()) goto out; connection_flags = G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT; connection = g_dbus_connection_new_for_address_sync (opt_address, connection_flags, NULL, /* GDBusAuthObserver */ NULL, /* GCancellable */ &error); if (connection == NULL) { g_printerr ("Error connecting to the DBus : %s\n", error->message); g_error_free(error); goto out; } g_print ("Connected to server!\n"); disallowed_chars = g_regex_new("\n", 0, 0, NULL); object_path = g_strdup_printf ("%s/%s", OBJECT_PATH,opt_name); // Now register the nickname error = NULL; value = g_dbus_connection_call_sync (connection, NULL, TMP_OBJECT_PATH, INTERFACE_PATH, "RegisterMe", g_variant_new ("(s)", opt_name), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (value == NULL) { g_printerr ("Could not register!\n"); goto out; } else { g_variant_get (value, "(&s)", &response); if (g_strcmp0(response,REGISTRATION_RESPONSE_OK) == 0) g_print ("Registered a nickname %s , the chat is ready!\n",opt_name); else if (g_strcmp0(response,REGISTRATION_RESPONSE_NOT_OK) == 0) { g_print ("Could not register your nickname %s, please change it!\n",opt_name); goto out; } } g_dbus_connection_signal_subscribe(connection, NULL, INTERFACE_PATH, NULL, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE, handle_signals, NULL, NULL); loop = g_main_loop_new (NULL, FALSE); // FD = 0 = stdin io_channel = g_io_channel_unix_new(0); if (!g_io_add_watch_full (io_channel, G_PRIORITY_HIGH, G_IO_IN, handle_input, NULL, NULL)) g_error ("Cannot add watch on GIOChannel!\n"); g_main_loop_run (loop); ret = 0; out: g_option_context_free (opt_context); return ret; }
int main (int argc, char *argv[]) { gs_unref_object GDBusConnection *connection = NULL; gs_free_error GError *error = NULL; gs_unref_variant GVariant *parameters = NULL; gs_unref_variant GVariant *result = NULL; gboolean success = FALSE; guint try_count = 0; gint64 time_end; nm_g_type_init (); /* FIXME: g_dbus_connection_new_for_address_sync() tries to connect to the socket in * non-blocking mode, which can easily fail with EAGAIN, causing the creation of the * socket to fail with "Could not connect: Resource temporarily unavailable". * * We should instead create the GIOStream ourself and block on connecting to * the socket. */ connection = g_dbus_connection_new_for_address_sync ("unix:path=" NMRUNDIR "/private-dhcp", G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); if (!connection) { g_dbus_error_strip_remote_error (error); _LOGE ("could not connect to NetworkManager D-Bus socket: %s", error->message); goto out; } parameters = build_signal_parameters (); time_end = g_get_monotonic_time () + (200 * 1000L); /* retry for at most 200 milliseconds */ do_notify: try_count++; result = g_dbus_connection_call_sync (connection, NULL, NM_DHCP_HELPER_SERVER_OBJECT_PATH, NM_DHCP_HELPER_SERVER_INTERFACE_NAME, NM_DHCP_HELPER_SERVER_METHOD_NOTIFY, parameters, NULL, G_DBUS_CALL_FLAGS_NONE, 1000, NULL, &error); if (!result) { gs_free char *s_err = NULL; s_err = g_dbus_error_get_remote_error (error); if (NM_IN_STRSET (s_err, "org.freedesktop.DBus.Error.UnknownMethod")) { gint64 remaining_time = time_end - g_get_monotonic_time (); /* I am not sure that a race can actually happen, as we register the object * on the server side during GDBusServer:new-connection signal. * * However, there was also a race for subscribing to an event, so let's just * do some retry. */ if (remaining_time > 0) { _LOGi ("failure to call notify: %s (retry %u)", error->message, try_count); g_usleep (NM_MIN (NM_CLAMP ((gint64) (100L * (1L << try_count)), 5000, 25000), remaining_time)); g_clear_error (&error); goto do_notify; } } _LOGW ("failure to call notify: %s (try signal via Event)", error->message); g_clear_error (&error); /* for backward compatibilty, try to emit the signal. There is no stable * API between the dhcp-helper and NetworkManager. However, while upgrading * the NetworkManager package, a newer helper might want to notify an * older server, which still uses the "Event". */ if (!g_dbus_connection_emit_signal (connection, NULL, "/", NM_DHCP_CLIENT_DBUS_IFACE, "Event", parameters, &error)) { g_dbus_error_strip_remote_error (error); _LOGE ("could not send DHCP Event signal: %s", error->message); goto out; } /* We were able to send the asynchronous Event. Consider that a success. */ success = TRUE; } else success = TRUE; if (!g_dbus_connection_flush_sync (connection, NULL, &error)) { g_dbus_error_strip_remote_error (error); _LOGE ("could not flush D-Bus connection: %s", error->message); success = FALSE; goto out; } out: if (!success) kill_pid (); return success ? EXIT_SUCCESS : EXIT_FAILURE; }
static gboolean spawn_bus (State *state, GCancellable *cancellable) { GDBusConnection *bus_connection = NULL; GPtrArray *arguments = NULL; GSubprocessLauncher *launcher = NULL; GSubprocess *subprocess = NULL; GInputStream *input_stream = NULL; GDataInputStream *data_stream = NULL; GError *error = NULL; char *bus_address_fd_string; char *bus_address = NULL; gsize bus_address_size; gboolean is_running = FALSE; int ret; int pipe_fds[2]; g_debug ("Running session message bus"); bus_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL); if (bus_connection != NULL) { g_debug ("session message bus already running, not starting another one"); state->bus_connection = bus_connection; return TRUE; } ret = g_unix_open_pipe (pipe_fds, FD_CLOEXEC, &error); if (!ret) { g_debug ("could not open pipe: %s", error->message); goto out; } arguments = g_ptr_array_new (); launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE); g_subprocess_launcher_take_fd (launcher, pipe_fds[1], BUS_ADDRESS_FILENO); bus_address_fd_string = g_strdup_printf ("%d", BUS_ADDRESS_FILENO); g_ptr_array_add (arguments, "dbus-daemon"); g_ptr_array_add (arguments, "--print-address"); g_ptr_array_add (arguments, bus_address_fd_string); g_ptr_array_add (arguments, "--session"); g_ptr_array_add (arguments, NULL); subprocess = g_subprocess_launcher_spawnv (launcher, (const char * const *) arguments->pdata, &error); g_free (bus_address_fd_string); g_clear_object (&launcher); g_ptr_array_free (arguments, TRUE); if (subprocess == NULL) { g_debug ("could not start dbus-daemon: %s", error->message); goto out; } input_stream = g_unix_input_stream_new (pipe_fds[0], TRUE); data_stream = g_data_input_stream_new (input_stream); g_clear_object (&input_stream); bus_address = g_data_input_stream_read_line (data_stream, &bus_address_size, cancellable, &error); if (error != NULL) { g_debug ("could not read address from session message bus: %s", error->message); goto out; } if (bus_address == NULL) { g_debug ("session message bus did not write address"); goto out; } state->bus_address = bus_address; state->bus_subprocess = g_object_ref (subprocess); g_subprocess_wait_async (state->bus_subprocess, cancellable, (GAsyncReadyCallback) on_bus_finished, state); bus_connection = g_dbus_connection_new_for_address_sync (state->bus_address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, cancellable, &error); if (bus_connection == NULL) { g_debug ("could not open connection to session bus: %s", error->message); goto out; } state->bus_connection = bus_connection; is_running = TRUE; out: g_clear_object (&data_stream); g_clear_object (&subprocess); g_clear_object (&launcher); g_clear_error (&error); return is_running; }
GDBusConnection * _g_dbus_connection_get_sync (const char *dbus_id, GCancellable *cancellable, GError **error) { GDBusConnection *bus; ThreadLocalConnections *local; GError *local_error; GDBusConnection *connection; gchar *address1; GVfsDBusDaemon *daemon_proxy; gboolean res; if (g_cancellable_set_error_if_cancelled (cancellable, error)) return NULL; local = g_private_get (&local_connections); if (local == NULL) { local = g_new0 (ThreadLocalConnections, 1); local->connections = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_object_unref); g_private_set (&local_connections, local); } if (dbus_id == NULL) { /* Session bus */ if (local->session_bus) { if (! g_dbus_connection_is_closed (local->session_bus)) return local->session_bus; /* Session bus was disconnected, re-connect */ g_object_unref (local->session_bus); local->session_bus = NULL; } } else { /* Mount daemon connection */ connection = g_hash_table_lookup (local->connections, dbus_id); if (connection != NULL) { if (g_dbus_connection_is_closed (connection)) { /* The mount for this connection died, we invalidate * the caches, and then caller needs to retry. */ invalidate_local_connection (dbus_id, error); return NULL; } return connection; } } if (local->session_bus == NULL) { bus = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, error); if (bus == NULL) return NULL; local->session_bus = bus; if (dbus_id == NULL) return bus; /* We actually wanted the session bus, so done */ } daemon_proxy = gvfs_dbus_daemon_proxy_new_sync (local->session_bus, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, dbus_id, G_VFS_DBUS_DAEMON_PATH, cancellable, error); if (daemon_proxy == NULL) return NULL; address1 = NULL; res = gvfs_dbus_daemon_call_get_connection_sync (daemon_proxy, &address1, NULL, cancellable, error); g_object_unref (daemon_proxy); if (!res) { g_free (address1); return NULL; } local_error = NULL; connection = g_dbus_connection_new_for_address_sync (address1, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, /* GDBusAuthObserver */ cancellable, &local_error); g_free (address1); if (!connection) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Error while getting peer-to-peer dbus connection: %s", local_error->message); g_error_free (local_error); return NULL; } vfs_connection_setup (connection, FALSE); g_hash_table_insert (local->connections, g_strdup (dbus_id), connection); return connection; }
int main (int argc, char *argv[]) { gint ret; gboolean opt_server; gchar *opt_address; GOptionContext *opt_context; gboolean opt_allow_anonymous; GError *error; GOptionEntry opt_entries[] = { { "server", 's', 0, G_OPTION_ARG_NONE, &opt_server, "Start a server instead of a client", NULL }, { "address", 'a', 0, G_OPTION_ARG_STRING, &opt_address, "D-Bus address to use", NULL }, { "allow-anonymous", 'n', 0, G_OPTION_ARG_NONE, &opt_allow_anonymous, "Allow anonymous authentication", NULL }, { NULL} }; ret = 1; g_type_init (); opt_address = NULL; opt_server = FALSE; opt_allow_anonymous = FALSE; opt_context = g_option_context_new ("peer-to-peer example"); error = NULL; g_option_context_add_main_entries (opt_context, opt_entries, NULL); if (!g_option_context_parse (opt_context, &argc, &argv, &error)) { g_printerr ("Error parsing options: %s\n", error->message); g_error_free (error); goto out; } if (opt_address == NULL) { g_printerr ("Incorrect usage, try --help.\n"); goto out; } if (!opt_server && opt_allow_anonymous) { g_printerr ("The --allow-anonymous option only makes sense when used with --server.\n"); goto out; } /* We are lazy here - we don't want to manually provide * the introspection data structures - so we just build * them from XML. */ introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL); g_assert (introspection_data != NULL); if (opt_server) { GDBusServer *server; gchar *guid; GMainLoop *loop; GDBusServerFlags server_flags; guid = g_dbus_generate_guid (); server_flags = G_DBUS_SERVER_FLAGS_NONE; if (opt_allow_anonymous) server_flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS; error = NULL; server = g_dbus_server_new_sync (opt_address, server_flags, guid, NULL, /* GDBusAuthObserver */ NULL, /* GCancellable */ &error); g_dbus_server_start (server); g_free (guid); if (server == NULL) { g_printerr ("Error creating server at address %s: %s\n", opt_address, error->message); g_error_free (error); goto out; } g_print ("Server is listening at: %s\n", g_dbus_server_get_client_address (server)); g_signal_connect (server, "new-connection", G_CALLBACK (on_new_connection), NULL); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); g_object_unref (server); g_main_loop_unref (loop); } else { GDBusConnection *connection; const gchar *greeting_response; GVariant *value; gchar *greeting; error = NULL; connection = g_dbus_connection_new_for_address_sync (opt_address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, /* GDBusAuthObserver */ NULL, /* GCancellable */ &error); if (connection == NULL) { g_printerr ("Error connecting to D-Bus address %s: %s\n", opt_address, error->message); g_error_free (error); goto out; } g_print ("Connected.\n" "Negotiated capabilities: unix-fd-passing=%d\n", g_dbus_connection_get_capabilities (connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING); greeting = g_strdup_printf ("Hey, it's %" G_GUINT64_FORMAT " already!", (guint64) time (NULL)); value = g_dbus_connection_call_sync (connection, NULL, /* bus_name */ "/org/gtk/GDBus/TestObject", "org.gtk.GDBus.TestPeerInterface", "HelloWorld", g_variant_new ("(s)", greeting), G_VARIANT_TYPE ("(s)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (value == NULL) { g_printerr ("Error invoking HelloWorld(): %s\n", error->message); g_error_free (error); goto out; } g_variant_get (value, "(&s)", &greeting_response); g_print ("Server said: %s\n", greeting_response); g_variant_unref (value); g_object_unref (connection); } g_dbus_node_info_unref (introspection_data); ret = 0; out: return ret; }
gpointer dbusSvc_instanceThread(gpointer data) { (void) data; /* * This is thread in which a GLIB "main" loop will run. The GLIB callback functionality is handled * and registered in this context. */ GError *error=NULL; GMainLoop *loop; GDBusConnection *connection; guint id; // Add watches for needed DBUS interfaces here // Create a new GLIB context which will attach to this thread loop = g_main_loop_new(NULL, FALSE); if(dbusRemoteIP == NULL) { // We are using the local DBUS SYSTEM bus g_print("[dbusSvc_instanceThread] Local DBUS connection on SYSTEM bus\n"); id = g_bus_own_name(G_BUS_TYPE_SYSTEM, DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, onBusAcquired, onNameAcquired, onNameLost, loop, NULL); } else { // We are using a remote connection to a target DBUS daemon gchar *remoteAddress; remoteAddress = g_strdup_printf("tcp:host=%s,port=%s",dbusRemoteIP,dbusRemotePort); g_print("[dbusSvc_instanceThread] Remote DBUS connection on: %s\n",remoteAddress); connection = g_dbus_connection_new_for_address_sync(remoteAddress, G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION | G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); g_free(remoteAddress); if (error != NULL) { /* * Critical error remote bus was not obtainable */ g_print("[dbusSvc_instanceThread] Failed to get remote bus. DBUS services disabled\n"); g_error_free(error); } else { onBusAcquired(connection,"Remote DBUS over TCP",NULL); id = g_bus_own_name_on_connection (connection, DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, onNameAcquired, onNameLost, loop, NULL); } } // Fire off the GLIB main loop. This will not return until the process is terminated. g_main_loop_run(loop); // Remove additional client watches here. // Release the DBUS name g_bus_unown_name(id); // Remove the DBUs watcher as we lost the connection anyways. dbusMesaInterface_removeDbusNameWatch(); // Free the main loop object g_main_loop_unref(loop); }