static void fwupd_remote_set_from_variant_iter (FwupdRemote *self, GVariantIter *iter) { FwupdRemotePrivate *priv = GET_PRIVATE (self); GVariant *value; const gchar *key; g_autoptr(GVariantIter) iter2 = g_variant_iter_copy (iter); g_autoptr(GVariantIter) iter3 = g_variant_iter_copy (iter); /* three passes, as we have to construct Id -> Url -> * */ while (g_variant_iter_loop (iter, "{sv}", &key, &value)) { if (g_strcmp0 (key, FWUPD_RESULT_KEY_REMOTE_ID) == 0) fwupd_remote_set_id (self, g_variant_get_string (value, NULL)); if (g_strcmp0 (key, "Type") == 0) fwupd_remote_set_kind (self, g_variant_get_uint32 (value)); if (g_strcmp0 (key, "Keyring") == 0) fwupd_remote_set_keyring_kind (self, g_variant_get_uint32 (value)); } while (g_variant_iter_loop (iter2, "{sv}", &key, &value)) { if (g_strcmp0 (key, FWUPD_RESULT_KEY_URI) == 0) fwupd_remote_set_metadata_uri (self, g_variant_get_string (value, NULL)); if (g_strcmp0 (key, "FilenameCache") == 0) fwupd_remote_set_filename_cache (self, g_variant_get_string (value, NULL)); if (g_strcmp0 (key, "FilenameSource") == 0) fwupd_remote_set_filename_source (self, g_variant_get_string (value, NULL)); if (g_strcmp0 (key, "ReportUri") == 0) fwupd_remote_set_report_uri (self, g_variant_get_string (value, NULL)); } while (g_variant_iter_loop (iter3, "{sv}", &key, &value)) { if (g_strcmp0 (key, "Username") == 0) { fwupd_remote_set_username (self, g_variant_get_string (value, NULL)); } else if (g_strcmp0 (key, "Password") == 0) { fwupd_remote_set_password (self, g_variant_get_string (value, NULL)); } else if (g_strcmp0 (key, "Title") == 0) { fwupd_remote_set_title (self, g_variant_get_string (value, NULL)); } else if (g_strcmp0 (key, "Agreement") == 0) { fwupd_remote_set_agreement (self, g_variant_get_string (value, NULL)); } else if (g_strcmp0 (key, FWUPD_RESULT_KEY_CHECKSUM) == 0) { fwupd_remote_set_checksum (self, g_variant_get_string (value, NULL)); } else if (g_strcmp0 (key, "Enabled") == 0) { priv->enabled = g_variant_get_boolean (value); } else if (g_strcmp0 (key, "ApprovalRequired") == 0) { priv->approval_required = g_variant_get_boolean (value); } else if (g_strcmp0 (key, "Priority") == 0) { priv->priority = g_variant_get_int32 (value); } else if (g_strcmp0 (key, "ModificationTime") == 0) { priv->mtime = g_variant_get_uint64 (value); } else if (g_strcmp0 (key, "FirmwareBaseUri") == 0) { fwupd_remote_set_firmware_base_uri (self, g_variant_get_string (value, NULL)); } } }
gboolean mm_bearer_properties_consume_variant (MMBearerProperties *properties, const gchar *key, GVariant *value, GError **error) { g_return_val_if_fail (MM_IS_BEARER_PROPERTIES (properties), FALSE); if (g_str_equal (key, PROPERTY_APN)) mm_bearer_properties_set_apn ( properties, g_variant_get_string (value, NULL)); else if (g_str_equal (key, PROPERTY_ALLOWED_AUTH)) mm_bearer_properties_set_allowed_auth ( properties, g_variant_get_uint32 (value)); else if (g_str_equal (key, PROPERTY_USER)) mm_bearer_properties_set_user ( properties, g_variant_get_string (value, NULL)); else if (g_str_equal (key, PROPERTY_PASSWORD)) mm_bearer_properties_set_password ( properties, g_variant_get_string (value, NULL)); else if (g_str_equal (key, PROPERTY_IP_TYPE)) mm_bearer_properties_set_ip_type ( properties, g_variant_get_uint32 (value)); else if (g_str_equal (key, PROPERTY_NUMBER)) mm_bearer_properties_set_number ( properties, g_variant_get_string (value, NULL)); else if (g_str_equal (key, PROPERTY_ALLOW_ROAMING)) mm_bearer_properties_set_allow_roaming ( properties, g_variant_get_boolean (value)); else { /* Set error */ g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Invalid properties dictionary, unexpected key '%s'", key); return FALSE; } return TRUE; }
static gint64 _tp_variant_convert_int64 (GVariant *variant, gboolean *valid) { guint64 u; *valid = TRUE; switch (g_variant_classify (variant)) { case G_VARIANT_CLASS_BYTE: return g_variant_get_byte (variant); case G_VARIANT_CLASS_UINT32: return g_variant_get_uint32 (variant); case G_VARIANT_CLASS_INT32: return g_variant_get_int32 (variant); case G_VARIANT_CLASS_INT64: return g_variant_get_int64 (variant); case G_VARIANT_CLASS_UINT64: u = g_variant_get_uint64 (variant); if (G_LIKELY (u <= G_MAXINT64)) return u; break; default: break; } *valid = FALSE; return 0; }
static void use_new_device (GUPnPNetworkManager *manager, NMDevice *nm_device) { NMDeviceState state; GVariant *value; manager->priv->nm_devices = g_list_append (manager->priv->nm_devices, nm_device); g_signal_connect (nm_device->proxy, "g-signal", G_CALLBACK (on_device_signal), nm_device); value = g_dbus_proxy_get_cached_property (nm_device->proxy, "State"); if (G_UNLIKELY (value == NULL)) return; if (G_UNLIKELY (!g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))) { g_variant_unref (value); return; } state = g_variant_get_uint32 (value); g_variant_unref (value); if (state == NM_OLD_DEVICE_STATE_ACTIVATED || state == NM_DEVICE_STATE_ACTIVATED) on_device_activated (nm_device); }
guint32 xdp_entry_get_flags (XdgAppDbEntry *entry) { g_autoptr(GVariant) v = xdg_app_db_entry_get_data (entry); g_autoptr(GVariant) c = g_variant_get_child_value (v, 3); return g_variant_get_uint32 (c); }
static void device_proxy_new_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { GUPnPNetworkManager *manager; GDBusProxy *device_proxy; NMDevice *nm_device = NULL; NMDeviceType type; GVariant *value; GError *error; error = NULL; device_proxy = g_dbus_proxy_new_for_bus_finish (res, &error); if (G_UNLIKELY (error != NULL)) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_message ("Failed to create D-Bus proxy: %s", error->message); g_error_free (error); goto done; } manager = GUPNP_NETWORK_MANAGER (user_data); value = g_dbus_proxy_get_cached_property (device_proxy, "DeviceType"); if (G_UNLIKELY (value == NULL)) { goto done; } if (G_UNLIKELY (!g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))) { g_variant_unref (value); goto done; } type = g_variant_get_uint32 (value); g_variant_unref (value); nm_device = nm_device_new (manager, device_proxy); if (type == NM_DEVICE_TYPE_WIFI) { const char *path; path = g_dbus_proxy_get_object_path (nm_device->proxy); g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, DBUS_SERVICE_NM, path, WIFI_INTERFACE, manager->priv->cancellable, wifi_proxy_new_cb, nm_device_ref (nm_device)); } else use_new_device (manager, nm_device); done: g_clear_pointer (&nm_device, (GDestroyNotify) nm_device_unref); g_clear_object (&device_proxy); }
static gdouble _tp_variant_convert_double (GVariant *variant, gboolean *valid) { *valid = TRUE; switch (g_variant_classify (variant)) { case G_VARIANT_CLASS_DOUBLE: return g_variant_get_double (variant); case G_VARIANT_CLASS_BYTE: return g_variant_get_byte (variant); case G_VARIANT_CLASS_UINT32: return g_variant_get_uint32 (variant); case G_VARIANT_CLASS_INT32: return g_variant_get_int32 (variant); case G_VARIANT_CLASS_INT64: return g_variant_get_int64 (variant); case G_VARIANT_CLASS_UINT64: return g_variant_get_uint64 (variant); default: break; } *valid = FALSE; return 0.0; }
/** * json_gvariant_serialize: * @variant: A #GVariant to convert * * Converts @variant to a JSON tree. * * Return value: (transfer full): A #JsonNode representing the root of the * JSON data structure obtained from @variant * * Since: 0.14 */ JsonNode * json_gvariant_serialize (GVariant *variant) { JsonNode *json_node = NULL; GVariantClass class; g_return_val_if_fail (variant != NULL, NULL); class = g_variant_classify (variant); if (! g_variant_is_container (variant)) { json_node = json_node_new (JSON_NODE_VALUE); switch (class) { case G_VARIANT_CLASS_BOOLEAN: json_node_set_boolean (json_node, g_variant_get_boolean (variant)); break; case G_VARIANT_CLASS_BYTE: json_node_set_int (json_node, g_variant_get_byte (variant)); break; case G_VARIANT_CLASS_INT16: json_node_set_int (json_node, g_variant_get_int16 (variant)); break; case G_VARIANT_CLASS_UINT16: json_node_set_int (json_node, g_variant_get_uint16 (variant)); break; case G_VARIANT_CLASS_INT32: json_node_set_int (json_node, g_variant_get_int32 (variant)); break; case G_VARIANT_CLASS_UINT32: json_node_set_int (json_node, g_variant_get_uint32 (variant)); break; case G_VARIANT_CLASS_INT64: json_node_set_int (json_node, g_variant_get_int64 (variant)); break; case G_VARIANT_CLASS_UINT64: json_node_set_int (json_node, g_variant_get_uint64 (variant)); break; case G_VARIANT_CLASS_HANDLE: json_node_set_int (json_node, g_variant_get_handle (variant)); break; case G_VARIANT_CLASS_DOUBLE: json_node_set_double (json_node, g_variant_get_double (variant)); break; case G_VARIANT_CLASS_STRING: case G_VARIANT_CLASS_OBJECT_PATH: case G_VARIANT_CLASS_SIGNATURE: json_node_set_string (json_node, g_variant_get_string (variant, NULL)); break; default: break; } }
static void update_failures (EmpathyWebcredentialsMonitor *self) { GVariant *failures, *f; GVariantIter iter; GList *new_list = NULL; guint i; failures = g_dbus_proxy_get_cached_property (self->priv->proxy, FAILURES_PROP); if (failures == NULL) { g_debug ("Does not implement Failures property"); return; } g_variant_iter_init (&iter, failures); while ((f = g_variant_iter_next_value (&iter)) != NULL) { guint32 id; AgAccount *account; id = g_variant_get_uint32 (f); account = ag_manager_get_account (self->priv->manager, id); if (account == NULL) continue; /* Pass ownership of 'account' to the list */ new_list = g_list_append (new_list, account); if (!tp_g_ptr_array_contains (self->priv->failures, account)) { g_ptr_array_add (self->priv->failures, g_object_ref (account)); g_signal_emit (self, signals[SIG_FAILURE_ADDED], 0, account); } g_variant_unref (f); } g_variant_unref (failures); for (i = 0; i < self->priv->failures->len; i++) { AgAccount *account = g_ptr_array_index (self->priv->failures, i); if (g_list_find (new_list, account) == NULL) { g_object_ref (account); g_ptr_array_remove (self->priv->failures, account); g_signal_emit (self, signals[SIG_FAILURE_REMOVED], 0, account); g_object_unref (account); } } g_list_free_full (new_list, g_object_unref); }
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username, const InitStateString &password) { // Expected content of parameter GVariant. boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free); // 'username' is the part after signon: which we can parse directly. GErrorCXX gerror; GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror), TRANSFER_REF); if (!parametersVar) { gerror.throwError(SE_HERE, "parsing 'signon:' username"); } GHashTableCXX parameters(Variant2HashTable(parametersVar)); // Extract the values that we expect in the parameters hash. guint32 signonID; const char *method; const char *mechanism; GVariant *value; value = (GVariant *)g_hash_table_lookup(parameters, "identity"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) { SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters"); } signonID = g_variant_get_uint32(value); value = (GVariant *)g_hash_table_lookup(parameters, "method"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'method: <string>' in 'signon:' parameters"); } method = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "mechanism"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'mechanism: <string>' in 'signon:' parameters"); } mechanism = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "session"); if (!value || !g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) { SE_THROW("need 'session: <hash>' in 'signon:' parameters"); } GHashTableCXX sessionData(Variant2HashTable(value)); SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s", signonID, method, mechanism); SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF); SE_LOG_DEBUG(NULL, "using signond identity %d", signonID); SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF); boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism)); return provider; }
static GUniquePtr<char> makeBusName(GVariant* userData) { // When the web extension is used by TestMultiprocess, an uint32 // identifier is passed as user data. It uniquely identifies // the web process, and the UI side expects it added as suffix to // the bus name. if (userData && g_variant_is_of_type(userData, G_VARIANT_TYPE_UINT32)) return GUniquePtr<char>(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", g_variant_get_uint32(userData))); return GUniquePtr<char>(g_strdup("org.webkit.gtk.WebExtensionTest")); }
static GError * _stmt_apply_GV_parameter_simple(sqlite3_stmt *stmt, int pos, GVariant *p) { int rc; gsize slen = 0; const gchar *s; switch (*((gchar*)g_variant_get_type(p))) { case 'b': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_boolean(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'i': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int32(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'n': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int16(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'q': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint16(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 's': s = g_variant_get_string(p, &slen); rc = sqlite3_bind_text(stmt, pos, s, slen, NULL); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 't': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint64(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'u': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint32(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'x': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int64(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; case 'y': rc = sqlite3_bind_int64(stmt, pos, g_variant_get_byte(p)); EXTRA_ASSERT(rc == SQLITE_OK); return NULL; /* XXX TODO manage the G_VARIANT_UNIT associtaed to NULL'd fields */ default: return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d ('%s')", pos, (gchar*)g_variant_get_type(p)); } (void) rc; }
void prop_set_from_gvariant(GVariant *v, prop_t *p) { const GVariantType *T = g_variant_get_type(v); if(g_variant_type_equal(T, G_VARIANT_TYPE_BOOLEAN)) { prop_set_int(p, g_variant_get_boolean(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_BYTE)) { prop_set_int(p, g_variant_get_byte(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT16)) { prop_set_int(p, g_variant_get_int16(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT16)) { prop_set_int(p, g_variant_get_uint16(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT32)) { prop_set_int(p, g_variant_get_int32(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT32)) { prop_set_int(p, g_variant_get_uint32(v)); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT64)) { int64_t val = g_variant_get_int64(v); if(val <= INT_MAX) prop_set_int(p, val); else prop_set_float(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT64)) { uint64_t val = g_variant_get_uint64(v); if(val <= INT_MAX) prop_set_int(p, val); else prop_set_float(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_STRING) || g_variant_type_equal(T, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_type_equal(T, G_VARIANT_TYPE_SIGNATURE)) { const gchar *val = g_variant_get_string(v, NULL); prop_set_string(p, val); } else if(g_variant_type_equal(T, G_VARIANT_TYPE_VARDICT)) { prop_void_childs(p); prop_set_from_vardict(v, p); } else if(g_variant_type_is_array(T)) { int num = g_variant_n_children(v); prop_destroy_childs(p); for(int i = 0; i < num; i++) { prop_set_from_gvariant(g_variant_get_child_value(v, i), prop_create(p, NULL)); } } else { fprintf(stderr, "%s(): can't deal with type %s\n", __FUNCTION__, g_variant_get_type_string(v)); } }
static gboolean ipcam_event_input_msg_handler_read_param(IpcamEventInputMsgHandler *handler, JsonBuilder *builder, const gchar *name) { IpcamIConfig *iconfig; g_object_get(G_OBJECT(handler), "app", &iconfig, NULL); gboolean ret = FALSE; GVariant *value = NULL; value = ipcam_iconfig_read(iconfig, IPCAM_EVENT_INPUT_TYPE, name, "enable"); if (value) { json_builder_set_member_name(builder, "enable"); json_builder_add_boolean_value(builder, g_variant_get_boolean(value)); g_variant_unref(value); } value = ipcam_iconfig_read(iconfig, IPCAM_EVENT_INPUT_TYPE, name, "schedules"); if (value) { Schedules *sche; if (IS_64BIT_MACHINE) { sche = GSIZE_TO_POINTER(g_variant_get_uint64(value)); } else { sche = GSIZE_TO_POINTER(g_variant_get_uint32(value)); } gint i = 0; json_builder_set_member_name(builder, "schedules"); json_builder_begin_object(builder); if (sche) { for (i = ENUM_MON; i < ENUM_WEEKDAY_LAST; i++) { if (sche->schedule[i]) { json_builder_set_member_name(builder, weekday_name[i]); json_builder_add_string_value(builder, sche->schedule[i]); g_free(sche->schedule[i]); } } g_free(sche); } json_builder_end_object(builder); g_variant_unref(value); } return ret; }
static gboolean get_rate (GValue *value, GVariant *variant, gpointer user_data) { int rate; gdouble fraction; rate = g_variant_get_uint32 (variant); fraction = 1.0 / ((gdouble) rate / 1000.0); g_value_set_double (value, fraction); g_debug ("Getting fraction %f for msecs %d", fraction, rate); return TRUE; }
QVariant gvariantToQVariant(GVariant *value) { GVariantClass c = g_variant_classify(value); if(c == G_VARIANT_CLASS_BOOLEAN) return QVariant((bool) g_variant_get_boolean(value)); else if(c == G_VARIANT_CLASS_BYTE) return QVariant((char) g_variant_get_byte(value)); else if(c == G_VARIANT_CLASS_INT16) return QVariant((int) g_variant_get_int16(value)); else if(c == G_VARIANT_CLASS_UINT16) return QVariant((unsigned int) g_variant_get_uint16(value)); else if(c == G_VARIANT_CLASS_INT32) return QVariant((int) g_variant_get_int32(value)); else if(c == G_VARIANT_CLASS_UINT32) return QVariant((unsigned int) g_variant_get_uint32(value)); else if(c == G_VARIANT_CLASS_INT64) return QVariant((long long) g_variant_get_int64(value)); else if(c == G_VARIANT_CLASS_UINT64) return QVariant((unsigned long long) g_variant_get_uint64(value)); else if(c == G_VARIANT_CLASS_DOUBLE) return QVariant(g_variant_get_double(value)); else if(c == G_VARIANT_CLASS_STRING) return QVariant(g_variant_get_string(value, NULL)); else if(c == G_VARIANT_CLASS_ARRAY) { gsize dictsize = g_variant_n_children(value); QVariantList list; for (int i=0;i<dictsize;i++) { GVariant *childvariant = g_variant_get_child_value(value,i); GVariant *innervariant = g_variant_get_variant(childvariant); list.append(gvariantToQVariant(innervariant)); } return list; } else return QVariant::Invalid; }
static gboolean g_settings_get_mapping_unsigned_int (GValue *value, GVariant *variant) { const GVariantType *type; guint64 u; type = g_variant_get_type (variant); if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) u = g_variant_get_uint16 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) u = g_variant_get_uint32 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) u = g_variant_get_uint64 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE)) u = g_variant_get_handle (variant); else return FALSE; if (G_VALUE_HOLDS_INT (value)) { g_value_set_int (value, u); return (u <= G_MAXINT32); } else if (G_VALUE_HOLDS_UINT (value)) { g_value_set_uint (value, u); return (u <= G_MAXUINT32); } else if (G_VALUE_HOLDS_INT64 (value)) { g_value_set_int64 (value, u); return (u <= G_MAXINT64); } else if (G_VALUE_HOLDS_UINT64 (value)) { g_value_set_uint64 (value, u); return (u <= G_MAXUINT64); } else if (G_VALUE_HOLDS_DOUBLE (value)) { g_value_set_double (value, u); return TRUE; } return FALSE; }
std::string StringFromVariant(GVariant* variant) { std::stringstream ss; const GVariantType* info_hint_type = g_variant_get_type(variant); if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_BOOLEAN)) { ss << g_variant_get_int16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT16)) { ss << g_variant_get_int16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT16)) { ss << g_variant_get_uint16(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT32)) { ss << g_variant_get_int32(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT32)) { ss << g_variant_get_uint32(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT64)) { ss << g_variant_get_int64(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT64)) { ss << g_variant_get_uint64(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_DOUBLE)) { ss << g_variant_get_double(variant); } else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_STRING)) { std::string str = g_variant_get_string(variant, NULL); ss << str; } else { ss << "unknown value"; } return ss.str(); }
guint InterfaceManagerImpl::getDeviceType(GDBusProxy* proxy) const { guint deviceType = NM_DEVICE_TYPE_UNKNOWN; GVariant* variant = g_dbus_proxy_get_cached_property(proxy, NM_IFACE_DEVICE_PROPERTY_TYPE); if (variant != nullptr) { deviceType = g_variant_get_uint32(variant); g_variant_unref(variant); } else{ throw std::runtime_error("Error reading device type"); } return deviceType; }
static gboolean variant_as_uint64 (GVariant *v, GVariantClass v_class, guint64 *as_uint) { gint64 i64; switch (v_class) { case G_VARIANT_CLASS_BYTE: *as_uint = (gint64) g_variant_get_byte (v); return TRUE; case G_VARIANT_CLASS_UINT16: *as_uint = g_variant_get_uint16 (v); return TRUE; case G_VARIANT_CLASS_UINT32: *as_uint = g_variant_get_uint32 (v); return TRUE; case G_VARIANT_CLASS_UINT64: *as_uint = g_variant_get_uint64 (v); return FALSE; case G_VARIANT_CLASS_INT16: i64 = g_variant_get_int16 (v); if (i64 > 0) { *as_uint = i64; return TRUE; } return FALSE; case G_VARIANT_CLASS_INT32: i64 = g_variant_get_int32 (v); if (i64 > 0) { *as_uint = i64; return TRUE; } return FALSE; case G_VARIANT_CLASS_INT64: i64 = g_variant_get_int64 (v); if (i64 > 0) { *as_uint = i64; return TRUE; } return FALSE; default: return FALSE; } }
static void rb_metadata_dbus_save (GVariant *parameters, GDBusMethodInvocation *invocation, ServiceData *svc) { const char *uri; GError *error = NULL; GVariantIter *metadata; RBMetaDataField key; GVariant *value; g_variant_get (parameters, "(&sa{iv})", &uri, &metadata); /* pass metadata to real metadata instance */ rb_metadata_reset (svc->metadata); while (g_variant_iter_next (metadata, "{iv}", &key, &value)) { GValue val = {0,}; switch (rb_metadata_get_field_type (key)) { case G_TYPE_STRING: g_value_init (&val, G_TYPE_STRING); g_value_set_string (&val, g_variant_get_string (value, NULL)); break; case G_TYPE_ULONG: g_value_init (&val, G_TYPE_ULONG); g_value_set_ulong (&val, g_variant_get_uint32 (value)); break; case G_TYPE_DOUBLE: g_value_init (&val, G_TYPE_DOUBLE); g_value_set_double (&val, g_variant_get_double (value)); break; default: g_assert_not_reached (); break; } rb_metadata_set (svc->metadata, key, &val); g_variant_unref (value); g_value_unset (&val); } rb_metadata_save (svc->metadata, uri, &error); g_dbus_method_invocation_return_value (invocation, g_variant_new ("(bis)", (error == NULL), (error != NULL ? error->code : 0), (error != NULL ? error->message : ""))); }
static void mate_panel_applet_frame_dbus_update_flags (MatePanelAppletFrame *frame, GVariant *value) { guint32 flags; gboolean major; gboolean minor; gboolean has_handle; flags = g_variant_get_uint32 (value); major = (flags & APPLET_EXPAND_MAJOR) != 0; minor = (flags & APPLET_EXPAND_MINOR) != 0; has_handle = (flags & APPLET_HAS_HANDLE) != 0; _mate_panel_applet_frame_update_flags (frame, major, minor, has_handle); }
static int init(struct sr_output *o, GHashTable *options) { struct context *ctx; struct sr_channel *ch; GSList *l; unsigned int i, j; if (!o || !o->sdi) return SR_ERR_ARG; ctx = g_malloc0(sizeof(struct context)); o->priv = ctx; ctx->trigger = -1; ctx->spl = g_variant_get_uint32(g_hash_table_lookup(options, "width")); for (l = o->sdi->channels; l; l = l->next) { ch = l->data; if (ch->type != SR_CHANNEL_LOGIC) continue; if (!ch->enabled) continue; ctx->num_enabled_channels++; } ctx->channel_index = g_malloc(sizeof(int) * ctx->num_enabled_channels); ctx->channel_names = g_malloc(sizeof(char *) * ctx->num_enabled_channels); ctx->lines = g_malloc(sizeof(GString *) * ctx->num_enabled_channels); ctx->sample_buf = g_malloc(ctx->num_enabled_channels); j = 0; for (i = 0, l = o->sdi->channels; l; l = l->next, i++) { ch = l->data; if (ch->type != SR_CHANNEL_LOGIC) continue; if (!ch->enabled) continue; ctx->channel_index[j] = ch->index; ctx->channel_names[j] = ch->name; ctx->lines[j] = g_string_sized_new(80); ctx->sample_buf[j] = 0; g_string_printf(ctx->lines[j], "%s:", ch->name); j++; } return SR_OK; }
/** * fu_util_status_changed_cb: **/ static void fu_util_status_changed_cb (GDBusProxy *proxy, GVariant *changed_properties, GStrv invalidated_properties, gpointer user_data) { _cleanup_variant_unref_ GVariant *val = NULL; /* print to the console */ val = g_dbus_proxy_get_cached_property (proxy, "Status"); if (val == NULL) return; switch (g_variant_get_uint32 (val)) { case FWUPD_STATUS_IDLE: /* TRANSLATORS: daemon is inactive */ g_print (" * %s\n", _("Idle")); break; case FWUPD_STATUS_DECOMPRESSING: /* TRANSLATORS: decompressing the firmware file */ g_print (" * %s\n", _("Decompressing firmware")); break; case FWUPD_STATUS_LOADING: /* TRANSLATORS: parsing the firmware information */ g_print (" * %s\n", _("Loading firmware")); break; case FWUPD_STATUS_DEVICE_RESTART: /* TRANSLATORS: restarting the device to pick up new F/W */ g_print (" * %s\n", _("Restarting device")); break; case FWUPD_STATUS_DEVICE_WRITE: /* TRANSLATORS: writing to the flash chips */ g_print (" * %s\n", _("Writing firmware to device")); break; case FWUPD_STATUS_DEVICE_VERIFY: /* TRANSLATORS: verifying we wrote the firmware correctly */ g_print (" * %s\n", _("Verifying firmware from device")); break; case FWUPD_STATUS_SCHEDULING: /* TRANSLATORS: scheduing an update to be done on the next boot */ g_print (" * %s\n", _("Scheduling upgrade")); break; default: break; } }
static gboolean load_access_technologies_finish (MMIfaceModem *self, GAsyncResult *res, MMModemAccessTechnology *access_technologies, guint *mask, GError **error) { GVariant *result; result = mm_base_modem_at_sequence_finish (MM_BASE_MODEM (self), res, NULL, error); if (!result) { if (error) g_assert (*error); return FALSE; } *access_technologies = (MMModemAccessTechnology) g_variant_get_uint32 (result); *mask = MM_MODEM_ACCESS_TECHNOLOGY_ANY; return TRUE; }
static void apply_value (GtkAdjustment *adj, GVariant *value, const gchar *property) { GValue val = { 0 }; gdouble v = 0.0; g_assert (GTK_IS_ADJUSTMENT (adj)); g_assert (value != NULL); g_assert (property != NULL); if (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE)) v = g_variant_get_double (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_INT16)) v = g_variant_get_int16 (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_UINT16)) v = g_variant_get_uint16 (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_INT32)) v = g_variant_get_int32 (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32)) v = g_variant_get_uint32 (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_INT64)) v = g_variant_get_int64 (value); else if (g_variant_is_of_type (value, G_VARIANT_TYPE_UINT64)) v = g_variant_get_uint64 (value); else g_warning ("Unknown variant type: %s\n", (gchar *)g_variant_get_type (value)); g_value_init (&val, G_TYPE_DOUBLE); g_value_set_double (&val, v); g_object_set_property (G_OBJECT (adj), property, &val); g_value_unset (&val); }
static void on_signal (GDBusProxy *proxy, gchar *sender_name, gchar *signal_name, GVariant *parameters, gpointer user_data) { guint32 new_state; /* Print all signals */ //gchar *parameters_str; //parameters_str = g_variant_print (parameters, TRUE); //g_print (" *** Received Signal: %s: %s\n", signal_name, parameters_str); //g_free (parameters_str); /* We are only interested in "StateChanged" signal */ if (strcmp (signal_name, "StateChanged") == 0) { GVariant *tmp = g_variant_get_child_value (parameters, 0); new_state = g_variant_get_uint32 (tmp); g_variant_unref (tmp); g_print ("NetworkManager state is: (%d) %s\n", new_state, nm_state_to_string ((NMState) new_state)); } }
static void modem_time_check_ready (MMBaseModem *self, GAsyncResult *res, GSimpleAsyncResult *simple) { GError *error = NULL; GVariant *result; g_simple_async_result_set_op_res_gboolean (simple, FALSE); result = mm_base_modem_at_sequence_finish (self, res, NULL, &error); if (!error) { MMBroadbandModemSierra *sierra = MM_BROADBAND_MODEM_SIERRA (self); sierra->priv->time_method = g_variant_get_uint32 (result); if (sierra->priv->time_method != TIME_METHOD_UNKNOWN) g_simple_async_result_set_op_res_gboolean (simple, TRUE); } g_clear_error (&error); g_simple_async_result_complete (simple); g_object_unref (simple); }
static void gs_plugin_steam_dump_apps (GPtrArray *apps) { guint i; GHashTable *app; for (i = 0; i < apps->len; i++) { g_autoptr(GList) keys = NULL; GList *l; app = g_ptr_array_index (apps, i); keys = g_hash_table_get_keys (app); for (l = keys; l != NULL; l = l->next) { const gchar *tmp; GVariant *value; tmp = l->data; value = g_hash_table_lookup (app, tmp); if (g_strcmp0 (g_variant_get_type_string (value), "s") == 0) g_print ("%s=%s\n", tmp, g_variant_get_string (value, NULL)); else if (g_strcmp0 (g_variant_get_type_string (value), "u") == 0) g_print ("%s=%u\n", tmp, g_variant_get_uint32 (value)); } g_print ("\n"); } }
JSValueRef dbus_to_js(JSContextRef ctx, GVariant *dbus) { JSValueRef jsvalue = NULL; GVariantClass type = g_variant_classify(dbus); switch (type) { case G_VARIANT_CLASS_STRING: case G_VARIANT_CLASS_OBJECT_PATH: case G_VARIANT_CLASS_SIGNATURE: { JSStringRef js_string = JSStringCreateWithUTF8CString(g_variant_get_string(dbus, NULL)); jsvalue = JSValueMakeString(ctx, js_string); JSStringRelease(js_string); return jsvalue; } case G_VARIANT_CLASS_BYTE: return JSValueMakeNumber(ctx, g_variant_get_byte(dbus)); case G_VARIANT_CLASS_DOUBLE: return JSValueMakeNumber(ctx, g_variant_get_double(dbus)); case G_VARIANT_CLASS_INT16: return JSValueMakeNumber(ctx, g_variant_get_int16(dbus)); case G_VARIANT_CLASS_UINT16: return JSValueMakeNumber(ctx, g_variant_get_uint16(dbus)); case G_VARIANT_CLASS_INT32: return JSValueMakeNumber(ctx, g_variant_get_int32(dbus)); case G_VARIANT_CLASS_UINT32: return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus)); case G_VARIANT_CLASS_INT64: return JSValueMakeNumber(ctx, g_variant_get_int64(dbus)); case G_VARIANT_CLASS_UINT64: return JSValueMakeNumber(ctx, g_variant_get_uint64(dbus)); case G_VARIANT_CLASS_BOOLEAN: return JSValueMakeBoolean(ctx, g_variant_get_boolean(dbus)); case G_VARIANT_CLASS_HANDLE: g_warning("didn't support FD type"); return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus)); case G_VARIANT_CLASS_VARIANT: { GVariant* v = g_variant_get_variant(dbus); jsvalue = dbus_to_js(ctx, v); g_variant_unref(v); return jsvalue; } case G_VARIANT_CLASS_DICT_ENTRY: /*g_assert_not_reached();*/ break; case G_VARIANT_CLASS_ARRAY: { if (g_variant_type_is_dict_entry(g_variant_type_element(g_variant_get_type(dbus)))) { jsvalue = JSObjectMake(ctx, NULL, NULL); for (size_t i=0; i<g_variant_n_children(dbus); i++) { GVariant *dic = g_variant_get_child_value(dbus, i); GVariant *key= g_variant_get_child_value (dic, 0); GVariant *value = g_variant_get_child_value (dic, 1); JSValueRef js_key = dbus_to_js(ctx, key); JSValueRef js_value = dbus_to_js(ctx, value); JSStringRef key_str = JSValueToStringCopy(ctx, js_key, NULL); JSObjectSetProperty(ctx, (JSObjectRef)jsvalue, key_str, js_value, 0, NULL); JSStringRelease(key_str); g_variant_unref(key); g_variant_unref(value); g_variant_unref(dic); } return jsvalue; } else { int n = g_variant_n_children(dbus); JSValueRef *args = g_new(JSValueRef, n); for (int i=0; i < n; i++) { GVariant* v = g_variant_get_child_value(dbus, i); args[i] = dbus_to_js(ctx, v); g_variant_unref(v); } jsvalue = JSObjectMakeArray(ctx, n, args, NULL); g_free(args); return jsvalue; } } case G_VARIANT_CLASS_TUPLE: { int n = g_variant_n_children(dbus); jsvalue = JSObjectMakeArray(ctx, 0, NULL, NULL); for (int i=0; i < n; i++) { GVariant* v = g_variant_get_child_value(dbus, i); JSObjectSetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, dbus_to_js(ctx, v), NULL); g_variant_unref(v); } return jsvalue; } case G_VARIANT_CLASS_MAYBE: g_assert_not_reached(); } g_warning("didn't support signature type:%c", type); return JSValueMakeUndefined(ctx); }