Beispiel #1
0
/* http://bugzilla.gnome.org/show_bug.cgi?id=165887 */
void 
test_group_remove (void)
{
  gchar **names;
  gsize len;
  GError *error = NULL;

  const gchar *data = 
    "[group1]\n"
    "[group2]\n"
    "key1=bla\n"
    "key2=bla\n"
    "[group3]\n"
    "key1=bla\n"
    "key2=bla\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, 3);
  check_name ("group name", names[0], "group1", 0);
  check_name ("group name", names[1], "group2", 1);
  check_name ("group name", names[2], "group3", 2);

  g_key_file_remove_group (keyfile, "group1", &error);
  check_no_error (error);
  
  g_strfreev (names);

  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], "group2", 0);
  check_name ("group name", names[1], "group3", 1);

  g_key_file_remove_group (keyfile, "group2", &error);
  check_no_error (error);
  
  g_strfreev (names);

  names = g_key_file_get_groups (keyfile, &len);
  cut_assert (names);

  check_length ("groups", g_strv_length (names), len, 1);
  check_name ("group name", names[0], "group3", 0);

  g_key_file_remove_group (keyfile, "no such group", &error);
  check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);

  g_strfreev (names);
}
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;
}
static void accountrc_decrypt(const gchar *filename)
{
	GKeyFile *kf = g_key_file_new();
	GError *error = NULL;

	if (! g_key_file_load_from_file(kf, filename, 0, &error)) {
		fprintf(stderr, "Failed to open file: %s\n", error->message);
		g_error_free(error);
	} else {
		gsize n_groups, i;
		gchar **groups = g_key_file_get_groups(kf, &n_groups);

		for (i = 0; i < n_groups; i++) {
			gchar *input = g_key_file_get_value(kf, groups[i], "password", NULL);
			gchar *address = g_key_file_get_value(kf, groups[i], "address", NULL);
			gchar *account = g_key_file_get_value(kf, groups[i], "account_name", NULL);
			gchar *output = input ? pass_decrypt(input) : NULL;

			printf("password for %s, %s is \"%s\"\n", account, address, output);
			g_free(input);
			g_free(output);
			g_free(address);
			g_free(account);
		}
		g_strfreev(groups);
	}
	g_key_file_free(kf);
}
static GstEncodingTarget *
parse_keyfile (GKeyFile * in, gchar * targetname, gchar * categoryname,
    gchar * description)
{
  GstEncodingTarget *res = NULL;
  GstEncodingProfile *prof;
  gchar **groups;
  gsize i, nbgroups;

  res = gst_encoding_target_new (targetname, categoryname, description, NULL);

  /* Figure out the various profiles */
  groups = g_key_file_get_groups (in, &nbgroups);
  for (i = 0; i < nbgroups; i++) {
    if (!g_ascii_strncasecmp (groups[i], "profile-", 8)) {
      prof = parse_encoding_profile (in, NULL, groups[i], nbgroups, groups);
      if (prof)
        gst_encoding_target_add_profile (res, prof);
    }
  }

  g_strfreev (groups);

  g_free (targetname);
  g_free (categoryname);
  g_free (description);

  return res;
}
Beispiel #5
0
static gboolean
deserialize_cache (MuContacts *self)
{
	gchar **groups;
	gsize i, len;

	groups = g_key_file_get_groups (self->_ccache, &len);
	for (i = 0; i != len; ++i) {
		ContactInfo *cinfo;
		char *name, *email;
		size_t tstamp;
		if (!get_values (self->_ccache, groups[i],
				 &email, &name, &tstamp))
			continue; /* ignore this one... */

		cinfo = contact_info_new (email, name, tstamp);

		/* note, we're using the groups[i], so don't free with g_strfreev */
		g_hash_table_insert (self->_hash, groups[i],
				     cinfo);
	}

	g_free (groups);
	return TRUE;
}
Beispiel #6
0
static gboolean
lookup_command_and_protocol(gchar *mimetype, gchar **command,
		gchar **protocol) {
	gsize number_of_groups;

	// Get all mime types in the config file
	gchar **groups = g_key_file_get_groups(keys, &number_of_groups);

	guint i = 0;

	for (; i < number_of_groups; i++) {
		if (g_pattern_match_simple(groups[i], mimetype)) {
			*command = g_key_file_get_string(keys, groups[i],
				"command", NULL);
			*protocol = g_key_file_get_string(keys, groups[i],
				"protocol", NULL);

			// Abort now since we found a match
			break;
		}
	}

	// Free the list of mime types
	g_strfreev(groups);

	return i != number_of_groups;
}
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;
}
Beispiel #8
0
static void load_desktop_datafile(gchar *filename)
{
  printf("load_desktop_datafile %s\n", filename);
  GKeyFile *keyfile = g_key_file_new ();
  GError *error = NULL;
  if ( ! g_key_file_load_from_file (keyfile,
				    filename,
				    G_KEY_FILE_NONE,
				    &error)  ) {
    if (error)
      g_error ("%s", error->message);
    return;
  }

  gsize n_level;
  gchar **groups = g_key_file_get_groups (keyfile, &n_level);
  int i;
  for (i=0; i<n_level; i++)
    {
      Level level;
      level.level = i + 1;
      level.questions = g_key_file_get_string (keyfile, groups[i],
					      "Questions", NULL);
      level.answers = g_key_file_get_string (keyfile, groups[i],
					    "Answers", NULL);
      g_array_append_vals (levels, &level, 1);
    }

  g_strfreev(groups);
  gcomprisBoard->maxlevel = n_level;
}
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);
		}
	}
}
/* Keyfile data */
GPtrArray *
mnp_load_zones (void)
{
	GKeyFile *kfile;
	char *pfile;
	GPtrArray *zones = g_ptr_array_new ();
	pfile = g_build_filename(g_get_user_config_dir(), "panel-clock-zones.conf", NULL);

	kfile = g_key_file_new ();
	if (g_key_file_load_from_file(kfile, pfile, G_KEY_FILE_NONE, NULL)) {
		guint len=0, i;
		char **grps;
		
		grps = g_key_file_get_groups (kfile, &len);
		for (i=0; i<len; i++) {
			MnpZoneLocation *loc = g_new0(MnpZoneLocation, 1);

			loc->display = g_strdup (grps[i]);
			loc->city = g_key_file_get_string (kfile, grps[i], "city", NULL);
			loc->tzid = g_key_file_get_string (kfile, grps[i], "tzid", NULL);
			g_ptr_array_add (zones, loc);
		}
		
		g_strfreev(grps);
	}
	g_key_file_free(kfile);
	g_free (pfile);

	return zones;
}
Beispiel #11
0
void
tlscerts_init(void)
{
    log_info("Loading TLS certificates");
    tlscerts_loc = files_get_data_path(FILE_TLSCERTS);

    if (g_file_test(tlscerts_loc, G_FILE_TEST_EXISTS)) {
        g_chmod(tlscerts_loc, S_IRUSR | S_IWUSR);
    }

    tlscerts = g_key_file_new();
    g_key_file_load_from_file(tlscerts, tlscerts_loc, G_KEY_FILE_KEEP_COMMENTS, NULL);

    certs_ac = autocomplete_new();
    gsize len = 0;
    gchar **groups = g_key_file_get_groups(tlscerts, &len);

    int i = 0;
    for (i = 0; i < g_strv_length(groups); i++) {
        autocomplete_add(certs_ac, groups[i]);
    }
    g_strfreev(groups);

    current_fp = NULL;
}
Beispiel #12
0
static void
n_core_parse_events_from_file (NCore *core, const char *filename)
{
    g_assert (core != NULL);
    g_assert (filename != NULL);

    GKeyFile  *keyfile    = NULL;
    GError    *error      = NULL;
    gchar    **group_list = NULL;
    gchar    **group      = NULL;
    NEvent    *event      = NULL;

    keyfile = g_key_file_new ();
    if (!g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, &error)) {
        N_WARNING (LOG_CAT "failed to load event file: %s", error->message);
        g_error_free    (error);
        g_key_file_free (keyfile);
        return;
    }

    /* each unique group is considered as an event, even if split within
       separate files. */

    N_DEBUG (LOG_CAT "processing event file '%s'", filename);

    group_list = g_key_file_get_groups (keyfile, NULL);
    for (group = group_list; *group; ++group) {
        event = n_event_new_from_group (core, keyfile, *group);
        if (event)
            n_core_add_event (core, event);
    }

    g_strfreev      (group_list);
    g_key_file_free (keyfile);
}
Beispiel #13
0
static gboolean ril_radio_settings_get_config(struct ril_radio_settings *rsd)
{
	gboolean needsconfig = FALSE;
	gboolean value = FALSE;

	/* Hmm... One file shared by all modems... Why?? */

	GKeyFile *keyfile = storage_open(NULL, RIL_STORE);
	char **alreadyset = g_key_file_get_groups(keyfile, NULL);

	if (alreadyset[0])
		value = g_key_file_get_boolean(
			keyfile, alreadyset[0], LTE_FLAG, NULL);
	else if (rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO)
		value = TRUE;

	if (!value && rsd->ratmode == PREF_NET_TYPE_LTE_GSM_WCDMA) {
			g_key_file_set_boolean(keyfile,
				LTE_FLAG, LTE_FLAG, TRUE);
			needsconfig = TRUE;
	} else if (value && rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) {
			g_key_file_set_boolean(keyfile,
				LTE_FLAG, LTE_FLAG, FALSE);
			needsconfig = TRUE;
	}

	g_strfreev(alreadyset);
	storage_close(NULL, RIL_STORE, keyfile, TRUE);

	DBG("needsconfig %d, rat mode %d", needsconfig, rsd->ratmode);
	return needsconfig;
}
Beispiel #14
0
/* Load in the cheat code file */
static void
nc_load_codes ( char * file )
{
    GError * error = NULL;
    gchar ** r;
    ini = file; /* store globally */
    
    /* Create new keyfile context */
    config = g_key_file_new();
    
    /* Open the file */
    if( !g_key_file_load_from_file( config, file, 0, &error ) )
    {
        printf("Error while loading configuration: %s\n", error->message );
        exit( -1 );
    }
    
    r = g_key_file_get_groups( config, NULL );
    
    while( *r )
    {
        nc_add_game( r[0] );
        g_print( "%s\n", *r );
        r++;
    }
}
Beispiel #15
0
GList*
tlscerts_list(void)
{
    GList *res = NULL;
    gsize len = 0;
    gchar **groups = g_key_file_get_groups(tlscerts, &len);

    int i = 0;
    for (i = 0; i < g_strv_length(groups); i++) {
        char *fingerprint = strdup(groups[i]);
        char *domain = g_key_file_get_string(tlscerts, fingerprint, "domain", NULL);
        char *organisation = g_key_file_get_string(tlscerts, fingerprint, "organisation", NULL);
        char *email = g_key_file_get_string(tlscerts, fingerprint, "email", NULL);
        char *notbefore = g_key_file_get_string(tlscerts, fingerprint, "start", NULL);
        char *notafter = g_key_file_get_string(tlscerts, fingerprint, "end", NULL);

        TLSCertificate *cert = tlscerts_new(fingerprint, domain, organisation, email, notbefore, notafter);

        res = g_list_append(res, cert);
    }

    if (groups) {
        g_strfreev(groups);
    }

    return res;
}
Beispiel #16
0
gboolean
lr_yum_repoconfs_parse(LrYumRepoConfs *repos,
                       const char *filename,
                       GError **err)
{
    _cleanup_strv_free_ gchar **groups = NULL;
    LrYumRepoFile *repofile = NULL;
    GKeyFile *keyfile = NULL;

    // Load key file content
    keyfile = lr_load_multiline_key_file(filename, err);
    if (!keyfile)
        return FALSE;

    // Create LrYumRepoFile object
    repofile = lr_yum_repofile_init(filename, keyfile);
    repos->files = g_slist_append(repos->files, repofile);

    // Create LrYumRepoConf objects
    groups = g_key_file_get_groups (keyfile, NULL);
    for (guint i = 0; groups[i]; i++) {
        LrYumRepoConf *repoconf = NULL;
        repoconf = lr_yum_repoconf_init(repofile, groups[i]);
        if (!repoconf)
            return FALSE;
        repos->repos = g_slist_append(repos->repos, repoconf);
    }

    return TRUE;
}
Beispiel #17
0
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);
    }
}
Beispiel #18
0
GtkListStore* script_list_load(void)
{
	GtkBuilder* builder = nall_gtk_builder_new();
	gtk_builder_connect_signals(builder, NULL);
	GtkListStore* store = GTK_LIST_STORE(gtk_builder_get_object(builder, "list_store_scripts"));
	g_object_unref(builder);

	GKeyFile* keyfile = g_key_file_new();
	GError *error = NULL;

	gchar* cfgfile = g_build_path ("/", g_get_home_dir(), ".nall/nall.ini", NULL);
	if (!g_key_file_load_from_file(keyfile, cfgfile, 0, &error)) {
		g_warning("Failed to read %s: %s", cfgfile, error->message);
		g_free(cfgfile);
		return store;
	}
	g_free(cfgfile);

	gsize num;
	gchar** groups = g_key_file_get_groups(keyfile, &num);

	gsize i;
	for (i = 0; i < num; i++) {
		script_from_keyfile(keyfile, groups[i], store);
		g_free(groups[i]);
	}

	g_free(groups);
	g_key_file_free(keyfile);

	return store;
}
static gboolean
add_extension_args (GKeyFile *metakey, const char *full_ref,
		    GPtrArray *argv_array, GCancellable *cancellable, GError **error)
{
  glnx_strfreev gchar **groups = NULL;
  glnx_strfreev gchar **parts = NULL;
  gboolean ret = FALSE;
  int i;

  ret = TRUE;

  parts = g_strsplit (full_ref, "/", 0);
  if (g_strv_length (parts) != 4)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Failed to determine parts from ref: %s", full_ref);
      goto out;
    }

  groups = g_key_file_get_groups (metakey, NULL);
  for (i = 0; groups[i] != NULL; i++)
    {
      char *extension;

      if (g_str_has_prefix (groups[i], "Extension ") &&
	  *(extension = (groups[i] + strlen ("Extension "))) != 0)
	{
	  g_autofree char *directory = g_key_file_get_string (metakey, groups[i], "directory", NULL);

	  if (directory == NULL)
	    continue;

	  if (g_key_file_get_boolean (metakey, groups[i],
				      "subdirectories", NULL))
	    {
	      g_autofree char *prefix = g_strconcat (extension, ".", NULL);
	      glnx_strfreev char **refs = NULL;
	      int i;

	      refs = xdg_app_list_deployed_refs (parts[0], prefix, parts[2], parts[3],
						 cancellable, error);
	      if (refs == NULL)
		goto out;

	      for (i = 0; refs[i] != NULL; i++)
		{
		  g_autofree char *extended_dir = g_build_filename (directory, refs[i] + strlen (prefix), NULL);
		  add_extension_arg (extended_dir, parts[0], refs[i], parts[2], parts[3],
				     argv_array, cancellable);
		}
	    }
	  else
	    add_extension_arg (directory, parts[0], extension, parts[2], parts[3],
			       argv_array, cancellable);
	}
    }

  ret = TRUE;
 out:
  return ret;
}
Beispiel #20
0
void _fm_archiver_init ()
{
#if 0
    GKeyFile *kf = g_key_file_new ();
    if (g_key_file_load_from_file (kf, PACKAGE_DATA_DIR "/archivers.list", 0, NULL))
    {
        int n_archivers;
        char **programs = g_key_file_get_groups (kf, &n_archivers);
        if (programs)
        {
            int i;
            for (i = 0; i < n_archivers; ++i)
            {
                FmArchiver *archiver = g_slice_new0 (FmArchiver);
                archiver->program = programs[i];
                archiver->create_cmd = g_key_file_get_string (kf, programs[i], "create", NULL);
                archiver->extract_cmd = g_key_file_get_string (kf, programs[i], "extract", NULL);
                archiver->extract_to_cmd = g_key_file_get_string (kf, programs[i], "extract_to", NULL);
                archiver->mime_types = g_key_file_get_string_list (kf, programs[i], "mime_types", NULL, NULL);
                archivers = g_list_append (archivers, archiver);
            }
            g_free (programs); // strings in the vector are stolen by FmArchiver.
        }
    }
    g_key_file_free (kf);
#endif
}
Beispiel #21
0
/** Fill in a wire db with data from a file
 *
 * This function load from the db argument the wires argument
 *
 * @param db KeyFile containing data
 * @param wires wire database to fill
 * @return an error indication
 */
static int
load_db_from_file(GKeyFile* db, wire_db_t *wires) {
  gint err;
  gsize nwires;
  gchar** wirenames;

  wirenames = g_key_file_get_groups(db, &nwires);

  debit_log(L_WIRES, "Wiring database contains %zd wires", nwires);

  /* Allocate the array */
  wires->dblen = nwires;
  wires->wires = g_new(wire_simple_t, nwires);
  wires->names = g_new(const gchar *, nwires);
  wires->details = g_new(wire_t, nwires);
  wires->wirenames = g_string_chunk_new(STRINGCHUNK_DEFAULT_SIZE);

  /* Iterate over groups */
  err = fill_db_from_file(wires, db, nwires, wirenames);

  /* Cleanup */
  g_strfreev(wirenames);

  return err;
}
Beispiel #22
0
int main(int argc, char **argv)
{
  GKeyFile *key_file = g_key_file_new();
  GError *err = NULL;

  // load file
  if (!g_key_file_load_from_file(
          key_file,
          "test.ini",
          G_KEY_FILE_KEEP_COMMENTS,
          &err)) {
    printf("%s\n", err->message);
  }

  // read groups
  gchar **groups = g_key_file_get_groups(key_file, NULL);
  printf("%s\n", *groups);
  // get a value
  gchar *name = g_key_file_get_value(key_file,
                                     groups[0],
                                     "user",
                                     &err);
  printf("name: %s\n", name);

  // free memory
  g_strfreev(groups);
  
  return EXIT_SUCCESS;
}
Beispiel #23
0
/* 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);
}
Beispiel #24
0
void
accounts_load(void)
{
    log_info("Loading accounts");
    all_ac = autocomplete_new();
    enabled_ac = autocomplete_new();
    accounts_loc = _get_accounts_file();

    if (g_file_test(accounts_loc, G_FILE_TEST_EXISTS)) {
        g_chmod(accounts_loc, S_IRUSR | S_IWUSR);
    }

    accounts = g_key_file_new();
    g_key_file_load_from_file(accounts, accounts_loc, G_KEY_FILE_KEEP_COMMENTS, NULL);

    // create the logins searchable list for autocompletion
    gsize naccounts;
    gchar **account_names = g_key_file_get_groups(accounts, &naccounts);

    gsize i;
    for (i = 0; i < naccounts; i++) {
        autocomplete_add(all_ac, account_names[i]);
        if (g_key_file_get_boolean(accounts, account_names[i], "enabled", NULL)) {
            autocomplete_add(enabled_ac, account_names[i]);
        }
    }

    g_strfreev(account_names);
}
Beispiel #25
0
/* return list of current uids of local active sessions */
static GSList *uids_with_local_active_session(const char *own_id)
{
	GSList *list = NULL;
	GKeyFile *keyfile;

	keyfile = g_key_file_new();
	if (g_key_file_load_from_file(keyfile, "/var/run/ConsoleKit/database", 0, NULL)) {
		gchar **groups;

		groups = g_key_file_get_groups(keyfile, NULL);
		if (groups != NULL) {
			int i;

			for (i = 0; groups[i] != NULL; i++) {
				uid_t u;

				if (!g_str_has_prefix(groups[i], "Session "))
					continue;
				if (own_id != NULL &&g_str_has_suffix(groups[i], own_id))
					continue;
				if (!g_key_file_get_boolean(keyfile, groups[i], "is_local", NULL))
					continue;
				if (!g_key_file_get_boolean(keyfile, groups[i], "is_active", NULL))
					continue;
				u = g_key_file_get_integer(keyfile, groups[i], "uid", NULL);
				if (u > 0 && !uid_in_list(list, u))
					list = g_slist_prepend(list, GUINT_TO_POINTER(u));
			}
			g_strfreev(groups);
		}
	}
	g_key_file_free(keyfile);

	return list;
}
Beispiel #26
0
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;
}
Beispiel #27
0
JS_EXPORT_API
gchar* greeter_get_session_by_conf ()
{
    GKeyFile* file = g_key_file_new();
    gboolean load = g_key_file_load_from_file(file, LIGHTDM_PATH,
                                              G_KEY_FILE_NONE, NULL);
    if (!load){
        g_key_file_unref(file);
        return NULL;
    }
    gsize len;
    gchar** groups = g_key_file_get_groups(file,&len);
    const gchar* session = NULL;
    for (guint i = 0;i < len; i++) {
        if (g_strcmp0(groups[i], "SeatDefaults") == 0){
            session = g_key_file_get_string(file,groups[i],
                                            "user-session", NULL);
            g_debug("[%s] groups[%d]: %s, user-session: %s\n",
                    __func__, i, groups[i], session);
        }
    }
    g_strfreev(groups);
    g_key_file_unref(file);
    return g_strdup(session);
}
Beispiel #28
0
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);
}
static void
panel_layout_append_from_file_real (const char *layout_file,
                                    int         screen_for_toplevels)
{
        GError    *error = NULL;
        GKeyFile  *keyfile = NULL;
        char     **groups = NULL;
        gboolean   found_one = FALSE;
        int        i;

        panel_layout_init ();

        keyfile = g_key_file_new ();

        error = NULL;
        if (!g_key_file_load_from_file (keyfile, layout_file,
                                        G_KEY_FILE_NONE, &error))
                goto out;

        groups = g_key_file_get_groups (keyfile, NULL);

        /* First pass to validate: we don't want to add only a subset of the
         * layout; the whole layout has to be valid */
        for (i = 0; groups[i] != NULL; i++) {
                if (!panel_layout_append_group (keyfile, groups[i],
                                                screen_for_toplevels,
                                                TRUE, &error))
                        goto out;
                else
                        found_one = TRUE;
        }

        if (!found_one) {
                error = g_error_new (PANEL_LAYOUT_ERROR, 0,
                                     "No defined toplevel or object");
                goto out;
        }

        /* Second pass to really add the layout. We know there'll be no error
         * since the first pass worked. */
        for (i = 0; groups[i] != NULL; i++)
                panel_layout_append_group (keyfile, groups[i],
                                           screen_for_toplevels,
                                           FALSE, NULL);

out:
        if (error) {
                g_printerr ("Error while parsing default layout from '%s': %s\n",
                            layout_file, error->message);
                g_error_free (error);
        }

        if (groups)
                g_strfreev (groups);

        if (keyfile)
                g_key_file_free (keyfile);
}
Beispiel #30
0
static gboolean ril_get_net_config(struct radio_data *rsd)
{
	GKeyFile *keyfile;
	GError *err = NULL;
	char *path = RIL_CONFIG;
	char **alreadyset = NULL;
	gboolean needsconfig = FALSE;
	gboolean value = FALSE;
	rsd->ratmode = PREF_NET_TYPE_GSM_WCDMA_AUTO;

	/*
	 * First we need to check should the LTE be on
	 * or not
	 */

	keyfile = g_key_file_new();

	g_key_file_set_list_separator(keyfile, ',');

	if (g_key_file_load_from_file(keyfile, path, 0, &err)) {
		if (g_key_file_has_group(keyfile, LTE_FLAG))
			rsd->ratmode = PREF_NET_TYPE_LTE_GSM_WCDMA;
	} else {
		g_error_free(err);
		needsconfig = TRUE;
	}

	g_key_file_free(keyfile);

	/* Then we need to check if it already set */

	keyfile = storage_open(NULL, RIL_STORE);
	alreadyset = g_key_file_get_groups(keyfile, NULL);

	if (alreadyset[0])
		value = g_key_file_get_boolean(
			keyfile, alreadyset[0], LTE_FLAG, NULL);
	else if (rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO)
		value = TRUE;

	if (!value && rsd->ratmode == PREF_NET_TYPE_LTE_GSM_WCDMA) {
			g_key_file_set_boolean(keyfile,
				LTE_FLAG, LTE_FLAG, TRUE);
			needsconfig = TRUE;
	} else if (value && rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) {
			g_key_file_set_boolean(keyfile,
				LTE_FLAG, LTE_FLAG, FALSE);
			needsconfig = TRUE;
	}

	g_strfreev(alreadyset);

	storage_close(NULL, RIL_STORE, keyfile, TRUE);

	return needsconfig;
}