void gprj_project_save(GKeyFile * key_file)
{
if (!g_prj)
return;
g_key_file_set_string_list(key_file, "gproject", "source_patterns",
(const gchar**) g_prj->source_patterns, g_strv_length(g_prj->source_patterns));
g_key_file_set_string_list(key_file, "gproject", "header_patterns",
(const gchar**) g_prj->header_patterns, g_strv_length(g_prj->header_patterns));
g_key_file_set_string_list(key_file, "gproject", "ignored_dirs_patterns",
(const gchar**) g_prj->ignored_dirs_patterns, g_strv_length(g_prj->ignored_dirs_patterns));
g_key_file_set_boolean(key_file, "gproject", "generate_tags", g_prj->generate_tags);
}
gboolean
conf_string_list_add(GKeyFile *keyfile, const char *const group, const char *const key, const char *const item)
{
gsize length;
gchar **list = g_key_file_get_string_list(keyfile, group, key, &length, NULL);
GList *glist = NULL;
// list found
if (list) {
int i = 0;
for (i = 0; i < length; i++) {
// item already in list, exit function
if (strcmp(list[i], item) == 0) {
g_list_free_full(glist, g_free);
g_strfreev(list);
return FALSE;
}
// add item to our g_list
glist = g_list_append(glist, strdup(list[i]));
}
// item not found, add to our g_list
glist = g_list_append(glist, strdup(item));
// create the new list entry
const gchar* new_list[g_list_length(glist)+1];
GList *curr = glist;
i = 0;
while (curr) {
new_list[i++] = curr->data;
curr = g_list_next(curr);
}
new_list[i] = NULL;
g_key_file_set_string_list(keyfile, group, key, new_list, g_list_length(glist));
// list not found
} else {
const gchar* new_list[2];
new_list[0] = item;
new_list[1] = NULL;
g_key_file_set_string_list(keyfile, group, key, new_list, 1);
}
g_strfreev(list);
g_list_free_full(glist, g_free);
return TRUE;
}
static int
notmuch_config_command_set (notmuch_config_t *config, char *item, int argc, char *argv[])
{
char *group, *key;
if (_item_split (item, &group, &key))
return 1;
/* With only the name of an item, we clear it from the
* configuration file.
*
* With a single value, we set it as a string.
*
* With multiple values, we set them as a string list.
*/
switch (argc) {
case 0:
g_key_file_remove_key (config->key_file, group, key, NULL);
break;
case 1:
g_key_file_set_string (config->key_file, group, key, argv[0]);
break;
default:
g_key_file_set_string_list (config->key_file, group, key,
(const gchar **) argv, argc);
break;
}
return notmuch_config_save (config);
}
void test_setstring()
{
GKeyFile *keyfile;
gchar **value;
gsize n = 2;
const gchar *list[2] =
{
"test1","test2"
};
const gchar *data =
"[1]\n"
"key1=123\n"
"[2]\n"
"key2=456\n";
keyfile = load_data (data, 0);
check_string_value (keyfile, "1", "key1", "123");
g_key_file_set_string(keyfile,"1","key1","789");
check_string_value (keyfile, "1", "key1", "789");
g_key_file_set_string_list(keyfile,"1","key1",list,2);
value = g_key_file_get_string_list(keyfile, "1", "key1",&n, NULL);
g_assert(!strcmp(value[0],"test1"));
g_assert(!strcmp(value[1],"test2"));
g_strfreev(value);
}
static gboolean
set_keyfile_string_array_from_json (GKeyFile *keyfile,
const char *keyfile_group,
const char *keyfile_key,
JsonArray *a,
GError **error)
{
gboolean ret = FALSE;
guint len = json_array_get_length (a);
guint i;
g_autoptr(GPtrArray) instlangs_v = g_ptr_array_new ();
for (i = 0; i < len; i++)
{
const char *elt = _rpmostree_jsonutil_array_require_string_element (a, i, error);
if (!elt)
goto out;
g_ptr_array_add (instlangs_v, (char*)elt);
}
g_key_file_set_string_list (keyfile, keyfile_group, keyfile_key,
(const char*const*)instlangs_v->pdata, instlangs_v->len);
ret = TRUE;
out:
return ret;
}
static void keystore_save_rsakey(gpointer key, gpointer value,
gpointer user_data)
{
const int key_index = GPOINTER_TO_INT(key);
const struct rsa_key_t *rsa_key = (const struct rsa_key_t *)value;
GKeyFile *key_file = (GKeyFile *)user_data;
g_assert(rsa_key != NULL);
g_assert(key_file != NULL);
gchar *index = g_strdup_printf("%d", key_index);
int pkcs_len = i2d_RSAPrivateKey(rsa_key->rsa, NULL);
unsigned char *pkcs_buf = malloc(pkcs_len);
unsigned char *tmp = pkcs_buf;
i2d_RSAPrivateKey(rsa_key->rsa, &tmp);
const gchar *const list[] =
{
g_strdup_printf("%d", rsa_key->keylen),
g_base64_encode(pkcs_buf, pkcs_len),
};
g_key_file_set_string_list(key_file, "rsa", index, list, 2);
g_free(index);
free(pkcs_buf);
g_free((gpointer)list[0]);
g_free((gpointer)list[1]);
}
/* FIXME:
* If the system-wide desktop file can meet our needs,
* remove the user-specific one instead of changing its key values. */
void update_enable_state(GKeyFile* kf, gboolean enabled, int flags, const char* session_name)
{
if( flags & NOT_SHOW_IN ) /* the desktop file contains NotShowIn key */
{
gsize n, i;
char** list = g_key_file_get_string_list(kf, grp, "NotShowIn", &n, NULL);
if( enabled ) /* remove our DE from NotShowIn */
{
for( i = 0; i < n; ++i )
{
if( strcmp(list[i], session_name) == 0 )
{
g_free(list[i]);
memcpy( list + i, list + i + 1, (n-i) * sizeof(char*) );
--n;
break;
}
}
}
else /* add our DE to NotShowIn */
{
++n;
if( list )
list = g_realloc( list, sizeof(char*) * (n + 1) );
else
list = g_new( char*, n + 1 );
list[n-1] = g_strdup(session_name);
list[n] = NULL;
}
if( n > 0 )
g_key_file_set_string_list( kf, grp, "NotShowIn", (const gchar * const *) list, n );
else
g_key_file_remove_key(kf, grp, "NotShowIn", NULL);
g_strfreev(list);
}
static GKeyFile *
make_key_file_from_configuration (void)
{
GKeyFile *key_file;
struct domains_dump_closure closure;
gint num_domains;
key_file = g_key_file_new ();
/* domains */
if (domains_hash) {
num_domains = g_hash_table_size (domains_hash);
if (num_domains != 0) {
closure.domains = g_new (gchar *, num_domains);
closure.num_domains = 0;
g_hash_table_foreach (
domains_hash,
domains_foreach_dump_cb,
&closure);
g_assert (num_domains == closure.num_domains);
g_key_file_set_string_list (
key_file,
KEY_FILE_GROUP,
KEY_FILE_DOMAINS_KEY,
(const gchar * const *) closure.domains,
closure.num_domains);
g_free (closure.domains);
}
}
static void
ip4_dns_writer (GKeyFile *file,
NMSetting *setting,
const char *key,
const GValue *value)
{
GArray *array;
char **list;
int i, num = 0;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UINT_ARRAY));
array = (GArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
list = g_new0 (char *, array->len + 1);
for (i = 0; i < array->len; i++) {
char buf[INET_ADDRSTRLEN + 1];
struct in_addr addr;
addr.s_addr = g_array_index (array, guint32, i);
if (!inet_ntop (AF_INET, &addr, buf, sizeof (buf))) {
nm_warning ("%s: error converting IP4 address 0x%X",
__func__, ntohl (addr.s_addr));
} else
list[num++] = g_strdup (buf);
}
g_key_file_set_string_list (file, nm_setting_get_name (setting), key, (const char **) list, num);
g_strfreev (list);
}
void rclib_settings_set_string_list(const gchar *group_name,
const gchar *key, const gchar * const list[], gsize length)
{
settings_dirty = TRUE;
if(settings_keyfile==NULL) return;
g_key_file_set_string_list(settings_keyfile, group_name, key,
list, length);
}
void
libbalsa_conf_set_vector(const char *path, int argc,
const char *const argv[])
{
g_key_file_set_string_list(lbc_conf.key_file, lbc_groups->data, path,
argv, argc);
++lbc_conf.changes;
}
void
mc_config_set_string_list (mc_config_t * mc_config, const gchar * group,
const gchar * param, const gchar * const value[], gsize length)
{
if (!mc_config || !group || !param || !value || length == 0)
return;
g_key_file_set_string_list (mc_config->handle, group, param, value, length);
}
static void
virt_viewer_file_set_string_list(VirtViewerFile* self, const char *group,
const gchar* key, const gchar* const* value,
gsize length)
{
g_return_if_fail(VIRT_VIEWER_IS_FILE(self));
g_return_if_fail(key != NULL);
g_key_file_set_string_list(self->priv->keyfile, group, key, value, length);
}
static void
_config_set_list (notmuch_config_t *config,
const char *group, const char *name,
const char *list[],
size_t length, const char ***config_var )
{
g_key_file_set_string_list (config->key_file, group, name, list, length);
talloc_free (*config_var);
*config_var = NULL;
}
void
caps_add_by_ver(const char *const ver, EntityCapabilities *caps)
{
if (ver == NULL || caps == NULL) {
return;
}
gboolean cached = g_key_file_has_group(cache, ver);
if (cached) {
return;
}
if (caps->identity) {
DiscoIdentity *identity = caps->identity;
if (identity->name) {
g_key_file_set_string(cache, ver, "name", identity->name);
}
if (identity->category) {
g_key_file_set_string(cache, ver, "category", identity->category);
}
if (identity->type) {
g_key_file_set_string(cache, ver, "type", identity->type);
}
}
if (caps->software_version) {
SoftwareVersion *software_version = caps->software_version;
if (software_version->software) {
g_key_file_set_string(cache, ver, "software", software_version->software);
}
if (software_version->software_version) {
g_key_file_set_string(cache, ver, "software_version", software_version->software_version);
}
if (software_version->os) {
g_key_file_set_string(cache, ver, "os", software_version->os);
}
if (software_version->os_version) {
g_key_file_set_string(cache, ver, "os_version", software_version->os_version);
}
}
if (caps->features) {
GSList *curr_feature = caps->features;
int num = g_slist_length(caps->features);
const gchar* features_list[num];
int curr = 0;
while (curr_feature) {
features_list[curr++] = curr_feature->data;
curr_feature = g_slist_next(curr_feature);
}
g_key_file_set_string_list(cache, ver, "features", features_list, num);
}
_save_cache();
}
static void
ip6_route_writer (GKeyFile *file,
const char *keyfile_dir,
const char *uuid,
NMSetting *setting,
const char *key,
const GValue *value)
{
GPtrArray *array;
const char *setting_name = nm_setting_get_name (setting);
char *list[3];
int i, j;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_IP6_ROUTE));
array = (GPtrArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
for (i = 0, j = 1; i < array->len; i++) {
GValueArray *values = g_ptr_array_index (array, i);
char *key_name;
guint32 int_val;
char buf[INET6_ADDRSTRLEN + 1];
gboolean is_unspec = FALSE;
memset (list, 0, sizeof (list));
/* Address and prefix */
list[0] = ip6_array_to_addr_prefix (values);
if (!list[0])
continue;
/* Next Hop */
if (!ip6_array_to_addr (values, 2, buf, sizeof (buf), &is_unspec))
continue;
if (is_unspec)
continue;
list[1] = g_strdup (buf);
/* Metric */
value = g_value_array_get_nth (values, 3);
int_val = g_value_get_uint (value);
list[2] = g_strdup_printf ("%d", int_val);
/* Write it out */
key_name = g_strdup_printf ("%s%d", key, j++);
g_key_file_set_string_list (file, setting_name, key_name, (const char **) list, 3);
g_free (key_name);
g_free (list[0]);
g_free (list[1]);
g_free (list[2]);
}
}
/* This function is used to handle the string arrays representing the ROM
and sample paths */
static void
mame_gui_prefs_save_string_arr (MameGuiPrefs *pr, GParamSpec *param, gpointer user_data)
{
gchar *key;
GValueArray *va;
gchar **value;
guint n_va;
guint i;
g_return_if_fail (pr->priv->prefs_ini_file != NULL);
g_return_if_fail (pr->priv->filename != NULL);
key = g_strdup (g_param_spec_get_name (param));
g_return_if_fail (key != NULL);
g_object_get (pr, key, &va, NULL);
g_return_if_fail (va != NULL);
GMAMEUI_DEBUG ("Saving string array %s", key);
if (va->n_values == 0) {
/* If the va has no values, then they have all been removed -
need to delete the key from the file */
GMAMEUI_DEBUG ("Saving %s - removing string array value %s",
pr->priv->filename, key);
g_key_file_remove_key (pr->priv->prefs_ini_file, "Preferences", key, NULL);
} else {
/* Copy all the elements in the value array to a string array */
n_va = va->n_values;
value = g_new0 (gchar*, n_va);
for (i = 0; i < n_va; i++) {
GMAMEUI_DEBUG ("Value at %d is %s", i, g_value_get_string (g_value_array_get_nth (va, i)));
value[i] = g_strdup (g_value_get_string (g_value_array_get_nth (va, i)));
}
GMAMEUI_DEBUG ("Saving %s - setting string array value %s",
pr->priv->filename, key);
/* Set the value and save the file */
g_key_file_set_string_list (pr->priv->prefs_ini_file, "Preferences", key, value, n_va);
}
g_key_file_save_to_file (pr->priv->prefs_ini_file, pr->priv->filename);
GMAMEUI_DEBUG ("Saving string array %s... done", key);
g_free (key);
/* FIXME TODO g_strfreev (value);*/
/* FIXME TODO Preferences is a temporary group name - need to find a way to
add more groups */
}
static void
write_ip4_values (GKeyFile *file,
const char *setting_name,
const char *key,
GPtrArray *array,
guint32 tuple_len,
guint32 addr1_pos,
guint32 addr2_pos)
{
char **list = NULL;
int i, j;
list = g_new (char *, tuple_len);
for (i = 0, j = 0; i < array->len; i++, j++) {
GArray *tuple = g_ptr_array_index (array, i);
gboolean success = TRUE;
char *key_name;
int k;
memset (list, 0, tuple_len * sizeof (char *));
for (k = 0; k < tuple_len; k++) {
if (k == addr1_pos || k == addr2_pos) {
char buf[INET_ADDRSTRLEN + 1];
struct in_addr addr;
/* IP addresses */
addr.s_addr = g_array_index (tuple, guint32, k);
if (!inet_ntop (AF_INET, &addr, buf, sizeof (buf))) {
nm_warning ("%s: error converting IP4 address 0x%X",
__func__, ntohl (addr.s_addr));
success = FALSE;
break;
} else {
list[k] = g_strdup (buf);
}
} else {
/* prefix, metric */
list[k] = g_strdup_printf ("%d", g_array_index (tuple, guint32, k));
}
}
if (success) {
key_name = g_strdup_printf ("%s%d", key, j + 1);
g_key_file_set_string_list (file, setting_name, key_name, (const char **) list, tuple_len);
g_free (key_name);
}
for (k = 0; k < tuple_len; k++)
g_free (list[k]);
}
g_free (list);
}
void
nautilus_keyfile_metadata_set_stringv (NautilusFile *file,
const char *keyfile_filename,
const char *name,
const char *key,
const char * const *stringv)
{
GKeyFile *keyfile;
guint length;
gchar **actual_stringv = NULL;
gboolean free_strv = FALSE;
keyfile = get_keyfile (keyfile_filename);
/* if we would be setting a single-length strv, append a fake
* terminator to the array, to be able to differentiate it later from
* the single string case
*/
length = g_strv_length ((gchar **) stringv);
if (length == 1)
{
actual_stringv = g_malloc0 (3 * sizeof (gchar *));
actual_stringv[0] = (gchar *) stringv[0];
actual_stringv[1] = STRV_TERMINATOR;
actual_stringv[2] = NULL;
length = 2;
free_strv = TRUE;
}
else
{
actual_stringv = (gchar **) stringv;
}
g_key_file_set_string_list (keyfile,
name,
key,
(const gchar **) actual_stringv,
length);
save_in_idle (keyfile_filename);
if (nautilus_keyfile_metadata_update_from_keyfile (file, keyfile_filename, name))
{
nautilus_file_changed (file);
}
if (free_strv)
{
g_free (actual_stringv);
}
}
gboolean
ol_config_set_str_list (OlConfig *config,
const char *group,
const char *name,
const char **value,
int len)
{
ol_assert_ret (config != NULL, FALSE);
ol_assert_ret (name != NULL, FALSE);
g_key_file_set_string_list (OL_CONFIG_GET_PRIVATE (config)->config, group, name, value, len);
ol_config_emit_change (config, group, name);
ol_config_save (config);
}
/* Write the project settings as well as the project session files into its configuration files.
* emit_signal defines whether the project-save signal should be emitted. When write_config()
* is called while closing a project, this is used to skip emitting the signal because
* project-close will be emitted afterwards.
* Returns: TRUE if project file was written successfully. */
static gboolean write_config(gboolean emit_signal)
{
GeanyProject *p;
GKeyFile *config;
gchar *filename;
gchar *data;
gboolean ret = FALSE;
GSList *node;
g_return_val_if_fail(app->project != NULL, FALSE);
p = app->project;
config = g_key_file_new();
/* try to load an existing config to keep manually added comments */
filename = utils_get_locale_from_utf8(p->file_name);
g_key_file_load_from_file(config, filename, G_KEY_FILE_NONE, NULL);
foreach_slist(node, stash_groups)
stash_group_save_to_key_file(node->data, config);
g_key_file_set_string(config, "project", "name", p->name);
g_key_file_set_string(config, "project", "base_path", p->base_path);
if (p->description)
g_key_file_set_string(config, "project", "description", p->description);
if (p->file_patterns)
g_key_file_set_string_list(config, "project", "file_patterns",
(const gchar**) p->file_patterns, g_strv_length(p->file_patterns));
g_key_file_set_integer(config, "long line marker", "long_line_behaviour", p->long_line_behaviour);
g_key_file_set_integer(config, "long line marker", "long_line_column", p->long_line_column);
/* store the session files into the project too */
if (project_prefs.project_session)
configuration_save_session_files(config);
build_save_menu(config, (gpointer)p, GEANY_BCS_PROJ);
if (emit_signal)
{
g_signal_emit_by_name(geany_object, "project-save", config);
}
/* write the file */
data = g_key_file_to_data(config, NULL, NULL);
ret = (utils_write_file(filename, data) == 0);
g_free(data);
g_free(filename);
g_key_file_free(config);
return ret;
}
static gboolean
save_state (time_t mtime,
gchar **converted)
{
gchar *filename;
GKeyFile *keyfile;
gchar *str;
GError *error;
gboolean result;
/* Make sure the state directory exists */
if (g_mkdir_with_parents (g_get_user_data_dir (), 0755))
{
g_printerr ("Failed to create directory %s: %s\n",
g_get_user_data_dir (), g_strerror (errno));
return FALSE;
}
filename = g_build_filename (g_get_user_data_dir (), "mateconf-gsettings-data-convert", NULL);
keyfile = g_key_file_new ();
str = g_strdup_printf ("%ld", mtime);
g_key_file_set_string (keyfile,
"State", "timestamp", str);
g_free (str);
g_key_file_set_string_list (keyfile,
"State", "converted",
(const gchar * const *)converted, g_strv_length (converted));
str = g_key_file_to_data (keyfile, NULL, NULL);
g_key_file_free (keyfile);
error = NULL;
if (!g_file_set_contents (filename, str, -1, &error))
{
g_printerr ("%s\n", error->message);
g_error_free (error);
result = FALSE;
}
else
result = TRUE;
g_free (filename);
g_free (str);
return result;
}
/**
* pragha_preferences_set_string_list
*
*/
void
pragha_preferences_set_string_list (PraghaPreferences *preferences,
const gchar *group_name,
const gchar *key,
const gchar * const list[],
gsize length)
{
g_return_if_fail(PRAGHA_IS_PREFERENCES(preferences));
g_key_file_set_string_list(preferences->priv->rc_keyfile,
group_name,
key,
list,
length);
}
gboolean
conf_string_list_remove(GKeyFile *keyfile, const char *const group, const char *const key, const char *const item)
{
gsize length;
gchar **list = g_key_file_get_string_list(keyfile, group, key, &length, NULL);
gboolean deleted = FALSE;
if (list) {
int i = 0;
GList *glist = NULL;
for (i = 0; i < length; i++) {
// item found, mark as deleted
if (strcmp(list[i], item) == 0) {
deleted = TRUE;
} else {
// add item to our g_list
glist = g_list_append(glist, strdup(list[i]));
}
}
if (deleted) {
if (g_list_length(glist) == 0) {
g_key_file_remove_key(keyfile, group, key, NULL);
} else {
// create the new list entry
const gchar* new_list[g_list_length(glist)+1];
GList *curr = glist;
i = 0;
while (curr) {
new_list[i++] = curr->data;
curr = g_list_next(curr);
}
new_list[i] = NULL;
g_key_file_set_string_list(keyfile, group, key, new_list, g_list_length(glist));
}
}
g_list_free_full(glist, g_free);
}
g_strfreev(list);
return deleted;
}
static void
lr_key_file_set_string_list(GKeyFile *keyfile,
const gchar *groupname,
const gchar *key,
const gchar **list)
{
gsize len = 0;
if (list)
len = g_strv_length((gchar **) list);
if (len == 0) {
g_key_file_remove_key(keyfile, groupname, key, NULL);
return;
}
g_key_file_set_string_list(keyfile, groupname, key, (const gchar * const*) list, len);
}
static void
_remove_from_list(GKeyFile *accounts, const char *const account_name, const char *const key, const char *const contact_jid)
{
gsize length;
gchar **list = g_key_file_get_string_list(accounts, account_name, key, &length, NULL);
if (list) {
int i = 0;
GList *glist = NULL;
gboolean deleted = FALSE;
for (i = 0; i < length; i++) {
// item found, mark as deleted
if (strcmp(list[i], contact_jid) == 0) {
deleted = TRUE;
} else {
// add item to our g_list
glist = g_list_append(glist, strdup(list[i]));
}
}
if (deleted) {
if (g_list_length(glist) == 0) {
g_key_file_remove_key(accounts, account_name, key, NULL);
} else {
// create the new list entry
const gchar* new_list[g_list_length(glist)+1];
GList *curr = glist;
i = 0;
while (curr) {
new_list[i++] = strdup(curr->data);
curr = g_list_next(curr);
}
new_list[i] = NULL;
g_key_file_set_string_list(accounts, account_name, key, new_list, g_list_length(glist));
}
}
g_list_free_full(glist, g_free);
}
g_strfreev(list);
}
static void save_timeservers(char **servers)
{
GKeyFile *keyfile;
int cnt;
keyfile = __connman_storage_load_global();
if (!keyfile)
keyfile = g_key_file_new();
for (cnt = 0; servers && servers[cnt]; cnt++);
g_key_file_set_string_list(keyfile, "global", "Timeservers",
(const gchar **)servers, cnt);
__connman_storage_save_global(keyfile);
g_key_file_free(keyfile);
return;
}
static void lxdm_save_login(char *session,char *lang)
{
char *old;
GKeyFile *var;
int dirty=0;
if(!session || !session[0])
session="__default__";
if(!lang)
lang="";
var=g_key_file_new();
g_key_file_set_list_separator(var, ' ');
g_key_file_load_from_file(var,VCONFIG_FILE,0,NULL);
old=g_key_file_get_string(var,"base","last_session",0);
if(0!=g_strcmp0(old,session))
{
g_key_file_set_string(var,"base","last_session",session);
dirty++;
}
g_free(old);
old=g_key_file_get_string(var,"base","last_lang",0);
if(0!=g_strcmp0(old,lang))
{
g_key_file_set_string(var,"base","last_lang",lang);
dirty++;
}
g_free(old);
if(lang[0])
{
char **list;
gsize len;
list=g_key_file_get_string_list(var,"base","last_langs",&len,NULL);
if(!list)
{
list=g_new0(char*,2);
list[0]=g_strdup(lang);
g_key_file_set_string_list(var,"base","last_langs",(void*)list,1);
g_strfreev(list);
dirty++;
}
else
{
static void
ip6_dns_writer (GKeyFile *file,
const char *keyfile_dir,
const char *uuid,
NMSetting *setting,
const char *key,
const GValue *value)
{
GPtrArray *array;
GByteArray *byte_array;
char **list;
int i, num = 0;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UCHAR));
array = (GPtrArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
list = g_new0 (char *, array->len + 1);
for (i = 0; i < array->len; i++) {
char buf[INET6_ADDRSTRLEN];
byte_array = g_ptr_array_index (array, i);
if (!inet_ntop (AF_INET6, (struct in6_addr *) byte_array->data, buf, sizeof (buf))) {
int j;
GString *ip6_str = g_string_new (NULL);
g_string_append_printf (ip6_str, "%02X", byte_array->data[0]);
for (j = 1; j < 16; j++)
g_string_append_printf (ip6_str, " %02X", byte_array->data[j]);
g_warning ("%s: error converting IP6 address %s",
__func__, ip6_str->str);
g_string_free (ip6_str, TRUE);
} else
list[num++] = g_strdup (buf);
}
g_key_file_set_string_list (file, nm_setting_get_name (setting), key, (const char **) list, num);
g_strfreev (list);
}
void
caps_add(const char * const ver, Capabilities *caps)
{
gboolean cached = g_key_file_has_group(cache, ver);
if (!cached) {
if (caps->name) {
g_key_file_set_string(cache, ver, "name", caps->name);
}
if (caps->category) {
g_key_file_set_string(cache, ver, "category", caps->category);
}
if (caps->type) {
g_key_file_set_string(cache, ver, "type", caps->type);
}
if (caps->software) {
g_key_file_set_string(cache, ver, "software", caps->software);
}
if (caps->software_version) {
g_key_file_set_string(cache, ver, "software_version", caps->software_version);
}
if (caps->os) {
g_key_file_set_string(cache, ver, "os", caps->os);
}
if (caps->os_version) {
g_key_file_set_string(cache, ver, "os_version", caps->os_version);
}
if (caps->features) {
GSList *curr_feature = caps->features;
int num = g_slist_length(caps->features);
const gchar* features_list[num];
int curr = 0;
while (curr_feature) {
features_list[curr++] = curr_feature->data;
curr_feature = g_slist_next(curr_feature);
}
g_key_file_set_string_list(cache, ver, "features", features_list, num);
}
_save_cache();
}
}
