Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
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);
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
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 ;
    }
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
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
Ejemplo n.º 10
0
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);
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
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;
}
Ejemplo n.º 13
0
/**
 * 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;
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 17
0
/* 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 ();
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
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;
}
Ejemplo n.º 23
0
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);
}
Ejemplo n.º 24
0
/* 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);
}
Ejemplo n.º 25
0
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);
}
Ejemplo n.º 26
0
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);
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
0
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);
}
Ejemplo n.º 29
0
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);
}
Ejemplo n.º 30
0
static void
remmina_pref_gen_secret (void)
{
    guchar s[32];
    gint i;
    GTimeVal gtime;
    GKeyFile *gkeyfile;
    gchar *content;
    gsize length;

    g_get_current_time (&gtime);
    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);
}