import.c

Go to the documentation of this file.

/*
 * File Name: import.c
 */

/*
 * This file is part of erconftool.
 *
 * erconftool 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.
 *
 * erconftool 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) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

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

// system include files, between < >
#include <glib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>

#include <gconf/gconf-client.h>

// ereader include files, between < >

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


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


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------


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


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

static void import_update_key(GConfClient *client, GKeyFile *keyfile, const char *group, const char *key);


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

void import_registry(GConfClient *client, const char *filename, const char **paths)
{
    GKeyFile *key_file = NULL;
    GError   *error = NULL;
    gsize    length = -1;
    char     **keys = NULL; 
    
    key_file = g_key_file_new();
    g_key_file_load_from_file(key_file, filename, G_KEY_FILE_NONE, &error);
    if (error != NULL) 
    {
        g_print("Error loading file: %s\n", error->message);
        g_key_file_free(key_file);
        g_error_free(error);
        return;
    }     

    // read and import registry group
    //
    keys = g_key_file_get_keys(key_file, INI_GROUP_REGISTRY, &length, &error);
    if (error != NULL) 
    {
        g_print("Error loading registry settings: %s\n", error->message);
        g_error_free(error);
        g_key_file_free(key_file);
        return;
    }     

    guint i = 0;
    for (i=0; i<length; i++)
    {
        gint j;
        for (j = 0; paths[j]; j++)
        {
            if (strstr(keys[i], paths[j]))
            {
                // TODO: make these exceptions implicit through the namespace
                if (strstr(keys[i], "list_locales") || strstr(keys[i], "list_languages"))
                {
                    // don't import these keys
                }
                else
                {
                    import_update_key((GConfClient*) client, key_file, INI_GROUP_REGISTRY, keys[i]);
                }
            }
        }
    }
 
    // read and import pointercal
#if 0   // disabled see PR3439
    import_pointercal(key_file);
#endif 

    // free memory
    g_strfreev(keys);
    g_key_file_free(key_file);
}


static void import_update_key(GConfClient *client, GKeyFile *key_file, const char *group, const char *key)
{
    /**
     * NOTE
     *  
     * Updating keys which do not exist and do not have a schema will
     * fail as no current value and data type can be determined for it.
     *
     * Optionally keys can be created by calling the appropriate 
     * gconf_client_set_xxx() function.
     */
    GError *error = NULL;
    
    GConfEntry *entry = gconf_client_get_entry(client, key, NULL, TRUE, NULL);
    GConfValue *value = gconf_entry_get_value(entry);
    gboolean is_writable = gconf_entry_get_is_writable(entry);
    GConfValueType type = GCONF_VALUE_INVALID;

    if (value) 
    { 
        type = value->type;
    }
    else
    {
        // try to get type from schema
        const char *schema_key = gconf_entry_get_schema_name(entry);
        if (schema_key)
        {
            GConfSchema *schema = gconf_client_get_schema(client, schema_key, NULL);
            if (schema)
            {
                type = gconf_schema_get_type(schema);
                is_writable = TRUE;
            }
        }
    }
    
    if (value && is_writable) 
    {
        switch (type) 
        {
        case GCONF_VALUE_STRING: 
            {
                gchar *ini_value = g_key_file_get_string(key_file, group, key, &error);
                if (!error)
                {
                    if (strcmp(gconf_value_get_string(value), ini_value) != 0) 
                    {
                        LOGPRINTF("key %s updated to `%s`", key, ini_value);
                        gconf_client_set_string(client, key, ini_value, &error);
                    }
                    g_free(ini_value);
                }
                else
                {
                    g_print("Error reading key %s, %s\n", key, error->message);
                    g_error_free(error);
                    error = NULL;
                }
            }
            break;
                
        case GCONF_VALUE_INT:
            {
                gint ini_value = g_key_file_get_integer(key_file, group, key, &error);
                if (!error)
                {
                    if (gconf_value_get_int(value) != ini_value) 
                    {
                        LOGPRINTF("key %s updated to %d", key, ini_value);
                        gconf_client_set_int(client, key, ini_value, &error);
                    }
                }
                else
                {
                    g_print("Error reading key %s, %s\n", key, error->message);
                    g_error_free(error);
                    error = NULL;
                }
            }
            break;      
                
        case GCONF_VALUE_FLOAT:
            {
                gdouble ini_value = g_key_file_get_double(key_file, group, key, &error);
                if (!error)
                {
                    if (gconf_value_get_float(value) != ini_value) 
                    {
                        LOGPRINTF("key %s updated to %f", key, ini_value);
                        gconf_client_set_float(client, key, ini_value, &error);
                    }
                }
                else
                {
                    g_print("Error reading key %s, %s\n", key, error->message);
                    g_error_free(error);
                }
            }
            break;      
                    
        case GCONF_VALUE_BOOL:
            {
                gdouble ini_value = g_key_file_get_boolean(key_file, group, key, &error);
                if (!error)
                {
                    if (gconf_value_get_bool(value) != ini_value) 
                    {
                        LOGPRINTF("key %s updated to %s", key, ini_value ? "true" : "false");
                        gconf_client_set_bool(client, key, ini_value, &error);
                    }
                }
                else
                {
                    g_print("Error reading key %s, %s\n", key, error->message);
                    g_error_free(error);
                    error = NULL;
                }
            }
            break;            

        case GCONF_VALUE_LIST:
            {
                GSList *list = NULL;
                gsize len = 0;
                switch (gconf_value_get_list_type(value))
                {
                case GCONF_VALUE_STRING:
                    {
                        gchar **lval = g_key_file_get_string_list(key_file, group, key, &len, &error);
                        if (lval && len > 0)
                        {
                            // create list, backwards for speed
                            int i;
                            for (i=len-1; i>=0; i--)
                            {
                                if (lval[i])
                                {
                                    GConfValue *conf_value = gconf_value_new(GCONF_VALUE_STRING);
                                    gconf_value_set_string(conf_value, lval[i]);
                                    list = g_slist_prepend(list, conf_value);
                                }
                            }
                            
                            if (list)
                            {
                                LOGPRINTF("key %s updated (%d string entries)", key, len);
                                
                                // add list to registry
                                gconf_value_set_list(value, list);
                                gconf_client_set(client, key, value, &error);

                                // free allocated memory
                                g_slist_free(list);
                                g_strfreev(lval);
                            }
                        }
                        else if (error)
                        {
                            g_print("Error reading key %s, %s\n", key, error->message);
                            g_error_free(error);
                            error = NULL;
                        }
                    }
                    break;
                            
                case GCONF_VALUE_INT:
                    {
                        gint *lval = g_key_file_get_integer_list(key_file, group, key, &len, &error);
                        if (lval && len > 0)
                        {
                            // create list, backwards for speed
                            int i;
                            for (i=len-1; i>=0; i--)
                            {
                                GConfValue *conf_value = gconf_value_new(GCONF_VALUE_INT);
                                gconf_value_set_int(conf_value, lval[i]);
                                list = g_slist_prepend(list, conf_value);
                            }
                            
                            if (list)
                            {
                                LOGPRINTF("key %s updated (%d integer entries)", key, len);
                                
                                // add list to registry
                                gconf_value_set_list(value, list);
                                gconf_client_set(client, key, value, &error);

                                // free allocated memory
                                g_slist_free(list);
                                g_free(lval);
                            }
                        }
                        else if (error)
                        {
                            g_print("Error reading key %s, %s\n", key, error->message);
                            g_error_free(error);
                            error = NULL;
                        }
                    }
                    break;
                            
                case GCONF_VALUE_BOOL:
                    {
                        gboolean *lval = g_key_file_get_boolean_list(key_file, group, key, &len, &error);
                        if (lval && len > 0)
                        {
                            // create list, backwards for speed
                            int i;
                            for (i=len-1; i>=0; i--)
                            {
                                GConfValue *conf_value = gconf_value_new(GCONF_VALUE_BOOL);
                                gconf_value_set_bool(conf_value, lval[i]);
                                list = g_slist_prepend(list, conf_value);
                            }
                            
                            if (list)
                            {
                                LOGPRINTF("key %s updated (%d boolean entries)", key, len);
                                
                                // add list to registry
                                gconf_value_set_list(value, list);
                                gconf_client_set(client, key, value, &error);

                                // free allocated memory
                                g_slist_free(list);
                                g_free(lval);
                            }
                        }
                        else if (error)
                        {
                            g_print("Error reading key %s, %s\n", key, error->message);
                            g_error_free(error);
                            error = NULL;
                        }
                    }
                    break;
                            
                case GCONF_VALUE_FLOAT:
                    {
                        gdouble *lval = g_key_file_get_double_list(key_file, group, key, &len, &error);
                        if (lval && len > 0)
                        {
                            // create list, backwards for speed
                            int i;
                            for (i=len-1; i>=0; i--)
                            {
                                GConfValue *conf_value = gconf_value_new(GCONF_VALUE_FLOAT);
                                gconf_value_set_float(conf_value, lval[i]);
                                list = g_slist_prepend(list, conf_value);
                            }
                            
                            if (list)
                            {
                                LOGPRINTF("key %s updated (%d float entries)", key, len);
                                
                                // add list to registry
                                gconf_value_set_list(value, list);
                                gconf_client_set(client, key, value, &error);

                                // free allocated memory
                                g_slist_free(list);
                                g_free(lval);
                            }
                        }
                        else if (error)
                        {
                            g_print("Error reading key %s, %s\n", key, error->message);
                            g_error_free(error);
                            error = NULL;
                        }
                    }
                    break;
                            
                default:
                    g_print("Unsupported data type of list for key: %s\n", key);
                    break;
                }
                            
            }
            break;
            
        case GCONF_VALUE_SCHEMA:
        case GCONF_VALUE_PAIR:
        case GCONF_VALUE_INVALID:
        default:
            g_print("Invalid or unsupported data type for key: %s\n", key);
            break;
        }
    }
    else
    {
        if (!value) 
        {
            LOGPRINTF("Key %s does not exist in device, not imported\n", key);
        }
        
        if (!is_writable) 
        {
            LOGPRINTF("Key %s is read-only in device, not imported\n", key);
        }
    } 
    
    if (error) 
    {
        g_print("Failed to set GConf key: %s\n", error->message);
        g_error_free(error);     
    }
}


#if 0  // disabled see PR3439
static void import_pointercal(GKeyFile *key_file)
{
    GError *error = NULL;
    FILE   *calfile = NULL;
    gint   *arr = NULL;
    gsize  a_length = 0;
    
    arr = g_key_file_get_integer_list(key_file, INI_GROUP_XTSCAL, "pointercal", &a_length, &error);
    if (error != NULL) 
    {
        g_print("Error loading from file: %s\n", error->message);
        g_error_free(error);
        return;
    }     

    if (a_length != 7)
    {
        g_print("Incorrect number of calibration values\n");
        return;
    }
    
    calfile = fopen(CAL_FILE, "w");
    if (calfile == NULL)
    {
        g_print("Failed to open for writing: %s\n", CAL_FILE);
        return;
    }
    
    fprintf(calfile, "%d %d %d %d %d %d %d\n", arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]);
    fclose(calfile); 
}
#endif