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 onPropertiesChanged(GDBusProxy *proxy,
GVariant *changed_properties,
const gchar* const *invalidated_properties,
gpointer pp)
{
if (g_variant_n_children(changed_properties) > 0) {
GVariantIter *iter;
gchar *key;
GVariant *value;
debug(" *** Properties Changed:\n");
g_variant_get(changed_properties, "a{sv}", &iter);
while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {
gchar *value_str;
value_str = g_variant_print(value, TRUE);
g_print(" %s -> %s\n", key, value_str);
g_free(value_str);
if (strncmp(key, "Metadata",8) == 0) {
trackChanged(value);
} else if (strcmp(key, "PlaybackStatus") == 0) {
playbackChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "LoopStatus") == 0) {
loopChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "Shuffle") == 0) {
shuffleChanged(g_variant_get_boolean(value));
} else if (strcmp(key, "Position") == 0) {
positionChanged(g_variant_get_int64(value));
} else if (strcmp(key, "Volume") == 0) {
volumeChanged(g_variant_get_double(value));
}
}
g_variant_iter_free (iter);
}
}
static void
print_playing_song (GDBusProxy *mpris, const char *format)
{
GHashTable *properties;
GVariant *v;
gint64 elapsed = 0;
char *string;
properties = get_playing_song_info (mpris);
if (properties == NULL) {
g_print ("%s\n", _("Not playing"));
return;
}
v = g_dbus_proxy_get_cached_property (mpris, "Position");
if (v != NULL) {
elapsed = g_variant_get_int64 (v);
g_variant_unref (v);
}
string = parse_pattern (format, properties, elapsed);
g_print ("%s\n", string);
g_hash_table_destroy (properties);
g_free (string);
}
static void
chat_mgr_proxy_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyGenChatManager *proxy;
GError *error = NULL;
GVariant *action_time = user_data;
proxy = empathy_gen_chat_manager_proxy_new_for_bus_finish (result, &error);
if (proxy == NULL)
{
DEBUG ("Failed to create ChatManager proxy: %s", error->message);
g_error_free (error);
goto finally;
}
empathy_gen_chat_manager_call_undo_closed_chat (proxy,
g_variant_get_int64 (action_time), NULL, undo_closed_cb, NULL);
g_object_unref (proxy);
finally:
g_variant_unref (action_time);
}
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;
}
}
gint64 gnc_prefs_get_int64 (const gchar *group,
const gchar *pref_name)
{
gint64 result = 0;
GVariant *var = gnc_prefs_get_value(group, pref_name);
result = g_variant_get_int64 (var);
g_variant_unref (var);
return result;
}
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;
}
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 struct call *get_call_from_gvariant(GVariant *param)
{
gint64 call_ptr;
struct call *call;
struct list *calls = ua_calls(uag_current());
struct le *le;
call_ptr = g_variant_get_int64(param);
call = GINT_TO_POINTER(call_ptr);
for (le = list_head(calls); le; le = le->next)
if (le->data == call)
return call;
return NULL;
}
void*
common_utils_pointer_from_variant(GVariant* val)
{
gint i;
if (sizeof(gint) == sizeof(gint64)) {
i = g_variant_get_int64(val);
}
else if (sizeof(gint) == sizeof(gint32)) {
i = g_variant_get_int32(val);
}
else {
i = g_variant_get_int16(val);
}
return GINT_TO_POINTER(i);
}
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 gboolean
g_settings_get_mapping_int (GValue *value,
GVariant *variant)
{
const GVariantType *type;
gint64 l;
type = g_variant_get_type (variant);
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
l = g_variant_get_int16 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
l = g_variant_get_int32 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
l = g_variant_get_int64 (variant);
else
return FALSE;
if (G_VALUE_HOLDS_INT (value))
{
g_value_set_int (value, l);
return (G_MININT32 <= l && l <= G_MAXINT32);
}
else if (G_VALUE_HOLDS_UINT (value))
{
g_value_set_uint (value, l);
return (0 <= l && l <= G_MAXUINT32);
}
else if (G_VALUE_HOLDS_INT64 (value))
{
g_value_set_int64 (value, l);
return (G_MININT64 <= l && l <= G_MAXINT64);
}
else if (G_VALUE_HOLDS_UINT64 (value))
{
g_value_set_uint64 (value, l);
return (0 <= l && l <= G_MAXUINT64);
}
else if (G_VALUE_HOLDS_DOUBLE (value))
{
g_value_set_double (value, l);
return TRUE;
}
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);
}
/**
* Set one or more options in a decoder instance.
*
* Handled options are removed from the hash.
*
* @param di Decoder instance.
* @param options A GHashTable of options to set.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.1.0
*/
SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
GHashTable *options)
{
PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval;
PyObject *py_optlist, *py_classval;
Py_UNICODE *py_ustr;
GVariant *value;
unsigned long long int val_ull;
gint64 val_int;
int num_optkeys, ret, size, i;
const char *val_str;
char *dbg, *key;
if (!di) {
srd_err("Invalid decoder instance.");
return SRD_ERR_ARG;
}
if (!options) {
srd_err("Invalid options GHashTable.");
return SRD_ERR_ARG;
}
if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
/* Decoder has no options. */
if (g_hash_table_size(options) == 0) {
/* No options provided. */
return SRD_OK;
} else {
srd_err("Protocol decoder has no options.");
return SRD_ERR_ARG;
}
return SRD_OK;
}
ret = SRD_ERR_PYTHON;
key = NULL;
py_dec_options = py_dec_optkeys = py_di_options = py_optval = NULL;
py_optlist = py_classval = NULL;
py_dec_options = PyObject_GetAttrString(di->decoder->py_dec, "options");
/* All of these are synthesized objects, so they're good. */
py_dec_optkeys = PyDict_Keys(py_dec_options);
num_optkeys = PyList_Size(py_dec_optkeys);
/*
* The 'options' dictionary is a class variable, but we need to
* change it. Changing it directly will affect the entire class,
* so we need to create a new object for it, and populate that
* instead.
*/
if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options")))
goto err_out;
Py_DECREF(py_di_options);
py_di_options = PyDict_New();
PyObject_SetAttrString(di->py_inst, "options", py_di_options);
for (i = 0; i < num_optkeys; i++) {
/* Get the default class value for this option. */
py_str_as_str(PyList_GetItem(py_dec_optkeys, i), &key);
if (!(py_optlist = PyDict_GetItemString(py_dec_options, key)))
goto err_out;
if (!(py_classval = PyList_GetItem(py_optlist, 1)))
goto err_out;
if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) {
srd_err("Options of type %s are not yet supported.",
Py_TYPE(py_classval)->tp_name);
goto err_out;
}
if ((value = g_hash_table_lookup(options, key))) {
dbg = g_variant_print(value, TRUE);
srd_dbg("got option '%s' = %s", key, dbg);
g_free(dbg);
/* An override for this option was provided. */
if (PyUnicode_Check(py_classval)) {
if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
srd_err("Option '%s' requires a string value.", key);
goto err_out;
}
val_str = g_variant_get_string(value, NULL);
if (!(py_optval = PyUnicode_FromString(val_str))) {
/* Some UTF-8 encoding error. */
PyErr_Clear();
srd_err("Option '%s' requires a UTF-8 string value.", key);
goto err_out;
}
} else if (PyLong_Check(py_classval)) {
if (!g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) {
srd_err("Option '%s' requires an integer value.", key);
goto err_out;
}
val_int = g_variant_get_int64(value);
if (!(py_optval = PyLong_FromLong(val_int))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option '%s' has invalid integer value.", key);
goto err_out;
}
}
g_hash_table_remove(options, key);
} else {
/* Use the class default for this option. */
if (PyUnicode_Check(py_classval)) {
/* Make a brand new copy of the string. */
py_ustr = PyUnicode_AS_UNICODE(py_classval);
size = PyUnicode_GET_SIZE(py_classval);
py_optval = PyUnicode_FromUnicode(py_ustr, size);
} else if (PyLong_Check(py_classval)) {
/* Make a brand new copy of the integer. */
val_ull = PyLong_AsUnsignedLongLong(py_classval);
if (val_ull == (unsigned long long)-1) {
/* OverFlowError exception */
PyErr_Clear();
srd_err("Invalid integer value for %s: "
"expected integer.", key);
goto err_out;
}
if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull)))
goto err_out;
}
}
/*
* If we got here, py_optval holds a known good new reference
* to the instance option to set.
*/
if (PyDict_SetItemString(py_di_options, key, py_optval) == -1)
goto err_out;
g_free(key);
key = NULL;
}
ret = SRD_OK;
err_out:
Py_XDECREF(py_di_options);
Py_XDECREF(py_dec_optkeys);
Py_XDECREF(py_dec_options);
g_free(key);
if (PyErr_Occurred()) {
srd_exception_catch("Stray exception in srd_inst_option_set().");
ret = SRD_ERR_PYTHON;
}
return ret;
}
/**
* Set one or more options in a decoder instance.
*
* Handled options are removed from the hash.
*
* @param di Decoder instance.
* @param options A GHashTable of options to set.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.1.0
*/
SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
GHashTable *options)
{
struct srd_decoder_option *sdo;
PyObject *py_di_options, *py_optval;
GVariant *value;
GSList *l;
double val_double;
gint64 val_int;
int ret;
const char *val_str;
if (!di) {
srd_err("Invalid decoder instance.");
return SRD_ERR_ARG;
}
if (!options) {
srd_err("Invalid options GHashTable.");
return SRD_ERR_ARG;
}
if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
/* Decoder has no options. */
if (g_hash_table_size(options) == 0) {
/* No options provided. */
return SRD_OK;
} else {
srd_err("Protocol decoder has no options.");
return SRD_ERR_ARG;
}
return SRD_OK;
}
ret = SRD_ERR_PYTHON;
py_optval = NULL;
/*
* The 'options' tuple is a class variable, but we need to
* change it. Changing it directly will affect the entire class,
* so we need to create a new object for it, and populate that
* instead.
*/
if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options")))
goto err_out;
Py_DECREF(py_di_options);
py_di_options = PyDict_New();
PyObject_SetAttrString(di->py_inst, "options", py_di_options);
for (l = di->decoder->options; l; l = l->next) {
sdo = l->data;
if ((value = g_hash_table_lookup(options, sdo->id))) {
/* A value was supplied for this option. */
if (!g_variant_type_equal(g_variant_get_type(value),
g_variant_get_type(sdo->def))) {
srd_err("Option '%s' should have the same type "
"as the default value.", sdo->id);
goto err_out;
}
} else {
/* Use default for this option. */
value = sdo->def;
}
if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
val_str = g_variant_get_string(value, NULL);
if (!(py_optval = PyUnicode_FromString(val_str))) {
/* Some UTF-8 encoding error. */
PyErr_Clear();
srd_err("Option '%s' requires a UTF-8 string value.", sdo->id);
goto err_out;
}
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) {
val_int = g_variant_get_int64(value);
if (!(py_optval = PyLong_FromLong(val_int))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option '%s' has invalid integer value.", sdo->id);
goto err_out;
}
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_DOUBLE)) {
val_double = g_variant_get_double(value);
if (!(py_optval = PyFloat_FromDouble(val_double))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option '%s' has invalid float value.",
sdo->id);
goto err_out;
}
}
if (PyDict_SetItemString(py_di_options, sdo->id, py_optval) == -1)
goto err_out;
/* Not harmful even if we used the default. */
g_hash_table_remove(options, sdo->id);
}
if (g_hash_table_size(options) != 0)
srd_warn("Unknown options specified for '%s'", di->inst_id);
ret = SRD_OK;
err_out:
Py_XDECREF(py_optval);
if (PyErr_Occurred()) {
srd_exception_catch("Stray exception in srd_inst_option_set()");
ret = SRD_ERR_PYTHON;
}
return ret;
}
static void
cd_profile_connect_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdProfile *profile;
CdProfilePrivate *priv;
g_autoptr(GError) error = NULL;
g_autoptr(GTask) task = G_TASK (user_data);
g_autoptr(GVariant) colorspace = NULL;
g_autoptr(GVariant) created = NULL;
g_autoptr(GVariant) filename = NULL;
g_autoptr(GVariant) format = NULL;
g_autoptr(GVariant) has_vcgt = NULL;
g_autoptr(GVariant) id = NULL;
g_autoptr(GVariant) is_system_wide = NULL;
g_autoptr(GVariant) kind = NULL;
g_autoptr(GVariant) metadata = NULL;
g_autoptr(GVariant) owner = NULL;
g_autoptr(GVariant) qualifier = NULL;
g_autoptr(GVariant) scope = NULL;
g_autoptr(GVariant) title = NULL;
g_autoptr(GVariant) warnings = NULL;
profile = CD_PROFILE (g_task_get_source_object (task));
priv = GET_PRIVATE (profile);
priv->proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
if (priv->proxy == NULL) {
g_task_return_new_error (task,
CD_PROFILE_ERROR,
CD_PROFILE_ERROR_INTERNAL,
"Failed to connect to profile %s: %s",
cd_profile_get_object_path (profile),
error->message);
return;
}
/* get profile id */
id = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_ID);
if (id != NULL)
priv->id = g_variant_dup_string (id, NULL);
/* if the profile is missing, then fail */
if (id == NULL) {
g_task_return_new_error (task,
CD_PROFILE_ERROR,
CD_PROFILE_ERROR_INTERNAL,
"Failed to connect to missing profile %s",
cd_profile_get_object_path (profile));
return;
}
/* get filename */
filename = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_FILENAME);
if (filename != NULL)
priv->filename = cd_profile_get_nullable_str (filename);
/* get qualifier */
qualifier = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_QUALIFIER);
if (qualifier != NULL)
priv->qualifier = cd_profile_get_nullable_str (qualifier);
/* get format */
format = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_FORMAT);
if (format != NULL)
priv->format = cd_profile_get_nullable_str (format);
/* get title */
title = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_TITLE);
if (title != NULL)
priv->title = cd_profile_get_nullable_str (title);
/* get kind */
kind = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_KIND);
if (kind != NULL)
priv->kind = cd_profile_kind_from_string (g_variant_get_string (kind, NULL));
/* get colorspace */
colorspace = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_COLORSPACE);
if (colorspace != NULL)
priv->colorspace = cd_colorspace_from_string (g_variant_get_string (colorspace, NULL));
/* get scope */
scope = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_SCOPE);
if (scope != NULL)
priv->scope = cd_object_scope_from_string (g_variant_get_string (scope, NULL));
/* get owner */
owner = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_OWNER);
if (owner != NULL)
priv->owner = g_variant_get_uint32 (owner);
/* get warnings */
warnings = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_WARNINGS);
if (warnings != NULL)
priv->warnings = g_variant_dup_strv (warnings, NULL);
/* get created */
created = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_CREATED);
if (created != NULL)
priv->created = g_variant_get_int64 (created);
/* get VCGT */
has_vcgt = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_HAS_VCGT);
if (has_vcgt != NULL)
priv->has_vcgt = g_variant_get_boolean (has_vcgt);
/* get if system wide */
is_system_wide = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_IS_SYSTEM_WIDE);
if (is_system_wide != NULL)
priv->is_system_wide = g_variant_get_boolean (is_system_wide);
/* get if system wide */
metadata = g_dbus_proxy_get_cached_property (priv->proxy,
CD_PROFILE_PROPERTY_METADATA);
if (metadata != NULL)
cd_profile_set_metadata_from_variant (profile, metadata);
/* get signals from DBus */
g_signal_connect_object (priv->proxy,
"g-signal",
G_CALLBACK (cd_profile_dbus_signal_cb),
profile, 0);
/* watch if any remote properties change */
g_signal_connect_object (priv->proxy,
"g-properties-changed",
G_CALLBACK (cd_profile_dbus_properties_changed_cb),
profile, 0);
/* success */
g_task_return_boolean (task, TRUE);
}
/**
* cd_profile_dbus_properties_changed_cb:
**/
static void
cd_profile_dbus_properties_changed_cb (GDBusProxy *proxy,
GVariant *changed_properties,
const gchar * const *invalidated_properties,
CdProfile *profile)
{
CdProfilePrivate *priv = GET_PRIVATE (profile);
guint i;
guint len;
GVariantIter iter;
gchar *property_name;
GVariant *property_value;
g_return_if_fail (CD_IS_PROFILE (profile));
len = g_variant_iter_init (&iter, changed_properties);
for (i = 0; i < len; i++) {
g_variant_get_child (changed_properties, i,
"{sv}",
&property_name,
&property_value);
if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_QUALIFIER) == 0) {
g_free (priv->qualifier);
priv->qualifier = cd_profile_get_nullable_str (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_FORMAT) == 0) {
g_free (priv->format);
priv->format = cd_profile_get_nullable_str (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_FILENAME) == 0) {
g_free (priv->filename);
priv->filename = cd_profile_get_nullable_str (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_ID) == 0) {
g_free (priv->id);
priv->id = g_variant_dup_string (property_value, NULL);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_TITLE) == 0) {
g_free (priv->title);
priv->title = g_variant_dup_string (property_value, NULL);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_WARNINGS) == 0) {
g_strfreev(priv->warnings);
priv->warnings = g_variant_dup_strv (property_value, NULL);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_KIND) == 0) {
priv->kind = cd_profile_kind_from_string (g_variant_get_string (property_value, NULL));
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_COLORSPACE) == 0) {
priv->colorspace = cd_colorspace_from_string (g_variant_get_string (property_value, NULL));
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_SCOPE) == 0) {
priv->scope = cd_object_scope_from_string (g_variant_get_string (property_value, NULL));
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_CREATED) == 0) {
priv->created = g_variant_get_int64 (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_HAS_VCGT) == 0) {
priv->has_vcgt = g_variant_get_boolean (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_OWNER) == 0) {
priv->owner = g_variant_get_uint32 (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_IS_SYSTEM_WIDE) == 0) {
priv->is_system_wide = g_variant_get_boolean (property_value);
} else if (g_strcmp0 (property_name, CD_PROFILE_PROPERTY_METADATA) == 0) {
cd_profile_set_metadata_from_variant (profile, property_value);
} else {
g_warning ("%s property unhandled", property_name);
}
g_free (property_name);
g_variant_unref (property_value);
}
}
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;
}
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 to_json(GVariant *obj, GString *str, int pretty, int indent)
{
if (g_variant_is_of_type (obj, G_VARIANT_TYPE_INT64)) {
g_string_append_printf(str, "%" PRId64, g_variant_get_int64(obj));
}
else if (g_variant_is_of_type (obj, G_VARIANT_TYPE_STRING)) {
const char *ptr;
ptr = g_variant_get_string(obj, NULL);
g_string_append_c(str, '\"');
while (*ptr) {
if ((ptr[0] & 0xE0) == 0xE0 &&
(ptr[1] & 0x80) && (ptr[2] & 0x80)) {
uint16_t wchar;
wchar = (ptr[0] & 0x0F) << 12;
wchar |= (ptr[1] & 0x3F) << 6;
wchar |= (ptr[2] & 0x3F);
ptr += 2;
g_string_append_printf(str, "\\u%04X", wchar);
} else if ((ptr[0] & 0xE0) == 0xC0 && (ptr[1] & 0x80)) {
uint16_t wchar;
wchar = (ptr[0] & 0x1F) << 6;
wchar |= (ptr[1] & 0x3F);
ptr++;
g_string_append_printf(str, "\\u%04X", wchar);
} else switch (ptr[0]) {
case '\"':
g_string_append(str, "\\\"");
break;
case '\\':
g_string_append(str, "\\\\");
break;
case '\b':
g_string_append(str, "\\b");
break;
case '\f':
g_string_append(str, "\\f");
break;
case '\n':
g_string_append(str, "\\n");
break;
case '\r':
g_string_append(str, "\\r");
break;
case '\t':
g_string_append(str, "\\t");
break;
default: {
if (ptr[0] <= 0x1F) {
g_string_append_printf(str, "\\u%04X", ptr[0]);
} else {
g_string_append_c(str, ptr[0]);
}
break;
}
}
ptr++;
}
g_string_append_c(str, '\"');
} else if (g_variant_is_of_type (obj, G_VARIANT_TYPE_DICTIONARY)) {
ToJsonIterState s;
s.count = 0;
s.str = str;
s.indent = indent + 1;
s.pretty = pretty;
g_string_append(str, "{");
g_variant_dictionary_iterate(obj, to_json_dict_iter, &s);
if (pretty) {
int j;
g_string_append_c(str, '\n');
for (j = 0 ; j < indent ; j++)
g_string_append(str, " ");
}
g_string_append(str, "}");
} else if (g_variant_is_of_type (obj, G_VARIANT_TYPE_ARRAY)) {
ToJsonIterState s;
s.count = 0;
s.str = str;
s.indent = indent + 1;
s.pretty = pretty;
g_string_append(str, "[");
g_variant_array_iterate(obj, (void *)to_json_list_iter, &s);
if (pretty) {
int j;
g_string_append_c(str, '\n');
for (j = 0 ; j < indent ; j++)
g_string_append(str, " ");
}
g_string_append(str, "]");
} else if (g_variant_is_of_type (obj, G_VARIANT_TYPE_DOUBLE)) {
char buffer[1024];
int len;
len = g_snprintf(buffer, sizeof(buffer), "%f", g_variant_get_double(obj));
while (len > 0 && buffer[len - 1] == '0') {
len--;
}
if (len && buffer[len - 1] == '.') {
buffer[len - 1] = 0;
} else {
buffer[len] = 0;
}
g_string_append(str, buffer);
} else if (g_variant_is_of_type (obj, G_VARIANT_TYPE_BOOLEAN)) {
if (g_variant_get_boolean(obj)) {
g_string_append(str, "true");
} else {
g_string_append(str, "false");
}
}
}
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;
}
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 gint64
arv_rtkit_get_int_property (GDBusConnection *connection, const char* propname, GError **error) {
GDBusMessage *message;
GDBusMessage *reply;
GError *local_error = NULL;
GVariant *body;
GVariant *parameter;
GVariant *variant;
const GVariantType *variant_type;
gint64 value;
message = g_dbus_message_new_method_call (RTKIT_SERVICE_NAME,
RTKIT_OBJECT_PATH,
"org.freedesktop.DBus.Properties",
"Get");
g_dbus_message_set_body (message, g_variant_new ("(ss)", "org.freedesktop.RealtimeKit1", propname));
reply = g_dbus_connection_send_message_with_reply_sync (connection, message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE, 1000, NULL, NULL,
&local_error);
g_object_unref (message);
if (local_error != NULL) {
g_propagate_error (error, local_error);
return 0;
}
if (g_dbus_message_get_message_type (reply) != G_DBUS_MESSAGE_TYPE_METHOD_RETURN) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_PERMISSION_DENIED,
"%s", g_dbus_message_get_error_name (reply));
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
if (!g_variant_type_equal ("v", g_dbus_message_get_signature (reply))) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_WRONG_REPLY,
"Invalid reply signature");
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
body = g_dbus_message_get_body (reply);
parameter = g_variant_get_child_value (body, 0);
variant = g_variant_get_variant (parameter);
variant_type = g_variant_get_type (variant);
if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32))
value = g_variant_get_int32 (variant);
else if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64))
value = g_variant_get_int64 (variant);
else
value = 0;
g_variant_unref (parameter);
g_variant_unref (variant);
g_object_unref (reply);
return value;
}
/* Returns a new floating variant (essentially a fixed-up copy of @value) */
static GVariant *
_my_replace (GVariant *value)
{
GVariant *ret;
const gchar *dbus_type;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARDICT) &&
g_variant_lookup (value, "_dbus_type", "&s", &dbus_type))
{
GVariant *passed_value;
passed_value = g_variant_lookup_value (value, "value", NULL);
if (passed_value != NULL)
{
JsonNode *serialized;
GError *error;
serialized = json_gvariant_serialize (passed_value);
error = NULL;
ret = json_gvariant_deserialize (serialized,
dbus_type,
&error);
json_node_free (serialized);
if (ret == NULL)
{
/*
* HACK: Work around bug in JSON-glib, see:
* https://bugzilla.gnome.org/show_bug.cgi?id=724319
*/
if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_INVALID_DATA &&
g_variant_is_of_type (passed_value, G_VARIANT_TYPE_INT64) &&
g_strcmp0 (dbus_type, "d") == 0)
{
ret = g_variant_new_double (g_variant_get_int64 (passed_value));
g_clear_error (&error);
}
else
{
g_warning ("Error converting JSON to requested type %s: %s (%s, %d)",
dbus_type,
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
ret = g_variant_ref (value);
}
}
}
else
{
g_warning ("Malformed _dbus_type vardict");
ret = g_variant_ref (value);
}
}
else if (g_variant_is_container (value))
{
GVariantBuilder builder;
GVariantIter iter;
GVariant *child;
g_variant_builder_init (&builder, g_variant_get_type (value));
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
g_variant_builder_add_value (&builder, _my_replace (child));
g_variant_unref (child);
}
ret = g_variant_builder_end (&builder);
}
else
{
ret = g_variant_ref (value);
}
return ret;
}
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;
}
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);
}
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);
}
