static void
get_active_connections (GDBusProxy *proxy)
{
GError *error = NULL;
GVariant *ret = NULL, *value = NULL;
char **paths;
int i;
/* Get the ActiveConnections property from the NM Manager object */
ret = g_dbus_proxy_call_sync (proxy,
"Get",
g_variant_new ("(ss)",
NM_DBUS_INTERFACE,
"ActiveConnections"),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &error);
if (!ret) {
g_dbus_error_strip_remote_error (error);
g_warning ("Failed to get ActiveConnections property: %s\n", error->message);
g_error_free (error);
return;
}
g_variant_get (ret, "(v)", &value);
/* Make sure the ActiveConnections property is the type we expect it to be */
if (!g_variant_is_of_type (value, G_VARIANT_TYPE ("ao"))) {
g_warning ("Unexpected type returned getting ActiveConnections: %s",
g_variant_get_type_string (value));
goto out;
}
/* Extract the active connections array from the GValue */
paths = g_variant_dup_objv (value, NULL);
if (!paths) {
g_warning ("Could not retrieve active connections property");
goto out;
}
/* And print out the details for each active connection */
for (i = 0; paths[i]; i++) {
g_print ("Active connection path: %s\n", paths[i]);
get_active_connection_details (paths[i]);
}
g_strfreev (paths);
out:
if (value)
g_variant_unref (value);
if (ret)
g_variant_unref (ret);
}
/*****************************************************************************
* neardal_adp_prv_cb_property_changed: Callback called when a NFC tag
* is found
****************************************************************************/
static void neardal_adp_prv_cb_property_changed(OrgNeardAdapter *proxy,
const gchar *arg_unnamed_arg0,
GVariant *arg_unnamed_arg1,
void *user_data)
{
AdpProp *adpProp = NULL;
errorCode_t err = NEARDAL_ERROR_NO_TAG;
char *dbusObjPath = NULL;
void *clientValue = NULL;
TagProp *tagProp = NULL;
DevProp *devProp = NULL;
gchar **array = NULL;
GVariant *gvalue = NULL;
gsize mode_len;
(void) proxy; /* remove warning */
(void) user_data; /* remove warning */
NEARDAL_TRACEIN();
NEARDAL_ASSERT(arg_unnamed_arg0 != NULL);
neardal_mgr_prv_get_adapter_from_proxy(proxy, &adpProp);
if (adpProp == NULL) {
err = NEARDAL_ERROR_GENERAL_ERROR;
goto exit;
}
gvalue = g_variant_get_variant(arg_unnamed_arg1);
if (gvalue == NULL) {
err = NEARDAL_ERROR_GENERAL_ERROR;
goto exit;
}
NEARDAL_TRACEF(" arg_unnamed_arg0 : %s\n", arg_unnamed_arg0);
if (!strcmp(arg_unnamed_arg0, "Mode")) {
if (adpProp->mode != NULL) {
g_free(adpProp->mode);
adpProp->mode = NULL;
}
adpProp->mode = g_strdup(g_variant_get_string(gvalue, &mode_len));
clientValue = adpProp->mode;
NEARDAL_TRACEF("neardalMgr.mode=%s\n", adpProp->mode);
}
if (!strcmp(arg_unnamed_arg0, "Polling")) {
adpProp->polling = g_variant_get_boolean(gvalue);
clientValue = GUINT_TO_POINTER(adpProp->polling);
NEARDAL_TRACEF("neardalMgr.polling=%d\n", adpProp->polling);
}
if (!strcmp(arg_unnamed_arg0, "Powered")) {
adpProp->powered = g_variant_get_boolean(gvalue);
clientValue = GINT_TO_POINTER(adpProp->powered);
NEARDAL_TRACEF("neardalMgr.powered=%d\n", adpProp->powered);
}
if (!strcmp(arg_unnamed_arg0, "Tags")) {
gsize tmpLen;
array = g_variant_dup_objv(gvalue, &tmpLen);
adpProp->tagNb = tmpLen;
if (adpProp->tagNb <= 0) { /* Remove all tags */
GList *node = NULL;
NEARDAL_TRACEF(
"Tag array empty! Removing all tags\n");
while (g_list_length(adpProp->tagList)) {
node = g_list_first(adpProp->tagList);
tagProp = (TagProp *) node->data;
neardal_adp_prv_cb_tag_lost(tagProp->proxy,
tagProp->name,
tagProp->parent);
}
g_strfreev(array);
err = NEARDAL_SUCCESS;
goto exit;
}
/* Extract the tags arrays List from the GValue */
err = NEARDAL_ERROR_NO_ADAPTER;
tmpLen = 0;
while (tmpLen < adpProp->tagNb) {
/* Getting last tag (tags list not updated with
* tags lost */
dbusObjPath = g_strdup(array[tmpLen++]);
/* TODO : for Neard Workaround, emulate 'TagFound'
* signals */
err = neardal_adp_prv_get_tag(adpProp,
dbusObjPath,
&tagProp);
clientValue = dbusObjPath;
if (err == NEARDAL_ERROR_NO_TAG) {
neardal_adp_prv_cb_tag_found(NULL,
dbusObjPath,
adpProp);
err = NEARDAL_SUCCESS;
}
}
g_strfreev(array);
array = NULL;
}
if (!strcmp(arg_unnamed_arg0, "Devices")) {
gsize tmpLen;
array = g_variant_dup_objv(gvalue, &tmpLen);
adpProp->devNb = tmpLen;
if (adpProp->devNb <= 0) { /* Remove all devs */
GList *node = NULL;
NEARDAL_TRACEF(
"Dev array empty! Removing all devs\n");
while (g_list_length(adpProp->devList)) {
node = g_list_first(adpProp->devList);
devProp = (DevProp *) node->data;
neardal_adp_prv_cb_dev_lost(NULL,
devProp->name,
devProp->parent);
}
g_strfreev(array);
err = NEARDAL_SUCCESS;
goto exit;
}
/* Extract the devs arrays List from the GValue */
err = NEARDAL_ERROR_NO_ADAPTER;
tmpLen = 0;
while (tmpLen < adpProp->devNb) {
/* Getting last dev (devs list not updated with
* devs lost */
dbusObjPath = g_strdup(array[tmpLen++]);
/* TODO : for Neard Workaround, emulate 'DevFound'
* signals */
err = neardal_adp_prv_get_dev(adpProp,
dbusObjPath,
&devProp);
if (err == NEARDAL_ERROR_NO_DEV) {
clientValue = dbusObjPath;
neardal_adp_prv_cb_dev_found(NULL,
dbusObjPath,
adpProp);
err = NEARDAL_SUCCESS;
}
}
g_strfreev(array);
array = NULL;
}
if (neardalMgr.cb.adp_prop_changed != NULL)
(neardalMgr.cb.adp_prop_changed)(adpProp->name,
(char *) arg_unnamed_arg0,
clientValue,
neardalMgr.cb.adp_prop_changed_ud);
return;
exit:
if (err != NEARDAL_SUCCESS)
NEARDAL_TRACEF("Exit with error code %d:%s\n", err,
neardal_error_get_text(err));
return;
}
/**
* 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;
}
}
