GVariant * _secret_session_encode_secret (SecretSession *session, SecretValue *value) { GVariantBuilder *builder; GVariant *result = NULL; GVariantType *type; gboolean ret; g_return_val_if_fail (session != NULL, NULL); g_return_val_if_fail (value != NULL, NULL); type = g_variant_type_new ("(oayays)"); builder = g_variant_builder_new (type); #ifdef WITH_GCRYPT if (session->key) ret = service_encode_aes_secret (session, value, builder); else #endif ret = service_encode_plain_secret (session, value, builder); if (ret) result = g_variant_builder_end (builder); g_variant_builder_unref (builder); g_variant_type_free (type); return result; }
static void _decode_username_password(GTlmNfc* self, const gchar* data) { gsize variant_s_size = 0; guchar* variant_s = g_base64_decode(data, &variant_s_size); GVariantType* v_t = g_variant_type_new("(msms)"); GVariant* v = g_variant_new_from_data(v_t, variant_s, variant_s_size, FALSE, NULL, NULL); if (v == NULL) { g_debug("Couldn't decode Payload data to variant"); g_variant_type_free(v_t); g_free(variant_s); g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0); return; } gchar* username = NULL; gchar* password = NULL; g_variant_get(v, "(msms)", &username, &password); g_signal_emit(self, signals[SIG_RECORD_FOUND], 0, username, password); g_free(username); g_free(password); g_variant_unref(v); g_variant_type_free(v_t); g_free(variant_s); }
gboolean g_variant_lookup (GVariant *dictionary, const gchar *key, const gchar *format_string, ...) { GVariantType *type; GVariant *value; /* flatten */ g_variant_get_data (dictionary); type = g_variant_type_new (format_string); value = g_variant_lookup_value (dictionary, key, type); g_variant_type_free (type); if (value) { va_list ap; va_start (ap, format_string); g_variant_get_va (value, format_string, NULL, &ap); g_variant_unref (value); va_end (ap); return TRUE; } else return FALSE; }
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username, const InitStateString &password) { // Expected content of parameter GVariant. boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free); // 'username' is the part after signon: which we can parse directly. GErrorCXX gerror; GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror), TRANSFER_REF); if (!parametersVar) { gerror.throwError(SE_HERE, "parsing 'signon:' username"); } GHashTableCXX parameters(Variant2HashTable(parametersVar)); // Extract the values that we expect in the parameters hash. guint32 signonID; const char *method; const char *mechanism; GVariant *value; value = (GVariant *)g_hash_table_lookup(parameters, "identity"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) { SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters"); } signonID = g_variant_get_uint32(value); value = (GVariant *)g_hash_table_lookup(parameters, "method"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'method: <string>' in 'signon:' parameters"); } method = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "mechanism"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'mechanism: <string>' in 'signon:' parameters"); } mechanism = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "session"); if (!value || !g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) { SE_THROW("need 'session: <hash>' in 'signon:' parameters"); } GHashTableCXX sessionData(Variant2HashTable(value)); SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s", signonID, method, mechanism); SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF); SE_LOG_DEBUG(NULL, "using signond identity %d", signonID); SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF); boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism)); return provider; }
GVariantType* gslit_to_varianttype(GSList* l) { GString* str = g_string_new("("); while (l != NULL) { g_string_append(str, l->data); l = g_slist_next(l); } g_string_append(str, ")"); return g_variant_type_new(g_string_free(str, FALSE)); }
static void get_properties_cb_4 (GObject *source_object, GAsyncResult *res, gpointer user_data) { NMBluezDevice *self = NM_BLUEZ_DEVICE (user_data); NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self); GError *err = NULL; GVariant *v_properties, *v_dict; GVariantType *v_type; v_properties = g_dbus_proxy_call_finish (priv->proxy, res, &err); if (!v_properties) { nm_log_warn (LOGD_BT, "bluez[%s] error getting device properties: %s", priv->path, err && err->message ? err->message : "(unknown)"); g_error_free (err); g_signal_emit (self, signals[INITIALIZED], 0, FALSE); goto END; } v_type = g_variant_type_new ("(a{sv})"); if (g_variant_is_of_type (v_properties, v_type)) { v_dict = g_variant_get_child_value (v_properties, 0); _set_properties (self, v_dict); g_variant_unref (v_dict); } else { nm_log_warn (LOGD_BT, "bluez[%s] GetProperties returns unexpected result of type %s", priv->path, g_variant_get_type_string (v_properties)); } g_variant_type_free (v_type); g_variant_unref (v_properties); /* Check if any connections match this device */ load_connections (self); priv->initialized = TRUE; g_signal_emit (self, signals[INITIALIZED], 0, TRUE); check_emit_usable (self); END: g_object_unref (self); }
static GVariant * parse_json_with_sig (JsonObject *object, GError **error) { GVariantType *inner_type; GVariant *inner; JsonNode *val; const gchar *sig; val = json_object_get_member (object, "val"); if (val == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "JSON did not contain a 'val' field"); return NULL; } if (!cockpit_json_get_string (object, "sig", NULL, &sig) || !sig) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "JSON did not contain valid 'sig' fields"); return NULL; } if (!g_variant_type_string_is_valid (sig)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "JSON 'sig' field '%s' is invalid", sig); return NULL; } inner_type = g_variant_type_new (sig); inner = parse_json (val, inner_type, error); g_variant_type_free (inner_type); if (!inner) return NULL; return g_variant_new_variant (inner); }
static void start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { ParseState *state = user_data; const GSList *element_stack; const gchar *container; element_stack = g_markup_parse_context_get_element_stack (context); container = element_stack->next ? element_stack->next->data : NULL; #define COLLECT(first, ...) \ g_markup_collect_attributes (element_name, \ attribute_names, attribute_values, error, \ first, __VA_ARGS__, G_MARKUP_COLLECT_INVALID) #define OPTIONAL G_MARKUP_COLLECT_OPTIONAL #define STRDUP G_MARKUP_COLLECT_STRDUP #define STRING G_MARKUP_COLLECT_STRING #define NO_ATTRS() COLLECT (G_MARKUP_COLLECT_INVALID, NULL) if (container == NULL) { if (strcmp (element_name, "schemalist") == 0) { COLLECT (OPTIONAL | STRDUP, "gettext-domain", &state->schemalist_domain); return; } } else if (strcmp (container, "schemalist") == 0) { if (strcmp (element_name, "schema") == 0) { const gchar *id, *path; if (COLLECT (STRING, "id", &id, OPTIONAL | STRING, "path", &path, OPTIONAL | STRDUP, "gettext-domain", &state->schema_domain)) { if (!g_hash_table_lookup (state->schemas, id)) { state->schema = gvdb_hash_table_new (state->schemas, id); state->schema_root = gvdb_hash_table_insert (state->schema, ""); if (path != NULL) gvdb_hash_table_insert_string (state->schema, ".path", path); } else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "<schema id='%s'> already specified", id); } return; } } else if (strcmp (container, "schema") == 0) { if (strcmp (element_name, "key") == 0) { const gchar *name, *type; if (COLLECT (STRING, "name", &name, STRING, "type", &type)) { if (!is_valid_keyname (name, error)) return; if (!g_hash_table_lookup (state->schema, name)) { state->key = gvdb_hash_table_insert (state->schema, name); gvdb_item_set_parent (state->key, state->schema_root); } else { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "<key name='%s'> already specified", name); return; } if (g_variant_type_string_is_valid (type)) state->type = g_variant_type_new (type); else { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "invalid GVariant type string '%s'", type); return; } g_variant_builder_init (&state->key_options, G_VARIANT_TYPE ("a{sv}")); } return; } else if (strcmp (element_name, "child") == 0) { const gchar *name, *schema; if (COLLECT (STRING, "name", &name, STRING, "schema", &schema)) { gchar *childname; if (!is_valid_keyname (name, error)) return; childname = g_strconcat (name, "/", NULL); if (!g_hash_table_lookup (state->schema, childname)) gvdb_hash_table_insert_string (state->schema, childname, schema); else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "<child name='%s'> already specified", name); g_free (childname); return; } } } else if (strcmp (container, "key") == 0) { if (strcmp (element_name, "default") == 0) { const gchar *l10n; if (COLLECT (STRING | OPTIONAL, "l10n", &l10n, STRDUP | OPTIONAL, "context", &state->context)) { if (l10n != NULL) { if (!g_hash_table_lookup (state->schema, ".gettext-domain")) { const gchar *domain = state->schema_domain ? state->schema_domain : state->schemalist_domain; if (domain == NULL) { g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "l10n requested, but no " "gettext domain given"); return; } gvdb_hash_table_insert_string (state->schema, ".gettext-domain", domain); if (strcmp (l10n, "messages") == 0) state->l10n = 'm'; else if (strcmp (l10n, "time") == 0) state->l10n = 't'; else { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "unsupported l10n category: %s", l10n); return; } } } else { state->l10n = '\0'; if (state->context != NULL) { g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "translation context given for " " value without l10n enabled"); return; } } state->string = g_string_new (NULL); } return; } else if (strcmp (element_name, "summary") == 0 || strcmp (element_name, "description") == 0) { state->string = g_string_new (NULL); NO_ATTRS (); return; } else if (strcmp (element_name, "range") == 0) { const gchar *min_str, *max_str; if (!type_allows_range (state->type)) { gchar *type = g_variant_type_dup_string (state->type); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "Element <%s> not allowed for keys of type \"%s\"\n", element_name, type); g_free (type); return; } if (!COLLECT (STRING, "min", &min_str, STRING, "max", &max_str)) return; state->min = g_variant_parse (state->type, min_str, NULL, NULL, error); if (state->min == NULL) return; state->max = g_variant_parse (state->type, max_str, NULL, NULL, error); if (state->max == NULL) return; if (g_variant_compare (state->min, state->max) > 0) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "Element <%s> specified minimum is greater than maxmimum", element_name); return; } g_variant_builder_add (&state->key_options, "{sv}", "range", g_variant_new ("(@?@?)", state->min, state->max)); return; } else if (strcmp (element_name, "choices") == 0) { if (!type_allows_choices (state->type)) { gchar *type = g_variant_type_dup_string (state->type); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "Element <%s> not allowed for keys of type \"%s\"\n", element_name, type); g_free (type); return; } state->choices = g_string_new ("\xff"); NO_ATTRS (); return; } } else if (strcmp (container, "choices") == 0) { if (strcmp (element_name, "choice") == 0) { const gchar *value; if (COLLECT (STRING, "value", &value)) g_string_append_printf (state->choices, "%s\xff", value); return; } } if (container) g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT, "Element <%s> not allowed inside <%s>\n", element_name, container); else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT, "Element <%s> not allowed at toplevel\n", element_name); }
void settings_manager_add_interested (SettingsManager* self, const gchar* app_desktop_name) { static const char key[] = "interested-media-players"; GVariantType* _tmp0_; GVariantType* _tmp1_; GVariantBuilder* _tmp2_; GVariantBuilder* _tmp3_; GVariantBuilder* players; GSettings* _tmp4_; gchar** _tmp5_; gchar** _tmp6_ = NULL; GVariantBuilder* _tmp12_; const gchar* _tmp13_; GSettings* _tmp14_; GVariantBuilder* _tmp15_; GVariant* _tmp16_ = NULL; GVariant* _tmp17_; GSettings* _tmp18_; g_return_if_fail (self != NULL); g_return_if_fail (app_desktop_name != NULL); _tmp0_ = g_variant_type_new ("as"); _tmp1_ = _tmp0_; _tmp2_ = g_variant_builder_new (_tmp1_); _tmp3_ = _tmp2_; _g_variant_type_free0 (_tmp1_); players = _tmp3_; _tmp4_ = self->priv->settings; _tmp6_ = _tmp5_ = g_settings_get_strv (_tmp4_, key); { gchar** player_collection = NULL; gint player_collection_length1 = 0; gint _player_collection_size_ = 0; gint player_it = 0; player_collection = _tmp6_; player_collection_length1 = _vala_array_length (_tmp5_); for (player_it = 0; player_it < _vala_array_length (_tmp5_); player_it = player_it + 1) { gchar* _tmp7_; gchar* player = NULL; _tmp7_ = g_strdup (player_collection[player_it]); player = _tmp7_; { const gchar* _tmp8_; const gchar* _tmp9_; GVariantBuilder* _tmp10_; const gchar* _tmp11_; _tmp8_ = player; _tmp9_ = app_desktop_name; if (g_strcmp0 (_tmp8_, _tmp9_) == 0) { _g_free0 (player); player_collection = (_vala_array_free (player_collection, player_collection_length1, (GDestroyNotify) g_free), NULL); _g_variant_builder_unref0 (players); return; } _tmp10_ = players; _tmp11_ = player; g_variant_builder_add (_tmp10_, "s", _tmp11_, NULL); _g_free0 (player); } } player_collection = (_vala_array_free (player_collection, player_collection_length1, (GDestroyNotify) g_free), NULL); } _tmp12_ = players; _tmp13_ = app_desktop_name; g_variant_builder_add (_tmp12_, "s", _tmp13_, NULL); _tmp14_ = self->priv->settings; _tmp15_ = players; _tmp16_ = g_variant_builder_end (_tmp15_); _tmp17_ = g_variant_ref_sink (_tmp16_); g_settings_set_value (_tmp14_, key, _tmp17_); _g_variant_unref0 (_tmp17_); _tmp18_ = self->priv->settings; g_settings_apply (_tmp18_); _g_variant_builder_unref0 (players); }
static void update_metadata (void * data, GObject * object) { char * title = NULL, * artist = NULL, * album = NULL, * file = NULL; int length = 0; int playlist = aud_playlist_get_playing (); int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1; if (entry >= 0) { aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE); file = aud_playlist_entry_get_filename (playlist, entry); length = aud_playlist_entry_get_length (playlist, entry, TRUE); } /* pointer comparison works for pooled strings */ if (title == last_title && artist == last_artist && album == last_album && file == last_file && length == last_length) { str_unref (title); str_unref (artist); str_unref (album); str_unref (file); return; } if (file != last_file) { if (image_file) aud_art_unref (last_file); image_file = file ? aud_art_get_file (file) : NULL; } str_unref (last_title); str_unref (last_artist); str_unref (last_album); str_unref (last_file); last_title = title; last_artist = artist; last_album = album; last_file = file; last_length = length; GVariant * elems[7]; int nelems = 0; if (title) { GVariant * key = g_variant_new_string ("xesam:title"); GVariant * str = g_variant_new_string (title); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (artist) { GVariant * key = g_variant_new_string ("xesam:artist"); GVariant * str = g_variant_new_string (artist); GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1); GVariant * var = g_variant_new_variant (array); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (album) { GVariant * key = g_variant_new_string ("xesam:album"); GVariant * str = g_variant_new_string (album); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (file) { GVariant * key = g_variant_new_string ("xesam:url"); GVariant * str = g_variant_new_string (file); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (length > 0) { GVariant * key = g_variant_new_string ("mpris:length"); GVariant * val = g_variant_new_int64 ((int64_t) length * 1000); GVariant * var = g_variant_new_variant (val); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (image_file) { GVariant * key = g_variant_new_string ("mpris:artUrl"); GVariant * str = g_variant_new_string (image_file); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } GVariant * key = g_variant_new_string ("mpris:trackid"); GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack"); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); if (! metadata_type) metadata_type = g_variant_type_new ("{sv}"); GVariant * array = g_variant_new_array (metadata_type, elems, nelems); g_object_set (object, "metadata", array, NULL); }
static void test_g_variant_type (void) { g_autoptr(GVariantType) val = g_variant_type_new ("s"); g_assert (val != NULL); }
static void setup_dialog_load_config (SetupDialog *dialog) { GVariant *values; GdkColor defcol; GtkCellRenderer *renderer; values = ibus_config_get_values (dialog->config, dialog->section); /* ibus_config_get_values may return NULL on failure */ if (values == NULL) { GVariantType *child_type = g_variant_type_new ("{sv}"); values = g_variant_new_array (child_type, NULL, 0); g_variant_type_free (child_type); } /* General -> Pre-edit Appearance */ /* foreground color of pre-edit buffer */ _gdk_color_from_uint (PREEDIT_FOREGROUND, &defcol); load_color (values, GTK_TOGGLE_BUTTON (dialog->checkbutton_foreground), GTK_COLOR_BUTTON (dialog->colorbutton_foreground), "preedit_foreground", &defcol); g_signal_connect (dialog->checkbutton_foreground, "toggled", G_CALLBACK (on_foreground_toggled), dialog); /* background color of pre-edit buffer */ _gdk_color_from_uint (PREEDIT_BACKGROUND, &defcol); load_color (values, GTK_TOGGLE_BUTTON (dialog->checkbutton_background), GTK_COLOR_BUTTON (dialog->colorbutton_background), "preedit_background", &defcol); g_signal_connect (dialog->checkbutton_background, "toggled", G_CALLBACK (on_background_toggled), dialog); /* underline of pre-edit buffer */ load_choice (values, GTK_COMBO_BOX (dialog->combobox_underline), "preedit_underline", IBUS_ATTR_UNDERLINE_NONE); /* General -> Other */ /* lookup table orientation */ load_choice (values, GTK_COMBO_BOX (dialog->combobox_orientation), "lookup_table_orientation", IBUS_ORIENTATION_SYSTEM); /* Advanced -> m17n-lib configuration */ dialog->store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); insert_m17n_items (dialog->store, dialog->lang, dialog->name); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview), GTK_TREE_MODEL (dialog->store)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->treeview), -1, "Key", renderer, "text", COLUMN_KEY, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->treeview), -1, "Value", renderer, "text", COLUMN_VALUE, NULL); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (on_edited), dialog); g_signal_connect (dialog->treeview, "query-tooltip", G_CALLBACK (on_query_tooltip), NULL); g_variant_unref (values); }