export.c

Go to the documentation of this file.

/*
 * File Name: export.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 <glib/gstdio.h>
#include <gconf/gconf-client.h>
#include <sys/utsname.h> /* for uname */
#include <unistd.h> /* for unlink */
#include <sys/stat.h> /* for mkdir */

// ereader include files, between < >

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

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


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


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

#define PATH_SYSSET "/sys/devices/system/sysset/sysset0/"


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


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

static gboolean create_registry (const char *filename);
static void export_device_info  (GKeyFile *key_file);
static void export_gconf        (GConfClient *client, GKeyFile *key_file, const char *path, gboolean force_defaults);
static void export_gconf_entries(GConfClient *client, GKeyFile *key_file, const char *path, gboolean force_defaults);
static void export_gconf_entry  (GConfClient *client, GKeyFile *key_file, GConfEntry* entry, gboolean force_defaults);

static gchar *get_file_content             (const gchar* file_path);
static char  *get_kernel_version           (void);
static char  *get_micro_bootloader_version (void);
static char  *get_micro_app_version        (void);
static char  *get_sub_dir                  (const char* parent, const char* sub_dir);


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

gboolean export_registry(GConfClient *client, const char *filename, const char **paths, gboolean force_defaults)
{
    GKeyFile *key_file = NULL;
    FILE     *inifile  = NULL;
    GError   *error    = NULL;

    // load ini file from disk
    //
    key_file = g_key_file_new();
    if (!g_key_file_load_from_file(key_file, filename, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error))
    {
        if (error->code == G_KEY_FILE_ERROR_PARSE)
        {
            g_error_free(error);
            error = NULL;

            g_print("Error parsing file, backup as: %s.old\n", filename);
            // parse error loading ini, backup old
            gchar *filename_old = g_strconcat(filename, ".old", NULL);
            unlink(filename_old);
            rename(filename, filename_old);
            g_free(filename_old);
        }

        g_print("File does not exist, create new: %s\n", filename);
        if (!create_registry(filename))
        {
            g_print("Error creating new file: %s\n", filename);
            return FALSE;
        }
    }
    
    // write system information
    //
    export_device_info(key_file);

    // recurse through registry to load current entries
    //
    gint i;
    for (i = 0; paths[i]; i++)
    {    
        export_gconf(client, key_file, paths[i], force_defaults);
    }
    
    // read pointercal to load calibation settings
#if 0  // disabled see PR3439
    export_pointercal(key_file);
#endif 

    // write updated ini file back to disk
    //
    inifile = fopen(filename, "w");
    if (inifile == NULL)
    {
        g_print("Error writing file: %s\n", filename);
        g_key_file_free(key_file);
        return FALSE;
    }
    else
    {
        fprintf(inifile, "%s", g_key_file_to_data(key_file, NULL, NULL));
        fclose(inifile);
    }

    g_key_file_free(key_file);
    
    return TRUE;
}


static gboolean create_registry(const char *filename)
{
    // create path
    gchar *path = g_path_get_dirname(filename);
    if (path)
    {
        gint rc = g_mkdir(path, 0755);
        g_free(path);
        if (rc < 0 && errno != EEXIST)
        {
            // failed to create directory
            g_printf("Error creating dir [%s]: %s\n", path, strerror(errno));
            return FALSE;
        }
    }
    else
    {
        // failed to get dirname
        return FALSE;
    }
    
    // create an empty ini
    if (!g_file_set_contents (filename, "", -1, NULL))
    { 
        // failed writing to file
        return FALSE;
    }
    
    return TRUE;
}


static void export_gconf_entry(GConfClient* client, GKeyFile *key_file, GConfEntry* entry, gboolean force_defaults)
{
    UNUSED(client);
    const char* key     = gconf_entry_get_key(entry);
    GConfValue* value   = gconf_entry_get_value(entry);
    gboolean is_default = gconf_entry_get_is_default(entry);

#if (LOGGING_ON)
    show_entry(client, entry);
#endif    
    
    // don't export default value unless forced and the key already exists in the ini file 
    if ( is_default 
         && !(force_defaults && g_key_file_has_key(key_file, INI_GROUP_REGISTRY, key, NULL)) )
    {
        LOGPRINTF("default key not exported: %s", key);
        return;
    }

    LOGPRINTF("is_default [%d] force [%d] has_key [%d]", is_default, force_defaults, g_key_file_has_key(key_file, INI_GROUP_REGISTRY, key, NULL));
    
    if (value) 
    {
        switch (value->type) 
        {
        case GCONF_VALUE_STRING: 
            g_key_file_set_string(key_file, INI_GROUP_REGISTRY, key, gconf_value_get_string(value));
            break;
        
        case GCONF_VALUE_INT:
            g_key_file_set_integer(key_file, INI_GROUP_REGISTRY, key, gconf_value_get_int(value));
            break;      
        
        case GCONF_VALUE_FLOAT:
            g_key_file_set_double(key_file, INI_GROUP_REGISTRY, key, gconf_value_get_float(value));
            break;            
        
        case GCONF_VALUE_BOOL:
            g_key_file_set_boolean(key_file, INI_GROUP_REGISTRY, key, gconf_value_get_bool(value));
            break;            
                    
        case GCONF_VALUE_LIST:
            {
                GSList *valuelist = gconf_value_get_list(value);
                gsize len = g_slist_length(valuelist);
                
                switch (gconf_value_get_list_type(value))
                {
                case GCONF_VALUE_STRING:
                    {
                        // make string list of GSList
                        //
                        gchar **list = g_malloc0((len+1)*sizeof(gchar *));
                        gchar **ptr=list;
                        while (valuelist!=NULL) 
                        {
                            const char *str = gconf_value_get_string(valuelist->data);
                            if (str)
                            {
                                *ptr = g_strdup(str);
                                ptr = ptr + 1;
                            }
                            valuelist=valuelist->next; 
                        }
                        
                        // set list
                        g_key_file_set_string_list(key_file, INI_GROUP_REGISTRY, key, (const gchar * const *)list, len);
                        
                        // free allocated memory
                        g_strfreev(list);                
                    }
                    break;
                            
                case GCONF_VALUE_INT:
                    {
                        // make integer list of GSList
                        //
                        gint *list = g_malloc0((len+1)*sizeof(gint));
                        gint *ptr=list;
                        while (valuelist!=NULL) 
                        {
                            gint val = gconf_value_get_int(valuelist->data);
                            if (val)
                            {
                                *ptr++ = val;
                            }
                            valuelist=valuelist->next; 
                        }
                        
                        // set list
                        g_key_file_set_integer_list(key_file, INI_GROUP_REGISTRY, key, list, len);
                        
                        // free allocated memory
                        g_free(list);                
                    }
                    break;
                            
                case GCONF_VALUE_FLOAT:
                    {
                        // make float list of GSList
                        //
                        double *list = g_malloc0((len+1)*sizeof(double));
                        double *ptr=list;
                        while (valuelist!=NULL) 
                        {
                            double val = gconf_value_get_float(valuelist->data);
                            if (val)
                            {
                                *ptr++ = val;
                            }
                            valuelist=valuelist->next; 
                        }
                        
                        // set list
                        g_key_file_set_double_list(key_file, INI_GROUP_REGISTRY, key, list, len);
                        
                        // free allocated memory
                        g_free(list);                
                    }
                    break;
                            
                case GCONF_VALUE_BOOL:
                    {
                        // make boolean list of GSList
                        //
                        gboolean *list = g_malloc0((len+1)*sizeof(gboolean));
                        gboolean *ptr=list;
                        while (valuelist!=NULL) 
                        {
                            gboolean val = gconf_value_get_bool(valuelist->data);
                            if (val)
                            {
                                *ptr++ = val;
                            }
                            valuelist=valuelist->next; 
                        }
                        
                        // set list
                        g_key_file_set_boolean_list(key_file, INI_GROUP_REGISTRY, key, list, len);
                        
                        // free allocated memory
                        g_free(list);                
                    }
                    break;
                            
                default:
                    g_print("Unsupported data type of list for key: %s\n", key);
                    break;
                }
                
                g_slist_free(valuelist);
            }
            break;            
                
        case GCONF_VALUE_INVALID:
        default:
            // invalid or supported data type
            g_print("Invalid or unsupported data type for key: %s\n", key);
            break;
        }
    }
    else
    {
        // invalid value
        g_print("Invalid value for key: %s\n", key);
    } 
}


static void export_gconf_entries(GConfClient *client, GKeyFile *key_file, const char *path, gboolean force_defaults)
{
    GSList *entries = gconf_client_all_entries(client, (char*) path, NULL);
    while (entries!=NULL)
    {
        export_gconf_entry(client, key_file, (GConfEntry*) entries->data, force_defaults);
        entries=entries->next;
    }   
}    


static void export_gconf(GConfClient *client, GKeyFile *key_file, const char *path, gboolean force_defaults)
{
    GSList *tmp = gconf_client_all_dirs(client, path, NULL);

    export_gconf_entries(client, key_file, path, force_defaults);

    // resursively dump all directories below
    while (tmp!=NULL) 
    {
        export_gconf(client, key_file, (char*) tmp->data, force_defaults);
        tmp=tmp->next; 
    }
}


#if 0  // disabled See PR3439
static void export_pointercal(GKeyFile *key_file)
{
    FILE        *calfile = NULL;
    gint        a_cur[7];
    
    calfile = fopen(CAL_FILE, "r");
    if (calfile == NULL)
    {
        g_print("Error opening file: %s\n", CAL_FILE);
        return;
    }
    else
    {
        fscanf(calfile, "%d %d %d %d %d %d %d",
                a_cur + 0,
                a_cur + 1,
                a_cur + 2,
                a_cur + 3,
                a_cur + 4,
                a_cur + 5,
                a_cur + 6);
        
        fclose(calfile);
    }
    
    g_key_file_set_integer_list(key_file, INI_GROUP_XTSCAL, "pointercal", a_cur, 7);

    return;
}
#endif 


static gchar *get_file_content(const gchar* file_path)
{
    gchar* contents = NULL;
    gsize  len      = 0;

    if (g_file_get_contents(file_path, &contents, &len, NULL) == FALSE)
    {
        return NULL;
    }

    // Remove trailing '\n' characters
    while (len > 0 && (contents[len - 1] == '\n' || contents[len - 1] == '\0'))
    {
        contents[len - 1] = '\0';
        len--;
    }
    return contents;
}


static char *get_kernel_version()
{
    struct utsname utsbuf;
    unsigned int   build_no;

    if (-1 == uname(&utsbuf))
    {
        // An error occurred.
        return NULL;
    }

    // Return only the build number of the kernel, not the major version
    sscanf(utsbuf.version, "#%d", &build_no);
    return g_strdup_printf("%d", build_no);
}


static char *get_micro_bootloader_version()
{
    char* serio = get_sub_dir("/sys/devices", "serio");
    char* bootloader_ver_path = NULL;
    char* content             = NULL;

    if (serio == NULL)
    {
        LOGPRINTF("Can't find the micro device name!");
        return NULL;
    }

    bootloader_ver_path = g_strdup_printf("%s/boot_ver", serio);
    content = get_file_content(bootloader_ver_path);

    g_free(bootloader_ver_path);
    g_free(serio);
    return content;
}


static char *get_micro_app_version()
{
    char* serio = get_sub_dir("/sys/devices", "serio");
    char* app_ver_path = NULL;
    char* content      = NULL;

    if (serio == NULL)
    {
        LOGPRINTF("Can't find the micro device name!");
        return NULL;
    }

    app_ver_path = g_strdup_printf("%s/micro_ver", serio);
    content = get_file_content(app_ver_path);

    g_free(app_ver_path);
    g_free(serio);
    return content;
}


static char *get_sub_dir(const char* parent, const char* sub_dir)
{
    GDir* dir  = g_dir_open(parent, 0, NULL);
    const char* file = NULL;
    char  full_path[256];

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

    while ((file = g_dir_read_name(dir)) != NULL)
    {
        // Skip regular file.
        snprintf(full_path, sizeof(full_path), "%s/%s", parent, file);

        if (g_file_test(full_path, G_FILE_TEST_IS_DIR) == TRUE &&
            g_str_has_prefix(file, sub_dir) == TRUE)
        {
            // Sub dir found.
            return g_strdup_printf("%s/%s", parent, file);
        }
    }

    g_dir_close(dir);
    return NULL;
}


static void export_device_info(GKeyFile *key_file)
{
    gchar *data = NULL;
    gchar *cat = NULL;
    gchar *mod = NULL;
    gchar *reg = NULL;
    
    // Build up product type from category model and region: e.g. DR1000S-XW
    cat = get_file_content(PATH_SYSSET "fasm/category");
    mod = get_file_content(PATH_SYSSET "fasm/model");
    if (mod) g_strchomp(mod); // Need to strip because Jan adds trailing spaces in sysset
    reg = get_file_content(PATH_SYSSET "fasm/region");
    if (cat && mod && reg) data = g_strconcat(cat, mod, "-", reg, NULL);
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "product_type", data);
    
    data = get_file_content(PATH_SYSSET "fasm/serial");
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "serial_number", data);

    data = get_file_content("/etc/version");
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "software_version", data);

    data = get_kernel_version();
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "kernel_version", data);
    
    data = get_micro_bootloader_version();
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "micro_bootloader", data);

    data = get_micro_app_version();
    if (data) g_key_file_set_string(key_file, INI_GROUP_DEVICEINFO, "micro_application", data);
    
    if (data) g_free(data);
    if (cat) g_free(cat);
    if (mod) g_free(mod);
    if (reg) g_free(reg);
}