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