/**
* 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;
}
}
/* uint16 GetSize() */
guint16 obex_phonebook_access_get_size(ObexPhonebookAccess *self, GError **error)
{
g_assert(OBEX_PHONEBOOK_ACCESS_IS(self));
guint16 ret = 0;
GVariant *proxy_ret = g_dbus_proxy_call_sync(self->priv->proxy, "GetSize", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
if (proxy_ret != NULL)
return 0;
proxy_ret = g_variant_get_child_value(proxy_ret, 0);
ret = g_variant_get_uint16(proxy_ret);
g_variant_unref(proxy_ret);
return ret;
}
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));
}
}
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();
}
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
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);
}
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);
}
static JsonBuilder *
_json_builder_add_gvariant (JsonBuilder *builder,
GVariant *value)
{
g_return_val_if_fail (JSON_IS_BUILDER (builder), builder);
g_variant_ref_sink (value);
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
json_builder_add_boolean_value (builder, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
json_builder_add_int_value (builder, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
json_builder_add_int_value (builder, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
json_builder_add_int_value (builder, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
json_builder_add_int_value (builder, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
json_builder_add_int_value (builder, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
json_builder_add_int_value (builder, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
json_builder_add_int_value (builder, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_HANDLE:
json_builder_add_int_value (builder, g_variant_get_handle (value));
break;
case G_VARIANT_CLASS_DOUBLE:
json_builder_add_double_value (builder, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING: /* explicit fall-through */
case G_VARIANT_CLASS_OBJECT_PATH: /* explicit fall-through */
case G_VARIANT_CLASS_SIGNATURE:
json_builder_add_string_value (builder, g_variant_get_string (value, NULL));
break;
/* TODO: */
case G_VARIANT_CLASS_VARIANT:
{
GVariant *child;
child = g_variant_get_variant (value);
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
break;
case G_VARIANT_CLASS_MAYBE:
g_assert_not_reached ();
break;
case G_VARIANT_CLASS_ARRAY:
{
const GVariantType *type;
const GVariantType *element_type;
type = g_variant_get_type (value);
element_type = g_variant_type_element (type);
if (g_variant_type_is_dict_entry (element_type))
{
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_object (builder);
}
else
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
}
break;
case G_VARIANT_CLASS_TUPLE:
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
break;
case G_VARIANT_CLASS_DICT_ENTRY:
{
GVariant *dict_key;
GVariant *dict_value;
gchar *dict_key_string;
dict_key = g_variant_get_child_value (value, 0);
dict_value = g_variant_get_child_value (value, 1);
if (g_variant_is_of_type (dict_key, G_VARIANT_TYPE("s")))
dict_key_string = g_variant_dup_string (dict_key, NULL);
else
dict_key_string = g_variant_print (dict_key, FALSE);
json_builder_set_member_name (builder, dict_key_string);
_json_builder_add_gvariant (builder, dict_value);
g_free (dict_key_string);
g_variant_unref (dict_key);
g_variant_unref (dict_value);
}
break;
}
g_variant_unref (value);
return builder;
}
static void _bt_agent_method_call_func(GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data)
{
// g_print("%s%s\n", method_name, g_variant_print(parameters, FALSE));
if (g_strcmp0(method_name, "AuthorizeService") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
const char *uuid = g_variant_get_string(g_variant_get_child_value(parameters, 1), NULL);
if (_interactive)
g_print("Device: %s (%s) for UUID %s\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error), uuid);
if (error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Internal error occurred");
return;
}
if (device_get_paired (device_obj, &error))
{
g_dbus_method_invocation_return_value(invocation, NULL);
}
else if (error)
{
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Internal error occurred");
g_error_free (error);
}
else
{
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Service authorization rejected");
}
}
else if (g_strcmp0(method_name, "Cancel") == 0)
{
if (_interactive)
g_print("Request canceled\n");
// Return void
g_dbus_method_invocation_return_value(invocation, NULL);
}
else if (g_strcmp0(method_name, "DisplayPasskey") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
const gchar *pin = _find_device_pin(device_get_dbus_object_path(device_obj));
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if (error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
if (_interactive)
{
g_print("Passkey: %u, entered: %u\n", g_variant_get_uint32(g_variant_get_child_value(parameters, 1)), g_variant_get_uint16(g_variant_get_child_value(parameters, 2)));
g_dbus_method_invocation_return_value(invocation, NULL);
return;
}
else if (pin != NULL)
{
/* OK, device found */
g_dbus_method_invocation_return_value(invocation, NULL);
return;
}
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Pairing rejected");
}
else if (g_strcmp0(method_name, "DisplayPinCode") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
const gchar *pin = _find_device_pin(device_get_dbus_object_path(device_obj));
const gchar *pincode = g_variant_get_string(g_variant_get_child_value(parameters, 1), NULL);
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if (error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
/* Try to use found PIN */
if (pin != NULL)
{
if (g_strcmp0(pin, "*") == 0 || g_strcmp0(pin, pincode) == 0)
{
if (_interactive)
g_print("Pin code confirmed\n");
g_dbus_method_invocation_return_value(invocation, NULL);
}
else
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Passkey does not match");
return;
}
else if (_interactive)
{
g_print("Confirm pin code: %s (yes/no)? ", pincode);
gchar yn[4] = {0,};
errno = 0;
if (scanf("%3s", yn) == EOF && errno)
g_warning("%s\n", strerror(errno));
if(g_ascii_strcasecmp(yn, "yes") == 0 || g_ascii_strcasecmp(yn, "y") == 0)
g_dbus_method_invocation_return_value(invocation, NULL);
else
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Passkey does not match");
return;
}
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Pairing rejected");
}
else if (g_strcmp0(method_name, "Release") == 0)
{
agent_need_unregister = FALSE;
if(_mainloop)
if (g_main_loop_is_running(_mainloop))
g_main_loop_quit(_mainloop);
g_print("Agent released\n");
// Return void
g_dbus_method_invocation_return_value(invocation, NULL);
}
else if (g_strcmp0(method_name, "RequestAuthorization") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if(error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
if (_interactive)
{
g_print("Authorize this device pairing (yes/no)? ");
gchar yn[4] = {0,};
errno = 0;
if (scanf("%3s", yn) == EOF && errno)
g_warning("%s\n", strerror(errno));
if(g_ascii_strcasecmp(yn, "yes") == 0 || g_ascii_strcasecmp(yn, "y") == 0)
g_dbus_method_invocation_return_value(invocation, NULL);
else
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Pairing rejected");
return;
}
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Pairing rejected");
}
else if (g_strcmp0(method_name, "RequestConfirmation") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
guint32 passkey = g_variant_get_uint32(g_variant_get_child_value(parameters, 1));
const gchar *pin = _find_device_pin(device_get_dbus_object_path(device_obj));
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if(error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
/* Try to use found PIN */
if (pin != NULL)
{
guint32 passkey_t;
sscanf(pin, "%u", &passkey_t);
if (g_strcmp0(pin, "*") == 0 || passkey_t == passkey)
{
if (_interactive)
g_print("Passkey confirmed\n");
g_dbus_method_invocation_return_value(invocation, NULL);
}
else
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Passkey does not match");
return;
}
else if (_interactive)
{
g_print("Confirm passkey: %u (yes/no)? ", passkey);
gchar yn[4] = {0,};
errno = 0;
if (scanf("%3s", yn) == EOF && errno)
g_warning("%s\n", strerror(errno));
if(g_ascii_strcasecmp(yn, "yes") == 0 || g_ascii_strcasecmp(yn, "y") == 0)
g_dbus_method_invocation_return_value(invocation, NULL);
else
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Passkey does not match");
return;
}
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "Passkey does not match");
}
else if (g_strcmp0(method_name, "RequestPasskey") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
const gchar *pin = _find_device_pin(device_get_dbus_object_path(device_obj));
guint32 ret = 0;
gboolean invoke = FALSE;
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if(error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
/* Try to use found PIN */
if (pin != NULL)
{
if (_interactive)
g_print("Passkey found\n");
sscanf(pin, "%u", &ret);
invoke = TRUE;
}
else if (_interactive)
{
g_print("Enter passkey: ");
errno = 0;
if (scanf("%u", &ret) == EOF && errno)
g_warning("%s\n", strerror(errno));
invoke = TRUE;
}
if (invoke)
{
g_dbus_method_invocation_return_value(invocation, g_variant_new ("(u)", ret));
}
else
{
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "No passkey inputted");
}
}
else if (g_strcmp0(method_name, "RequestPinCode") == 0)
{
GError *error = NULL;
Device *device_obj = device_new(g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL));
const gchar *pin = _find_device_pin(device_get_dbus_object_path(device_obj));
gchar *ret = NULL;
gboolean invoke = FALSE;
if (_interactive)
g_print("Device: %s (%s)\n", device_get_alias(device_obj, &error), device_get_address(device_obj, &error));
if(error)
{
g_critical("Failed to get remote device's MAC address: %s", error->message);
g_error_free(error);
}
g_object_unref(device_obj);
/* Try to use found PIN */
if (pin != NULL)
{
if (_interactive)
g_print("Passkey found\n");
sscanf(pin, "%ms", &ret);
invoke = TRUE;
}
else if (_interactive)
{
g_print("Enter passkey: ");
errno = 0;
if (scanf("%ms", &ret) == EOF && errno)
g_warning("%s\n", strerror(errno));
invoke = TRUE;
}
if (invoke)
{
g_dbus_method_invocation_return_value(invocation, g_variant_new ("(s)", ret));
}
else
{
g_dbus_method_invocation_return_dbus_error(invocation, "org.bluez.Error.Rejected", "No passkey inputted");
}
if (ret)
free(ret);
}
}
QT_BEGIN_NAMESPACE
QVariant convertValue(GVariant *value)
{
if (!value)
return QVariant(QVariant::Invalid);
switch (g_variant_classify(value)) {
case G_VARIANT_CLASS_BOOLEAN:
return QVariant((bool)g_variant_get_boolean(value));
case G_VARIANT_CLASS_BYTE:
return QVariant(QLatin1Char(g_variant_get_byte(value)));
case G_VARIANT_CLASS_INT16:
return QVariant((int)g_variant_get_int16(value));
case G_VARIANT_CLASS_UINT16:
return QVariant((uint)g_variant_get_uint16(value));
case G_VARIANT_CLASS_INT32:
return QVariant((int)g_variant_get_int32(value));
case G_VARIANT_CLASS_UINT32:
return QVariant((uint)g_variant_get_uint32(value));
case G_VARIANT_CLASS_INT64:
return QVariant((qlonglong)g_variant_get_int64(value));
case G_VARIANT_CLASS_UINT64:
return QVariant((qulonglong)g_variant_get_uint64(value));
case G_VARIANT_CLASS_DOUBLE:
return QVariant(g_variant_get_double(value));
case G_VARIANT_CLASS_STRING:
return QVariant(QString::fromUtf8(g_variant_get_string(value, NULL)));
case G_VARIANT_CLASS_ARRAY:
if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY)) {
GVariantIter iter;
QStringList list;
const gchar *str;
g_variant_iter_init(&iter, value);
while (g_variant_iter_next(&iter, "&s", &str))
list.append(QString::fromUtf8(str));
return QVariant(list);
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_BYTESTRING_ARRAY)) {
GVariantIter iter;
QVariantList list;
const gchar *item;
g_variant_iter_init(&iter, value);
while (g_variant_iter_next(&iter, "&y", &item))
list.append(QByteArray(item));
return list;
#ifndef QT_NO_DATASTREAM
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_BYTESTRING)) {
QByteArray a(g_variant_get_bytestring(value));
QDataStream s(&a, QIODevice::ReadOnly);
s.setVersion(QDataStream::Qt_4_0);
QVariant result;
s >> result;
return result;
#else
Q_ASSERT(!"QConfiguration: Cannot load custom types without QDataStream support");
#endif
}
default:
break;
}
return QVariant(QVariant::Invalid);
}
static GConfValue *
gconf_settings_backend_simple_gvariant_to_gconf_value (GVariant *value,
const GVariantType *type)
{
GConfValue *gconf_value = NULL;
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
gconf_value = gconf_value_new (GCONF_VALUE_BOOL);
gconf_value_set_bool (gconf_value, g_variant_get_boolean (value));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
{
guchar i = g_variant_get_byte (value);
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
{
gint16 i = g_variant_get_int16 (value);
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
{
guint16 i = g_variant_get_uint16 (value);
if (i > G_MAXINT)
return NULL;
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
{
gint32 i = g_variant_get_int32 (value);
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
{
guint32 i = g_variant_get_uint32 (value);
if (i > G_MAXINT)
return NULL;
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
{
gint64 i = g_variant_get_int64 (value);
if (i < G_MININT || i > G_MAXINT)
return NULL;
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
{
guint64 i = g_variant_get_uint64 (value);
if (i > G_MAXINT)
return NULL;
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
{
guint32 i = g_variant_get_handle (value);
if (i > G_MAXINT)
return NULL;
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value, i);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
{
gconf_value = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (gconf_value, g_variant_get_double (value));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
{
gconf_value = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (gconf_value, g_variant_get_string (value, NULL));
}
return gconf_value;
}
static void test_compare(CVariant *cv, GVariant *gv) {
const GVariantType *gvt;
GVariantIter gvi[C_VARIANT_MAX_VARG];
GVariant *gvig[C_VARIANT_MAX_VARG];
CVariantVarg varg;
const char *s, *type;
uint64_t val_64;
uint32_t val_32;
uint16_t val_16;
uint8_t val_8;
double val_f;
size_t n, nest;
GVariant *g;
int r, c;
type = c_variant_peek_type(cv, &n);
gvt = g_variant_get_type(gv);
assert(n == g_variant_type_get_string_length(gvt));
assert(!memcmp(type, g_variant_type_peek_string(gvt), n));
nest = 0;
g = gv;
for (c = c_variant_varg_init(&varg, type, n);
c;
c = c_variant_varg_next(&varg)) {
if (c == -1) {
r = c_variant_exit(cv, NULL);
assert(r >= 0);
assert(nest-- > 0);
g_variant_unref(gvig[nest]);
continue;
}
if (nest > 0)
g = g_variant_iter_next_value(&gvi[nest - 1]);
else
g = g_variant_ref(gv);
assert(g);
switch (c) {
case C_VARIANT_VARIANT:
c_variant_enter(cv, "v");
type = c_variant_peek_type(cv, &n);
c_variant_varg_push(&varg, type, n, -1);
g_variant_iter_init(&gvi[nest], g);
gvig[nest] = g_variant_ref(g);
++nest;
break;
case C_VARIANT_MAYBE:
c_variant_enter(cv, "m");
n = c_variant_peek_count(cv);
c_variant_varg_enter_bound(&varg, cv, n);
g_variant_iter_init(&gvi[nest], g);
gvig[nest] = g_variant_ref(g);
++nest;
break;
case C_VARIANT_ARRAY:
c_variant_enter(cv, "a");
n = c_variant_peek_count(cv);
c_variant_varg_enter_bound(&varg, cv, n);
g_variant_iter_init(&gvi[nest], g);
gvig[nest] = g_variant_ref(g);
++nest;
break;
case C_VARIANT_TUPLE_OPEN:
c_variant_enter(cv, "(");
c_variant_varg_enter_unbound(&varg, cv, ')');
g_variant_iter_init(&gvi[nest], g);
gvig[nest] = g_variant_ref(g);
++nest;
break;
case C_VARIANT_PAIR_OPEN:
c_variant_enter(cv, "{");
c_variant_varg_enter_unbound(&varg, cv, '}');
g_variant_iter_init(&gvi[nest], g);
gvig[nest] = g_variant_ref(g);
++nest;
break;
case C_VARIANT_INT64:
c_variant_read(cv, "x", &val_64);
assert((int64_t)val_64 == g_variant_get_int64(g));
break;
case C_VARIANT_UINT64:
c_variant_read(cv, "t", &val_64);
assert((uint64_t)val_64 == g_variant_get_uint64(g));
break;
case C_VARIANT_DOUBLE:
c_variant_read(cv, "d", &val_f);
assert(!(val_f > g_variant_get_double(g)) &&
!(val_f < g_variant_get_double(g)));
break;
case C_VARIANT_INT32:
c_variant_read(cv, "i", &val_32);
assert((int32_t)val_32 == g_variant_get_int32(g));
break;
case C_VARIANT_UINT32:
c_variant_read(cv, "u", &val_32);
assert((uint32_t)val_32 == g_variant_get_uint32(g));
break;
case C_VARIANT_HANDLE:
c_variant_read(cv, "h", &val_32);
assert((int32_t)val_32 == g_variant_get_handle(g));
break;
case C_VARIANT_INT16:
c_variant_read(cv, "n", &val_16);
assert((int16_t)val_16 == g_variant_get_int16(g));
break;
case C_VARIANT_UINT16:
c_variant_read(cv, "q", &val_16);
assert((uint16_t)val_16 == g_variant_get_uint16(g));
break;
case C_VARIANT_BOOL:
c_variant_read(cv, "b", &val_8);
assert((bool)val_8 == g_variant_get_boolean(g));
break;
case C_VARIANT_BYTE:
c_variant_read(cv, "y", &val_8);
assert((guchar)val_8 == g_variant_get_byte(g));
break;
case C_VARIANT_STRING:
c_variant_read(cv, "s", &s);
assert(!strcmp(s, g_variant_get_string(g, NULL)));
break;
case C_VARIANT_PATH:
c_variant_read(cv, "o", &s);
assert(!strcmp(s, g_variant_get_string(g, NULL)));
break;
case C_VARIANT_SIGNATURE:
c_variant_read(cv, "g", &s);
assert(!strcmp(s, g_variant_get_string(g, NULL)));
break;
default:
assert(0);
break;
}
r = c_variant_return_poison(cv);
assert(r >= 0);
g_variant_unref(g);
}
}
static void
build_json (JsonBuilder *builder,
GVariant *value)
{
const GVariantType *type;
const GVariantType *element_type;
g_variant_ref_sink (value);
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
json_builder_add_boolean_value (builder, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
json_builder_add_int_value (builder, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
json_builder_add_int_value (builder, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
json_builder_add_int_value (builder, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
json_builder_add_int_value (builder, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
json_builder_add_int_value (builder, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
json_builder_add_int_value (builder, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
json_builder_add_int_value (builder, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_HANDLE:
json_builder_add_int_value (builder, g_variant_get_handle (value));
break;
case G_VARIANT_CLASS_DOUBLE:
json_builder_add_double_value (builder, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING: /* explicit fall-through */
case G_VARIANT_CLASS_OBJECT_PATH: /* explicit fall-through */
case G_VARIANT_CLASS_SIGNATURE:
{
/* HACK: We can't use json_builder_add_string_value here since
it turns empty strings into 'null' values inside arrays.
https://bugzilla.gnome.org/show_bug.cgi?id=730803
*/
JsonNode *string_element = json_node_alloc ();
json_node_init_string (string_element, g_variant_get_string (value, NULL));
json_builder_add_value (builder, string_element);
}
break;
case G_VARIANT_CLASS_VARIANT:
build_json_variant (builder, value);
break;
case G_VARIANT_CLASS_ARRAY:
type = g_variant_get_type (value);
element_type = g_variant_type_element (type);
if (g_variant_type_is_dict_entry (element_type))
build_json_dictionary (builder, element_type, value);
else
build_json_array_or_tuple (builder, value);
break;
case G_VARIANT_CLASS_TUPLE:
build_json_array_or_tuple (builder, value);
break;
case G_VARIANT_CLASS_DICT_ENTRY:
case G_VARIANT_CLASS_MAYBE:
default:
g_return_if_reached ();
break;
}
g_variant_unref (value);
}
static gchar *
gvariant_simple_to_string (GVariant *variant)
{
GVariantClass class;
gchar *str;
class = g_variant_classify (variant);
switch (class)
{
case G_VARIANT_CLASS_BOOLEAN:
if (g_variant_get_boolean (variant))
str = g_strdup ("true");
else
str = g_strdup ("false");
break;
case G_VARIANT_CLASS_BYTE:
str = g_strdup_printf ("%u", g_variant_get_byte (variant));
break;
case G_VARIANT_CLASS_INT16:
str = g_strdup_printf ("%d", g_variant_get_int16 (variant));
break;
case G_VARIANT_CLASS_UINT16:
str = g_strdup_printf ("%u", g_variant_get_uint16 (variant));
break;
case G_VARIANT_CLASS_INT32:
str = g_strdup_printf ("%d", g_variant_get_int32 (variant));
break;
case G_VARIANT_CLASS_UINT32:
str = g_strdup_printf ("%u", g_variant_get_uint32 (variant));
break;
case G_VARIANT_CLASS_INT64:
str = g_strdup_printf ("%" G_GINT64_FORMAT,
g_variant_get_int64 (variant));
break;
case G_VARIANT_CLASS_UINT64:
str = g_strdup_printf ("%" G_GUINT64_FORMAT,
g_variant_get_uint64 (variant));
break;
case G_VARIANT_CLASS_HANDLE:
str = g_strdup_printf ("%d", g_variant_get_handle (variant));
break;
case G_VARIANT_CLASS_DOUBLE:
{
gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_formatd (buf,
G_ASCII_DTOSTR_BUF_SIZE,
"%f",
g_variant_get_double (variant));
str = g_strdup (buf);
break;
}
case G_VARIANT_CLASS_STRING:
case G_VARIANT_CLASS_OBJECT_PATH:
case G_VARIANT_CLASS_SIGNATURE:
str = g_strdup (g_variant_get_string (variant, NULL));
break;
default:
g_assert_not_reached ();
break;
}
return str;
}
/**
* g_dbus_gvariant_to_gvalue:
* @value: A #GVariant.
* @out_gvalue: (out): Return location pointing to a zero-filled (uninitialized) #GValue.
*
* Converts a #GVariant to a #GValue. If @value is floating, it is consumed.
*
* The rules specified in the g_dbus_gvalue_to_gvariant() function are
* used - this function is essentially its reverse form.
*
* The conversion never fails - a valid #GValue is always returned in
* @out_gvalue.
*
* Since: 2.30
*/
void
g_dbus_gvariant_to_gvalue (GVariant *value,
GValue *out_gvalue)
{
const GVariantType *type;
gchar **array;
g_return_if_fail (value != NULL);
g_return_if_fail (out_gvalue != NULL);
memset (out_gvalue, '\0', sizeof (GValue));
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
g_value_init (out_gvalue, G_TYPE_BOOLEAN);
g_value_set_boolean (out_gvalue, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_UCHAR);
g_value_set_uchar (out_gvalue, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
g_value_init (out_gvalue, G_TYPE_INT);
g_value_set_int (out_gvalue, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
g_value_init (out_gvalue, G_TYPE_UINT);
g_value_set_uint (out_gvalue, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
g_value_init (out_gvalue, G_TYPE_INT);
g_value_set_int (out_gvalue, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
g_value_init (out_gvalue, G_TYPE_UINT);
g_value_set_uint (out_gvalue, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
g_value_init (out_gvalue, G_TYPE_INT64);
g_value_set_int64 (out_gvalue, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
g_value_init (out_gvalue, G_TYPE_UINT64);
g_value_set_uint64 (out_gvalue, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_DOUBLE:
g_value_init (out_gvalue, G_TYPE_DOUBLE);
g_value_set_double (out_gvalue, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_SIGNATURE:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
break;
case G_VARIANT_CLASS_ARRAY:
type = g_variant_get_type (value);
switch (g_variant_type_peek_string (type)[1])
{
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_STRING);
g_value_set_string (out_gvalue, g_variant_get_bytestring (value));
break;
case G_VARIANT_CLASS_STRING:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_strv (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
case G_VARIANT_CLASS_OBJECT_PATH:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_objv (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[2])
{
case G_VARIANT_CLASS_BYTE:
g_value_init (out_gvalue, G_TYPE_STRV);
array = g_variant_dup_bytestring_array (value, NULL);
g_value_take_boxed (out_gvalue, array);
break;
default:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
break;
default:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
break;
case G_VARIANT_CLASS_HANDLE:
case G_VARIANT_CLASS_VARIANT:
case G_VARIANT_CLASS_MAYBE:
case G_VARIANT_CLASS_TUPLE:
case G_VARIANT_CLASS_DICT_ENTRY:
g_value_init (out_gvalue, G_TYPE_VARIANT);
g_value_set_variant (out_gvalue, value);
break;
}
}
static gboolean
dconf_dbus_from_gv (DBusMessageIter *iter,
GVariant *value,
GError **error)
{
switch (g_variant_get_type_class (value))
{
case G_VARIANT_CLASS_BOOLEAN:
{
dbus_bool_t v = g_variant_get_boolean (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v);
break;
}
case G_VARIANT_CLASS_BYTE:
{
guint8 v = g_variant_get_byte (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &v);
break;
}
case G_VARIANT_CLASS_INT16:
{
gint16 v = g_variant_get_int16 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT16, &v);
break;
}
case G_VARIANT_CLASS_UINT16:
{
guint16 v = g_variant_get_uint16 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT16, &v);
break;
}
case G_VARIANT_CLASS_INT32:
{
gint32 v = g_variant_get_int32 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &v);
break;
}
case G_VARIANT_CLASS_UINT32:
{
guint32 v = g_variant_get_uint32 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &v);
break;
}
case G_VARIANT_CLASS_INT64:
{
gint64 v = g_variant_get_int64 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &v);
break;
}
case G_VARIANT_CLASS_UINT64:
{
guint64 v = g_variant_get_uint64 (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &v);
break;
}
case G_VARIANT_CLASS_DOUBLE:
{
gdouble v = g_variant_get_double (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &v);
break;
}
case G_VARIANT_CLASS_STRING:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &v);
break;
}
case G_VARIANT_CLASS_OBJECT_PATH:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &v);
break;
}
case G_VARIANT_CLASS_SIGNATURE:
{
const gchar *v = g_variant_get_string (value, NULL);
dbus_message_iter_append_basic (iter, DBUS_TYPE_SIGNATURE, &v);
break;
}
case G_VARIANT_CLASS_VARIANT:
{
DBusMessageIter sub;
GVariant *child;
child = g_variant_get_child_value (value, 0);
dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT,
g_variant_get_type_string (child),
&sub);
if (!dconf_dbus_from_gv (&sub, child, error))
{
g_variant_unref (child);
goto fail;
}
dbus_message_iter_close_container (iter, &sub);
g_variant_unref (child);
break;
}
case G_VARIANT_CLASS_ARRAY:
{
DBusMessageIter dbus_iter;
const gchar *type_string;
GVariantIter gv_iter;
GVariant *item;
type_string = g_variant_get_type_string (value);
type_string++; /* skip the 'a' */
dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
type_string, &dbus_iter);
g_variant_iter_init (&gv_iter, value);
while ((item = g_variant_iter_next_value (&gv_iter)))
{
if (!dconf_dbus_from_gv (&dbus_iter, item, error))
{
goto fail;
}
}
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
case G_VARIANT_CLASS_TUPLE:
{
DBusMessageIter dbus_iter;
GVariantIter gv_iter;
GVariant *item;
dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT,
NULL, &dbus_iter);
g_variant_iter_init (&gv_iter, value);
while ((item = g_variant_iter_next_value (&gv_iter)))
{
if (!dconf_dbus_from_gv (&dbus_iter, item, error))
goto fail;
}
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
case G_VARIANT_CLASS_DICT_ENTRY:
{
DBusMessageIter dbus_iter;
GVariant *key, *val;
dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY,
NULL, &dbus_iter);
key = g_variant_get_child_value (value, 0);
if (!dconf_dbus_from_gv (&dbus_iter, key, error))
{
g_variant_unref (key);
goto fail;
}
g_variant_unref (key);
val = g_variant_get_child_value (value, 1);
if (!dconf_dbus_from_gv (&dbus_iter, val, error))
{
g_variant_unref (val);
goto fail;
}
g_variant_unref (val);
dbus_message_iter_close_container (iter, &dbus_iter);
break;
}
default:
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_CONVERSION_FAILED,
_("Error serializing GVariant with type-string `%s' to a D-Bus message"),
g_variant_get_type_string (value));
goto fail;
}
return TRUE;
fail:
return FALSE;
}
