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); }
void storage_sync(const char *imsi, const char *store, GKeyFile *keyfile) { char *path; char *data; gsize length = 0; if (imsi) path = g_strdup_printf(STORAGEDIR "/%s/%s", imsi, store); else path = g_strdup_printf(STORAGEDIR "/%s", store); if (path == NULL) return; if (create_dirs(path, S_IRUSR | S_IWUSR | S_IXUSR) != 0) { g_free(path); return; } data = g_key_file_to_data(keyfile, &length, NULL); g_file_set_contents(path, data, length, NULL); g_free(data); g_free(path); }
void config_write() { assert(m_config_file != NULL); GKeyFile * kf = g_key_file_new(); g_key_file_set_integer(kf, "StatusIcon", "stepsize", m_stepsize); g_key_file_set_boolean(kf, "StatusIcon", "lmb_slider", m_lmb_slider); g_key_file_set_boolean(kf, "StatusIcon", "mmb_mute", m_mmb_mute); g_key_file_set_boolean(kf, "StatusIcon", "use_horizontal_slider", m_use_horizontal_slider); g_key_file_set_boolean(kf, "StatusIcon", "show_sound_level", m_show_sound_level); g_key_file_set_boolean(kf, "Hotkeys", "up_enabled", m_hotkey_up_enabled); g_key_file_set_boolean(kf, "Hotkeys", "down_enabled", m_hotkey_down_enabled); g_key_file_set_boolean(kf, "Hotkeys", "mute_enabled", m_hotkey_mute_enabled); if(m_helper_program) g_key_file_set_value(kf, "StatusIcon", "onclick", m_helper_program); if(m_theme) g_key_file_set_value(kf, "StatusIcon", "theme", m_theme); if(m_card) g_key_file_set_value(kf, "Alsa", "card", m_card); if(m_channel) g_key_file_set_value(kf, "Alsa", "channel", m_channel); if(m_hotkey_up) g_key_file_set_value(kf, "Hotkeys", "up", m_hotkey_up); if(m_hotkey_down) g_key_file_set_value(kf, "Hotkeys", "down", m_hotkey_down); if(m_hotkey_mute) g_key_file_set_value(kf, "Hotkeys", "mute", m_hotkey_mute); gsize length; gchar * data = g_key_file_to_data(kf, &length, NULL); g_file_set_contents(m_config_file, data, -1, NULL); g_free(data); g_key_file_free(kf); }
static void encodeGKeyFile(ArgumentEncoder* encoder, GKeyFile* keyFile) { gsize dataSize; GOwnPtr<char> data(g_key_file_to_data(keyFile, &dataSize, 0)); DataReference dataReference(reinterpret_cast<uint8_t*>(data.get()), dataSize); encoder->encode(dataReference); }
static void save_greeter_settings (void) { char *str, *tfname; char buffer[256]; GKeyFile *kf; gsize len; gint handle; // read in data from file to a key file kf = g_key_file_new (); if (!g_key_file_load_from_file (kf, GREETER_CONFIG_FILE, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL)) return; // update changed values in the key file sprintf (buffer, "%s", gdk_color_to_string (&desktop_colour)); g_key_file_set_string (kf, "greeter", "desktop_bg", buffer); g_key_file_set_string (kf, "greeter", "wallpaper", desktop_picture); g_key_file_set_string (kf, "greeter", "wallpaper_mode", desktop_mode); g_key_file_set_string (kf, "greeter", "gtk-font-name", desktop_font); g_key_file_set_string (kf, "greeter", "gtk-theme-name", "PiX"); g_key_file_set_string (kf, "greeter", "gtk-icon-theme-name", "PiX"); // write the modified key file out to a temp file str = g_key_file_to_data (kf, &len, NULL); handle = g_file_open_tmp ("XXXXXX", &tfname, NULL); write (handle, str, len); close (handle); g_free (str); // copy the temp file to the correct place with sudo sprintf (buffer, "sudo cp %s %s", tfname, GREETER_CONFIG_FILE); system (buffer); }
void cid_write_keys_to_file (GKeyFile *pKeyFile, const gchar *cConfFilePath) { cid_debug ("%s (%s)", __func__, cConfFilePath); GError *erreur = NULL; gchar *cDirectory = g_path_get_dirname (cConfFilePath); if (! g_file_test (cDirectory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_EXECUTABLE)) { g_mkdir_with_parents (cDirectory, 7*8*8+7*8+5); } g_free (cDirectory); gsize length; gchar *cNewConfFilePath = g_key_file_to_data (pKeyFile, &length, &erreur); if (erreur != NULL) { cid_warning ("Error while fetching data : %s", erreur->message); g_error_free (erreur); return ; } g_file_set_contents (cConfFilePath, cNewConfFilePath, length, &erreur); if (erreur != NULL) { cid_warning ("Error while writing data : %s", erreur->message); g_error_free (erreur); return ; } }
static gchar * prefsToData (PrettyPrintingOptions* ppo, gsize* size, GError** error) { GKeyFile *kf; gchar *contents; kf = g_key_file_new (); g_key_file_set_string (kf, "pretty-printer", "newLineChars", ppo->newLineChars); g_key_file_set_integer (kf, "pretty-printer", "indentChar", (int)ppo->indentChar); g_key_file_set_integer (kf, "pretty-printer", "indentLength", ppo->indentLength); g_key_file_set_boolean (kf, "pretty-printer", "oneLineText", ppo->oneLineText); g_key_file_set_boolean (kf, "pretty-printer", "inlineText", ppo->inlineText); g_key_file_set_boolean (kf, "pretty-printer", "oneLineComment", ppo->oneLineComment); g_key_file_set_boolean (kf, "pretty-printer", "inlineComment", ppo->inlineComment); g_key_file_set_boolean (kf, "pretty-printer", "oneLineCdata", ppo->oneLineCdata); g_key_file_set_boolean (kf, "pretty-printer", "inlineCdata", ppo->inlineCdata); g_key_file_set_boolean (kf, "pretty-printer", "emptyNodeStripping", ppo->emptyNodeStripping); g_key_file_set_boolean (kf, "pretty-printer", "emptyNodeStrippingSpace", ppo->emptyNodeStrippingSpace); g_key_file_set_boolean (kf, "pretty-printer", "forceEmptyNodeSplit", ppo->forceEmptyNodeSplit); g_key_file_set_boolean (kf, "pretty-printer", "trimLeadingWhites", ppo->trimLeadingWhites); g_key_file_set_boolean (kf, "pretty-printer", "trimTrailingWhites", ppo->trimTrailingWhites); g_key_file_set_boolean (kf, "pretty-printer", "alignComment", ppo->alignComment); g_key_file_set_boolean (kf, "pretty-printer", "alignText", ppo->alignText); g_key_file_set_boolean (kf, "pretty-printer", "alignCdata", ppo->alignCdata); contents = g_key_file_to_data (kf, size, error); g_key_file_free (kf); return contents; }
void _gtk_print_save_custom_papers (GtkListStore *store) { GtkTreeModel *model = GTK_TREE_MODEL (store); GtkTreeIter iter; GKeyFile *keyfile; gchar *filename, *data; gsize len; gint i = 0; keyfile = g_key_file_new (); if (gtk_tree_model_get_iter_first (model, &iter)) { do { GtkPageSetup *page_setup; gchar group[32]; g_snprintf (group, sizeof (group), "Paper%u", i); gtk_tree_model_get (model, &iter, 0, &page_setup, -1); gtk_page_setup_to_key_file (page_setup, keyfile, group); ++i; } while (gtk_tree_model_iter_next (model, &iter)); } filename = custom_paper_get_filename (); data = g_key_file_to_data (keyfile, &len, NULL); g_file_set_contents (filename, data, len, NULL); g_free (data); g_free (filename); }
bool SaveConfig( const char file[], const Config *cfg ) { FILE* fp; GKeyFile *keyfile; gchar *str; gsize len; bool succ; succ = false; keyfile = g_key_file_new(); g_key_file_set_value( keyfile, kMainSec, kAdapterKey, cfg->adapter ); g_key_file_set_integer( keyfile, kMainSec, kPortKey, cfg->dst_port ); g_key_file_set_integer( keyfile, kMainSec, kFilterKey, cfg->filter ); g_key_file_set_value( keyfile, kMainSec, kFilterWordsKey, cfg->filterwords ); g_key_file_set_integer( keyfile, kMainSec, kFilterIdURLKey, cfg->filteridurl ); g_key_file_set_integer( keyfile, kMainSec, kCheckUpdateKey, cfg->checkupdate ); str = g_key_file_to_data( keyfile, &len, NULL ); fp = fopen( file, "w" ); if( fp != NULL ) { fwrite( str, len, 1, fp ); succ = true; fclose( fp ); }//end if g_free( str ); g_key_file_free( keyfile ); return succ; }//end SaveConfig
static void save_settings(void) { GKeyFile *config = g_key_file_new(); gchar *data; gchar *config_dir = g_path_get_dirname(config_file); g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL); g_key_file_set_boolean(config, "geanyprj", "display_sidebar", display_sidebar); if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0) { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Plugin configuration directory could not be created.")); } else { /* write config to file */ data = g_key_file_to_data(config, NULL, NULL); utils_write_file(config_file, data); g_free(data); } g_free(config_dir); g_key_file_free(config); }
static gboolean serialize_cache (MuContacts *self) { gchar *data; gsize len; gboolean rv; g_hash_table_foreach (self->_hash, (GHFunc) each_keyval, self); /* Note: err arg is unused */ data = g_key_file_to_data (self->_ccache, &len, NULL); if (len) { GError *err; err = NULL; rv = g_file_set_contents (self->_path, data, len, &err); if (!rv) { g_warning ("failed to serialize cache to %s: %s", self->_path, err->message); g_error_free (err); } g_free (data); } return rv; }
static gboolean config_save (TrackerConfigFile *file) { GError *error = NULL; gchar *filename; gchar *data; gsize size; if (!file->key_file) { g_critical ("Could not save config, GKeyFile was NULL, has the config been loaded?"); return FALSE; } #ifdef CONFIG_ENABLE_TRACE g_message ("Setting details to GKeyFile object..."); #endif /* CONFIG_ENABLE_TRACE */ /* FIXME: Get to GKeyFile from object properties */ #ifdef CONFIG_ENABLE_TRACE g_message ("Saving config to disk..."); #endif /* CONFIG_ENABLE_TRACE */ /* Do the actual saving to disk now */ data = g_key_file_to_data (file->key_file, &size, &error); if (error) { g_warning ("Could not get config data to write to file, %s", error->message); g_error_free (error); return FALSE; } filename = g_file_get_path (file->file); g_file_set_contents (filename, data, size, &error); g_free (data); if (error) { g_warning ("Could not write %" G_GSIZE_FORMAT " bytes to file '%s', %s", size, filename, error->message); g_free (filename); g_error_free (error); return FALSE; } #ifdef CONFIG_ENABLE_TRACE g_message ("Wrote config to '%s' (%" G_GSIZE_FORMAT " bytes)", filename, size); #endif /* CONFIG_ENABLE_TRACE */ g_free (filename); return TRUE; }
/** * Write a key to blow.ini * @param [in] section configuration section * @param [in] key configuration key * @param [in] value value to write * @param [in] filepath file path to blow.ini * @return 1 if everything is ok -1 if not * * Example Usage: * @code * // Set the plain_prefix variable as "+zbr " * WritePrivateProfileString("FiSH", "plain_prefix", "+zbr ", iniPath); * @endcode */ int WritePrivateProfileString(const char *section, const char *key, const char *value, const char *filepath) { GKeyFile *key_file; GError *error = NULL; FILE *outfile = NULL; gsize length = 0; gchar *config = NULL; key_file = g_key_file_new(); (void) g_key_file_load_from_file(key_file, filepath, G_KEY_FILE_NONE, NULL); g_key_file_set_string(key_file, section, key, value); // Get the content of the config to a string... config = g_key_file_to_data(key_file, &length, &error); if (error == NULL) { // If everything is ok... outfile = fopen(filepath, "w"); if (outfile != NULL) { (void) fwrite(config, sizeof(gchar), (size_t) length, outfile); (void) fclose(outfile); } } g_free(config); g_key_file_free(key_file); if ((error != NULL) || (outfile == NULL)) { return -1; } return 1; }
static void write_proximity_config(struct btd_device *device, const char *alert, const char *level) { char *filename; GKeyFile *key_file; char *data; gsize length = 0; filename = btd_device_get_storage_path(device, "proximity"); key_file = g_key_file_new(); g_key_file_load_from_file(key_file, filename, 0, NULL); if (level) g_key_file_set_string(key_file, alert, "Level", level); else g_key_file_remove_group(key_file, alert, NULL); data = g_key_file_to_data(key_file, &length, NULL); if (length > 0) { create_file(filename, S_IRUSR | S_IWUSR); g_file_set_contents(filename, data, length, NULL); } g_free(data); g_free(filename); g_key_file_free(key_file); }
void ol_config_save (OlConfig *config) { OlConfigPrivate *priv = OL_CONFIG_GET_PRIVATE (config); gsize len; char *file_content = g_key_file_to_data (priv->config, &len, NULL); g_file_set_contents (ol_config_get_path (), file_content, len, NULL); }
static gboolean save_password_file (TrackerPasswordProviderKeyfile *kf, GError **error) { TrackerPasswordProviderKeyfilePrivate *priv; gchar *filename; gchar *directory; gchar *data; gsize size; directory = config_dir_ensure_exists_and_return (error); if (!directory) { return FALSE; } filename = g_build_filename (directory, KEYFILE_FILENAME, NULL); g_free (directory); priv = TRACKER_PASSWORD_PROVIDER_KEYFILE_GET_PRIVATE (kf); data = g_key_file_to_data (priv->password_file, &size, NULL); g_file_set_contents (filename, data, size, error); g_free (data); g_free (filename); return *error == NULL ? TRUE : FALSE; }
/* Custom function to save the keyfile to disk. If the file does not exist, it will be created */ gboolean g_key_file_save_to_file(GKeyFile *kf, const gchar *file) { GError *error = NULL; gsize length, nr; char *data = g_key_file_to_data(kf, &length, &error); GIOChannel *gio; if (!data) return FALSE; gio = g_io_channel_new_file(file, "w+", &error); if (!gio) { GMAMEUI_DEBUG ("Could not save key file %s: %s", file, error->message); g_error_free (error); error = NULL; g_free(data); return FALSE; } g_io_channel_write_chars(gio, data, length, &nr, &error); g_free(data); g_io_channel_unref(gio); return TRUE; }
static void ep_key_file_save (void) { gchar *contents; gchar *filename; gchar *pathname; gsize length = 0; GError *error = NULL; if (!check_key_file (G_STRFUNC)) return; filename = ep_key_file_get_filename (); contents = g_key_file_to_data (key_file, &length, &error); pathname = g_path_get_dirname (filename); if (!error) { g_mkdir_with_parents (pathname, 0700); g_file_set_contents (filename, contents, length, &error); } g_free (pathname); if (error != NULL) { g_warning ("%s: %s", filename, error->message); g_error_free (error); } g_free (contents); g_free (filename); }
void create_custom_theme (const char *parent) { GKeyFile *keyfile; char *data; char *path; /* Create the custom directory */ path = custom_theme_dir_path (NULL); g_mkdir_with_parents (path, 0755); g_free (path); /* Set the data for index.theme */ keyfile = g_key_file_new (); g_key_file_set_string (keyfile, "Sound Theme", "Name", _("Custom")); g_key_file_set_string (keyfile, "Sound Theme", "Inherits", parent); g_key_file_set_string (keyfile, "Sound Theme", "Directories", "."); data = g_key_file_to_data (keyfile, NULL, NULL); g_key_file_free (keyfile); /* Save the index.theme */ path = custom_theme_dir_path ("index.theme"); g_file_set_contents (path, data, -1, NULL); g_free (path); g_free (data); custom_theme_update_time (); }
bool_t save_preset_file (EqualizerPreset * preset, const char * filename) { GKeyFile *rcfile; int i; char *data; gsize len; GError *error = NULL; rcfile = g_key_file_new(); g_key_file_set_double(rcfile, "Equalizer preset", "Preamp", preset->preamp); for (i = 0; i < 10; i++) { char tmp[7]; g_snprintf(tmp, sizeof(tmp), "Band%d", i); g_key_file_set_double(rcfile, "Equalizer preset", tmp, preset->bands[i]); } data = g_key_file_to_data(rcfile, &len, &error); bool_t success = FALSE; VFSFile * file = vfs_fopen (filename, "w"); if (file == NULL) goto DONE; if (vfs_fwrite (data, 1, strlen (data), file) == strlen (data)) success = TRUE; vfs_fclose (file); DONE: g_free(data); g_key_file_free(rcfile); return success; }
static void _save_prefs(void) { gsize g_data_size; char *g_prefs_data = g_key_file_to_data(prefs, &g_data_size, NULL); g_file_set_contents(prefs_loc, g_prefs_data, g_data_size, NULL); }
gchar * gst_validate_media_info_to_string (GstValidateMediaInfo * mi, gsize * length) { GKeyFile *kf = g_key_file_new (); gchar *data = NULL; gchar *str; /* file info */ g_key_file_set_string (kf, "file-info", "uri", mi->uri); g_key_file_set_uint64 (kf, "file-info", "file-size", mi->file_size); /* media info */ g_key_file_set_uint64 (kf, "media-info", "file-duration", mi->duration); g_key_file_set_boolean (kf, "media-info", "seekable", mi->seekable); g_key_file_set_boolean (kf, "media-info", "is-image", mi->is_image); if (mi->stream_info && mi->stream_info->caps) { str = gst_caps_to_string (mi->stream_info->caps); g_key_file_set_string (kf, "media-info", "caps", str); g_free (str); } /* playback tests */ g_key_file_set_string (kf, "playback-tests", "playback-error", mi->playback_error ? mi->playback_error : ""); g_key_file_set_string (kf, "playback-tests", "reverse-playback-error", mi->reverse_playback_error ? mi->reverse_playback_error : ""); g_key_file_set_string (kf, "playback-tests", "track-switch-error", mi->track_switch_error ? mi->track_switch_error : ""); data = g_key_file_to_data (kf, length, NULL); g_key_file_free (kf); return data; }
static void save_lxsession_settings (void) { const char *session_name; char *user_config_file, *str; char colbuf[128]; GKeyFile *kf; gsize len; // construct the file path session_name = g_getenv ("DESKTOP_SESSION"); if (!session_name) session_name = DEFAULT_SES; user_config_file = g_build_filename (g_get_user_config_dir (), "lxsession/", session_name, "/desktop.conf", NULL); // read in data from file to a key file kf = g_key_file_new (); if (!g_key_file_load_from_file (kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL)) { g_free (user_config_file); return; } // update changed values in the key file sprintf (colbuf, "selected_bg_color:%s\nselected_fg_color:%s\nbar_bg_color:%s\nbar_fg_color:%s\n", gdk_color_to_string (&theme_colour), gdk_color_to_string (&themetext_colour), gdk_color_to_string (&bar_colour), gdk_color_to_string (&bartext_colour)); g_key_file_set_string (kf, "GTK", "sGtk/ColorScheme", colbuf); g_key_file_set_string (kf, "GTK", "sGtk/FontName", desktop_font); // write the modified key file out str = g_key_file_to_data (kf, &len, NULL); g_file_set_contents (user_config_file, str, len, NULL); g_free (user_config_file); g_free (str); }
/* create basic conffile with sensible defaults */ static void create_conf_file(void) { GKeyFile *settingsfile; gchar *keyfile; int dir = 1; struct stat dir_stat; /* since this function can also be called when the dir exists we only create it if it is missing */ if(stat(CONFIG_FILE_DIR, &dir_stat)) { dir = mkdir(CONFIG_FILE_DIR, 0755); if(dir < 0) { log_warning("Could not create confdir, continuing without configuration!\n"); /* no point in trying to generate the config file if the dir cannot be created */ return; } } settingsfile = g_key_file_new(); g_key_file_set_string(settingsfile, MODE_SETTING_ENTRY, MODE_SETTING_KEY, MODE_DEVELOPER ); keyfile = g_key_file_to_data (settingsfile, NULL, NULL); if(g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL) == 0) log_debug("Conffile creation failed. Continuing without configuration!\n"); free(keyfile); g_key_file_free(settingsfile); }
static void set_lxsession_theme (const char *theme) { const char *session_name; char *user_config_file, *str; GKeyFile *kf; gsize len; // construct the file path session_name = g_getenv ("DESKTOP_SESSION"); if (!session_name) session_name = DEFAULT_SES; user_config_file = g_build_filename (g_get_user_config_dir (), "lxsession/", session_name, "/desktop.conf", NULL); // read in data from file to a key file kf = g_key_file_new (); if (!g_key_file_load_from_file (kf, user_config_file, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL)) { g_free (user_config_file); return; } // update changed values in the key file g_key_file_set_string (kf, "GTK", "sNet/ThemeName", theme); // write the modified key file out str = g_key_file_to_data (kf, &len, NULL); g_file_set_contents (user_config_file, str, len, NULL); g_free (user_config_file); g_free (str); }
set_config_result_t set_config_setting(const char *entry, const char *key, const char *value) { GKeyFile *settingsfile; gboolean test = FALSE; set_config_result_t ret = SET_CONFIG_ERROR; gchar *keyfile; settingsfile = g_key_file_new(); test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL); if(test) { if(config_value_changed(settingsfile, entry, key, value)) { g_key_file_free(settingsfile); return SET_CONFIG_UNCHANGED; } } else { log_debug("No conffile. Creating.\n"); create_conf_file(); } g_key_file_set_string(settingsfile, entry, key, value); keyfile = g_key_file_to_data (settingsfile, NULL, NULL); /* free the settingsfile before writing things out to be sure the contents will be correctly written to file afterwards. Just a precaution. */ g_key_file_free(settingsfile); if (g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL)) ret = SET_CONFIG_UPDATED; g_free(keyfile); return (ret); }
static gboolean save_in_idle_cb (const gchar *keyfile_filename) { KeyfileMetadataData *data; gchar *contents; gsize length; GError *error = NULL; data = g_hash_table_lookup (data_hash, keyfile_filename); data->save_in_idle_id = 0; contents = g_key_file_to_data (data->keyfile, &length, NULL); if (contents != NULL) { g_file_set_contents (keyfile_filename, contents, length, &error); g_free (contents); } if (error != NULL) { g_warning ("Couldn't save the desktop metadata keyfile to disk: %s", error->message); g_error_free (error); } return FALSE; }
void __connman_storage_close(const char *ident, GKeyFile *keyfile, gboolean save) { gchar *pathname, *data = NULL; gsize length = 0; _DBG_STORAGE("ident %s keyfile %p save %d", ident, keyfile, save); if (save == FALSE) { g_key_file_free(keyfile); return; } pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident); if (pathname == NULL) return; data = g_key_file_to_data(keyfile, &length, NULL); if (g_file_set_contents(pathname, data, length, NULL) == FALSE) connman_error("Failed to store information"); g_free(data); g_free(pathname); g_key_file_free(keyfile); }
void keystore_save(struct keystore_t *keystore) { g_assert(keystore); GKeyFile *keyfile = g_key_file_new(); if (NULL != keystore->aes) { g_hash_table_foreach(keystore->aes, keystore_save_aeskey, keyfile); } if (NULL != keystore->rsa) { g_hash_table_foreach(keystore->rsa, keystore_save_rsakey, keyfile); } /* save to disk */ if (0 == g_mkdir_with_parents(SECURITY_KEYSTORE_DIR, 0700)) { gsize length = 0; gchar *keystore_data = g_key_file_to_data(keyfile, &length, NULL); if (!g_file_set_contents(SECURITY_KEYSTORE_PATH, keystore_data, length, NULL)) { nyx_debug("%s: g_file_set_contents error", __FUNCTION__); } g_free(keystore_data); } g_key_file_free(keyfile); }
static void remmina_pref_gen_secret (void) { guchar s[32]; gint i; GTimeVal gtime; GKeyFile *gkeyfile; gchar *content; gsize length; g_get_current_time (>ime); srand (gtime.tv_sec); for (i = 0; i < 32; i++) { s[i] = (guchar) (rand () % 256); } remmina_pref.secret = g_base64_encode (s, 32); gkeyfile = g_key_file_new (); g_key_file_load_from_file (gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL); g_key_file_set_string (gkeyfile, "remmina_pref", "secret", remmina_pref.secret); 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); }