/* check key and group listing */ void test_listing (void) { gchar **names; gsize len; gchar *start; GError *error = NULL; const gchar *data = "[group1]\n" "key1=value1\n" "key2=value2\n" "[group2]\n" "key3=value3\n" "key4=value4\n"; cut_assert (g_key_file_load_from_data (keyfile, data, -1, 0, NULL)); names = g_key_file_get_groups (keyfile, &len); cut_assert (names); check_length ("groups", g_strv_length (names), len, 2); check_name ("group name", names[0], "group1", 0); check_name ("group name", names[1], "group2", 1); g_strfreev (names); names = g_key_file_get_keys (keyfile, "group1", &len, &error); check_no_error (error); check_length ("keys", g_strv_length (names), len, 2); check_name ("key", names[0], "key1", 0); check_name ("key", names[1], "key2", 1); g_strfreev (names); names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error); check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND); g_strfreev (names); cut_assert (g_key_file_has_group (keyfile, "group1") && g_key_file_has_group (keyfile, "group2") && !g_key_file_has_group (keyfile, "group10") && !g_key_file_has_group (keyfile, "group2 "), cut_message ("Group finding trouble")); start = g_key_file_get_start_group (keyfile); cut_assert_equal_string ("group1", start); g_free (start); cut_assert (g_key_file_has_key (keyfile, "group1", "key1", &error) && g_key_file_has_key (keyfile, "group2", "key3", &error) && !g_key_file_has_key (keyfile, "group2", "no-such-key", &error), cut_message ("Key finding trouble")); check_no_error (error); g_key_file_has_key (keyfile, "no-such-group", "key", &error); check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND); }
static gboolean _nm_keyfile_equals_ordered (GKeyFile *kf_a, GKeyFile *kf_b) { gs_strfreev char **groups = NULL; gs_strfreev char **groups_b = NULL; guint i, j; if (kf_a == kf_b) return TRUE; if (!kf_a || !kf_b) return FALSE; groups = g_key_file_get_groups (kf_a, NULL); groups_b = g_key_file_get_groups (kf_b, NULL); if (!groups && !groups_b) return TRUE; if (!groups || !groups_b) return FALSE; for (i = 0; groups[i] && groups_b[i] && !strcmp (groups[i], groups_b[i]); i++) ; if (groups[i] || groups_b[i]) return FALSE; for (i = 0; groups[i]; i++) { gs_strfreev char **keys = NULL; gs_strfreev char **keys_b = NULL; keys = g_key_file_get_keys (kf_a, groups[i], NULL, NULL); keys_b = g_key_file_get_keys (kf_b, groups[i], NULL, NULL); if ((!keys) != (!keys_b)) return FALSE; if (!keys) continue; for (j = 0; keys[j] && keys_b[j] && !strcmp (keys[j], keys_b[j]); j++) ; if (keys[j] || keys_b[j]) return FALSE; for (j = 0; keys[j]; j++) { gs_free char *key_a = g_key_file_get_value (kf_a, groups[i], keys[j], NULL); gs_free char *key_b = g_key_file_get_value (kf_b, groups[i], keys[j], NULL); if (g_strcmp0 (key_a, key_b) != 0) return FALSE; } } return TRUE; }
nyx_error_t keystore_load(struct keystore_t *keystore) { if (FALSE == g_file_test(SECURITY_KEYSTORE_PATH, G_FILE_TEST_EXISTS)) { return NYX_ERROR_NONE; } GKeyFile *keyfile = g_key_file_new(); GKeyFileFlags flags = G_KEY_FILE_NONE; if (!g_key_file_load_from_file(keyfile, SECURITY_KEYSTORE_PATH, flags, NULL)) { nyx_debug("%s: g_key_file_load_from_file error", __FUNCTION__); g_key_file_free(keyfile); return NYX_ERROR_GENERIC; } int i; /* load aes keys */ gchar **aes_keys = g_key_file_get_keys(keyfile, "aes", NULL, NULL); if (NULL != aes_keys) { for (i = 0; aes_keys[i] != NULL; ++i) { keystore_load_aeskey(keyfile, aes_keys[i], keystore); } g_strfreev(aes_keys); } /* load rsa keys */ gchar **rsa_keys = g_key_file_get_keys(keyfile, "rsa", NULL, NULL); if (NULL != rsa_keys) { for (i = 0; rsa_keys[i] != NULL; ++i) { keystore_load_rsakey(keyfile, rsa_keys[i], keystore); } g_strfreev(rsa_keys); } g_key_file_free(keyfile); return NYX_ERROR_NONE; }
gboolean _nm_keyfile_a_contains_all_in_b (GKeyFile *kf_a, GKeyFile *kf_b) { gs_strfreev char **groups = NULL; guint i, j; if (kf_a == kf_b) return TRUE; if (!kf_a || !kf_b) return FALSE; groups = g_key_file_get_groups (kf_a, NULL); for (i = 0; groups && groups[i]; i++) { gs_strfreev char **keys = NULL; keys = g_key_file_get_keys (kf_a, groups[i], NULL, NULL); if (!keys) continue; for (j = 0; keys[j]; j++) { gs_free char *key_a = g_key_file_get_value (kf_a, groups[i], keys[j], NULL); gs_free char *key_b = g_key_file_get_value (kf_b, groups[i], keys[j], NULL); if (g_strcmp0 (key_a, key_b) != 0) return FALSE; } } return TRUE; }
void _nm_keyfile_copy (GKeyFile *dst, GKeyFile *src) { gs_strfreev char **groups = NULL; guint g, k; groups = g_key_file_get_groups (src, NULL); for (g = 0; groups && groups[g]; g++) { const char *group = groups[g]; gs_strfreev char **keys = NULL; keys = g_key_file_get_keys (src, group, NULL, NULL); if (!keys) continue; for (k = 0; keys[k]; k++) { const char *key = keys[k]; gs_free char *value = NULL; value = g_key_file_get_value (src, group, key, NULL); if (value) g_key_file_set_value (dst, group, key, value); else g_key_file_remove_key (dst, group, key, NULL); } } }
static gboolean roccat_orig_timer_import_iterate_keys(GKeyFile *roccat_orig_timer_file, RoccatTimers *timers, GError **error) { gchar **key_names, **key_name; RoccatOrigTimer *roccat_orig_timer; RoccatTimer *timer; key_names = g_key_file_get_keys(roccat_orig_timer_file, group_name, NULL, error); for (key_name = key_names; *key_name; ++key_name) { if (strcmp(*key_name, counter_name)) { roccat_orig_timer = roccat_key_file_get_binary(roccat_orig_timer_file, group_name, *key_name, sizeof(RoccatOrigTimer), error); if (*error) goto free_keys; timer = roccat_timer_new(); roccat_timer_set_seconds(timer, roccat_orig_timer_get_seconds(roccat_orig_timer)); roccat_timer_set_name(timer, (gchar const *)roccat_orig_timer->name); roccat_timers_set(timers, timer); roccat_timer_free(timer); g_free(roccat_orig_timer); } } g_strfreev(key_names); return TRUE; free_keys: g_strfreev(key_names); return FALSE; }
static const char * get_conf_string(const gchar *entry, const gchar *key) { GKeyFile *settingsfile; gboolean test = FALSE; gchar **keys, *tmp_char = NULL; const char *ret = NULL; settingsfile = g_key_file_new(); test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL); if(!test) { log_debug("No conffile. Creating\n"); create_conf_file(); } keys = g_key_file_get_keys (settingsfile, entry, NULL, NULL); if(keys == NULL) return ret; while (*keys != NULL) { if(!strcmp(*keys, key)) { tmp_char = g_key_file_get_string(settingsfile, entry, *keys, NULL); if(tmp_char) { log_debug("key %s value = %s\n", key, tmp_char); } } keys++; } g_key_file_free(settingsfile); return(g_strdup(tmp_char)); }
/** * @brief Reads key/value pairs (strings) from a GKeyFile into a GHashtable. * * Will free the GKeyFile. * * @param gkeyfile GKeyFile to use, will be freed. * * @return A GHashTable, mirroring the file or NULL in case of an error. */ static GHashTable * hash_table_from_gkeyfile (GKeyFile * gkeyfile) { gchar **keys; gchar **keys_it; gsize length; GHashTable *returntable = NULL; if (!gkeyfile) return NULL; returntable = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); keys = g_key_file_get_keys (gkeyfile, GROUP_NONE, &length, NULL); keys_it = keys; // Add each key / value pair from file while (keys_it != NULL && (*keys_it) != NULL) { char *value = g_key_file_get_value (gkeyfile, GROUP_NONE, (*keys_it), NULL); g_hash_table_insert (returntable, estrdup (*keys_it), value); ++keys_it; } if (keys != NULL) g_strfreev (keys); g_key_file_free (gkeyfile); return returntable; }
static void maki_instance_load_plugins (makiInstance* inst) { gchar** plugins; guint plugins_len; guint i; plugins = g_key_file_get_keys(inst->key_file, "plugins", NULL, NULL); if (plugins == NULL) { return; } plugins_len = g_strv_length(plugins); for (i = 0; i < plugins_len; i++) { GModule* module; if (!g_key_file_get_boolean(inst->key_file, "plugins", plugins[i], NULL)) { continue; } if ((module = maki_plugin_load(plugins[i])) != NULL) { g_hash_table_insert(inst->plugins, g_strdup(plugins[i]), module); } } g_strfreev(plugins); }
void write_item_ex_info( FILE* of, const char* desktop_file ) { gsize len; GKeyFile* kf = g_key_file_new(); if( g_key_file_load_from_file( kf, desktop_file, 0, NULL ) ) { char** keys = g_key_file_get_keys( kf, "Desktop Entry", &len, NULL ); char** key; char* val; char** vals; gsize n_vals; for( key = keys; *key; ++key ) { if( g_str_has_prefix( *key, "X-" ) ) { char* val = g_key_file_get_value( kf, "Desktop Entry", *key, NULL ); fprintf( of, "%s=%s\n", *key, val ); g_free( val ); } } g_strfreev( keys ); } g_key_file_free( kf ); }
static GHashTable * gst_camera_settings_load (GKeyFile * file, const char *group) { gsize length = 0; char **keys = NULL; int x; GHashTable *table = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); keys = g_key_file_get_keys (file, group, &length, NULL); for (x = 0; x < length; x++) { char *key_str = keys[x]; int key = atoi (keys[x]); gchar *value = g_key_file_get_string (file, group, key_str, NULL); g_hash_table_insert (table, GINT_TO_POINTER (key), value); } if (keys) { g_strfreev (keys); } return table; }
/* Load a section from a keyfile to a hash-table (replace existing keys in the hash) */ static void section_to_hash (GKeyFile *file, const gchar *section, GHashTable *hash) { GError *error; gchar **keys; gint i; error = NULL; keys = g_key_file_get_keys (file, section, NULL, &error); if (error) { g_printf ("Error: Couldn't load configuration section %s!\n", section); } for (i = 0; keys[i] != NULL; i++) { gchar *uncompressed_value; uncompressed_value = g_key_file_get_value (file, section, keys[i], NULL); g_hash_table_insert (hash, g_strdup (keys[i]), g_strcompress (uncompressed_value)); g_free (uncompressed_value); } g_strfreev (keys); }
static GHashTable * load_language_mappings_group (GKeyFile *key_file, const gchar *group) { GHashTable *table; gchar **keys; gsize length = 0; int i; table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); keys = g_key_file_get_keys (key_file, group, &length, NULL); gedit_debug_message (DEBUG_PLUGINS, "%" G_GSIZE_FORMAT " mappings in group %s", length, group); for (i = 0; i < length; i++) { /* steal the name string */ gchar *name = keys[i]; gchar *id = g_key_file_get_string (key_file, group, name, NULL); g_hash_table_insert (table, name, id); } g_free (keys); return table; }
void panel_key_file_remove_all_locale_key (GKeyFile *keyfile, const gchar *key) { char **keys; int key_len; int i; if (!key) return; keys = g_key_file_get_keys (keyfile, G_KEY_FILE_DESKTOP_GROUP, NULL, NULL); if (!keys) return; key_len = strlen (key); for (i = 0; keys[i] != NULL; i++) { int len; if (strncmp (keys[i], key, key_len)) continue; len = strlen (keys[i]); if (len == key_len || (len > key_len && keys[i][key_len] == '[')) g_key_file_remove_key (keyfile, G_KEY_FILE_DESKTOP_GROUP, keys[i], NULL); } g_strfreev (keys); }
void remmina_pref_clear_recent (void) { GKeyFile *gkeyfile; gchar **keys; gint i; gchar *content; gsize length; gkeyfile = g_key_file_new (); g_key_file_load_from_file (gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL); keys = g_key_file_get_keys (gkeyfile, "remmina_pref", NULL, NULL); if (keys) { for (i = 0; keys[i]; i++) { if (strncmp (keys[i], "recent_", 7) == 0) { g_key_file_set_string (gkeyfile, "remmina_pref", keys[i], ""); } } g_strfreev (keys); } content = g_key_file_to_data (gkeyfile, &length, NULL); g_file_set_contents (remmina_pref_file, content, length, NULL); g_key_file_free (gkeyfile); g_free (content); }
static void on_load_preferences (Viewer *viewer, GKeyFile *keyfile, void *user_data) { RendererCamThumb *self = user_data; GError *gerr = NULL; char **keys = g_key_file_get_keys (keyfile, RENDERER_NAME, NULL, &gerr); if (gerr) { g_error_free (gerr); return; } for (int i=0; keys[i]; i++) { char *key = keys[i]; cam_renderer_t *cr = g_hash_table_lookup (self->cam_handlers, key); if (!cr) { cr = (cam_renderer_t*) calloc (1, sizeof (cam_renderer_t)); cr->channel = strdup (key); cr->renderer = self; g_hash_table_replace (self->cam_handlers, cr->channel, cr); } char *val = g_key_file_get_string (keyfile, RENDERER_NAME, key, NULL); cr->render_place = 0; cr->expanded = 0; if (val) { sscanf (val, "%d %d", &cr->render_place, &cr->expanded); } } g_strfreev (keys); }
int check_android_section(void) { GKeyFile *settingsfile; gboolean test = FALSE; gchar **keys; int ret = 1; settingsfile = g_key_file_new(); test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL); if(!test) { ret = 0; goto cleanup; } keys = g_key_file_get_keys (settingsfile, ANDROID_ENTRY, NULL, NULL); if(keys == NULL) { ret = 0; goto cleanup; } g_strfreev(keys); cleanup: g_key_file_free(settingsfile); return(ret); }
bool ConfigFile::loadFeatures(int &features, const std::string §ion) { if (!g_key_file_has_group(keyfile, section.c_str())) return false; char **keys = g_key_file_get_keys(keyfile, section.c_str(), NULL, NULL); bool val; int feature; features = TRANSPORT_FEATURE_ALL; for (int i = 0; keys[i]; i++) { std::string key(keys[i]); loadBoolean(val, section, key); if (key == "chatstate") feature = TRANSPORT_FEATURE_TYPING_NOTIFY; else if (key == "avatars") feature = TRANSPORT_FEATURE_AVATARS; else if (key == "filetransfer") feature = TRANSPORT_FEATURE_FILETRANSFER; else if (key == "statistics") feature = TRANSPORT_FEATURE_STATISTICS; else continue; if (val) features = features | feature; else features = features & (~feature); } g_strfreev(keys); return true; }
GList * prefs_get_aliases(void) { if (!g_key_file_has_group(prefs, PREF_GROUP_ALIAS)) { return NULL; } else { GList *result = NULL; gsize len; gchar **keys = g_key_file_get_keys(prefs, PREF_GROUP_ALIAS, &len, NULL); int i; for (i = 0; i < len; i++) { char *name = keys[i]; char *value = g_key_file_get_string(prefs, PREF_GROUP_ALIAS, name, NULL); ProfAlias *alias = malloc(sizeof(struct prof_alias_t)); alias->name = strdup(name); alias->value = strdup(value); result = g_list_insert_sorted(result, alias, (GCompareFunc)_alias_cmp); } g_strfreev(keys); return result; } }
void moloch_config_load_includes(char **includes) { int i, g, k; for (i = 0; includes[i]; i++) { GKeyFile *keyFile = g_key_file_new(); GError *error = 0; gboolean status = g_key_file_load_from_file(keyFile, includes[i], G_KEY_FILE_NONE, &error); if (!status || error) { printf("Couldn't load config includes file (%s) %s\n", includes[i], (error?error->message:"")); exit(1); } gchar **groups = g_key_file_get_groups (keyFile, NULL); for (g = 0; groups[g]; g++) { gchar **keys = g_key_file_get_keys (keyFile, groups[g], NULL, NULL); for (k = 0; keys[k]; k++) { char *value = g_key_file_get_value(keyFile, groups[g], keys[k], NULL); if (value && !error) { g_key_file_set_value(molochKeyFile, groups[g], keys[k], value); g_free(value); } } g_strfreev(keys); } g_strfreev(groups); g_key_file_free(keyFile); } }
static void add_keys(struct vpn_config_provider *config_provider, GKeyFile *keyfile, const char *group) { char **avail_keys; gsize nb_avail_keys, i; avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL); if (!avail_keys) return; for (i = 0 ; i < nb_avail_keys; i++) { char *value = g_key_file_get_value(keyfile, group, avail_keys[i], NULL); if (!value) { connman_warn("Cannot find value for %s", avail_keys[i]); continue; } set_string(config_provider, avail_keys[i], value); g_free(value); } g_strfreev(avail_keys); }
static void add_properties(GHashTable *ht, GKeyFile *kf, const char *group) { g_hash_table_insert(ht, g_strdup(OPENSLIDE_PROPERTY_NAME_VENDOR), g_strdup("hamamatsu")); char **keys = g_key_file_get_keys(kf, group, NULL, NULL); if (keys == NULL) { return; } for (char **key = keys; *key != NULL; key++) { char *value = g_key_file_get_value(kf, group, *key, NULL); if (value) { g_hash_table_insert(ht, g_strdup_printf("hamamatsu.%s", *key), g_strdup(value)); g_free(value); } } g_strfreev(keys); // this allows openslide.objective-power to have a fractional component // but it's better than rounding _openslide_duplicate_double_prop(ht, "hamamatsu.SourceLens", OPENSLIDE_PROPERTY_NAME_OBJECTIVE_POWER); // TODO: can we calculate MPP from PhysicalWidth/PhysicalHeight? }
static void pka_config_dump (void) { gchar **groups; gchar **keys; gchar *key; gchar *value; gint i; gint j; g_return_if_fail(config != NULL); ENTRY; DEBUG(Config, "--- HOST DEFAULTS %s", config_filename); groups = g_key_file_get_groups(config, NULL); for (i = 0; groups[i]; i++) { keys = g_key_file_get_keys(config, groups[i], NULL, NULL); for (j = 0; keys[j]; j++) { key = g_strdup_printf("%s.%s", groups[i], keys[j]); value = g_key_file_get_value(config, groups[i], keys[j], NULL); DEBUG(Config, " %32s = \"%s\"", key, value); g_free(key); g_free(value); } g_strfreev(keys); } g_strfreev(groups); EXIT; }
// list installed version of Erlang void list_erlangs() { GKeyFile* kf = g_key_file_new(); GError* error = NULL; gchar* fn = get_configdir_file_name("config"); if(g_key_file_load_from_file(kf, fn, G_KEY_FILE_NONE, &error)) { if (error != NULL) { g_error("Unable to read file: %s\n", error->message); //g_error_free(error); program exits, can't free } GError* keyerror = NULL; gchar** keys = g_key_file_get_keys(kf, "Erlangs", NULL, &keyerror); if (keyerror != NULL) { g_error("Unable to read Erlangs section from ~/" ERLN8_CONFIG_DIR "/config: %s\n", keyerror->message); //g_error_free(error); } else { gchar** it = keys; while(*it) { GError* valerror = NULL; gchar* v = g_key_file_get_string(kf, "Erlangs", *it, &valerror); printf("%s -> %s\n",*it++, v); g_free(v); } } g_strfreev(keys); g_key_file_free(kf); } else { g_error("Cannot read from ~/" ERLN8_CONFIG_DIR "/config\n"); } g_free(fn); }
static void translate_keyfile_to_json( const char * old_file, const char * new_file ) { tr_benc dict; GKeyFile * keyfile; gchar ** keys; gsize i; gsize length; static struct pref_entry { const char* oldkey; const char* newkey; } renamed[] = { { "default-download-directory", "download-dir" }, { "encrypted-connections-only", "encryption" }, { "listening-port", "peer-port" }, { "nat-traversal-enabled", "port-forwarding-enabled" }, { "open-dialog-folder", "open-dialog-dir" }, { "watch-folder", "watch-dir" }, { "watch-folder-enabled", "watch-dir-enabled" } }; keyfile = g_key_file_new( ); g_key_file_load_from_file( keyfile, old_file, 0, NULL ); length = 0; keys = g_key_file_get_keys( keyfile, "general", &length, NULL ); tr_bencInitDict( &dict, length ); for( i = 0; i < length; ++i ) { guint j; const char * key = keys[i]; gchar * val = g_key_file_get_value( keyfile, "general", key, NULL ); for( j = 0; j < G_N_ELEMENTS( renamed ); ++j ) if( !strcmp( renamed[j].oldkey, key ) ) key = renamed[j].newkey; if( !strcmp( val, "true" ) || !strcmp( val, "false" ) ) tr_bencDictAddInt( &dict, key, !strcmp( val, "true" ) ); else { char * end; long l; errno = 0; l = strtol( val, &end, 10 ); if( !errno && end && !*end ) tr_bencDictAddInt( &dict, key, l ); else tr_bencDictAddStr( &dict, key, val ); } g_free( val ); } g_key_file_free( keyfile ); tr_bencToFile( &dict, TR_FMT_JSON, new_file ); tr_bencFree( &dict ); }
static int get_conf_int(const gchar *entry, const gchar *key) { GKeyFile *settingsfile; gboolean test = FALSE; gchar **keys, **origkeys; int ret = 0; settingsfile = g_key_file_new(); test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL); if(!test) { log_debug("no conffile, Creating\n"); create_conf_file(); } keys = g_key_file_get_keys (settingsfile, entry, NULL, NULL); if(keys == NULL) return ret; origkeys = keys; while (*keys != NULL) { if(!strcmp(*keys, key)) { ret = g_key_file_get_integer(settingsfile, entry, *keys, NULL); log_debug("%s key value = %d\n", key, ret); } keys++; } g_strfreev(origkeys); g_key_file_free(settingsfile); return(ret); }
RemminaFile* remmina_file_load(const gchar *filename) { GKeyFile *gkeyfile; RemminaFile *remminafile; gchar **keys; gchar *key; gint i; gchar *s; gboolean encrypted; gkeyfile = g_key_file_new(); if (!g_key_file_load_from_file(gkeyfile, filename, G_KEY_FILE_NONE, NULL)) return NULL; if (g_key_file_has_key(gkeyfile, "remmina", "name", NULL)) { remminafile = remmina_file_new_empty(); remminafile->filename = g_strdup(filename); keys = g_key_file_get_keys(gkeyfile, "remmina", NULL, NULL); if (keys) { for (i = 0; keys[i]; i++) { key = keys[i]; encrypted = FALSE; remmina_setting_get_group(key, &encrypted); if (encrypted) { s = g_key_file_get_string(gkeyfile, "remmina", key, NULL); if (g_strcmp0(s, ".") == 0) { remmina_file_set_string(remminafile, key, s); } else { remmina_file_set_string_ref(remminafile, key, remmina_crypt_decrypt(s)); } g_free(s); } else { remmina_file_set_string_ref(remminafile, key, g_key_file_get_string(gkeyfile, "remmina", key, NULL)); } } g_strfreev(keys); } } else { remminafile = NULL; } g_key_file_free(gkeyfile); return remminafile; }
static NProplist* n_core_load_params (NCore *core, const char *plugin_name) { g_assert (core != NULL); g_assert (plugin_name != NULL); NProplist *proplist = NULL; GKeyFile *keyfile = NULL; gchar *filename = NULL; gchar *full_path = NULL; gchar **keys = NULL; gchar **iter = NULL; GError *error = NULL; gchar *value = NULL; filename = g_strdup_printf ("%s.ini", plugin_name); full_path = g_build_filename (core->conf_path, PLUGIN_CONF_PATH, filename, NULL); keyfile = g_key_file_new (); if (!g_key_file_load_from_file (keyfile, full_path, G_KEY_FILE_NONE, &error)) { if (error->code & G_KEY_FILE_ERROR_NOT_FOUND) { N_WARNING (LOG_CAT "problem with configuration file '%s': %s", filename, error->message); } goto done; } keys = g_key_file_get_keys (keyfile, plugin_name, NULL, NULL); if (!keys) { N_WARNING (LOG_CAT "no group '%s' within configuration file '%s'", plugin_name, filename); goto done; } proplist = n_proplist_new (); for (iter = keys; *iter; ++iter) { if ((value = g_key_file_get_string (keyfile, plugin_name, *iter, NULL)) == NULL) continue; N_DEBUG (LOG_CAT "+ plugin parameter: %s = %s", *iter, value); n_proplist_set_string (proplist, *iter, value); g_free (value); } g_strfreev (keys); done: if (error) g_error_free (error); if (keyfile) g_key_file_free (keyfile); g_free (full_path); g_free (filename); return proplist; }
static void remmina_pref_init_keymap (void) { GKeyFile *gkeyfile; gchar **groups; gchar **gptr; gchar **keys; gchar **kptr; gsize nkeys; gchar *value; guint *table; guint *tableptr; guint k1, k2; if (remmina_keymap_table) g_hash_table_destroy (remmina_keymap_table); remmina_keymap_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); gkeyfile = g_key_file_new (); if (!g_key_file_load_from_file (gkeyfile, remmina_keymap_file, G_KEY_FILE_NONE, NULL)) { if (!g_key_file_load_from_data (gkeyfile, default_keymap_data, strlen (default_keymap_data), G_KEY_FILE_NONE, NULL)) { g_print ("Failed to initialize keymap table\n"); g_key_file_free (gkeyfile); return; } } groups = g_key_file_get_groups (gkeyfile, NULL); gptr = groups; while (*gptr) { keys = g_key_file_get_keys (gkeyfile, *gptr, &nkeys, NULL); table = g_new0 (guint, nkeys * 2 + 1); g_hash_table_insert (remmina_keymap_table, g_strdup (*gptr), table); kptr = keys; tableptr = table; while (*kptr) { k1 = remmina_pref_get_keyval_from_str (*kptr); if (k1) { value = g_key_file_get_string (gkeyfile, *gptr, *kptr, NULL); k2 = remmina_pref_get_keyval_from_str (value); g_free (value); *tableptr++ = k1; *tableptr++ = k2; } kptr++; } g_strfreev (keys); gptr++; } g_strfreev (groups); }
/* * Write the application configuration to the same file it was read from. * * On I/O problems, FALSE will be returned and error will be set accordingly. */ gboolean ph_config_save(GError **error) { gchar *dirname; gsize length; gboolean success; gboolean empty; gchar **groups, **current_group; g_return_val_if_fail(ph_config != NULL, FALSE); g_return_val_if_fail(error == NULL || *error == NULL, FALSE); /* check if the key file is empty */ empty = TRUE; groups = g_key_file_get_groups(ph_config->key_file, NULL); for (current_group = groups; *current_group != NULL; ++current_group) { gsize length; g_strfreev(g_key_file_get_keys(ph_config->key_file, *current_group, &length, NULL)); if (length > 0) { empty = FALSE; break; } } /* first create the directory, if necessary */ dirname = g_path_get_dirname(ph_config->path); success = (g_mkdir_with_parents(dirname, 0755) == 0); if (!success) g_set_error(error, G_FILE_ERROR, g_file_error_from_errno(errno), "Could not create the configuration directory `%s': %s.", dirname, g_strerror(errno)); g_free(dirname); /* then either write the file or delete it */ if (success) { if (!empty) { gchar *data; data = g_key_file_to_data(ph_config->key_file, &length, NULL); success = g_file_set_contents(ph_config->path, data, length, error); g_free(data); } else if (g_file_test(ph_config->path, G_FILE_TEST_EXISTS)) { success = (g_unlink(ph_config->path) == 0); if (!success) g_set_error(error, G_FILE_ERROR, g_file_error_from_errno(errno), "Could not remove empty configuration file `%s': %s.", ph_config->path, g_strerror(errno)); } } return success; }