/****************************************************************************
* apps/system/settings/settings.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <sys/types.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <nuttx/crc32.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <ctype.h>
#include <nuttx/config.h>
#include "storage.h"
#include "system/settings.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifdef CONFIG_SYSTEM_SETTINGS_CACHED_SAVES
# define TIMER_SIGNAL SIGRTMIN
#endif
#ifndef CONFIG_SYSTEM_SETTINGS_CACHE_TIME_MS
# define CONFIG_SYSTEM_SETTINGS_CACHE_TIME_MS 100
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int sanity_check(FAR char *str);
static uint32_t hash_calc(void);
static int get_setting(FAR char *key, FAR setting_t **setting);
static size_t get_string(FAR setting_t *setting, FAR char *buffer,
size_t size);
static int set_string(FAR setting_t *setting, FAR char *str);
static int get_int(FAR setting_t *setting, FAR int *i);
static int set_int(FAR setting_t *setting, int i);
static int get_bool(FAR setting_t *setting, FAR int *i);
static int set_bool(FAR setting_t *setting, int i);
static int get_float(FAR setting_t *setting, FAR double *f);
static int set_float(FAR setting_t *setting, FAR double f);
static int get_ip(FAR setting_t *setting, FAR struct in_addr *ip);
static int set_ip(FAR setting_t *setting, FAR struct in_addr *ip);
static int load(void);
static void save(void);
static void signotify(void);
static void dump_cache(union sigval ptr);
/****************************************************************************
* Private Data
****************************************************************************/
static struct
{
pthread_mutex_t mtx;
uint32_t hash;
bool wrpend;
bool initialized;
storage_t store[CONFIG_SYSTEM_SETTINGS_MAX_STORAGES];
struct notify_s notify[CONFIG_SYSTEM_SETTINGS_MAX_SIGNALS];
#if defined(CONFIG_SYSTEM_SETTINGS_CACHED_SAVES)
struct sigevent sev;
struct itimerspec trigger;
timer_t timerid;
#endif
} g_settings;
setting_t map[CONFIG_SYSTEM_SETTINGS_MAP_SIZE];
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: hash_calc
*
* Description:
* Gets a setting for a string value
*
* Input Parameters:
* none
* Returned Value:
* crc32 hash of all the settings
*
****************************************************************************/
static uint32_t hash_calc(void)
{
return crc32((FAR uint8_t *)map, sizeof(map));
}
/****************************************************************************
* Name: get_setting
*
* Description:
* Gets a setting for a given key
*
* Input Parameters:
* key - key of the required setting
* setting - pointer to pointer for the setting
*
* Returned Value:
* The value of the setting for the given key
*
****************************************************************************/
static int get_setting(FAR char *key, FAR setting_t **setting)
{
int i;
int ret = OK;
assert(*setting == NULL);
for (i = 0; i < CONFIG_SYSTEM_SETTINGS_MAP_SIZE; i++)
{
if (map[i].type == SETTING_EMPTY)
{
ret = -ENOENT;
goto exit;
}
if (strcmp(map[i].key, key) == 0)
{
*setting = &map[i];
goto exit;
}
}
*setting = NULL;
ret = -ENOENT;
exit:
return ret;
}
/****************************************************************************
* Name: get_string
*
* Description:
* Gets a setting for a string value
*
* Input Parameters:
* setting - pointer to the setting type
* str - pointer to return the string value
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static size_t get_string(FAR setting_t *setting, FAR char *buffer,
size_t size)
{
assert(setting);
if ((setting->type != SETTING_STRING) &&
(setting->type != SETTING_IP_ADDR))
{
return -EACCES;
}
if (setting->type == SETTING_STRING)
{
FAR const char *s = setting->val.s;
size_t len = strlen(s);
assert(len < size);
if (len >= size)
{
return 0;
}
strncpy(buffer, s, size);
buffer[size - 1] = '\0';
return len;
}
else if (setting->type == SETTING_IP_ADDR)
{
assert(INET_ADDRSTRLEN < size);
inet_ntop(AF_INET, &setting->val.ip, buffer, size);
buffer[size - 1] = '\0';
return strlen(buffer);
}
return 0;
}
/****************************************************************************
* Name: set_string
*
* Description:
* Creates a setting for a string value setting->type != set_
*
* Input Parameters:
* setting - pointer to the setting type
* str - the string value
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int set_string(FAR setting_t *setting, FAR char *str)
{
assert(setting);
if ((setting->type != SETTING_STRING) &&
(setting->type != SETTING_IP_ADDR))
{
return -EACCES;
}
ASSERT(strlen(str) < CONFIG_SYSTEM_SETTINGS_VALUE_SIZE);
if (strlen(str) >= CONFIG_SYSTEM_SETTINGS_VALUE_SIZE)
{
return -EINVAL;
}
if (strlen(str) && (sanity_check(str) < 0))
{
return -EINVAL;
}
setting->type = SETTING_STRING;
strncpy(setting->val.s, str, CONFIG_SYSTEM_SETTINGS_VALUE_SIZE);
setting->val.s[CONFIG_SYSTEM_SETTINGS_VALUE_SIZE - 1] = '\0';
return OK;
}
/****************************************************************************
* Name: get_int
*
* Description:
* Gets a setting for an integer value
*
* Input Parameters:
* setting - pointer to the setting type
* i - pointer to return the integer value
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int get_int(FAR setting_t *setting, FAR int *i)
{
assert(setting);
if ((setting->type != SETTING_INT) &&
(setting->type != SETTING_BOOL) &&
(setting->type != SETTING_FLOAT))
{
return -EACCES;
}
if (setting->type == SETTING_INT)
{
*i = setting->val.i;
}
else if (setting->type == SETTING_BOOL)
{
*i = !!setting->val.i;
}
else if (setting->type == SETTING_FLOAT)
{
*i = (int)setting->val.f;
}
else
{
return -EINVAL;
}
return OK;
}
/****************************************************************************
* Name: set_int
*
* Description:
* Creates a setting for an integer value
*
* Input Parameters:
* setting - pointer to the setting type
* i - the integer value
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int set_int(FAR setting_t *setting, int i)
{
assert(setting);
if ((setting->type != SETTING_INT) &&
(setting->type != SETTING_BOOL) &&
(setting->type != SETTING_FLOAT))
{
return -EACCES;
}
setting->type = SETTING_INT;
setting->val.i = i;
return OK;
}
/****************************************************************************
* Name: get_bool
*
* Description:
* Gets a setting for a boolean value
*
* Input Parameters:
* setting - pointer to the setting type
* f - pointer to return the boolean value
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int get_bool(FAR setting_t *setting, FAR int *i)
{
assert(setting);
if ((setting->type != SETTING_BOOL) &&
(setting->type != SETTING_INT))
{
return -EACCES;
}
if ((setting->type == SETTING_INT) || (setting->type == SETTING_BOOL))
{
*i = !!setting->val.i;
}
else
{
return -EINVAL;
}
return OK;
}
/****************************************************************************
* Name: set_bool
*
* Description:
* Creates a setting for a boolean value
*
* Input Parameters:
* setting - pointer to the setting type
* i - the boolean value
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int set_bool(FAR setting_t *setting, int i)
{
assert(setting);
if ((setting->type != SETTING_BOOL) && (setting->type != SETTING_INT))
{
return -EACCES;
}
setting->type = SETTING_BOOL;
setting->val.i = !!i;
return OK;
}
/****************************************************************************
* Name: get_float
*
* Description:
* Gets a setting for a float value
*
* Input Parameters:
* setting - pointer to the setting type
* f - pointer to return the floating point value
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int get_float(FAR setting_t *setting, FAR double *f)
{
assert(setting);
if ((setting->type != SETTING_FLOAT) &&
(setting->type != SETTING_INT))
{
return -EACCES;
}
if (setting->type == SETTING_FLOAT)
{
*f = setting->val.f;
}
else if (setting->type == SETTING_INT)
{
*f = (double)setting->val.i;
}
else
{
return -EINVAL;
}
return OK;
}
/****************************************************************************
* Name: set_float
*
* Description:
* Creates a setting for a float value
*
* Input Parameters:
* setting - pointer to the setting type
* f - the floating point value
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int set_float(FAR setting_t *setting, double f)
{
assert(setting);
if ((setting->type != SETTING_FLOAT) &&
(setting->type != SETTING_INT))
{
return -EACCES;
}
setting->type = SETTING_FLOAT;
setting->val.f = f;
return OK;
}
/****************************************************************************
* Name: get_ip
*
* Description:
* Creates a setting for an IP address
*
* Input Parameters:
* setting - pointer to the setting type
* ip - pointer to return the IP address
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int get_ip(FAR setting_t *setting, FAR struct in_addr *ip)
{
int ret;
assert(setting);
if ((setting->type != SETTING_IP_ADDR) &&
(setting->type != SETTING_STRING))
{
return -EACCES;
}
if (setting->type == SETTING_IP_ADDR)
{
memcpy(ip, &setting->val.ip, sizeof(struct in_addr));
ret = OK;
}
else if (setting->type == SETTING_STRING)
{
ret = inet_pton(AF_INET, setting->val.s, ip);
}
else
{
ret = -EINVAL;
}
return ret;
}
/****************************************************************************
* Name: set_ip
*
* Description:
* Creates a setting for an IP address
*
* Input Parameters:
* setting - pointer to the setting type
* ip - IP address (in network byte order)
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int set_ip(FAR setting_t *setting, FAR struct in_addr *ip)
{
assert(setting);
if ((setting->type != SETTING_IP_ADDR) &&
(setting->type != SETTING_STRING))
{
return -EACCES;
}
setting->type = SETTING_IP_ADDR;
memcpy(&setting->val.ip, ip, sizeof(struct in_addr));
return OK;
}
/****************************************************************************
* Name: load
*
* Description:
* Loads all values
*
* Input Parameters:
* none
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int load(void)
{
int i;
int ret;
int loadfailed = 0;
for (i = 0; i < CONFIG_SYSTEM_SETTINGS_MAX_STORAGES; i++)
{
if ((g_settings.store[i].file[0] != '\0') &&
g_settings.store[i].load_fn)
{
ret = g_settings.store[i].load_fn(g_settings.store[i].file);
if (ret < 0)
{
loadfailed++;
}
}
}
if (loadfailed >= CONFIG_SYSTEM_SETTINGS_MAX_STORAGES)
{
/* ALL storages failed to load. We have a problem. */
return -ENODATA;
}
else
{
return OK;
}
}
/****************************************************************************
* Name: save
*
* Description:
* Saves cached values, either immediately or on a timer
*
* Input Parameters:
* none
*
* Returned Value:
* None
*
****************************************************************************/
static void save(void)
{
g_settings.wrpend = true;
#ifdef CONFIG_SYSTEM_SETTINGS_CACHED_SAVES
ret = timer_settime(g_settings.timerid, 0, &g_settings.trigger, NULL);
#else
union sigval value =
{
.sival_ptr = &g_settings.wrpend,
};
dump_cache(value);
#endif
}
/****************************************************************************
* Name: signotify
*
* Description:
* Notify anything waiting for a signal
*
* Input Parameters:
* none
*
* Returned Value:
* none
*
****************************************************************************/
static void signotify(void)
{
int i;
for (i = 0; i < CONFIG_SYSTEM_SETTINGS_MAX_SIGNALS; i++)
{
if (g_settings.notify[i].pid == 0)
{
break;
}
kill(g_settings.notify[i].pid, g_settings.notify[i].signo);
}
}
/****************************************************************************
* Name: dump_cache
*
* Description:
* Writes out the cached data to the appropriate storage
*
* Input Parameters:
* value - parameter passed if called from a timer signal
*
* Returned Value:
* None
*
****************************************************************************/
static void dump_cache(union sigval ptr)
{
int ret = OK;
FAR bool *wrpend = (bool *)ptr.sival_ptr;
int i;
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
assert(0);
}
for (i = 0; i < CONFIG_SYSTEM_SETTINGS_MAX_STORAGES; i++)
{
if ((g_settings.store[i].file[0] != '\0') &&
g_settings.store[i].save_fn)
{
ret = g_settings.store[i].save_fn(g_settings.store[i].file);
#if 0
if (ret < 0)
{
/* What to do? We can't return anything from a void function.
*
* MIGHT BE A FUTURE REVISIT NEEDED
*/
}
#endif
}
}
*wrpend = false;
pthread_mutex_unlock(&g_settings.mtx);
}
/****************************************************************************
* Name: sanity_check
*
* Description:
* Checks that the string does not contain "illegal" characters
*
* Input Parameters:
* str - the string to check
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
static int sanity_check(FAR char *str)
{
#ifdef CONFIG_DEBUG_ASSERTIONS
assert(strchr(str, '=') == NULL);
assert(strchr(str, ';') == NULL);
assert(strchr(str, '\n') == NULL);
assert(strchr(str, '\r') == NULL);
#else
if ((strchr(str, '=') != NULL) || (strchr(str, ';') != NULL) ||
(strchr(str, '\n') != NULL) || (strchr(str, '\r') != NULL))
{
return -EINVAL;
}
#endif
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: settings_init
*
* Description:
* Initializes the settings storage.
*
* Input Parameters: none
*
* Returned Value: none
*
****************************************************************************/
void settings_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&g_settings.mtx, &attr);
memset(map, 0, sizeof(map));
memset(g_settings.store, 0, sizeof(g_settings.store));
memset(g_settings.notify, 0, sizeof(g_settings.notify));
#if defined(CONFIG_SYSTEM_SETTINGS_CACHED_SAVES)
memset(&g_settings.sev, 0, sizeof(struct sigevent));
g_settings.sev.sigev_notify = SIGEV_THREAD;
g_settings.sev.sigev_signo = TIMER_SIGNAL;
g_settings.sev.sigev_value.sival_ptr = &g_settings.wrpend;
g_settings.sev.sigev_notify_function = dump_cache;
memset(&g_settings.trigger, 0, sizeof(struct itimerspec));
g_settings.trigger.it_value.tv_sec =
CONFIG_SYSTEM_SETTINGS_CACHE_TIME_MS / 1000;
g_settings.trigger.it_value.tv_nsec =
(CONFIG_SYSTEM_SETTINGS_CACHE_TIME_MS % 1000) *
1000 * 1000;
timer_create(CLOCK_REALTIME, &g_settings.sev, &g_settings.timerid);
#endif
g_settings.initialized = true;
g_settings.hash = 0;
g_settings.wrpend = false;
}
/****************************************************************************
* Name: settings_setstorage
*
* Description:
* Sets a file to be used as a settings storage.
* Except from the first file, if loading the file causes any changes
* to the settings, then the new map will be dumped to all files
* (effectively it syncs all storages).
*
* Input Parameters:
* file - the filename of the storage to use
* type - the type of the storage (BINARY or TEXT)
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_setstorage(FAR char *file, enum storage_type_e type)
{
FAR storage_t *storage = NULL;
int ret = OK;
int idx = 0;
uint32_t h;
if (!g_settings.initialized)
{
assert(0);
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
while ((idx < CONFIG_SYSTEM_SETTINGS_MAX_STORAGES) &&
(g_settings.store[idx].file[0] != '\0'))
{
idx++;
}
assert(idx < CONFIG_SYSTEM_SETTINGS_MAX_STORAGES);
if (idx >= CONFIG_SYSTEM_SETTINGS_MAX_STORAGES)
{
ret = -ENOSPC;
goto errout;
}
assert(strlen(file) < CONFIG_SYSTEM_SETTINGS_MAX_FILENAME);
if (strlen(file) >= CONFIG_SYSTEM_SETTINGS_MAX_FILENAME)
{
ret = -EINVAL;
goto errout;
}
storage = &g_settings.store[idx];
strncpy(storage->file, file, sizeof(storage->file));
storage->file[sizeof(storage->file) - 1] = '\0';
switch (type)
{
case STORAGE_BINARY:
{
storage->load_fn = load_bin;
storage->save_fn = save_bin;
}
break;
case STORAGE_TEXT:
{
storage->load_fn = load_text;
storage->save_fn = save_text;
}
break;
default:
{
assert(0);
}
break;
}
ret = storage->load_fn(storage->file);
h = hash_calc();
/* Only save if there are more than 1 storages. */
if ((storage != &g_settings.store[0]) && ((h != g_settings.hash) ||
(access(file, F_OK) != 0)))
{
signotify();
save();
}
g_settings.hash = h;
errout:
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}
/****************************************************************************
* Name: settings_sync
*
* Description:
* Synchronizes the storage.
*
* wait_dump - if cached saves are enabled, this determines whether
* the function will wait until the save is actually
* completed or just schedule a new save
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_sync(bool wait_dump)
{
int ret = OK;
uint32_t h;
if (!g_settings.initialized)
{
assert(0);
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
ret = load();
if (ret < 0) /* All storages failed to load */
{
goto done;
}
h = hash_calc();
if (h != g_settings.hash)
{
g_settings.hash = h;
signotify();
save();
}
done:
pthread_mutex_unlock(&g_settings.mtx);
#ifdef CONFIG_SYSTEM_SETTINGS_CACHED_SAVES
if ((wait_dump && (ret >= 0)))
{
while (g_settings.wrpend)
{
usleep(10 * 1000); /* Sleep for 10ms */
}
}
#endif
return ret;
}
/****************************************************************************
* Name: settings_notify
*
* Description:
* Registers a task to be notified on any change of the settings.
* Whenever any value is changed, a signal will be sent to all
* registered threads. Signals are NOT sent when new settings are
* created or when the whole storage is cleared.
*
* Input Parameters:
* none
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_notify(void)
{
int ret;
int idx = 0;
if (!g_settings.initialized)
{
assert(0);
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
while ((idx < CONFIG_SYSTEM_SETTINGS_MAX_SIGNALS) &&
g_settings.notify[idx].pid)
{
idx++;
}
assert(idx < CONFIG_SYSTEM_SETTINGS_MAX_SIGNALS);
if (idx >= CONFIG_SYSTEM_SETTINGS_MAX_SIGNALS)
{
ret = -EINVAL;
goto errout;
}
g_settings.notify[idx].pid = getpid();
g_settings.notify[idx].signo = CONFIG_SYSTEM_SETTINGS_SIGNO;
errout:
pthread_mutex_unlock(&g_settings.mtx);
return OK;
}
/****************************************************************************
* Name: settings_hash
*
* Description:
* Gets the hash of the settings storage.
*
* This hash represents the internal state of the settings map. A
* unique number is calculated based on the contents of the whole map.
*
* This hash can be used to check the settings for any alterations, i.e.
* any setting that may had its value changed since last check.
*
* Input Parameters:
* none
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_hash(FAR uint32_t *h)
{
if (!g_settings.initialized)
{
assert(0);
}
*h = g_settings.hash;
return OK;
}
/****************************************************************************
* Name: settings_clear
*
* Description:
* Clears all settings.
* Data in all storages are purged.
*
* Note that if the settings are cleared during the application run-time
* (i.e. not during initialization), every access to the settings storage
* will fail.
*
* All settings must be created again. This can be done either by calling
* Settings_create() again, or by restarting the application.
*
* Input Parameters:
* none
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_clear(void)
{
int ret;
if (!g_settings.initialized)
{
assert(0);
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
memset(map, 0, sizeof(map));
g_settings.hash = 0;
save();
pthread_mutex_unlock(&g_settings.mtx);
while (g_settings.wrpend)
{
usleep(10 * 1000); /* Sleep for 10ms */
}
return OK;
}
/****************************************************************************
* Name: settings_create
*
* Description:
* Creates a new setting.
*
* If the setting is found to exist in any of the storages, it will
* be loaded. Else, it will be created and the default value will be
* assigned.
*
* Input Parameters:
* key - the key of the setting.
* type - the type of the setting.
* ... - the default value of the setting.
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_create(FAR char *key, enum settings_type_e type, ...)
{
int ret = OK;
FAR setting_t *setting = NULL;
int j;
if (!g_settings.initialized)
{
assert(0);
}
assert(type != SETTING_EMPTY);
assert(strlen(key));
if (strlen(key) == 0)
{
return -EINVAL;
}
assert(strlen(key) < CONFIG_SYSTEM_SETTINGS_KEY_SIZE);
if (strlen(key) >= CONFIG_SYSTEM_SETTINGS_KEY_SIZE)
{
return -EINVAL;
}
assert(isalpha(key[0]) && (sanity_check(key) == OK));
if (!isalpha(key[0]) || (sanity_check(key) < 0))
{
return -EINVAL;
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
for (j = 0; j < CONFIG_SYSTEM_SETTINGS_MAP_SIZE; j++)
{
if (strcmp(key, map[j].key) == 0)
{
setting = &map[j];
/* We found a setting with this key name */
goto errout;
}
if (map[j].type == SETTING_EMPTY)
{
setting = &map[j];
strncpy(setting->key, key, CONFIG_SYSTEM_SETTINGS_KEY_SIZE);
setting->key[CONFIG_SYSTEM_SETTINGS_KEY_SIZE - 1] = '\0';
/* This setting is empty/unused - we can use it */
break;
}
}
assert(setting);
if (setting == NULL)
{
goto errout;
}
if ((setting->type == SETTING_EMPTY) ||
(setting->type != type))
{
bool set_val = false;
va_list ap;
va_start(ap, type);
switch (type)
{
case SETTING_STRING:
{
FAR char *str = va_arg(ap, FAR char *);
if ((setting->type == SETTING_STRING) ||
(setting->type == SETTING_IP_ADDR))
{
break;
}
set_val = true;
setting->type = SETTING_STRING;
ret = set_string(setting, str);
}
break;
case SETTING_INT:
{
int i = va_arg(ap, int);
if ((setting->type == SETTING_INT) ||
(setting->type == SETTING_BOOL) ||
(setting->type == SETTING_FLOAT))
{
break;
}
set_val = true;
setting->type = SETTING_INT;
ret = set_int(setting, i);
}
break;
case SETTING_BOOL:
{
int i = va_arg(ap, int);
if ((setting->type == SETTING_BOOL) ||
(setting->type == SETTING_INT))
{
break;
}
set_val = true;
setting->type = SETTING_BOOL;
ret = set_bool(setting, i);
}
break;
case SETTING_FLOAT:
{
double f = va_arg(ap, double);
if ((setting->type == SETTING_FLOAT) ||
(setting->type == SETTING_INT))
{
break;
}
set_val = true;
setting->type = SETTING_FLOAT;
ret = set_float(setting, f);
}
break;
case SETTING_IP_ADDR:
{
FAR struct in_addr *ip = va_arg(ap, FAR struct in_addr *);
if ((setting->type == SETTING_IP_ADDR) ||
(setting->type == SETTING_STRING))
{
break;
}
set_val = true;
setting->type = SETTING_IP_ADDR;
ret = set_ip(setting, ip);
}
break;
default:
case SETTING_EMPTY:
{
assert(0);
ret = -EINVAL;
}
break;
}
va_end(ap);
if ((ret < 0) || !set_val)
{
memset(setting, 0, sizeof(setting_t));
setting = NULL;
}
else
{
g_settings.hash = hash_calc();
save();
}
}
errout:
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}
/****************************************************************************
* Name: settings_type
*
* Description:
* Gets the type of a setting.
*
* Input Parameters:
* key - the key of the setting.
* type - pointer to int for the returned setting type
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_type(FAR char *key, FAR enum settings_type_e *stype)
{
int ret;
FAR setting_t *setting;
if (!g_settings.initialized)
{
assert(0);
}
assert(stype != NULL);
assert(key != NULL);
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
ret = get_setting(key, &setting);
if (setting)
{
*stype = setting->type;
}
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}
/****************************************************************************
* Name: settings_get
*
* Description:
* Gets the value of a setting.
*
* Input Parameters:
* key - the key of the setting.
* type - the type of the setting
* ... - pointer to store the setting value plus, if a string
* setting, the length of the string to get
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_get(FAR char *key, enum settings_type_e type, ...)
{
int ret;
FAR setting_t *setting;
if (!g_settings.initialized)
{
assert(0);
}
assert(type != SETTING_EMPTY);
assert(key[0] != '\0');
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
ret = get_setting(key, &setting);
if (ret < 0)
{
goto errout;
}
va_list ap;
va_start(ap, type);
switch (type)
{
case SETTING_STRING:
{
FAR char *buf = va_arg(ap, FAR char *);
size_t len = va_arg(ap, size_t);
ret = (int)get_string(setting, buf, len);
}
break;
case SETTING_INT:
{
FAR int *i = va_arg(ap, FAR int *);
ret = get_int(setting, i);
}
break;
case SETTING_BOOL:
{
FAR int *i = va_arg(ap, FAR int *);
ret = get_bool(setting, i);
}
break;
case SETTING_FLOAT:
{
FAR double *f = va_arg(ap, FAR double *);
ret = get_float(setting, f);
}
break;
case SETTING_IP_ADDR:
{
FAR struct in_addr *ip = va_arg(ap, FAR struct in_addr *);
ret = get_ip(setting, ip);
}
break;
default:
{
assert(0);
}
break;
}
va_end(ap);
errout:
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}
/****************************************************************************
* Name: settings_set
*
* Description:
* Sets the value of a setting. The type can be changed, within limits,
* here too.
*
* Input Parameters:
* key - the key of the setting.
* type - the type of the setting
* ... - the new value of the setting.
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_set(FAR char *key, enum settings_type_e type, ...)
{
int ret;
FAR setting_t *setting;
uint32_t h;
if (!g_settings.initialized)
{
assert(0);
}
assert(type != SETTING_EMPTY);
assert(key[0] != '\0');
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
ret = get_setting(key, &setting);
if (ret < 0)
{
goto errout;
}
va_list ap;
va_start(ap, type);
switch (type)
{
case SETTING_STRING:
{
FAR char *str = va_arg(ap, FAR char *);
ret = set_string(setting, str);
}
break;
case SETTING_INT:
{
int i = va_arg(ap, int);
ret = set_int(setting, i);
}
break;
case SETTING_BOOL:
{
int i = va_arg(ap, int);
ret = set_bool(setting, i);
}
break;
case SETTING_FLOAT:
{
double f = va_arg(ap, double);
ret = set_float(setting, f);
}
break;
case SETTING_IP_ADDR:
{
FAR struct in_addr *ip = va_arg(ap, FAR struct in_addr *);
ret = set_ip(setting, ip);
}
break;
default:
{
assert(0);
}
break;
}
va_end(ap);
if (ret >= 0)
{
h = hash_calc();
if (h != g_settings.hash)
{
g_settings.hash = h;
signotify();
save();
}
}
errout:
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}
/****************************************************************************
* Name: settings_iterate
*
* Description:
* Gets a copy of a setting at the specified position. It can be used to
* iterate over the settings map, by using successive values of idx.
*
* Input Parameters:
* idx - the iteration index for the setting.
* setting - pointer to return the setting value
*
* Returned Value:
* Success or negated failure code
*
****************************************************************************/
int settings_iterate(int idx, FAR setting_t *setting)
{
int ret;
if (!g_settings.initialized)
{
assert(0);
}
assert(setting);
if ((idx < 0) || (idx >= CONFIG_SYSTEM_SETTINGS_MAP_SIZE))
{
memset(setting, 0, sizeof(setting_t));
return -EINVAL;
}
ret = pthread_mutex_lock(&g_settings.mtx);
if (ret < 0)
{
return ret;
}
memcpy(setting, &map[idx], sizeof(setting_t));
if (map[idx].type == SETTING_EMPTY)
{
ret = -ENOENT;
}
pthread_mutex_unlock(&g_settings.mtx);
return ret;
}