static GArray *
get_login_history (ActUser *user)
{
GArray *login_history;
GVariantIter *iter, *iter2;
GVariant *variant;
const GVariant *value;
const gchar *key;
UmLoginHistory history;
login_history = NULL;
value = act_user_get_login_history (user);
g_variant_get ((GVariant *) value, "a(xxa{sv})", &iter);
while (g_variant_iter_loop (iter, "(xxa{sv})", &history.login_time, &history.logout_time, &iter2)) {
while (g_variant_iter_loop (iter2, "{sv}", &key, &variant)) {
if (g_strcmp0 (key, "type") == 0) {
history.type = g_variant_get_string (variant, NULL);
}
}
if (login_history == NULL) {
login_history = g_array_new (FALSE, TRUE, sizeof (UmLoginHistory));
}
g_array_append_val (login_history, history);
}
return login_history;
}
static const gchar *lookup(GVariant *dictionary, const gchar *lookup_key, const gchar *default_value)
{
GVariantIter dictionary_iter;
g_variant_iter_init(&dictionary_iter, dictionary);
const char *key = NULL;
GVariant *value = NULL;
while (g_variant_iter_loop(&dictionary_iter, "{s@v}", &key, &value)) {
if(strcmp(key, lookup_key) != 0)
continue;
GVariant *unboxed = g_variant_get_variant(value);
if(strcmp(g_variant_get_type_string(unboxed), "s") == 0) {
return g_variant_get_string(unboxed, NULL);
} else if(strcmp(g_variant_get_type_string(unboxed), "ay") != 0) {
return g_variant_print(unboxed, FALSE);
} else if(g_variant_n_children(unboxed) < 256) { // skip preview
gchar *buffer = (gchar *)malloc(256+1);
int i=0;
guchar c;
GVariantIter char_iter;
g_variant_iter_init(&char_iter, unboxed);
while (g_variant_iter_loop(&char_iter, "y", &c)) {
buffer[i] = c;
++i;
}
buffer[i] = 0;
return buffer;
}
}
return default_value;
}
static void
fwupd_remote_set_from_variant_iter (FwupdRemote *self, GVariantIter *iter)
{
FwupdRemotePrivate *priv = GET_PRIVATE (self);
GVariant *value;
const gchar *key;
g_autoptr(GVariantIter) iter2 = g_variant_iter_copy (iter);
g_autoptr(GVariantIter) iter3 = g_variant_iter_copy (iter);
/* three passes, as we have to construct Id -> Url -> * */
while (g_variant_iter_loop (iter, "{sv}", &key, &value)) {
if (g_strcmp0 (key, FWUPD_RESULT_KEY_REMOTE_ID) == 0)
fwupd_remote_set_id (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "Type") == 0)
fwupd_remote_set_kind (self, g_variant_get_uint32 (value));
if (g_strcmp0 (key, "Keyring") == 0)
fwupd_remote_set_keyring_kind (self, g_variant_get_uint32 (value));
}
while (g_variant_iter_loop (iter2, "{sv}", &key, &value)) {
if (g_strcmp0 (key, FWUPD_RESULT_KEY_URI) == 0)
fwupd_remote_set_metadata_uri (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "FilenameCache") == 0)
fwupd_remote_set_filename_cache (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "FilenameSource") == 0)
fwupd_remote_set_filename_source (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "ReportUri") == 0)
fwupd_remote_set_report_uri (self, g_variant_get_string (value, NULL));
}
while (g_variant_iter_loop (iter3, "{sv}", &key, &value)) {
if (g_strcmp0 (key, "Username") == 0) {
fwupd_remote_set_username (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Password") == 0) {
fwupd_remote_set_password (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Title") == 0) {
fwupd_remote_set_title (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Agreement") == 0) {
fwupd_remote_set_agreement (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, FWUPD_RESULT_KEY_CHECKSUM) == 0) {
fwupd_remote_set_checksum (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Enabled") == 0) {
priv->enabled = g_variant_get_boolean (value);
} else if (g_strcmp0 (key, "ApprovalRequired") == 0) {
priv->approval_required = g_variant_get_boolean (value);
} else if (g_strcmp0 (key, "Priority") == 0) {
priv->priority = g_variant_get_int32 (value);
} else if (g_strcmp0 (key, "ModificationTime") == 0) {
priv->mtime = g_variant_get_uint64 (value);
} else if (g_strcmp0 (key, "FirmwareBaseUri") == 0) {
fwupd_remote_set_firmware_base_uri (self, g_variant_get_string (value, NULL));
}
}
}
static void
seat_properties_changed_cb (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
Login1Seat *seat = user_data;
GVariantIter *iter;
GVariantIter *invalidated_properties;
const gchar *name;
GVariant *value;
g_variant_get (parameters, "(sa{sv}as)", NULL, &iter, &invalidated_properties);
while (g_variant_iter_loop (iter, "{&sv}", &name, &value))
update_property (seat, name, value);
g_variant_iter_free (iter);
while (g_variant_iter_loop (invalidated_properties, "&s", &name))
{
GVariant *result;
GError *error = NULL;
result = g_dbus_connection_call_sync (connection,
LOGIN1_SERVICE_NAME,
seat->priv->path,
"org.freedesktop.DBus.Properties",
"Get",
g_variant_new ("(ss)", "org.freedesktop.login1.Seat", name),
G_VARIANT_TYPE ("(v)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error)
g_warning ("Error updating seat property %s: %s", name, error->message);
g_clear_error (&error);
if (result)
{
g_variant_get (result, "(v)", &value);
update_property (seat, name, value);
g_variant_unref (value);
g_variant_unref (result);
}
}
g_variant_iter_free (invalidated_properties);
}
static Login1Seat *
add_seat (Login1Service *service, const gchar *id, const gchar *path)
{
Login1Seat *seat;
GVariant *result;
GError *error = NULL;
seat = g_object_new (LOGIN1_SEAT_TYPE, NULL);
seat->priv->connection = g_object_ref (service->priv->connection);
seat->priv->id = g_strdup (id);
seat->priv->path = g_strdup (path);
seat->priv->signal_id = g_dbus_connection_signal_subscribe (seat->priv->connection,
LOGIN1_SERVICE_NAME,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
path,
"org.freedesktop.login1.Seat",
G_DBUS_SIGNAL_FLAGS_NONE,
seat_properties_changed_cb,
g_object_ref (seat),
g_object_unref);
/* Get properties for this seat */
result = g_dbus_connection_call_sync (seat->priv->connection,
LOGIN1_SERVICE_NAME,
path,
"org.freedesktop.DBus.Properties",
"GetAll",
g_variant_new ("(s)", "org.freedesktop.login1.Seat"),
G_VARIANT_TYPE ("(a{sv})"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error)
g_warning ("Failed to get seat properties: %s", error->message);
g_clear_error (&error);
if (result)
{
GVariantIter *properties;
const gchar *name;
GVariant *value;
g_variant_get (result, "(a{sv})", &properties);
while (g_variant_iter_loop (properties, "{&sv}", &name, &value))
{
if (strcmp (name, "CanGraphical") == 0 && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN))
seat->priv->can_graphical = g_variant_get_boolean (value);
else if (strcmp (name, "CanMultiSession") == 0 && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN))
seat->priv->can_multi_session = g_variant_get_boolean (value);
}
g_variant_iter_free (properties);
g_variant_unref (result);
}
service->priv->seats = g_list_append (service->priv->seats, seat);
return seat;
}
static void
g_dbus_menu_path_signal (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
GDBusMenuPath *path = user_data;
GVariantIter *iter;
guint group_id;
guint menu_id;
guint position;
guint removes;
GVariant *adds;
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(a(uuuuaa{sv}))")))
return;
g_variant_get (parameters, "(a(uuuuaa{sv}))", &iter);
while (g_variant_iter_loop (iter, "(uuuu@aa{sv})", &group_id, &menu_id, &position, &removes, &adds))
{
GDBusMenuGroup *group;
group = g_hash_table_lookup (path->groups, GINT_TO_POINTER (group_id));
if (group != NULL)
g_dbus_menu_group_changed (group, menu_id, position, removes, adds);
}
g_variant_iter_free (iter);
}
static void
on_message_update (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
ReaderEngine *engine)
{
GVariantIter *iter1, *iter2;
gchar *class_name;
gint graph = 0, subject = 0, predicate = 0, object = 0;
g_variant_get (parameters, "(&sa(iiii)a(iiii))", &class_name, &iter1, &iter2);
/*
TODO
while (g_variant_iter_loop (iter1, "(iiii)", &graph, &subject, &predicate, &object))
handle_feed_deletes (engine, subject);
*/
while (g_variant_iter_loop (iter2, "(iiii)", &graph, &subject, &predicate, &object))
handle_feed_inserts (engine, subject);
g_variant_iter_free (iter1);
g_variant_iter_free (iter2);
}
static void
on_properties_changed(GDBusProxy *proxy, GVariant *changed, const char *const *invalidated, gpointer user_data)
{
struct app *app = user_data;
printf("%015.3f --- Properties Changed ---\n",
g_timer_elapsed(app->timer, NULL));
if (g_variant_n_children(changed) > 0) {
GVariantIter *itr;
const char *prop;
GVariant *value;
printf("Changed Properties:");
g_variant_get(changed, "a{sv}", &itr);
while (g_variant_iter_loop(itr, "{&sv}", &prop, &value)) {
char *str;
str = g_variant_print(value, TRUE);
printf(" %s=%s", prop, str);
g_free(str);
}
g_variant_iter_free(itr);
printf("\n");
}
if (invalidated[0] != NULL) {
const char * const *itr;
printf("Invalidated Properties:");
for (itr = invalidated; *itr != NULL; itr++)
printf(" %s", *itr);
printf("\n");
}
print_server(proxy);
}
bool Variant::ASVToHints(HintsMap& hints) const
{
GVariantIter* hints_iter;
char* key = NULL;
GVariant* value = NULL;
if (!variant_)
return false;
if (!g_variant_is_of_type (variant_, G_VARIANT_TYPE ("(a{sv})")) &&
!g_variant_is_of_type (variant_, G_VARIANT_TYPE ("a{sv}")))
{
return false;
}
g_variant_get(variant_, g_variant_get_type_string(variant_), &hints_iter);
while (g_variant_iter_loop(hints_iter, "{sv}", &key, &value))
{
hints[key] = value;
}
g_variant_iter_free(hints_iter);
return true;
}
static void
do_countBools (SoupMessage *msg, SoupXMLRPCParams *params)
{
GVariant *args;
GVariant *child;
GVariantIter iter;
gboolean val;
int trues = 0, falses = 0;
GVariantDict dict;
if (!(args = parse_params (msg, params, "(ab)")))
return;
child = g_variant_get_child_value (args, 0);
g_variant_iter_init (&iter, child);
while (g_variant_iter_loop (&iter, "b", &val)) {
if (val)
trues++;
else
falses++;
}
g_variant_dict_init (&dict, NULL);
g_variant_dict_insert (&dict, "true", "i", trues);
g_variant_dict_insert (&dict, "false", "i", falses);
soup_xmlrpc_message_set_response (msg, g_variant_dict_end (&dict), NULL);
g_variant_unref (args);
g_variant_unref (child);
}
static GHashTable *
get_playing_song_info (GDBusProxy *mpris)
{
GHashTable *properties;
GVariant *prop;
GVariant *metadata;
GVariantIter iter;
GVariant *value;
char *key;
GError *error = NULL;
prop = g_dbus_proxy_call_sync (mpris,
"org.freedesktop.DBus.Properties.Get",
g_variant_new ("(ss)", "org.mpris.MediaPlayer2.Player", "Metadata"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (annoy (&error)) {
return NULL;
}
g_variant_get (prop, "(v)", &metadata);
properties = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
g_variant_iter_init (&iter, metadata);
while (g_variant_iter_loop (&iter, "{sv}", &key, &value)) {
g_hash_table_insert (properties, g_strdup (key), g_variant_ref (value));
}
g_variant_unref (prop);
return properties;
}
static void pocketvox_setup_get_modules_grid(PocketvoxSetup *setup)
{
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
GVariant *modules;
GVariantIter *iter;
gchar *key, *value;
gboolean isapps;
priv->listBox = gtk_list_box_new();
GtkWidget *ph_widget = gtk_label_new("Add your modules");
gtk_label_set_markup(GTK_LABEL(ph_widget), _("<b><b><big> ADD YOUR MODULES </big></b></b>"));
gtk_widget_show(ph_widget);
gtk_list_box_set_placeholder(GTK_LIST_BOX(priv->listBox),ph_widget);
//only need to connect signals
modules = g_settings_get_value(priv->settings, "list-apps");
//get the content of the GVariant
g_variant_get(modules, "a(ssb)", &iter);
//loop other all apps
while(g_variant_iter_loop(iter, "(ssb)", &key, &value, &isapps))
{
pocketvox_setup_add_module(setup, key, value, isapps);
}
g_variant_iter_free(iter);
}
static void
services_array_add (GUPnPConnmanManager *manager, GVariant *data)
{
GVariant *dict;
CMService *cm_service;
gchar *path;
GVariantIter iter;
GVariantIter dict_iter;
guint port;
g_object_get (manager, "port", &port, NULL);
g_variant_iter_init (&iter, data);
while (g_variant_iter_loop (&iter, "(&o@a{sv})", &path, &dict)) {
if (path == NULL)
continue;
if (dict == NULL)
continue;
if (g_variant_iter_init (&dict_iter, dict) == 0)
continue;
cm_service = g_hash_table_lookup (manager->priv->cm_services,
path);
if (cm_service == NULL)
cm_service_add (manager, dict, path, port);
else
cm_service_update (cm_service, dict, port);
}
}
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 gboolean
do_print_related (OstreeRepo *repo,
const char *rev,
const char *resolved_rev,
GError **error)
{
gboolean ret = FALSE;
const char *name;
gs_unref_variant GVariant *csum_v = NULL;
gs_unref_variant GVariant *variant = NULL;
gs_unref_variant GVariant *related = NULL;
GVariantIter *viter = NULL;
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT,
resolved_rev, &variant, error))
goto out;
/* PARSE OSTREE_SERIALIZED_COMMIT_VARIANT */
related = g_variant_get_child_value (variant, 2);
viter = g_variant_iter_new (related);
while (g_variant_iter_loop (viter, "(&s@ay)", &name, &csum_v))
{
gs_free char *checksum = ostree_checksum_from_bytes_v (csum_v);
g_print ("%s %s\n", name, checksum);
}
csum_v = NULL;
ret = TRUE;
out:
if (viter)
g_variant_iter_free (viter);
return ret;
}
static GList *
process_children (GVariant *children, GList **photos_list)
{
GVariantIter *iter = NULL;
GVariant *var = NULL;
GList *containers = NULL;
GomDlnaPhotoItem *photo;
g_variant_get (children, "aa{sv}", &iter);
while (g_variant_iter_loop (iter, "@a{sv}", &var))
{
photo = photo_item_new (var);
if (g_str_equal (photo->type, "image.photo"))
{
*photos_list = g_list_prepend (*photos_list, photo);
}
else if (g_str_equal (photo->type, "container"))
{
containers = g_list_prepend (containers, g_strdup (photo->path));
gom_dlna_photo_item_free (photo);
}
}
return containers;
}
static void on_properties_changed (GDBusProxy *proxy,
GVariant *changed_properties,
const gchar* const *invalidated_properties,
gpointer user_data)
{
/*
* Note that we are guaranteed that changed_properties and
* invalidated_properties are never NULL
*/
if (g_variant_n_children (changed_properties) > 0){
GVariantIter *iter;
const gchar *key;
GVariant *value;
g_printf ("*** 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_printf(" %s -> %s\n", key, value_str);
g_free(value_str);
}
g_variant_iter_free(iter);
}
if (g_strv_length((GStrv) invalidated_properties) > 0){
guint n;
g_printf ("*** Properties Invalidated:\n");
for (n = 0; invalidated_properties[n] != NULL; n++){
const gchar *key = invalidated_properties[n];
g_printf(" %s\n", key);
}
}
}
/**
* signal_mcuinfo_handler - signal mcuinfo handler
*
* @object :
* @arg :
* @userdata :
*
* returns:
* 0 - true, -1 - false
*/
static gboolean
signal_mcuinfo_handler (GdbusMcuinfo *object, GVariant *in_arg, gpointer userdata)
{
autolink_mcu_info_dbus_st mcu_info;
GVariantIter *iter;
guchar *pos;
guchar arg;
pos = &mcu_info;
/** Get the input parameters */
g_variant_get (in_arg, "(ay)", &iter);
while (g_variant_iter_loop (iter, "y", &arg)) {
*pos = arg;
pos++;
}
g_variant_iter_free (iter);
DBG_LOG ("Received signal mcuinfo, info type: %d.\n", mcu_info.mcu_info_type);
if (NULL != signal_cb.mcuinfo_cb)
signal_cb.mcuinfo_cb (&mcu_info);
return TRUE;
}
GMountSpec *
g_mount_spec_from_dbus (GVariant *value)
{
GMountSpec *spec;
const gchar *key;
const gchar *mount_prefix;
GVariantIter *iter_mount_spec_items;
GVariant *v;
mount_prefix = NULL;
g_variant_get (value, "(^&aya{sv})",
&mount_prefix,
&iter_mount_spec_items);
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = NULL;
if (mount_prefix && mount_prefix[0])
spec->mount_prefix = g_strdup (mount_prefix);
while (g_variant_iter_loop (iter_mount_spec_items, "{&sv}", &key, &v))
{
add_item (spec, key, g_variant_dup_bytestring (v, NULL));
}
g_variant_iter_free (iter_mount_spec_items);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
/**
* method_send_mcuinfo - the callback of method SendMcuinfo, send a uart frame to mcu
*
* @object :
* @invocation:
* @in_arg : GVariant arguments of this method
* @user_data :
*
* returns:
* void
*
*/
static gboolean
method_send_mcuinfo(GdbusMcuinfo *object,
GDBusMethodInvocation *invocation,
GVariant *in_arg,
gpointer user_data)
{
autolink_mcu_info_dbus_st mcu_info;
GVariantIter *iter;
guchar *pos;
guchar arg;
gchar out_buf[BUF_LEN];
pos = &mcu_info;
/** Get the input parameters */
g_variant_get (in_arg, "(ay)", &iter);
while (g_variant_iter_loop (iter, "y", &arg)) {
*pos = arg;
pos++;
}
g_variant_iter_free (iter);
DBG_LOG ("Received method send mcuinfo, info type: %d.\n", mcu_info.mcu_info_type);
if (NULL != method_cb.mcuinfo_cb)
method_cb.mcuinfo_cb (&mcu_info, out_buf, user_data);
else
g_strlcpy (out_buf, "err no cb", BUF_LEN);
gdbus_mcuinfo_complete_send_mcuinfo(object, invocation, out_buf);
return TRUE;
}
void get_connection_contexts(struct modemdata *data)
{
GError *err = NULL;
GVariantIter *iter;
const char *obj_path;
int i;
GVariant *contexts = g_dbus_proxy_call_sync(data->connman,
"GetContexts", NULL, G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &err);
if (err) {
g_warning("GetContexts failed: %s\n", err->message);
g_error_free(err);
return;
}
g_print("contexts type: %s\n",
g_variant_get_type_string(contexts));
g_variant_get(contexts, "(a(oa{sv}))", &iter);
i = 0;
while (g_variant_iter_loop(iter, "oa{sv}", &obj_path, NULL)) {
g_print("context: %s\n", obj_path);
if (i == used_context)
activate_context(data, obj_path);
i++;
}
g_variant_iter_free(iter);
g_variant_unref(contexts);
}
/**
* tracker_miner_manager_get_running:
* @manager: a #trackerMinerManager
*
* Returns a list of references for all active miners. Active miners
* are miners which are running within a process.
*
* Returns: (transfer full) (element-type utf8) (nullable): a #GSList which
* must be freed with g_slist_free() and all contained data with g_free().
* Otherwise %NULL is returned if there are no miners.
*
* Since: 0.8
**/
GSList *
tracker_miner_manager_get_running (TrackerMinerManager *manager)
{
TrackerMinerManagerPrivate *priv;
GSList *list = NULL;
GError *error = NULL;
GVariant *v;
GVariantIter *iter;
const gchar *str = NULL;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
if (!priv->connection) {
return NULL;
}
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"ListNames",
NULL,
G_VARIANT_TYPE ("(as)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_critical ("Could not get a list of names registered on the session bus, %s",
error ? error->message : "no error given");
g_clear_error (&error);
return NULL;
}
g_variant_get (v, "(as)", &iter);
while (g_variant_iter_loop (iter, "&s", &str)) {
if (!g_str_has_prefix (str, TRACKER_MINER_DBUS_NAME_PREFIX)) {
continue;
}
/* Special case miner-fs which has
* additional D-Bus interface.
*/
if (strcmp (str, "org.freedesktop.Tracker1.Miner.Files.Index") == 0) {
continue;
}
list = g_slist_prepend (list, g_strdup (str));
}
g_variant_iter_free (iter);
g_variant_unref (v);
list = g_slist_reverse (list);
return list;
}
static void
got_users (GObject *object,
GAsyncResult *res,
gpointer data)
{
UmUserManager *manager = data;
GVariant *result;
GError *error = NULL;
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (!result) {
manager->no_service = TRUE;
g_error_free (error);
goto done;
}
if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(ao)"))) {
GVariantIter *iter;
gchar *object_path;
g_variant_get (result, "(ao)", &iter);
while (g_variant_iter_loop (iter, "&o", &object_path))
user_added_handler (manager, object_path);
g_variant_iter_free (iter);
}
g_variant_unref (result);
done:
g_signal_emit (G_OBJECT (manager), signals[USERS_LOADED], 0);
}
/**
* urf_session_checker_get_seats:
**/
static gboolean
urf_session_checker_get_seats (UrfSessionChecker *logind)
{
UrfLogindPrivate *priv = logind->priv;
GError *error = NULL;
const char *seat_name, *seat_path;
GVariant *retval;
GVariantIter *iter;
retval = g_dbus_proxy_call_sync (priv->proxy, "ListSeats",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (error) {
g_warning ("ListSeats Failed: %s", error->message);
g_error_free (error);
return FALSE;
}
if (retval == NULL) {
g_debug ("No Seat exists");
return FALSE;
}
g_variant_get (retval, "(a(so))", &iter);
while (g_variant_iter_loop (iter, "(so)", &seat_name, &seat_path)) {
urf_session_checker_add_seat (logind, seat_path);
g_debug ("Added seat: %s", seat_name);
}
g_variant_iter_free (iter);
g_variant_unref (retval);
return TRUE;
}
static gboolean
on_location_app_state_set (GtkSwitch *widget,
gboolean state,
gpointer user_data)
{
LocationAppStateData *data = (LocationAppStateData *) user_data;
CcPrivacyPanel *self = data->self;
GVariant *params;
GVariantIter iter;
gchar *key;
gchar **value;
GVariantBuilder builder;
if (data->changing_state)
return TRUE;
data->changing_state = TRUE;
data->pending_state = state;
g_variant_iter_init (&iter, self->priv->location_apps_perms);
g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
while (g_variant_iter_loop (&iter, "{s^as}", &key, &value))
{
gchar *tmp = NULL;
if (g_strv_length (value) < 2)
/* It's OK to drop the entry if it's not in expected format */
continue;
if (g_strcmp0 (data->app_id, key) == 0)
{
tmp = value[0];
value[0] = state ? "EXACT" : "NONE";
}
g_variant_builder_add (&builder, "{s^as}", key, value);
if (tmp != NULL)
value[0] = tmp;
}
params = g_variant_new ("(sbsa{sas}v)",
APP_PERMISSIONS_TABLE,
TRUE,
APP_PERMISSIONS_ID,
&builder,
self->priv->location_apps_data);
g_dbus_proxy_call (self->priv->perm_store,
"Set",
params,
G_DBUS_CALL_FLAGS_NONE,
-1,
self->priv->cancellable,
on_perm_store_set_done,
data);
return TRUE;
}
void on_menu_changed(gpointer instance, GVariant *parameters, gpointer user_data)
{
WorkraveApplet *applet = WORKRAVE_APPLET(user_data);
GVariantIter *iter;
g_variant_get (parameters, "(a(sii))", &iter);
char *text;
int id;
int flags;
gboolean visible[sizeof(menu_data)/sizeof(struct Menuitems)];
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
visible[i] = menu_data[i].visible_when_not_running;
}
while (g_variant_iter_loop(iter, "(sii)", &text, &id, &flags))
{
int index = lookup_menu_index_by_id((enum MenuCommand)id);
if (index == -1)
{
continue;
}
GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[index].action);
if (flags & MENU_ITEM_FLAG_SUBMENU_END ||
flags & MENU_ITEM_FLAG_SUBMENU_BEGIN)
{
continue;
}
visible[index] = TRUE;
if (g_action_get_state_type(G_ACTION(action)) != NULL)
{
if (menu_data[index].state == NULL)
{
g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_boolean(flags & MENU_ITEM_FLAG_ACTIVE));
}
else
{
if (flags & MENU_ITEM_FLAG_ACTIVE)
{
g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_string(menu_data[index].state));
}
}
}
}
g_variant_iter_free (iter);
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[i].action);
g_simple_action_set_enabled(G_SIMPLE_ACTION(action), visible[i]);
}
}
static gboolean set_prop_list(GVariantIter* iter) {
gchar* val;
gchar* key;
while (g_variant_iter_loop(iter, "{ss}", &key, &val)) {
set_prop(key, val);
}
return TRUE;
}
void Peer::handle_property_change (const char *name, GVariant *property)
{
if (g_strcmp0(name, "State") == 0) {
state_changed (g_variant_get_string (property, NULL));
} else if (g_strcmp0(name, "Name") == 0) {
name_changed (g_variant_get_string (property, NULL));
} else if (g_strcmp0(name, "Services") == 0) {
GVariantIter *service_array, *services;
GVariant *spec_val;
g_variant_get (property, "a(a{sv})", &service_array);
while (g_variant_iter_loop (service_array, "(a{sv})", &services)) {
const char *service_name;
while (g_variant_iter_loop (services, "{sv}", &service_name, &spec_val)) {
if (g_strcmp0 (service_name, "WiFiDisplayIEs") == 0) {
uint8_t *bytes;
gsize length;
bytes = (uint8_t*)g_variant_get_fixed_array (spec_val, &length, 1);
std::unique_ptr<P2P::InformationElementArray> array
(new P2P::InformationElementArray(length, bytes));
ie_.reset(new P2P::InformationElement (array));
}
}
}
g_variant_iter_free (service_array);
} else if (g_strcmp0(name, "IPv4") == 0) {
GVariantIter *ips;
GVariant *spec_val;
char *name;
const char *remote = "";
const char *local = "";
g_variant_get (property, "a{sv}", &ips);
while (g_variant_iter_loop (ips, "{sv}", &name, &spec_val)) {
if (g_strcmp0 (name, "Remote") == 0) {
remote = g_variant_get_string (spec_val, NULL);
} else if (g_strcmp0 (name, "Local") == 0) {
local = g_variant_get_string (spec_val, NULL);
}
}
ips_changed (remote, local);
g_variant_iter_free (ips);
}
}
static GVariant *
read_xattrs_cb (OstreeRepo *repo,
const char *relpath,
GFileInfo *file_info,
gpointer user_data)
{
int rootfs_fd = GPOINTER_TO_INT (user_data);
/* Hardcoded at the moment, we're only taking file caps */
static const char *accepted_xattrs[] = { "security.capability" };
guint i;
gs_unref_variant GVariant *existing_xattrs = NULL;
gs_free_variant_iter GVariantIter *viter = NULL;
GError *local_error = NULL;
GError **error = &local_error;
GVariant *key, *value;
GVariantBuilder builder;
if (relpath[0] == '/')
relpath++;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(ayay)"));
if (!*relpath)
{
if (!gs_fd_get_all_xattrs (rootfs_fd, &existing_xattrs, NULL, error))
goto out;
}
else
{
if (!gs_dfd_and_name_get_all_xattrs (rootfs_fd, relpath, &existing_xattrs,
NULL, error))
goto out;
}
viter = g_variant_iter_new (existing_xattrs);
while (g_variant_iter_loop (viter, "(@ay@ay)", &key, &value))
{
for (i = 0; i < G_N_ELEMENTS (accepted_xattrs); i++)
{
const char *validkey = accepted_xattrs[i];
const char *attrkey = g_variant_get_bytestring (key);
if (g_str_equal (validkey, attrkey))
g_variant_builder_add (&builder, "(@ay@ay)", key, value);
}
}
out:
if (local_error)
{
g_variant_builder_clear (&builder);
/* Unfortunately we have no way to throw from this callback */
g_printerr ("Failed to read xattrs of '%s': %s\n",
relpath, local_error->message);
exit (1);
}
return g_variant_ref_sink (g_variant_builder_end (&builder));
}
static void
get_methods_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GVariant *matches;
gpointer *closure;
GError *error = NULL;
GList *list = NULL;
closure = (gpointer *)user_data;
if (!gb_dbus_typelib_call_get_methods_finish(GB_DBUS_TYPELIB(object),
&matches,
result,
&error)) {
if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_warning("%s", error->message);
}
goto cleanup;
}
if (matches) {
GVariantIter *viter;
const gchar *text;
const gchar *markup;
gdouble score;
g_variant_get(matches, "a(sd)", &viter);
while (g_variant_iter_loop(viter, "(sd)", &text, &score)) {
GtkSourceCompletionItem *item;
item = g_object_new(GB_TYPE_SOURCE_TYPELIB_COMPLETION_ITEM,
"icon", gMethodPixbuf,
"search-term", (gchar *)closure[2],
"text", text,
NULL);
if (!item) {
g_error("Failed to create item.");
}
list = g_list_prepend(list, item);
}
list = g_list_reverse(list);
g_variant_unref(matches);
}
gtk_source_completion_context_add_proposals(closure[1], closure[0], list, TRUE);
g_list_foreach(list, (GFunc)g_object_unref, NULL);
g_list_free(list);
cleanup:
g_object_unref(closure[0]);
g_object_unref(closure[1]);
g_free(closure[2]);
g_free(closure);
}
