/* 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;
}
