static void dnsmasq_update_done (GDBusProxy *proxy, GAsyncResult *res, gpointer user_data) { NMDnsDnsmasq *self; NMDnsDnsmasqPrivate *priv; gs_free_error GError *error = NULL; gs_unref_variant GVariant *response = NULL; response = g_dbus_proxy_call_finish (proxy, res, &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_DNS_DNSMASQ (user_data); priv = NM_DNS_DNSMASQ_GET_PRIVATE (self); if (!response) _LOGW ("dnsmasq update failed: %s", error->message); else { g_dbus_proxy_call (priv->dnsmasq, "ClearCache", NULL, G_DBUS_CALL_FLAGS_NONE, -1, priv->update_cancellable, (GAsyncReadyCallback) dnsmasq_clear_cache_done, self); } }
static void on_get_user_id_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); gpointer *info = g_task_get_source_object (task); GClueClientInfoPrivate *priv = GCLUE_CLIENT_INFO (info)->priv; GError *error = NULL; GVariant *results = NULL; results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (results == NULL) { g_task_return_error (task, error); g_object_unref (task); return; } g_assert (g_variant_n_children (results) > 0); g_variant_get_child (results, 0, "u", &priv->user_id); g_variant_unref (results); g_dbus_proxy_call (priv->dbus_proxy, "GetConnectionUnixProcessID", g_variant_new ("(s)", priv->bus_name), G_DBUS_CALL_FLAGS_NONE, -1, g_task_get_cancellable (task), on_get_pid_ready, task); }
static void _set_property_cb (GObject *object, GAsyncResult *res, gpointer user_data) { char *key; GVariant *var; GError *error; key = (char *)user_data; error = NULL; var = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error); if (var) { g_variant_unref (var); } else if (error) { g_warning ("Connman Manager.SetProperty() for '%s' failed: %s", key, error->message); /* TODO: call a error handler method */ g_error_free (error); } g_free (key); }
static void on_client_registered (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVariant *variant; GError *error = NULL; gchar *object_path = NULL; variant = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (error != NULL) { g_warning ("Unable to register client: %s", error->message); g_error_free (error); } else { g_variant_get (variant, "(o)", &object_path); g_debug ("Registered client at path %s", object_path); g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION, 0, NULL, GNOME_SESSION_DBUS_NAME, object_path, GNOME_SESSION_CLIENT_PRIVATE_DBUS_INTERFACE, NULL, got_client_proxy, manager); g_free (object_path); g_variant_unref (variant); } }
static void iface_check_netreply_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_unref_variant GVariant *variant = NULL; gs_free_error GError *error = NULL; /* We know NetworkReply is supported if the NetworkReply method returned * successfully (which is unexpected since we sent a bogus network * object path) or if we got an "InvalidArgs" (which indicates NetworkReply * is supported). We know it's not supported if we get an * "UnknownMethod" error. */ variant = g_dbus_proxy_call_finish (proxy, result, &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); if (variant || _nm_dbus_error_has_name (error, "fi.w1.wpa_supplicant1.InvalidArgs")) priv->has_credreq = TRUE; nm_log_dbg (LOGD_SUPPLICANT, "Supplicant %s network credentials requests", priv->has_credreq ? "supports" : "does not support"); iface_check_ready (self); }
static void on_get_unit_file_state_done (GObject *object, GAsyncResult *res, gpointer user_data) { GetServiceInfoData *data = user_data; GError *error = NULL; gs_unref_variant GVariant *result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error); if (error) { end_invocation_take_gerror (data->invocation, error); g_free (data); return; } const gchar *state; g_variant_get (result, "(&s)", &state); GVariantBuilder bob; g_variant_builder_init (&bob, G_VARIANT_TYPE("a{sv}")); g_variant_builder_add (&bob, "{sv}", "Id", g_variant_new_string (data->name)); g_variant_builder_add (&bob, "{sv}", "IsTemplate", g_variant_new_boolean (TRUE)); g_variant_builder_add (&bob, "{sv}", "UnitFileState", g_variant_new_string (state)); cockpit_services_complete_get_service_info (COCKPIT_SERVICES (data->services), data->invocation, g_variant_builder_end (&bob)); g_free (data->name); g_free (data); }
static void on_prompt_prompted (GObject *source, GAsyncResult *result, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res); SecretPrompt *self = SECRET_PROMPT (source); GError *error = NULL; GVariant *retval; retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error); if (retval) g_variant_unref (retval); if (closure->vanished) g_clear_error (&error); if (error != NULL) { g_simple_async_result_take_error (res, error); perform_prompt_complete (res, TRUE); } else { closure->prompting = TRUE; g_atomic_int_set (&self->pv->prompted, 1); /* And now we wait for the signal */ } g_object_unref (res); }
static void on_get_client_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GDBusProxy *manager = G_DBUS_PROXY (source_object); GVariant *results; const char *client_path; GError *error = NULL; results = g_dbus_proxy_call_finish (manager, res, &error); if (results == NULL) { g_critical ("Failed to connect to GeoClue2 service: %s", error->message); exit (-2); } g_assert (g_variant_n_children (results) > 0); g_variant_get_child (results, 0, "&o", &client_path); g_print ("Client object: %s\n", client_path); g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.freedesktop.GeoClue2", client_path, "org.freedesktop.GeoClue2.Client", NULL, on_client_proxy_ready, manager); g_variant_unref (results); }
static gpointer read_characteristic_finish( GIO_ASYNCSEQ_HANDLE async_seq_handle, GAsyncResult* result, GError** error ) { READ_CONTEXT* context = (READ_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle); GBytes* result_value; GVariant* ret = g_dbus_proxy_call_finish( G_DBUS_PROXY(context->characteristic), result, error ); if (ret != NULL && *error == NULL) { result_value = g_variant_get_data_as_bytes(ret); g_variant_unref(ret); } else { result_value = NULL; } return result_value; }
static void on_perm_store_set_done (GObject *source_object, GAsyncResult *res, gpointer user_data) { LocationAppStateData *data; GVariant *results; GError *error = NULL; results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (results == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Failed to store permissions: %s", error->message); g_error_free (error); return; } g_variant_unref (results); data = (LocationAppStateData *) user_data; data->changing_state = FALSE; gtk_switch_set_state (GTK_SWITCH (data->widget), data->pending_state); }
static void on_perm_store_lookup_done(GObject *source_object, GAsyncResult *res, gpointer user_data) { GVariant *ret, *permissions, *permissions_data; GError *error = NULL; ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (ret == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Failed fetch permissions from xdg-app permission store: %s", error->message); g_error_free (error); return; } permissions = g_variant_get_child_value (ret, 0); permissions_data = g_variant_get_child_value (ret, 1); update_perm_store (user_data, permissions, permissions_data); g_signal_connect_object (source_object, "g-signal", G_CALLBACK (on_perm_store_signal), user_data, 0); }
static void get_brightness_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GVariant *result; guint brightness; GtkRange *range; CcScreenPanel *self = CC_SCREEN_PANEL (user_data); result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (result == NULL) { gtk_widget_hide (WID ("screen_brightness_hscale")); gtk_widget_hide (WID ("screen_auto_reduce_checkbutton")); gtk_widget_hide (WID ("brightness-frame")); g_object_set (G_OBJECT (WID ("turn-off-alignment")), "left-padding", 0, NULL); g_warning ("Error getting brightness: %s", error->message); g_error_free (error); return; } /* set the slider */ g_variant_get (result, "(u)", &brightness); range = GTK_RANGE (WID ("screen_brightness_hscale")); gtk_range_set_range (range, 0, 100); gtk_range_set_increments (range, 1, 10); gtk_range_set_value (range, brightness); g_signal_connect (range, "value-changed", G_CALLBACK (brightness_slider_value_changed_cb), user_data); g_variant_unref (result); }
static void packagekit_install_package_names_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { InstallerData *idata = user_data; GDBusProxy *proxy; GVariant *values; GError *error = NULL; char *message = NULL; proxy = G_DBUS_PROXY (source_object); values = g_dbus_proxy_call_finish (proxy, res, &error); if (values == NULL) { message = g_strdup_printf ("%s\n%s", _("There was an internal error trying to search for applications:"), error->message); g_clear_error (&error); } package_installer_terminated (idata, message); g_free (message); if (values != NULL) g_variant_unref (values); g_object_unref (proxy); }
static void _get_properties_for_passphrase_cb (GObject *obj, GAsyncResult *res, gpointer user_data) { MtnConnmanService *service; GError *error; GVariant *var; service = MTN_CONNMAN_SERVICE (obj); error = NULL; var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error); if (!var) { g_warning ("Connman Service.GetProperties failed: %s", error->message); g_error_free (error); } else { GVariant *value; char *key; GVariantIter *iter; g_variant_get (var, "(a{sv})", &iter); while (g_variant_iter_next (iter, "{sv}", &key, &value)) { if (g_strcmp0 (key, "Passphrase") == 0 || g_strcmp0 (key, "PassphraseRequired") == 0) { mtn_connman_service_handle_new_property (service, key, value); } } g_variant_iter_free (iter); g_variant_unref (var); } }
static void got_users (GObject *object, GAsyncResult *res, gpointer data) { UmUserManager *manager = data; GVariant *result; GError *error = NULL; result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error); if (!result) { manager->no_service = TRUE; g_error_free (error); goto done; } if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(ao)"))) { GVariantIter *iter; gchar *object_path; g_variant_get (result, "(ao)", &iter); while (g_variant_iter_loop (iter, "&o", &object_path)) user_added_handler (manager, object_path); g_variant_iter_free (iter); } g_variant_unref (result); done: g_signal_emit (G_OBJECT (manager), signals[USERS_LOADED], 0); }
static void on_service_open_session_plain (GObject *source, GAsyncResult *result, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); OpenSessionClosure *closure = g_simple_async_result_get_op_res_gpointer (res); SecretService *service = SECRET_SERVICE (source); GError *error = NULL; GVariant *response; response = g_dbus_proxy_call_finish (G_DBUS_PROXY (service), result, &error); /* A successful response, decode it */ if (response != NULL) { if (response_open_session_plain (closure->session, response)) { _secret_service_take_session (service, closure->session); closure->session = NULL; } else { g_simple_async_result_set_error (res, SECRET_ERROR, SECRET_ERROR_PROTOCOL, _("Couldn’t communicate with the secret storage")); } g_simple_async_result_complete (res); g_variant_unref (response); } else { g_simple_async_result_take_error (res, error); g_simple_async_result_complete (res); } g_object_unref (res); }
static void on_list_units_done (GObject *object, GAsyncResult *res, gpointer user_data) { ListServicesData *data = user_data; GError *error = NULL; data->units = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error); if (error) { end_invocation_take_gerror (data->invocation, error); g_free (data); return; } g_dbus_proxy_call (data->services->systemd, "ListUnitFiles", NULL, G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, on_list_files_done, data); }
static void first_call_complete(GObject *proxy, GAsyncResult *res, XmrMMKeysPlugin *plugin) { GVariant *result; GError *error = NULL; result = g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), res, &error); if (error != NULL) { xmr_debug("Unable to grab media player keys: %s", error->message); g_clear_error(&error); #ifdef HAVE_MMKEYS_H mmkeys_grab(plugin, TRUE); plugin->grab_type = X_KEY_GRAB; #endif return; } g_signal_connect_object(plugin->proxy, "g-signal", G_CALLBACK(media_player_key_pressed), plugin, 0); /* re-grab keys when the main window gains focus */ g_signal_connect_object(plugin->window, "focus-in-event", G_CALLBACK(window_focus_cb), plugin, 0); g_variant_unref(result); }
static void get_capabilities_callback(GObject* source, GAsyncResult* res, gpointer user_data UNUSED) { char** caps; GVariant* result; result = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, NULL); if (result == NULL || !g_variant_is_of_type(result, G_VARIANT_TYPE("(as)"))) { if (result != NULL) { g_variant_unref(result); } return; } g_variant_get(result, "(^a&s)", &caps); for (int i = 0; caps[i] != NULL; i++) { if (g_strcmp0(caps[i], "actions") == 0) { server_supports_actions = TRUE; break; } } g_free(caps); g_variant_unref(result); }
static void first_call_complete (GObject *proxy, GAsyncResult *res, RBMMKeysPlugin *plugin) { GVariant *result; GError *error = NULL; GtkWindow *window; result = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, &error); if (error != NULL) { g_warning ("Unable to grab media player keys: %s", error->message); g_clear_error (&error); #ifdef HAVE_MMKEYS if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) { mmkeys_grab (plugin, TRUE); plugin->grab_type = X_KEY_GRAB; } #endif return; } rb_debug ("grabbed media player keys"); g_signal_connect_object (plugin->proxy, "g-signal", G_CALLBACK (media_player_key_pressed), plugin, 0); /* re-grab keys when the main window gains focus */ g_object_get (plugin->shell, "window", &window, NULL); g_signal_connect_object (window, "focus-in-event", G_CALLBACK (window_focus_cb), plugin, 0); g_object_unref (window); g_variant_unref (result); }
static void on_prompt_dismissed (GObject *source, GAsyncResult *result, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res); SecretPrompt *self = SECRET_PROMPT (source); GError *error = NULL; GVariant *retval; retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error); if (retval) g_variant_unref (retval); if (closure->vanished) g_clear_error (&error); if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD)) g_clear_error (&error); if (error != NULL) { g_simple_async_result_take_error (res, error); perform_prompt_complete (res, TRUE); } g_object_unref (res); }
static void on_discover_done (GObject *object, GAsyncResult *res, gpointer user_data) { struct DiscoverData *data = (struct DiscoverData *)user_data; GError *error = NULL; gs_unref_variant GVariant *discover_result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error); if (error) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (data->invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_free (data); g_error_free (error); return; } g_variant_builder_init (&(data->all_details), G_VARIANT_TYPE ("aa{sv}")); g_variant_get (discover_result, "(iao)", NULL, &(data->object_paths)); data->cur_proxy = NULL; get_next_discover_info (data); }
static void set_ap_scan_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_unref_variant GVariant *reply = NULL; gs_free_error GError *error = NULL; reply = g_dbus_proxy_call_finish (proxy, result, &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); if (!reply) { g_dbus_error_strip_remote_error (error); nm_log_warn (LOGD_SUPPLICANT, "Couldn't send AP scan mode to the supplicant interface: %s.", error->message); emit_error_helper (self, error); return; } nm_log_info (LOGD_SUPPLICANT, "Config: set interface ap_scan to %d", nm_supplicant_config_get_ap_scan (priv->cfg)); g_dbus_proxy_call (priv->iface_proxy, "AddNetwork", g_variant_new ("(@a{sv})", nm_supplicant_config_to_variant (priv->cfg)), G_DBUS_CALL_FLAGS_NONE, -1, priv->assoc_cancellable, (GAsyncReadyCallback) add_network_cb, self); }
static void is_active_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { gboolean active = FALSE; GError *error = NULL; GVariant *result; GnomeSettingsSession *session = GNOME_SETTINGS_SESSION (user_data); /* is our session active */ result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (result == NULL) { g_warning ("IsActive failed: %s", error->message); g_error_free (error); return; } g_variant_get (result, "(b)", &active); gnome_settings_session_set_state (session, active); /* watch for changes */ g_signal_connect (session->priv->proxy_session, "g-signal", G_CALLBACK (gnome_settings_session_proxy_signal_cb), session); g_variant_unref (result); }
static void finish_auth_check(GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GVariant *result; gboolean authorized; struct auth_check *auth_check = user_data; if (auth_check->cancel_id) g_source_remove(auth_check->cancel_id); g_free(auth_check->cancel_string); result = g_dbus_proxy_call_finish(polkit_proxy, res, &error); if (!result) { g_dbus_error_strip_remote_error(error); g_printerr("Failed to check authorization: %s\n", error->message); g_error_free(error); authorized = FALSE; } else { g_variant_get(result, "((bba{ss}))", &authorized, NULL, NULL); g_variant_unref(result); } if (authorized) { (auth_check->handler)(auth_check->invocation, auth_check->handler_data); } else { return_error(auth_check->invocation, G_DBUS_ERROR_AUTH_FAILED, "Not authorized"); } g_object_unref(auth_check->cancellable); g_free(auth_check->handler_data); g_free(auth_check); g_assert(running_auth_checks); running_auth_checks--; }
static void got_session_path_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GVariant *result; GError *error = NULL; GnomeSettingsSession *session = GNOME_SETTINGS_SESSION (user_data); result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error); if (result == NULL) { g_warning ("Failed to get session for pid: %s", error->message); g_error_free (error); return; } g_variant_get (result, "(o)", &session->priv->session_id); g_debug ("ConsoleKit session ID: %s", session->priv->session_id); /* connect to session */ g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL, CONSOLEKIT_NAME, session->priv->session_id, CONSOLEKIT_SESSION_INTERFACE, session->priv->cancellable, got_session_proxy_cb, session); g_variant_unref (result); }
static void _get_services_cb (GObject *obj, GAsyncResult *res, gpointer user_data) { MtnConnman *connman; GError *error; GVariant *var; InitData *data; connman = MTN_CONNMAN (obj); data = (InitData*)user_data; error = NULL; var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error); if (!var) { g_warning ("Initial GetServices() failed: %s\n", error->message); g_error_free (error); } else { connman->priv->services = var; } if (data->done_props) { g_simple_async_result_complete_in_idle (data->res); g_object_unref (data->res); g_free (data); } else { data->done_services = TRUE; } }
static void print_file_done (GObject *source, GAsyncResult *result, gpointer data) { GtkPrintOperation *op = data; GtkPrintOperationPortal *op_portal = op->priv->platform_data; GError *error = NULL; GVariant *ret; ret = g_dbus_proxy_call_finish (op_portal->proxy, result, &error); if (ret == NULL) { if (op->priv->error == NULL) op->priv->error = g_error_copy (error); g_warning ("Print file failed: %s", error->message); g_error_free (error); } else g_variant_unref (ret); if (op_portal->loop) g_main_loop_quit (op_portal->loop); g_object_unref (op); }
static void install_mime_types_ready_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GtkAppChooserOnlinePk *self = user_data; GDBusProxy *proxy = G_DBUS_PROXY (source); GError *error = NULL; GVariant *variant; variant = g_dbus_proxy_call_finish (proxy, res, &error); if (variant == NULL) { /* don't show errors if the user cancelled the installation explicitely * or if PK wasn't able to find any apps */ if (g_strcmp0 (g_dbus_error_get_remote_error (error), "org.freedesktop.PackageKit.Modify.Cancelled") != 0 && g_strcmp0 (g_dbus_error_get_remote_error (error), "org.freedesktop.PackageKit.Modify.NoPackagesFound") != 0) g_simple_async_result_set_from_error (self->priv->result, error); g_error_free (error); } g_simple_async_result_complete (self->priv->result); g_clear_object (&self->priv->result); }
static void keys_grab_complete_cb (GObject *proxy, GAsyncResult *result, MexMMkeys *self) { MexMMkeysPrivate *priv = MEX_MMKEYS (self)->priv; GError *error = NULL; g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error); if (error) { g_warning ("media player keys not available: %s", error->message); g_clear_error (&error); } else { priv->key_grab_active = TRUE; g_signal_connect_object (priv->proxy, "g-signal", G_CALLBACK (mm_keys_pressed), self, 0); } }