Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/**
* @file mce-conf.c
* Configuration option handling for MCE
* <p>
* Copyright © 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
* Copyright (C) 2013-2019 Jolla Ltd.
* <p>
* @author David Weinehall <david.weinehall@nokia.com>
* @author Santtu Lakkala <ext-santtu.1.lakkala@nokia.com>
* @author Simo Piiroinen <simo.piiroinen@jollamobile.com>
*
* mce is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 2.1 as published by the Free Software Foundation.
*
* mce 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mce. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mce-conf.h"
#include "mce.h"
#include "mce-log.h"
#include "modules/led.h"
#include <string.h>
#include <glob.h>
/** Pointer to the keyfile structure where config values are read from */
static gpointer keyfile = NULL;
/** Internal helper for insuring valid keyfile pointer is available
*
* @param keyfilepointer custom key file, or NULL to use the default one
*
* @returns non-null keyfile pointer, or aborts
*/
static gpointer mce_conf_get_keyfile(void)
{
if( !keyfile ) {
/* Earlier it was possible to have mce running with NULL
* keyfile. Now the only reasons that might happen are:
* 1) mce_conf_init() was not called yet
* 2) mce_conf_init() has failed
* 3) mce_conf_exit() has already been called
* i.e. critical logic errors somewhere */
mce_log(LL_CRIT, "mce config subsystem used without "
"properly initializing it");
mce_abort();
}
return keyfile;
}
/** Check if configuration group is available
*
* @param group The configuration group
*
* @return TRUE if group is available, FALSE otherwise
*/
gboolean mce_conf_has_group(const gchar *group)
{
gpointer keyfileptr = mce_conf_get_keyfile();
return g_key_file_has_group(keyfileptr, group);
}
/** Check if configuration key is available
*
* @param group The configuration group
* @param key The configuration key
*
* @return TRUE if key is available, FALSE otherwise
*/
gboolean mce_conf_has_key(const gchar *group, const gchar *key)
{
gpointer keyfileptr = mce_conf_get_keyfile();
GError *error = NULL;
gboolean res = g_key_file_has_key(keyfileptr, group, key, &error);
g_clear_error(&error);
return res;
}
/**
* Get a boolean configuration value
*
* @param group The configuration group to get the value from
* @param key The configuration key to get the value of
* @param defaultval The default value to use if the key isn't set
* @param keyfileptr A keyfile pointer, or NULL to use the default keyfile
* @return The configuration value on success, the default value on failure
*/
gboolean mce_conf_get_bool(const gchar *group, const gchar *key,
const gboolean defaultval)
{
gboolean tmp = FALSE;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_boolean(keyfileptr, group, key, &error);
if (error != NULL) {
mce_log(LL_DEBUG,
"Could not get config key %s/%s; %s; "
"defaulting to `%d'",
group, key, error->message, defaultval);
tmp = defaultval;
}
g_clear_error(&error);
return tmp;
}
/**
* Get an integer configuration value
*
* @param group The configuration group to get the value from
* @param key The configuration key to get the value of
* @param defaultval The default value to use if the key isn't set
* @param keyfileptr A keyfile pointer, or NULL to use the default keyfile
* @return The configuration value on success, the default value on failure
*/
gint mce_conf_get_int(const gchar *group, const gchar *key,
const gint defaultval)
{
gint tmp = -1;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_integer(keyfileptr, group, key, &error);
if (error != NULL) {
mce_log(LL_DEBUG,
"Could not get config key %s/%s; %s; "
"defaulting to `%d'",
group, key, error->message, defaultval);
tmp = defaultval;
}
g_clear_error(&error);
return tmp;
}
/**
* Get an integer list configuration value
*
* @param group The configuration group to get the value from
* @param key The configuration key to get the value of
* @param length The length of the list, or NULL if not needed
* @param keyfileptr A keyfile pointer, or NULL to use the default keyfile
* @return The configuration value on success, NULL on failure
*/
gint *mce_conf_get_int_list(const gchar *group, const gchar *key,
gsize *length)
{
gint *tmp = NULL;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_integer_list(keyfileptr, group, key,
length, &error);
if (error != NULL) {
mce_log(LL_DEBUG,
"Could not get config key %s/%s; %s",
group, key, error->message);
if( length )
*length = 0;
}
g_clear_error(&error);
return tmp;
}
/**
* Get a string configuration value
*
* @param group The configuration group to get the value from
* @param key The configuration key to get the value of
* @param defaultval The default value to use if the key isn't set
* @param keyfileptr A keyfile pointer, or NULL to use the default keyfile
* @return The configuration value on success, the default value on failure
*/
gchar *mce_conf_get_string(const gchar *group, const gchar *key,
const gchar *defaultval)
{
gchar *tmp = NULL;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_string(keyfileptr, group, key, &error);
if (error != NULL) {
mce_log(LL_DEBUG,
"Could not get config key %s/%s; %s; %s%s%s",
group, key, error->message,
defaultval ? "defaulting to `" : "no default set",
defaultval ? defaultval : "",
defaultval ? "'" : "");
if (defaultval != NULL)
tmp = g_strdup(defaultval);
}
g_clear_error(&error);
return tmp;
}
/**
* Get a string list configuration value
*
* @param group The configuration group to get the value from
* @param key The configuration key to get the value of
* @param length The length of the list, or NULL if not needed
* @param keyfileptr A keyfile pointer, or NULL to use the default keyfile
* @return The configuration value on success, NULL on failure
*/
gchar **mce_conf_get_string_list(const gchar *group, const gchar *key,
gsize *length)
{
gchar **tmp = NULL;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_string_list(keyfileptr, group, key,
length, &error);
if (error != NULL) {
mce_log(LL_DEBUG,
"Could not get config key %s/%s; %s",
group, key, error->message);
if( length )
*length = 0;
}
g_clear_error(&error);
return tmp;
}
gchar **mce_conf_get_keys(const gchar *group, gsize *length)
{
gchar **tmp = NULL;
GError *error = NULL;
gpointer keyfileptr = mce_conf_get_keyfile();
tmp = g_key_file_get_keys(keyfileptr, group, length, &error);
if (error != NULL) {
mce_log(LL_WARN,
"Could not get config keys %s; %s",
group, error->message);
if( length )
*length = 0;
}
g_clear_error(&error);
return tmp;
}
/** Copy key value key value from one keyfile to another
*
* @param dest keyfile to modify
* @param srce keyfile to copy from
* @param grp value group to copy
* @param key value key to copy
*/
static void mce_conf_override_key(GKeyFile *dest, GKeyFile *srce,
const char *grp, const char *key)
{
gchar *val = g_key_file_get_value(srce, grp, key, 0);
if( val ) {
//mce_log(LL_NOTICE, "[%s] %s = %s", grp, key, val);
g_key_file_set_value(dest, grp, key, val);
g_free(val);
}
}
/** Augment key value with data from another file
*
* @param dest keyfile to modify
* @param srce keyfile to add from
* @param grp value group to add
* @param key value key to add
*/
static void mce_conf_append_key(GKeyFile *dest, GKeyFile *srce,
const char *grp, const char *key)
{
gchar *val = g_key_file_get_value(srce, grp, key, 0);
if( val ) {
gchar *old = g_key_file_get_value(dest, grp, key, 0);
gchar *tmp = 0;
if( old && *old ) {
tmp = g_strconcat(val, ";", old, NULL);
}
//mce_log(LL_NOTICE, "[%s] %s = %s", grp, key, tmp ?: val);
g_key_file_set_value(dest, grp, key, tmp ?: val);
g_free(tmp);
g_free(old);
g_free(val);
}
}
/** Merge value from one keyfile to another
*
* Existing values will be overridden, except for values
* in group [evdev] that are appended to existing data.
*
* @param dest keyfile to modify
* @param srce keyfile to merge from
* @param grp value group to merge
* @param key value key to merge
*/
static void mce_conf_merge_key(GKeyFile *dest, GKeyFile *srce,
const char *grp, const char *key)
{
/* groups/keys to append instead of overriding */
static const struct {
const gchar *grp;
const gchar *key; // NULL == every key in the group
} lut[] = {
{
.grp = "evdev",
},
{
.grp = "modules/display",
},
{
.grp = MCE_CONF_LED_GROUP,
.key = MCE_CONF_LED_PATTERNS_REQUIRED,
},
{
.grp = MCE_CONF_LED_GROUP,
.key = MCE_CONF_LED_PATTERNS_DISABLED,
},
{
.grp = NULL,
}
};
for( size_t i = 0; ; ++i ) {
if( lut[i].grp == NULL ) {
mce_conf_override_key(dest, srce, grp, key);
break;
}
if( strcmp(lut[i].grp, grp) )
continue;
if( !lut[i].key || !strcmp(lut[i].key, key) ) {
mce_conf_append_key(dest, srce, grp, key);
break;
}
}
}
/** Merge group of values from one keyfile to another
*
* @param dest keyfile to modify
* @param srce keyfile to merge from
* @param grp value group to merge
*/
static void mce_conf_merge_group(GKeyFile *dest, GKeyFile *srce,
const char *grp)
{
gchar **key = g_key_file_get_keys(srce, grp, 0, 0);
if( key ) {
for( size_t k = 0; key[k]; ++k )
mce_conf_merge_key(dest, srce, grp, key[k]);
g_strfreev(key);
}
}
/** Merge all groups and values from one keyfile to another
*
* @param dest keyfile to modify
* @param srce keyfile to merge from
*/
static void mce_conf_merge_file(GKeyFile *dest, GKeyFile *srce)
{
gchar **grp = g_key_file_get_groups(srce, 0);
if( grp ) {
for( size_t g = 0; grp[g]; ++g )
mce_conf_merge_group(dest, srce, grp[g]);
g_strfreev(grp);
}
}
/** Callback function for logging errors within glob()
*
* @param path path to file/dir where error occurred
* @param err errno that occurred
*
* @return 0 (= do not stop glob)
*/
static int mce_conf_glob_error_cb(const char *path, int err)
{
mce_log(LL_WARN, "%s: glob: %s", path, g_strerror(err));
return 0;
}
/** Process config data from /etc/mce/mce.d/xxx.ini files
*/
static GKeyFile *mce_conf_read_ini_files(void)
{
static const char pattern[] = MCE_CONF_DIR"/[0-9][0-9]*.ini";
GKeyFile *ini = g_key_file_new();
glob_t gb;
memset(&gb, 0, sizeof gb);
if( glob(pattern, 0, mce_conf_glob_error_cb, &gb) != 0 ) {
mce_log(LL_WARN, "no mce configuration ini-files found");
goto EXIT;
}
for( size_t i = 0; i < gb.gl_pathc; ++i ) {
const char *path = gb.gl_pathv[i];
GError *err = 0;
GKeyFile *tmp = g_key_file_new();
if( !g_key_file_load_from_file(tmp, path, 0, &err) ) {
mce_log(LL_WARN, "%s: can't load: %s", path,
err->message ?: "unknown");
}
else {
mce_log(LL_NOTICE, "processing %s ...", path);
mce_conf_merge_file(ini, tmp);
}
g_clear_error(&err);
g_key_file_free(tmp);
}
EXIT:
globfree(&gb);
return ini;
}
/* XXX:
* We should probably use
* /dev/input/keypad
* /dev/input/gpio-keys
* /dev/input/pwrbutton
* /dev/input/ts
* and add whitelist entries for misc devices instead
*/
/**
* List of drivers that provide touchscreen events
* XXX: If this is made case insensitive,
* we could search for "* touchscreen" instead
*/
static const gchar *const touch_builtin[] = {
/** Input layer name for the Atmel mXT touchscreen */
"Atmel mXT Touchscreen",
/** Input layer name for the Atmel QT602240 touchscreen */
"Atmel QT602240 Touchscreen",
/** TSC2005 touchscreen */
"TSC2005 touchscreen",
/** TSC2301 touchscreen */
"TSC2301 touchscreen",
/** ADS784x touchscreen */
"ADS784x touchscreen",
/** No more entries */
NULL
};
/**
* List of drivers that provide keyboard events
*/
static const gchar *const keybd_builtin[] = {
/** Input layer name for the TWL4030 keyboard/keypad */
"TWL4030 Keypad",
/** Legacy input layer name for the TWL4030 keyboard/keypad */
"omap_twl4030keypad",
/** Generic input layer name for keyboard/keypad */
"Internal keyboard",
/** Input layer name for the LM8323 keypad */
"LM8323 keypad",
/** Generic input layer name for keypad */
"Internal keypad",
/** Input layer name for the TSC2301 keypad */
"TSC2301 keypad",
/** Legacy generic input layer name for keypad */
"omap-keypad",
/** Input layer name for standard PC keyboards */
"AT Translated Set 2 keyboard",
/** Input layer name for the power button in various MeeGo devices */
"msic_power_btn",
/** Input layer name for the TWL4030 power button */
"twl4030_pwrbutton",
/** Input layer name for the Triton 2 power button */
"triton2-pwrbutton",
/** Input layer name for the Retu powerbutton */
"retu-pwrbutton",
/** Input layer name for the PC Power button */
"Power Button",
/** Input layer name for the PC Sleep button */
"Sleep Button",
/** Input layer name for the Thinkpad extra buttons */
"Thinkpad Extra Buttons",
/** Input layer name for ACPI virtual keyboard */
"ACPI Virtual Keyboard Device",
/** Input layer name for GPIO-keys */
"gpio-keys",
/** Input layer name for DFL-61/TWL4030 jack sense */
"dfl61-twl4030 Jack",
/** Legacy input layer name for TWL4030 jack sense */
"rx71-twl4030 Jack",
/** Input layer name for PC Lid switch */
"Lid Switch",
/** No more entries */
NULL
};
/**
* List of drivers that we should not monitor
*/
static const gchar *const black_builtin[] = {
/** Input layer name for the AMI305 magnetometer */
"ami305 magnetometer",
/** Input layer name for the ST LIS3LV02DL accelerometer */
"ST LIS3LV02DL Accelerometer",
/** Input layer name for the ST LIS302DL accelerometer */
"ST LIS302DL Accelerometer",
/** Input layer name for the TWL4030 vibrator */
"twl4030:vibrator",
/** Input layer name for AV accessory */
"AV Accessory",
/** Input layer name for the video bus */
"Video Bus",
/** Input layer name for the PC speaker */
"PC Speaker",
/** Input layer name for the Intel HDA headphone */
"HDA Intel Headphone",
/** Input layer name for the Intel HDA microphone */
"HDA Intel Mic",
/** Input layer name for the UVC 17ef:4807 webcam in thinkpad X301 */
"UVC Camera (17ef:4807)",
/** Input layer name for the UVC 17ef:480c webcam in thinkpad X201si */
"UVC Camera (17ef:480c)",
/** No more entries */
NULL
};
/** List of touchscreen event devices obtained from ini files */
static gchar **touch_cached = NULL;
/** List of keyboard event devices obtained from ini files */
static gchar **keybd_cached = NULL;
/** List of blacklisted event devices obtained from ini files */
static gchar **black_cached = NULL;
/**
* Init function for the mce-conf component
*
* @return TRUE on success, FALSE on failure
*/
gboolean mce_conf_init(void)
{
gboolean status = FALSE;
if( !(keyfile = mce_conf_read_ini_files()) )
goto EXIT;
touch_cached = g_key_file_get_string_list(keyfile,
"evdev",
"touch",
0, 0);
keybd_cached = g_key_file_get_string_list(keyfile,
"evdev",
"keybd",
0, 0);
black_cached = g_key_file_get_string_list(keyfile,
"evdev",
"black",
0, 0);
status = TRUE;
EXIT:
return status;
}
/**
* Exit function for the mce-conf component
*/
void mce_conf_exit(void)
{
g_strfreev(touch_cached), touch_cached = 0;
g_strfreev(keybd_cached), keybd_cached = 0;
g_strfreev(black_cached), black_cached = 0;
if( keyfile ) g_key_file_free(keyfile), keyfile = 0;
return;
}
const gchar * const *mce_conf_get_touchscreen_event_drivers(void)
{
return (const gchar*const*)touch_cached ?: touch_builtin;
}
const gchar * const *mce_conf_get_keyboard_event_drivers(void)
{
return (const gchar*const*)keybd_cached ?: keybd_builtin;
}
const gchar * const *mce_conf_get_blacklisted_event_drivers(void)
{
return (const gchar*const*)black_cached ?: black_builtin;
}