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