static void onPropertiesChanged(GDBusProxy *proxy, GVariant *changed_properties, const gchar* const *invalidated_properties, gpointer pp) { if (g_variant_n_children(changed_properties) > 0) { GVariantIter *iter; gchar *key; GVariant *value; debug(" *** Properties Changed:\n"); g_variant_get(changed_properties, "a{sv}", &iter); while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) { gchar *value_str; value_str = g_variant_print(value, TRUE); g_print(" %s -> %s\n", key, value_str); g_free(value_str); if (strncmp(key, "Metadata",8) == 0) { trackChanged(value); } else if (strcmp(key, "PlaybackStatus") == 0) { playbackChanged(g_variant_dup_string(value, NULL)); } else if (strcmp(key, "LoopStatus") == 0) { loopChanged(g_variant_dup_string(value, NULL)); } else if (strcmp(key, "Shuffle") == 0) { shuffleChanged(g_variant_get_boolean(value)); } else if (strcmp(key, "Position") == 0) { positionChanged(g_variant_get_int64(value)); } else if (strcmp(key, "Volume") == 0) { volumeChanged(g_variant_get_double(value)); } } g_variant_iter_free (iter); } }
static OlLyricSourceCandidate * ol_lyric_source_candidate_new_with_variant (GVariant *dict) { ol_log_func (); OlLyricSourceCandidate *candidate = NULL; GVariantIter *dictiter = NULL; gchar *key = NULL; gchar *title, *artist, *album, *comment, *sourceid; GVariant *downloadinfo = NULL; GVariant *value = NULL; title = artist = album = comment = sourceid = NULL; g_variant_get (dict, "a{sv}", &dictiter); while (g_variant_iter_loop (dictiter, "{sv}", &key, &value)) { if (strcmp (key, "title") == 0 && title == NULL) { title = g_variant_dup_string (value, NULL); } else if (strcmp (key, "artist") == 0 && artist == NULL) { artist = g_variant_dup_string (value, NULL); } else if (strcmp (key, "album") == 0 && album == NULL) { album = g_variant_dup_string (value, NULL); } else if (strcmp (key, "comment") == 0 && comment == NULL) { comment = g_variant_dup_string (value, NULL); } else if (strcmp (key, "sourceid") == 0 && sourceid == NULL) { sourceid = g_variant_dup_string (value, NULL); } else if (strcmp (key, "downloadinfo") == 0 && downloadinfo == NULL) { downloadinfo = g_variant_ref (value); } else { ol_errorf ("Unknown candidate key: %s\n", key); } } g_variant_iter_free (dictiter); candidate = ol_lyric_source_candidate_new (title, artist, album, comment, sourceid, downloadinfo); g_free (title); g_free (artist); g_free (album); g_free (comment); g_free (sourceid); g_variant_unref (downloadinfo); return candidate; }
ConnmanService *connman_service_new(GVariant *variant) { ConnmanService *service = g_object_new(CONNMAN_TYPE_SERVICE, NULL); GVariant *child = g_variant_get_child_value(variant, 0); GVariant *attrs; gsize i; service->object_path = g_variant_dup_string(child, NULL); attrs = g_variant_get_child_value(variant, 1); for (i = 0; i < g_variant_n_children(attrs); i++) { GVariant *attr = g_variant_get_child_value(attrs, i); GVariant *key_v = g_variant_get_child_value(attr, 0); GVariant *val_v = g_variant_get_child_value(attr, 1); GVariant *val = g_variant_get_variant(val_v); const gchar *key = g_variant_get_string(key_v, NULL); if (g_str_equal(key, "Name")) service->name = g_variant_dup_string(val, NULL); if (g_str_equal(key, "Type")) { const gchar *v = g_variant_get_string(val, NULL); if (g_str_equal(v, "wifi")) service->type = CONNMAN_SERVICE_TYPE_WIFI; if (g_str_equal(v, "ethernet")) service->type = CONNMAN_SERVICE_TYPE_ETHERNET; } if (g_str_equal(key, "LoginRequired")) service->login_required = g_variant_get_boolean(val); if (g_str_equal(key, "PassphraseRequired")) service->passphrase_required = g_variant_get_boolean(val); if (g_str_equal(key, "AutoConnect")) service->auto_connect = g_variant_get_boolean(val); if (g_str_equal(key, "Immutable")) service->immutable = g_variant_get_boolean(val); if (g_str_equal(key, "Favorite")) service->favorite = g_variant_get_boolean(val); if (g_str_equal(key, "Strength")) service->strength = g_variant_get_byte(val); } g_message("new service %p: '%s' (%d)", service, service->name, service->type); return service; }
static void photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosCreateCollectionJob *self = PHOTOS_CREATE_COLLECTION_JOB (user_data); TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object); GError *error; GVariant *variant; GVariant *child; gchar *key = NULL; gchar *val = NULL; error = NULL; variant = tracker_sparql_connection_update_blank_finish (connection, res, &error); if (error != NULL) { g_warning ("Unable to create collection: %s", error->message); g_error_free (error); goto out; } child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); key = g_variant_dup_string (child, NULL); g_variant_unref (child); child = g_variant_get_child_value (variant, 1); val = g_variant_dup_string (child, NULL); g_variant_unref (child); g_variant_unref (variant); if (g_strcmp0 (key, "res") == 0) self->created_urn = val; out: if (self->callback != NULL) (*self->callback) (self->created_urn, self->user_data); self->created_urn = NULL; g_free (val); g_free (key); }
/* --- genlist callbacks --- */ static char * gl_text_get(void *data, Evas_Object * obj, const char *part) { (void) obj; GHashTable *entry = (GHashTable *) data; GVariant *val; g_debug("gl_text_get: %s", part); if (!strcmp(part, "elm.text")) { val = g_hash_table_lookup(entry, "Name"); if (val) { return g_variant_dup_string(val, NULL); } return strdup(""); } if (!strcmp(part, "elm.text.sub")) { val = g_hash_table_lookup(entry, "Peer"); if (val) { return g_variant_dup_string(val, NULL); } return strdup(CONTACT_PHONE_UNDEFINED_STRING); } if (!strcmp(part, "elm.text.2")) { val = g_hash_table_lookup(entry, "Timestamp"); if (val) { return common_utils_timestamp_to_date (g_variant_get_int32(val)); } } if (!strcmp(part, "elm.text.sub.2")) { val = g_hash_table_lookup(entry, "Duration"); if (val) { float duration = strtof(g_variant_get_string(val, NULL), NULL); int h = duration / 3600; int m = duration / 60 - h * 60; int s = duration - h * 3600 - m * 60; char durstr[10]; if (h > 0) { snprintf(durstr, 10, "%02d:%02d:%02d", h, m, s); } else { snprintf(durstr, 10, "%02d:%02d", m, s); } return strdup(durstr); } return strdup("00:00"); } return strdup(""); }
void connman_service_update_properties(connman_service_t *service, GVariant *properties) { if(NULL == service || NULL == properties) return; gsize i; for (i = 0; i < g_variant_n_children(properties); i++) { GVariant *property = g_variant_get_child_value(properties, i); GVariant *key_v = g_variant_get_child_value(property, 0); GVariant *val_v = g_variant_get_child_value(property, 1); GVariant *val = g_variant_get_variant(val_v); const gchar *key = g_variant_get_string(key_v, NULL); if (g_str_equal(key, "Name")) { g_free(service->name); service->name = g_variant_dup_string(val, NULL); } else if (g_str_equal(key, "Type")) { const gchar *v = g_variant_get_string(val, NULL); if (g_str_equal(v, "wifi")) service->type = CONNMAN_SERVICE_TYPE_WIFI; if (g_str_equal(v, "ethernet")) service->type = CONNMAN_SERVICE_TYPE_ETHERNET; } else if (g_str_equal(key, "State")) { g_free(service->state); service->state = g_variant_dup_string(val, NULL); // Only a hidden service gets added as a new service with "association" state if(g_str_equal(service->state, "association")) service->hidden = TRUE; } else if (g_str_equal(key, "Strength")) service->strength = g_variant_get_byte(val); else if(g_str_equal(key, "Security")) { g_strfreev(service->security); service->security = g_variant_dup_strv(val, NULL); } else if (g_str_equal(key, "AutoConnect")) service->auto_connect = g_variant_get_boolean(val); else if (g_str_equal(key, "Immutable")) service->immutable = g_variant_get_boolean(val); else if (g_str_equal(key, "Favorite")) service->favorite = g_variant_get_boolean(val); } }
static void photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object); GError *error; GVariant *variant; GVariant *child; gchar *key = NULL; gchar *val = NULL; error = NULL; variant = tracker_sparql_connection_update_blank_finish (connection, res, &error); if (error != NULL) { g_task_return_error (task, error); return; } child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */ g_variant_unref (variant); variant = child; child = g_variant_get_child_value (variant, 0); key = g_variant_dup_string (child, NULL); g_variant_unref (child); child = g_variant_get_child_value (variant, 1); val = g_variant_dup_string (child, NULL); g_variant_unref (child); g_variant_unref (variant); if (g_strcmp0 (key, "res") == 0) g_task_return_pointer (task, g_strdup (val), g_free); else g_task_return_new_error (task, PHOTOS_ERROR, 0, "Failed to parse GVariant"); g_free (val); g_free (key); }
static void _dbus_steadyflow_iapp_service_add_file (SteadyflowIAppService* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error = NULL; GVariantIter _arguments_iter; gchar* url = NULL; GVariant* _tmp0_; GDBusMessage* _reply_message; GVariant* _reply; GVariantBuilder _reply_builder; g_variant_iter_init (&_arguments_iter, parameters); _tmp0_ = g_variant_iter_next_value (&_arguments_iter); url = g_variant_dup_string (_tmp0_, NULL); g_variant_unref (_tmp0_); steadyflow_iapp_service_add_file (self, url, &error); if (error) { g_dbus_method_invocation_return_gerror (invocation, error); return; } _reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation)); g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE); _reply = g_variant_builder_end (&_reply_builder); g_dbus_message_set_body (_reply_message, _reply); _g_free0 (url); g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL); g_object_unref (invocation); g_object_unref (_reply_message); }
static gboolean handle_set_property (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GVariant *value, GError **error, gpointer user_data) { printf("set property: '%s'\n", property_name); if (!g_strcmp0(property_name, "Title")) { if (g_strcmp0(_global_title, g_variant_get_string (value, NULL))) { GVariantBuilder *builder; GError *local_error; g_free(_global_title); _global_title = g_variant_dup_string(value, NULL); local_error = NULL; builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY); g_variant_builder_add (builder, "{sv}", "Title", g_variant_new_string(_global_title)); g_dbus_connection_emit_signal (connection, NULL, object_path, "org.freedesktop.DBus.Properties", "PropertiesChanged", g_variant_new("(sa{sv}as)", interface_name, builder, NULL), &local_error); g_assert_no_error (local_error); } } return *error == NULL; }
static void _dbus_geany_dbus_application_open_documents (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error; char** filenames = NULL; int filenames_length1; GVariant* _tmp1_; char** _tmp2_; int _tmp2__length; int _tmp2__size; int _tmp2__length1; GVariantIter _tmp3_; GVariant* _tmp4_; GVariantIter _arguments_iter; GVariant* _reply; GVariantBuilder _reply_builder; error = NULL; g_variant_iter_init (&_arguments_iter, parameters); filenames_length1 = 0; _tmp1_ = g_variant_iter_next_value (&_arguments_iter); _tmp2_ = g_new (char*, 5); _tmp2__length = 0; _tmp2__size = 4; _tmp2__length1 = 0; g_variant_iter_init (&_tmp3_, _tmp1_); for (; _tmp4_ = g_variant_iter_next_value (&_tmp3_); _tmp2__length1++) { if (_tmp2__size == _tmp2__length) { _tmp2__size = 2 * _tmp2__size; _tmp2_ = g_renew (char*, _tmp2_, _tmp2__size + 1); } _tmp2_[_tmp2__length++] = g_variant_dup_string (_tmp4_, NULL); g_variant_unref (_tmp4_); }
gchar *gstd_pipeline_element_get_property_string(GDBusProxy *pipeline_proxy, const gchar *element, const gchar *name) { GError *error = NULL; GVariant *variant = NULL; gchar *property_string = NULL; variant = g_dbus_proxy_call_sync(pipeline_proxy, "ElementGetPropertyString", g_variant_new("(ss)", element, name), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_printerr("g_dbus_proxy_new_for_bus_sync failed: %s\n", error->message); return NULL; } if (!g_strcmp0(g_variant_get_type_string(variant), "(sb)")) { GVariant *string_variant = g_variant_get_child_value(variant, 0); property_string = g_variant_dup_string(string_variant, NULL); } g_variant_unref(variant); return property_string; }
static void create_context_for_device (NMDevice *nm_device) { GError *error = NULL; guint port; GVariant *value; char *iface; char *ssid = NULL; g_object_get (nm_device->manager, "port", &port, NULL); value = g_dbus_proxy_get_cached_property (nm_device->proxy, "Interface"); if (G_UNLIKELY (value == NULL)) return; if (G_UNLIKELY (!g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))) { g_variant_unref (value); return; } iface = g_variant_dup_string (value, NULL); g_variant_unref (value); if (nm_device->ap_proxy != NULL) { value = g_dbus_proxy_get_cached_property (nm_device->ap_proxy, "Ssid"); if (G_LIKELY (value != NULL)) { ssid = g_strndup (g_variant_get_data (value), g_variant_get_size (value)); g_variant_unref (value); } } nm_device->context = g_initable_new (GUPNP_TYPE_CONTEXT, NULL, &error, "interface", iface, "network", ssid, "port", port, NULL); g_free (iface); g_free (ssid); if (error) { g_warning ("Error creating GUPnP context: %s\n", error->message); g_error_free (error); return; } g_signal_emit_by_name (nm_device->manager, "context-available", nm_device->context); }
gchar* dbus_get_string_property(GDBusProxy *proxy, gchar * property) { GVariant* var; gchar* rv; var = g_dbus_proxy_get_cached_property(proxy, property); rv = g_variant_dup_string(var, 0); g_variant_unref(var); return rv; }
// webkit_web_extension_initialize_with_user_data initializes the web extension // // The profile name should be passed as the user data. G_MODULE_EXPORT void webkit_web_extension_initialize_with_user_data(WebKitWebExtension *extension, GVariant *data) { gchar *profile = g_variant_dup_string(data, NULL); g_signal_connect(extension, "page-created", G_CALLBACK(web_page_created_callback), profile); }
void updatePlaybackProperty() { GVariant * playback = updateProperty(mpris_data->player, "PlaybackStatus"); if (playback == NULL) { return; } playbackChanged(g_variant_dup_string(playback, NULL)); g_variant_unref(playback); }
MMLocationGpsRaw * mm_location_gps_raw_new_from_dictionary (GVariant *dictionary, GError **error) { GError *inner_error = NULL; MMLocationGpsRaw *self; GVariantIter iter; gchar *key; GVariant *value; self = mm_location_gps_raw_new (); if (!dictionary) return self; if (!g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{sv}"))) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Cannot create GPS RAW location from dictionary: " "invalid variant type received"); g_object_unref (self); return NULL; } g_variant_iter_init (&iter, dictionary); while (!inner_error && g_variant_iter_next (&iter, "{sv}", &key, &value)) { if (g_str_equal (key, PROPERTY_UTC_TIME)) self->priv->utc_time = g_variant_dup_string (value, NULL); else if (g_str_equal (key, PROPERTY_LONGITUDE)) self->priv->longitude = g_variant_get_double (value); else if (g_str_equal (key, PROPERTY_LATITUDE)) self->priv->latitude = g_variant_get_double (value); else if (g_str_equal (key, PROPERTY_ALTITUDE)) self->priv->altitude = g_variant_get_double (value); g_free (key); g_variant_unref (value); } /* If any of the mandatory parameters is missing, cleanup */ if (!self->priv->utc_time || self->priv->longitude == MM_LOCATION_LONGITUDE_UNKNOWN || self->priv->latitude == MM_LOCATION_LATITUDE_UNKNOWN) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Cannot create GPS RAW location from dictionary: " "mandatory parameters missing " "(utc-time: %s, longitude: %s, latitude: %s)", self->priv->utc_time ? "yes" : "missing", (self->priv->longitude != MM_LOCATION_LONGITUDE_UNKNOWN) ? "yes" : "missing", (self->priv->latitude != MM_LOCATION_LATITUDE_UNKNOWN) ? "yes" : "missing"); g_clear_object (&self); } return self; }
static gboolean handle_set_property (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GVariant *value, GError **error, gpointer user_data) { if (g_strcmp0 (property_name, "Title") == 0) { if (g_strcmp0 (_global_title, g_variant_get_string (value, NULL)) != 0) { GVariantBuilder *builder; GError *local_error; g_free (_global_title); _global_title = g_variant_dup_string (value, NULL); local_error = NULL; builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY); g_variant_builder_add (builder, "{sv}", "Title", g_variant_new_string (_global_title)); g_dbus_connection_emit_signal (connection, NULL, object_path, "org.freedesktop.DBus.Properties", "PropertiesChanged", g_variant_new ("(sa{sv}as)", interface_name, builder, NULL), &local_error); g_assert_no_error (local_error); } } else if (g_strcmp0 (property_name, "ReadingAlwaysThrowsError") == 0) { /* do nothing - they can't read it after all! */ } else if (g_strcmp0 (property_name, "WritingAlwaysThrowsError") == 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Hello AGAIN %s. I thought I said writing this property " "always results in an error. kthxbye", sender); } return *error == NULL; }
// If kwalletd isn't running: try to start it static gboolean start_kwallet(backend_kwallet_context_t *context) { GError *error = NULL; // Sadly kwalletd doesn't use DBUS activation, so we have to make a call to // klauncher to start it. /* * signature: * * in s serviceName, * in as urls, * in as envs, * in s startup_id, * in b blind, * * out i arg_0, * out s dbusServiceName, * out s error, * out i pid */ GVariant *ret = g_dbus_connection_call_sync(context->connection, klauncher_service_name, klauncher_path, klauncher_interface, "start_service_by_desktop_name", g_variant_new ("(sasassb)", "kwalletd", NULL, NULL, "", FALSE), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if(check_error(error)) { g_variant_unref(ret); return FALSE; } GVariant *child = g_variant_get_child_value(ret, 2); gchar *error_string = g_variant_dup_string(child, NULL); g_variant_unref(child); g_variant_unref(ret); if(error_string && error_string[0] != '\0') { dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_kwallet] ERROR: error launching kwalletd: %s\n", error_string); g_free(error_string); return FALSE; } g_free(error_string); return TRUE; }
static void property_changed_cb(ConnmanInterfaceService *proxy, gchar * property, GVariant *v, connman_service_t *service) { /* Invoke function pointers only for state changed */ if(g_str_equal(property, "State") == FALSE) return; g_free(service->state); service->state = g_variant_dup_string(g_variant_get_variant(v), NULL); if(NULL != service->handle_state_change_fn) (service->handle_state_change_fn)((gpointer)service, service->state); }
// Initialize the connection to KWallet static gboolean init_kwallet(backend_kwallet_context_t *context) { GError *error = NULL; // Make a proxy to KWallet. if(context->proxy) g_object_unref(context->proxy); context->proxy = g_dbus_proxy_new_sync(context->connection, G_DBUS_PROXY_FLAGS_NONE, NULL, kwallet_service_name, kwallet_path, kwallet_interface, NULL, &error); if(check_error(error)) { context->proxy = NULL; return FALSE; } // Check KWallet is enabled. GVariant *ret = g_dbus_proxy_call_sync(context->proxy, "isEnabled", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if(!ret) return FALSE; GVariant *child = g_variant_get_child_value(ret, 0); gboolean is_enabled = g_variant_get_boolean(child); g_variant_unref(child); g_variant_unref(ret); if(check_error(error) || !is_enabled) return FALSE; // Get the wallet name. g_free(context->wallet_name); ret = g_dbus_proxy_call_sync(context->proxy, "networkWallet", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); child = g_variant_get_child_value(ret, 0); context->wallet_name = g_variant_dup_string(child, NULL); g_variant_unref(child); g_variant_unref(ret); if(check_error(error) || !context->wallet_name) { context->wallet_name = NULL; // yes, it's stupid. go figure. return FALSE; } return TRUE; }
gchar *get_connection(const gchar *obj, GError **error){ GDBusProxy *proxy = NULL; proxy = g_dbus_proxy_new_for_bus_sync( G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.freedesktop.Telepathy.AccountManager", obj, "org.freedesktop.Telepathy.Account", NULL, error); if (proxy == NULL) return NULL; GVariant *res = g_dbus_proxy_get_cached_property(proxy, "Connection"); gchar *ret = g_variant_dup_string(res, NULL); g_object_unref(proxy); return ret; }
static char * systemd_unit_property(const char *obj, const gchar * iface, const char *name) { GError *error = NULL; GDBusProxy *proxy; GVariant *asv = NULL; GVariant *value = NULL; GVariant *_ret = NULL; char *output = NULL; crm_trace("Calling GetAll on %s", obj); proxy = get_proxy(obj, BUS_PROPERTY_IFACE); if (!proxy) { return NULL; } _ret = g_dbus_proxy_call_sync(proxy, "GetAll", g_variant_new("(s)", iface), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { crm_err("Cannot get properties for %s: %s", g_dbus_proxy_get_object_path(proxy), error->message); g_error_free(error); g_object_unref(proxy); return NULL; } crm_debug("Call to GetAll passed: type '%s' %d\n", g_variant_get_type_string(_ret), g_variant_n_children(_ret)); asv = g_variant_get_child_value(_ret, 0); crm_trace("asv type '%s' %d\n", g_variant_get_type_string(asv), g_variant_n_children(asv)); value = g_variant_lookup_value(asv, name, NULL); if (value && g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { crm_info("Got value '%s' for %s[%s]", g_variant_get_string(value, NULL), obj, name); output = g_variant_dup_string(value, NULL); } else { crm_info("No value for %s[%s]", obj, name); } g_object_unref(proxy); g_variant_unref(_ret); return output; }
gchar* get_version() { g_type_init(); GDBusProxy* UD2_Manager_Proxy = NULL; GError* error=NULL; UD2_Manager_Proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, UD2_DBUS_NAME, UD2_MANAGER_PATH, DBUS_PROP_IFACE, NULL, &error); if (!UD2_Manager_Proxy) { g_printerr("%s\n", error->message); g_error_free(error); } GVariant* UD2_Version = g_dbus_proxy_call_sync( UD2_Manager_Proxy, (gchar*) "Get", g_variant_new( "(ss)", "org.freedesktop.UDisks2.Manager", "Version" ), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!UD2_Version) { g_printerr("%s\n", error->message); g_error_free(error); } GVariant* version_string; g_variant_get(UD2_Version, "(v)", &version_string); /* version is allocated independently from the GVariants */ gchar* version=g_variant_dup_string(version_string, NULL); g_variant_unref(version_string); g_variant_unref(UD2_Version); g_object_unref(UD2_Manager_Proxy); return version; }
static void try_update_version (NMShellWatcher *watcher) { NMShellWatcherPrivate *priv = watcher->priv; GVariant *v; char *version, *p; v = g_dbus_proxy_get_cached_property (priv->shell_proxy, "ShellVersion"); if (!v) { /* The shell has claimed the name, but not yet registered its interfaces... * (https://bugzilla.gnome.org/show_bug.cgi?id=673182). There's no way * to make GDBusProxy re-read the properties at this point, so we * have to destroy this proxy and try again. */ if (priv->signal_id) { g_signal_handler_disconnect (priv->shell_proxy, priv->signal_id); priv->signal_id = 0; } g_object_unref (priv->shell_proxy); priv->shell_proxy = NULL; priv->retry_timeout = g_timeout_add_seconds (2, retry_create_shell_proxy, watcher); return; } g_warn_if_fail (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING)); version = g_variant_dup_string (v, NULL); if (version) { guint major, minor; major = strtoul (version, &p, 10); if (*p == '.') minor = strtoul (p + 1, NULL, 10); else minor = 0; g_warn_if_fail (major < 256); g_warn_if_fail (minor < 256); priv->shell_version = (major << 8) | minor; g_object_notify (G_OBJECT (watcher), "shell-version"); } g_variant_unref (v); }
char * gnome_settings_get_chassis_type (void) { char *ret = NULL; GError *error = NULL; GVariant *inner; GVariant *variant = NULL; GDBusConnection *connection; connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (connection == NULL) { g_warning ("system bus not available: %s", error->message); g_error_free (error); goto out; } variant = g_dbus_connection_call_sync (connection, "org.freedesktop.hostname1", "/org/freedesktop/hostname1", "org.freedesktop.DBus.Properties", "Get", g_variant_new ("(ss)", "org.freedesktop.hostname1", "Chassis"), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (variant == NULL) { g_debug ("Failed to get property '%s': %s", "Chassis", error->message); g_error_free (error); goto out; } g_variant_get (variant, "(v)", &inner); ret = g_variant_dup_string (inner, NULL); g_variant_unref (inner); out: g_clear_object (&connection); g_clear_pointer (&variant, g_variant_unref); return ret; }
static gchar * get_profile_for_window (GdkWindow *window) { GError *error = NULL; guint xid; gchar *icc_profile = NULL; GVariant *args = NULL; GVariant *response = NULL; GVariant *response_child = NULL; GVariantIter *iter = NULL; /* get color profile */ xid = GDK_WINDOW_XID (window); args = g_variant_new ("(u)", xid), response = g_dbus_connection_call_sync (connection, "org.gnome.ColorManager", "/org/gnome/ColorManager", "org.gnome.ColorManager", "GetProfileForWindow", args, G_VARIANT_TYPE ("(s)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (response == NULL) { /* not a warning, as GCM might not be installed / running */ g_debug ("The GetProfileForWindow request failed: %s", error->message); g_error_free (error); goto out; } /* get icc profile filename */ response_child = g_variant_get_child_value (response, 0); icc_profile = g_variant_dup_string (response_child, NULL); out: if (iter != NULL) g_variant_iter_free (iter); if (args != NULL) g_variant_unref (args); if (response != NULL) g_variant_unref (response); return icc_profile; }
static gboolean demarshal_dhcp_options (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field) { NMDhcpConfigPrivate *priv = NM_DHCP_CONFIG_GET_PRIVATE (object); GVariantIter iter; const char *key; GVariant *opt; g_hash_table_remove_all (priv->options); g_variant_iter_init (&iter, value); while (g_variant_iter_next (&iter, "{&sv}", &key, &opt)) { g_hash_table_insert (priv->options, g_strdup (key), g_variant_dup_string (opt, NULL)); g_variant_unref (opt); } _nm_object_queue_notify (object, NM_DHCP_CONFIG_OPTIONS); return TRUE; }
/***************************************************************************** * neardal_tag_prv_read_properties: Get Neard Tag Properties ****************************************************************************/ static errorCode_t neardal_tag_prv_read_properties(TagProp *tagProp) { errorCode_t err = NEARDAL_SUCCESS; GVariant *tmp = NULL; GVariant *tmpOut = NULL; gsize len; NEARDAL_TRACEIN(); NEARDAL_ASSERT_RET(tagProp != NULL, NEARDAL_ERROR_INVALID_PARAMETER); NEARDAL_ASSERT_RET(tagProp->proxy != NULL , NEARDAL_ERROR_GENERAL_ERROR); tmp = g_datalist_get_data(&(neardalMgr.dbus_data), tagProp->name); if (tmp == NULL) { err = NEARDAL_ERROR_NO_TAG; NEARDAL_TRACE_ERR("Unable to read tag's properties\n"); goto exit; } NEARDAL_TRACEF("Reading:\n%s\n", g_variant_print(tmp, TRUE)); tmpOut = g_variant_lookup_value(tmp, "TagType", G_VARIANT_TYPE_ARRAY); if (tmpOut != NULL) { tagProp->tagType = g_variant_dup_strv(tmpOut, &len); tagProp->tagTypeLen = len; if (len == 0) { g_strfreev(tagProp->tagType); tagProp->tagType = NULL; } } tmpOut = g_variant_lookup_value(tmp, "Type", G_VARIANT_TYPE_STRING); if (tmpOut != NULL) tagProp->type = g_variant_dup_string(tmpOut, NULL); tmpOut = g_variant_lookup_value(tmp, "ReadOnly", G_VARIANT_TYPE_BOOLEAN); if (tmpOut != NULL) tagProp->readOnly = g_variant_get_boolean(tmpOut); exit: return err; }
connman_service_t *connman_service_new(GVariant *variant) { if(NULL == variant) return NULL; connman_service_t *service = g_new0(connman_service_t, 1); if(service == NULL) { WCA_LOG_FATAL("Out of memory !!!"); return NULL; } GVariant *service_v = g_variant_get_child_value(variant, 0); service->path = g_variant_dup_string(service_v, NULL); GError *error = NULL; service->remote = connman_interface_service_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, "net.connman", service->path, NULL, &error); if (error) { WCA_LOG_CRITICAL("%s", error->message); g_error_free(error); g_free(service); return NULL; } g_dbus_proxy_set_default_timeout(service->remote, DBUS_CALL_TIMEOUT); service->sighandler_id = g_signal_connect_data(G_OBJECT(service->remote), "property-changed", G_CALLBACK(property_changed_cb), service, NULL, 0); GVariant *properties = g_variant_get_child_value(variant, 1); connman_service_update_properties(service, properties); return service; }
static void _dbus_geany_dbus_application_open_document (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) { GError* error; char* filename = NULL; GVariant* _tmp0_; gboolean result; GVariantIter _arguments_iter; GVariant* _reply; GVariantBuilder _reply_builder; error = NULL; g_variant_iter_init (&_arguments_iter, parameters); _tmp0_ = g_variant_iter_next_value (&_arguments_iter); filename = g_variant_dup_string (_tmp0_, NULL); g_variant_unref (_tmp0_); result = geany_dbus_application_open_document (self, filename); g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE); _g_free0 (filename); g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result)); _reply = g_variant_builder_end (&_reply_builder); g_dbus_method_invocation_return_value (invocation, _reply); }