gconf_utils.c

Go to the documentation of this file.

/**
 * \file gconf_utils.c
 * \brief A lightweight wrapper for gconf library.
 */

/*
 * This file is part of liberutils.
 *
 * liberutils is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * liberutils is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >

#include <string.h>
#include <gconf/gconf-client.h>

// ereader library include files, between < >

#include "er_error.h"

// local include files, between " "
#include "log.h"
#include "gconf_utils.h"

#define UNUSED(x) (void)(x)


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

typedef struct
{
    const char *key;
    gboolean found;
} FindKeyInfo;

//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static GConfClient*             client             = NULL;
static gconf_cb_value_changed_t g_cb_value_changed = NULL;

//============================================================================
// Local Function Definitions
//============================================================================

static void find_gconf_key (gpointer key, gpointer value, gpointer user_data);
static void write_properties_stringhash (gpointer key, gpointer value, gpointer user_data);
static void on_value_changed (GConfClient *client, const gchar* key, GConfValue* value);

// implementation of virtual methods


// signal handlers


//============================================================================
// Functions Implementation
//============================================================================

void ergconf_initialize()
{
    if (client == NULL)
    {
        client = gconf_client_get_default();
        g_signal_connect(G_OBJECT(client), "value-changed", G_CALLBACK(on_value_changed), NULL);
    }
}

void ergconf_finalize()
{
    if (client)
    {
        g_object_unref(client);
        client = NULL;
    }
}

void ergconf_set_cb_value_changed(gconf_cb_value_changed_t callback)
{
    g_cb_value_changed = callback;
}

void on_value_changed (GConfClient *client, const gchar* key, GConfValue* value)
{
    UNUSED(client);
    if (g_cb_value_changed)
    {
        (*g_cb_value_changed)(key, value);
    }
}

void ergconf_add_monitor_dir(const gchar *dir)
{
    g_assert(client);
    g_assert(dir && *dir == '/');
    gconf_client_add_dir(client, dir, GCONF_CLIENT_PRELOAD_NONE, NULL);
}

void ergconf_unset(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    gconf_client_unset(client, key, NULL);
}

void ergconf_recursive_unset(const gchar *dir)
{
    g_assert(client);
    g_assert(dir && *dir);
    gconf_client_recursive_unset (client, dir, 0, NULL);
}

int ergconf_get_int(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    return gconf_client_get_int(client, key, NULL);
}

int ergconf_set_int(const gchar* key, int new_value)
{
    gboolean ok;

    g_assert(client);
    g_assert(key && *key);

    ok = gconf_client_set_int(client, key, new_value, NULL);
    return (ok ?  ER_OK : ER_FAIL);
}

gboolean ergconf_get_bool(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    return gconf_client_get_bool(client, key, NULL);
}

int ergconf_set_bool(const gchar* key, gboolean new_value)
{
    gboolean ok;

    g_assert(client);
    g_assert(key && *key);
    
    ok = gconf_client_set_bool(client, key, new_value, NULL);
    return (ok ?  ER_OK : ER_FAIL);
}

gchar* ergconf_get_string(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    return gconf_client_get_string(client, key, NULL);
}

int ergconf_set_string(const gchar* key, const gchar* new_value)
{
    gboolean ok;

    g_assert(client);
    g_assert(key && *key);
    g_assert(new_value);

    ok = gconf_client_set_string(client, key, new_value, NULL);
    return (ok ?  ER_OK : ER_FAIL);
}

GSList* ergconf_get_string_list(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    return gconf_client_get_list(client, key, GCONF_VALUE_STRING, NULL);
}

int ergconf_set_string_list(const gchar* key, const GSList *new_value)
{
    gboolean ok;

    g_assert(client);
    g_assert(key && *key);
    g_return_val_if_fail (new_value != NULL, FALSE);

    ok = gconf_client_set_list ( client, 
                                 key,
                                 GCONF_VALUE_STRING,
                                 (GSList*)new_value,  // const_cast
                                 NULL );
    return (ok ?  ER_OK : ER_FAIL);
}

GByteArray* ergconf_get_byte_array(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);

    GByteArray *ret = NULL;
    GConfValue *gc_value = gconf_client_get (client, key, NULL);
    if (gc_value == NULL )
    {
        return NULL;
    }

    if (gc_value->type == GCONF_VALUE_LIST &&
        gconf_value_get_list_type (gc_value) == GCONF_VALUE_INT)
    {
        GSList *elt;

        ret = g_byte_array_new ();
        for (elt = gconf_value_get_list (gc_value); elt != NULL; elt = g_slist_next (elt))
        {
            int i = gconf_value_get_int ((GConfValue *) elt->data);
            guint8 val = (guint8) (i & 0xFF);

            if (i < 0 || i > 255)
            {
                g_log (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
                       "value %d out-of-range for a byte value", i);
                g_byte_array_free (ret, TRUE);
                ret = NULL;
                break;  // exit for loop
            }

            g_byte_array_append (ret, &val, 1);
        }
    }

    if (gc_value != NULL)
    {
        gconf_value_free (gc_value);
    }
    return ret;
}

int ergconf_set_byte_array(const gchar* key, const GByteArray *new_value)
{
    gboolean ok;
    GSList *list = NULL;

    g_assert(client);
    g_assert(key && *key);

    unsigned int i;
    for (i = 0; i < new_value->len; i++)
    {
        list = g_slist_append(list, GINT_TO_POINTER ((int) new_value->data[i]));
    }

    ok = gconf_client_set_list (client, key, GCONF_VALUE_INT, list, NULL);

    g_slist_free (list);
    return (ok ? ER_OK : ER_FAIL);
}

GHashTable* ergconf_get_string_hash(const gchar* dir)
{
    g_assert(client);
    g_assert(dir && *dir);

    char *gc_key = NULL;
    int prefix_len = strlen (dir);
    GSList *iter;
    GSList *gconf_entries = gconf_client_all_entries (client, dir, NULL);

    if (gconf_entries == NULL)
    {
        return NULL;
    }

    GHashTable *ret = g_hash_table_new_full (g_str_hash,
                                             g_str_equal,
                                             (GDestroyNotify) g_free,
                                             (GDestroyNotify) g_free);

    for (iter = gconf_entries; iter; iter = iter->next)
    {
        GConfEntry *entry = (GConfEntry *) iter->data;

        gc_key = (char *) gconf_entry_get_key (entry);
        gc_key += prefix_len + 1; /* get rid of the full path */

        const GConfValue *gc_val = gconf_entry_get_value (entry);

        if (gc_val)
        {
            const char *gc_str = gconf_value_get_string (gc_val);

            if (gc_str != NULL && strlen (gc_str) > 0)
            {
                g_hash_table_insert (ret, gconf_unescape_key (gc_key, -1), g_strdup (gc_str));
            }
        }
        gconf_entry_free (entry);
    }

    g_slist_free (gconf_entries);
    return ret;
}

int ergconf_set_string_hash(const gchar* dir, const GHashTable *new_value)
{
    GSList *existing = NULL;
    GSList *iter;

    g_assert(client);
    g_assert(dir && *dir);
    g_return_val_if_fail(new_value != NULL, FALSE);

    /* Delete GConf entries that are not in the hash table to be written */
    existing = gconf_client_all_entries (client, dir, NULL);
    for (iter = existing; iter; iter = g_slist_next (iter))
    {
        GConfEntry *entry = (GConfEntry *) iter->data;
        char *basename = g_path_get_basename (entry->key);
        FindKeyInfo fk_info = { basename, FALSE };

        g_hash_table_foreach ( (GHashTable*)new_value,  // const_cast
                               find_gconf_key,
                               &fk_info );
        //TODO: Why not use g_hash_table_lookup_extended() here ??
        //TODO  Seems we don't need FindKeyInfo and find_gconf_key then.
        /* Be sure to never delete "special" VPN keys */
        if (fk_info.found == FALSE)
        {
            ergconf_unset (entry->key);
        }

        gconf_entry_free (entry);
        g_free (basename);
    }
    g_slist_free (existing);

    /* Now update entries and write new ones */
    g_hash_table_foreach ( (GHashTable*)new_value,  // const_cast
                           write_properties_stringhash,
                           (gpointer)dir );
    return ER_OK;
}

static void find_gconf_key (gpointer key, gpointer value, gpointer user_data)
{
    UNUSED(value);
    FindKeyInfo *info = (FindKeyInfo *) user_data;

    if (   !info->found
        && strcmp ((char *) key, info->key) == 0 )
    {
        info->found = TRUE;
    }
}

static void write_properties_stringhash (gpointer key, gpointer value, gpointer user_data)
{
    char *esc_key;
    char *full_key;
    const char *path = (const char*) user_data;
    const char *str_value = (const char *) value;

    if (str_value && *str_value)
    {
        esc_key = gconf_escape_key ((char *) key, -1);
        full_key = g_strconcat (path, "/", esc_key, NULL);
        gconf_client_set_string (client, full_key, (char *) str_value, NULL);
        g_free (esc_key);
        g_free (full_key);
    }
}

GArray* ergconf_get_int_array(const gchar* key)
{
    GConfValue *gc_value = NULL;
    GArray *ret = NULL;

    g_assert(client);
    g_assert(key && *key);

    gc_value = gconf_client_get (client, key, NULL);
    if (gc_value == NULL)
    {
        return NULL;
    }

    if (gc_value->type == GCONF_VALUE_LIST
        && gconf_value_get_list_type (gc_value) == GCONF_VALUE_INT)
    {
        GSList *elt;

        ret = g_array_new (FALSE, FALSE, sizeof (gint));
        for (elt = gconf_value_get_list (gc_value); elt != NULL; elt = g_slist_next (elt))
        {
            int i = gconf_value_get_int ((GConfValue *) elt->data);
            g_array_append_val (ret, i);
        }
    }

    if (gc_value != NULL)
    {
        gconf_value_free (gc_value);
    }
    return ret;
}

int ergconf_set_int_array(const gchar* key, const GArray* new_value)
{
    gboolean ret = FALSE;
    GSList *list = NULL;

    g_assert(client);
    g_assert(key && *key);
    g_return_val_if_fail(new_value != NULL, FALSE);

    unsigned int i;
    for (i = 0; i < new_value->len; i++)
    {
        gint val = g_array_index (new_value, gint, i);
        list = g_slist_append (list, GINT_TO_POINTER(val));
    }

    ret = gconf_client_set_list (client, key, GCONF_VALUE_INT, list, NULL);

    g_slist_free (list);
    return ret == TRUE ? ER_OK : ER_FAIL;
}

GPtrArray* ergconf_get_int_tuples(const gchar* key, guint tuple_len)
{
    GConfValue *gc_value = NULL;
    GPtrArray *ret = NULL;
    GSList *values, *iter;
    GArray *tuple = NULL;

    g_assert(client);
    g_assert(key && *key);
    g_return_val_if_fail (tuple_len > 0, FALSE);

    if (!(gc_value = gconf_client_get (client, key, NULL)))
    {
        goto out;
    }

    if (   (gc_value->type != GCONF_VALUE_LIST)
        || (gconf_value_get_list_type (gc_value) != GCONF_VALUE_INT))
    {
        goto out;
    }

    values = gconf_value_get_list (gc_value);
    if (g_slist_length (values) % tuple_len != 0)
    {
        g_warning ("%s: %s format invalid; # elements not divisible by %d",
                   __func__, key, tuple_len);
        goto out;
    }

    ret = g_ptr_array_sized_new (1);
    for (iter = values; iter; iter = g_slist_next (iter))
    {
        int i = gconf_value_get_int ((GConfValue *) iter->data);

        if (tuple == NULL)
        {
            tuple = g_array_sized_new (FALSE, TRUE, sizeof (guint32), tuple_len);
        }

        g_array_append_val (tuple, i);

        /* Got all members; add to the array */
        if (tuple->len == tuple_len)
        {
            g_ptr_array_add (ret, tuple);
            tuple = NULL;
        }
    }

out:
    if (gc_value)
    {
        gconf_value_free (gc_value);
    }
    return ret;
}

int ergconf_set_int_tuples(const gchar* key, const GPtrArray* value, guint tuple_len)
{
    GSList *list = NULL;
    gboolean ret = FALSE;

    g_assert(client);
    g_assert(key && *key);
    g_return_val_if_fail(value != NULL, FALSE);
    g_return_val_if_fail (tuple_len > 0, FALSE);

    unsigned int i;
    for (i = 0; i < value->len; i++)
    {
        GArray *tuple = g_ptr_array_index (value, i);

        if (tuple->len != tuple_len)
        {
            g_warning ("%s: invalid IPv4 address/route structure!", __func__);
            goto out;
        }

        unsigned int j;
        for (j = 0; j < tuple_len; j++)
        {
            list = g_slist_append (list, GUINT_TO_POINTER (g_array_index (tuple, guint32, j)));
        }
    }

    ret = gconf_client_set_list (client, key, GCONF_VALUE_INT, list, NULL);

out:
    g_slist_free (list);
    return ret == TRUE ? ER_OK : ER_FAIL;
}

void ergconf_free_int_tuples(GPtrArray* tuple_list)
{
    g_return_if_fail(tuple_list);

    unsigned int i;
    for (i = 0; i < tuple_list->len; i++)
    {
        GArray *tuple = g_ptr_array_index (tuple_list, i);
        g_array_free(tuple, TRUE);
    }
    g_ptr_array_free(tuple_list, TRUE);
}

GSList* ergconf_get_sub_dirs(const gchar *dir)
{
    g_assert(client);
    g_assert(dir && *dir);

    GError *err = NULL;
    GSList *list = gconf_client_all_dirs(client, dir, &err);

    if (err != NULL )
    {
        g_warning ("Error while reading connection: %s", err->message);
        g_error_free (err);
        return NULL;
    }

    return list;
}

void ergconf_free_string_list(GSList* str_list)
{
    GSList* p = str_list;

    g_assert(client);

    while (p)
    {
        g_free(p->data);
        p = p->next;
    }

    g_slist_free(str_list);
}

gboolean ergconf_dir_exist(const gchar* dir)
{
    return gconf_client_dir_exists(client, dir, NULL);
}

gboolean ergconf_is_default(const gchar* key)
{
    g_assert(client);
    g_assert(key && *key);
    GConfEntry *entry = gconf_client_get_entry(client, key, NULL, TRUE, NULL);
    return gconf_entry_get_is_default(entry);
}