bool_t getBoolConf(param_t param)
{
config_setting_t *setting = NULL;
switch (param) {
case ALLOW_TEXTMESSAGE:
setting = config_lookup(&configuration, "allow_textmessage");
if (!setting)
return true;
else
return config_setting_get_bool(setting);
break;
case ENABLE_BAN:
setting = config_lookup(&configuration, "enable_ban");
if (!setting)
return false;
else
return config_setting_get_bool(setting);
break;
case SYNC_BANFILE:
setting = config_lookup(&configuration, "sync_banfile");
if (!setting)
return false;
else
return config_setting_get_bool(setting);
break;
default:
doAssert(false);
}
}
int Conf_getNextChannel(conf_channel_t *chdesc, int index)
{
config_setting_t *setting = NULL;
int maxconfig = 64, ret = 0;
char configstr[maxconfig];
ret = snprintf(configstr, maxconfig, "channels.[%d].name", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL)
return -1; /* Required */
chdesc->name = config_setting_get_string(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].parent", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL)
return -1; /* Required */
chdesc->parent = config_setting_get_string(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].description", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
chdesc->description = NULL;
else
chdesc->description = config_setting_get_string(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].password", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
chdesc->password = NULL;
else
chdesc->password = config_setting_get_string(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].noenter", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
chdesc->noenter = false;
else
chdesc->noenter = config_setting_get_bool(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].silent", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
chdesc->silent = false;
else
chdesc->silent = config_setting_get_bool(setting);
ret = snprintf(configstr, maxconfig, "channels.[%d].position", index);
setting = config_lookup(&configuration, configstr);
if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
chdesc->position = 0;
else
chdesc->position = config_setting_get_int(setting);
return 0;
}
//------------------------------------------------------------------------------
// UWAGA - istniejaca lista czujnikow JEST czyszczona !
// Dzieki temu kolejnosc czujnikow na liscie jest zgodna z kolejnoscia z pliku.
int sensors_load_configuration (config_setting_t *setting)
{
config_setting_t *sensor_list = NULL, *sensor = NULL, *s = NULL ;
unsigned int i ;
const char *s_id = NULL, *s_name = NULL ;
unsigned int s_res = 9, s_interval = 5 ;
gboolean s_cached = FALSE ;
sensor_list = config_setting_get_member(setting, "Sensor_List") ;
clear_sensor_list() ;
i=0 ;
while ((sensor = config_setting_get_elem(sensor_list,i)) != NULL) {
// ten kod powinien chyba byc w t_sensor.c
s = config_setting_get_member(sensor, "sensor_id") ;
if (s != NULL) s_id = config_setting_get_string(s) ;
s = config_setting_get_member(sensor, "name") ;
if (s != NULL) s_name = config_setting_get_string(s) ;
s = config_setting_get_member(sensor, "resolution") ;
if (s != NULL) s_res = config_setting_get_int(s) ;
s = config_setting_get_member(sensor, "read_interval") ;
if (s != NULL) s_interval = config_setting_get_int(s) ;
s = config_setting_get_member(sensor, "cached") ;
if (s != NULL) s_cached = config_setting_get_bool(s) ;
add_sensor (s_name, s_id, s_res, s_interval, s_cached) ;
i++ ;
} ;
rebuild_sensors_tree(FALSE) ;
return 0 ;
} ;
static config_setting_t *interface_group_for(const char *ifname) {
assert(config_setting_is_list(app_config));
config_setting_t *default_if_conf = NULL;
for (int i = 0; i < config_setting_length(app_config); i++) {
config_setting_t *cur = config_setting_get_elem(app_config, i);
config_setting_t *cur_ifname = config_setting_get_member(cur, "interface");
if (cur_ifname != NULL) {
const char *cur_ifname_str = config_setting_get_string(cur_ifname);
assert(cur_ifname_str != NULL);
if (strcmp(cur_ifname_str, ifname) == 0) return cur;
}
config_setting_t *cur_is_default = config_setting_get_member(cur, "default");
if (
default_if_conf == NULL &&
cur_is_default != NULL &&
config_setting_get_bool(cur_is_default)
) {
default_if_conf = cur;
}
}
return default_if_conf;
}
void config_setting_copy_simple(config_setting_t *parent, const config_setting_t *src)
{
if (config_setting_is_aggregate(src)) {
config_setting_copy_aggregate(parent, src);
}
else {
config_setting_t *set;
if( config_setting_get_member(parent, config_setting_name(src)) != NULL )
return;
if ((set = config_setting_add(parent, config_setting_name(src), config_setting_type(src))) == NULL)
return;
if (CONFIG_TYPE_INT == config_setting_type(src)) {
config_setting_set_int(set, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
config_setting_set_int64(set, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float(set, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string(set, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool(set, config_setting_get_bool(src));
}
}
}
LIBCONFIG_API int config_lookup_bool(const config_t *config, const char *path)
{
const config_setting_t *s = config_lookup(config, path);
if(! s)
return(0);
return(config_setting_get_bool(s));
}
int config_setting_lookup_bool (const config_setting_t * setting, const char *name, int *value)
{
config_setting_t *member = config_setting_get_member (setting, name);
if (!member)
return (CONFIG_FALSE);
if (config_setting_type (member) != CONFIG_TYPE_BOOL)
return (CONFIG_FALSE);
*value = config_setting_get_bool (member);
return (CONFIG_TRUE);
}
int config_lookup_bool(const config_t *config, const char *path, int *value)
{
const config_setting_t *s = config_lookup(config, path);
if(! s)
return(CONFIG_FALSE);
if(config_setting_type(s) != CONFIG_TYPE_BOOL)
return(CONFIG_FALSE);
*value = config_setting_get_bool(s);
return(CONFIG_TRUE);
}
//-----------------------------------------------------------------------------
T_Display *t_display_new_from_configuration(config_setting_t *disp)
{
T_Display *d ;
config_setting_t *s, *plot_list, *p ;
unsigned width = 200, height = 200, i ;
T_DisplayType type = GRAPHICAL ;
s = config_setting_get_member(disp, "type") ;
if (s != NULL) type = config_setting_get_int(s) ;
if (type == ALPHANUMERIC)
d = t_display_new_alphanumeric() ;
else
d = t_display_new() ;
s = config_setting_get_member(disp, "width") ;
if (s != NULL) width = config_setting_get_int(s) ;
s = config_setting_get_member(disp, "height") ;
if (s != NULL) height = config_setting_get_int(s) ;
gtk_widget_set_size_request((GtkWidget*)(d->canvas),width,height) ;
s = config_setting_get_member(disp, "time_range") ;
if (s != NULL) d->time_range = config_setting_get_int(s) ;
//s = config_setting_get_member(disp, "last_time") ; // to chyba usunac
//d->last_time = config_setting_get_int(s) ;
s = config_setting_get_member(disp, "time_step") ;
if (s != NULL) d->time_step = config_setting_get_int(s) ;
s = config_setting_get_member(disp, "temp_max") ;
if (s != NULL) d->temp_max = config_setting_get_int(s) ;
s = config_setting_get_member(disp, "temp_min") ;
if (s != NULL) d->temp_min = config_setting_get_int(s) ;
s = config_setting_get_member(disp, "temp_step") ;
if (s != NULL) d->temp_step = config_setting_get_int(s) ;
d->font_size = 10 ;
s = config_setting_get_member(disp, "font_size") ;
if (s != NULL) d->font_size = config_setting_get_int(s) ;
d->show_legend = TRUE ;
s = config_setting_get_member(disp, "show_legend") ;
if (s != NULL) d->show_legend = config_setting_get_bool(s) ;
plot_list = config_setting_get_member(disp, "Plots") ;
i=0 ;
while ((p = config_setting_get_elem(plot_list,i)) != NULL) {
t_display_add_plot(d,t_plot_new_from_configuration(p)) ;
i++ ;
} ;
return d ;
} ;
/**
* Load boolean value from config.
* @param[in] section Config section.
* @param[in] option Option name.
* @param[out] pvalue Value pointer.
* @return <0 - error. 0 - success. >0 - not found.
*/
static int zcfg_load_bool(const config_setting_t *option, bool *pvalue)
{
*pvalue = false;
if (!option) {
return 1;
}
if (CONFIG_TYPE_BOOL != option->type) {
return -1;
}
*pvalue = (bool) config_setting_get_bool(option);
return 0;
}
bool directivaHabilitada(config_t* cf, Ruta_t* estructura_ruta)
{
const config_setting_t *path_habilitado;
bool activo = false;
//formo la ruta que uso en la config
char tag_ruta_activo[4+4+4+7] = "confRuta";
char aux[3];
sprintf(aux, "%d",estructura_ruta->id_ruta);
strncat(tag_ruta_activo, aux, 3);
strncat(tag_ruta_activo, ".activo", 7);
path_habilitado= config_lookup(cf, tag_ruta_activo);
activo = config_setting_get_bool(path_habilitado);
return activo;
}
bool directivaRecursiva(config_t* cf, Ruta_t* estructura_ruta)
{
const config_setting_t *path_recursivo;
bool recursivo = false;
//formo la ruta que uso en la config
char tag_ruta_recursivo[4+4+4+10] = "confRuta";
char aux[3];
sprintf(aux, "%d",estructura_ruta->id_ruta);
strncat(tag_ruta_recursivo, aux, 3);
strncat(tag_ruta_recursivo, ".recursivo", 10);
path_recursivo = config_lookup(cf, tag_ruta_recursivo);
recursivo = config_setting_get_bool(path_recursivo);
return recursivo;
}
int read_system_specific_config(config_t * config)
{
config_setting_t * system_settings = config_lookup(config, "system");
if (system_settings == NULL)
{
message(LOG_INFO, FACILITY_CONFIG, "System config section is missing in local config\n");
/* System config is optional section */
return CONFIG_TRUE;
}
config_setting_t * member;
/*mlock*/
member = config_setting_get_member(system_settings, "mlock");
if (member != NULL)
{
if (config_setting_type(member) != CONFIG_TYPE_BOOL)
{
message(LOG_ERROR, FACILITY_CONFIG, "In system local config mlock key has wrong type, it should be bool.\n");
return CONFIG_FALSE;
}
zfs_config.mlock_zfsd = config_setting_get_bool(member);
}
/*metadata_tree_depth*/
member = config_setting_get_member(system_settings, "metadata_tree_depth");
if (member != NULL)
{
if (config_setting_type(member) != CONFIG_TYPE_INT)
{
message(LOG_ERROR, FACILITY_CONFIG, "In system local config metadata_tree_depth key has wrong type, it should be int.\n");
return CONFIG_FALSE;
}
zfs_config.metadata.metadata_tree_depth = config_setting_get_int(member);
if (!is_valid_metadata_tree_depth(zfs_config.metadata.metadata_tree_depth))
{
message(LOG_ERROR, FACILITY_CONFIG, "In system local config metadata_tree_depth key is out of range (min=%d max=%d current=%d).\n",
MIN_METADATA_TREE_DEPTH, MAX_METADATA_TREE_DEPTH, zfs_config.metadata.metadata_tree_depth);
return CONFIG_FALSE;
}
}
return CONFIG_TRUE;
}
void config_setting_copy_elem(config_setting_t *parent, const config_setting_t *src)
{
config_setting_t *set = NULL;
if (config_setting_is_aggregate(src))
config_setting_copy_aggregate(parent, src);
else if (CONFIG_TYPE_INT == config_setting_type(src)) {
set = config_setting_set_int_elem(parent, -1, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
set = config_setting_set_int64_elem(parent, -1, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float_elem(parent, -1, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string_elem(parent, -1, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool_elem(parent, -1, config_setting_get_bool(src));
}
}
static void get_value_libconfig(const config_setting_t *e, void *dest)
{
int type = config_setting_type(e);
switch (type) {
case CONFIG_TYPE_INT:
*(int *)dest = config_setting_get_int(e);
case CONFIG_TYPE_INT64:
*(long long *)dest = config_setting_get_int64(e);
break;
case CONFIG_TYPE_STRING:
dest = (void *)config_setting_get_string(e);
break;
case CONFIG_TYPE_BOOL:
*(int *)dest = config_setting_get_bool(e);
break;
case CONFIG_TYPE_FLOAT:
*(double *)dest = config_setting_get_float(e);
/* Do nothing, add if needed */
}
}
unsigned char config_get_bool(config_t *config, char *setting, unsigned char initial)
{
unsigned char value = 0;
config_setting_t *config_setting = config_lookup(config,setting);
PRINT_SETTING;
if (config_setting == NULL)
{
PRINT_NOT_FOUND;
value = initial;
}
else
{
value = config_setting_get_bool(config_setting);
}
PRINT_VALUE_NUM;
return value;
}
/**
* Loads group configuration from config file into memory.
* @private
*/
static void read_config(void)
{
config_setting_t *groups = NULL;
const char *config_filename = "conf/groups.conf"; // FIXME hardcoded name
int group_count = 0;
if (conf_read_file(&pc_group_config, config_filename))
return;
groups = config_lookup(&pc_group_config, "groups");
if (groups != NULL) {
GroupSettings *group_settings = NULL;
DBIterator *iter = NULL;
int i, loop = 0;
group_count = config_setting_length(groups);
for (i = 0; i < group_count; ++i) {
int id = 0, level = 0;
const char *groupname = NULL;
int log_commands = 0;
config_setting_t *group = config_setting_get_elem(groups, i);
if (!config_setting_lookup_int(group, "id", &id)) {
ShowConfigWarning(group, "pc_groups:read_config: \"groups\" list member #%d has undefined id, removing...", i);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
if (id2group(id) != NULL) {
ShowConfigWarning(group, "pc_groups:read_config: duplicate group id %d, removing...", i);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
config_setting_lookup_int(group, "level", &level);
config_setting_lookup_bool(group, "log_commands", &log_commands);
if (!config_setting_lookup_string(group, "name", &groupname)) {
char temp[20];
config_setting_t *name = NULL;
snprintf(temp, sizeof(temp), "Group %d", id);
if ((name = config_setting_add(group, "name", CONFIG_TYPE_STRING)) == NULL ||
!config_setting_set_string(name, temp)) {
ShowError("pc_groups:read_config: failed to set missing group name, id=%d, skipping... (%s:%d)\n",
id, config_setting_source_file(group), config_setting_source_line(group));
continue;
}
config_setting_lookup_string(group, "name", &groupname); // Retrieve the pointer
}
if (name2group(groupname) != NULL) {
ShowConfigWarning(group, "pc_groups:read_config: duplicate group name %s, removing...", groupname);
config_setting_remove_elem(groups, i);
--i;
--group_count;
continue;
}
CREATE(group_settings, GroupSettings, 1);
group_settings->id = id;
group_settings->level = level;
group_settings->name = groupname;
group_settings->log_commands = (bool)log_commands;
group_settings->inherit = config_setting_get_member(group, "inherit");
group_settings->commands = config_setting_get_member(group, "commands");
group_settings->permissions = config_setting_get_member(group, "permissions");
group_settings->inheritance_done = false;
group_settings->root = group;
group_settings->group_pos = i;
strdb_put(pc_groupname_db, groupname, group_settings);
idb_put(pc_group_db, id, group_settings);
}
group_count = config_setting_length(groups); // Save number of groups
// Check if all commands and permissions exist
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *commands = group_settings->commands, *permissions = group_settings->permissions;
int count = 0, j;
// Make sure there is "commands" group
if (commands == NULL)
commands = group_settings->commands = config_setting_add(group_settings->root, "commands", CONFIG_TYPE_GROUP);
count = config_setting_length(commands);
for (j = 0; j < count; ++j) {
config_setting_t *command = config_setting_get_elem(commands, j);
const char *name = config_setting_name(command);
if (!atcommand_exists(name)) {
ShowConfigWarning(command, "pc_groups:read_config: non-existent command name '%s', removing...", name);
config_setting_remove(commands, name);
--j;
--count;
}
}
// Make sure there is "permissions" group
if (permissions == NULL)
permissions = group_settings->permissions = config_setting_add(group_settings->root, "permissions", CONFIG_TYPE_GROUP);
count = config_setting_length(permissions);
for(j = 0; j < count; ++j) {
config_setting_t *permission = config_setting_get_elem(permissions, j);
const char *name = config_setting_name(permission);
int p;
ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), p, strcmp(pc_g_permission_name[p].name, name) == 0);
if (p == ARRAYLENGTH(pc_g_permission_name)) {
ShowConfigWarning(permission, "pc_groups:read_config: non-existent permission name '%s', removing...", name);
config_setting_remove(permissions, name);
--p;
--count;
}
}
}
dbi_destroy(iter);
// Apply inheritance
i = 0; // counter for processed groups
while (i < group_count) {
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *inherit = NULL,
*commands = group_settings->commands,
*permissions = group_settings->permissions;
int j, inherit_count = 0, done = 0;
if (group_settings->inheritance_done) // group already processed
continue;
if ((inherit = group_settings->inherit) == NULL ||
(inherit_count = config_setting_length(inherit)) <= 0) { // this group does not inherit from others
++i;
group_settings->inheritance_done = true;
continue;
}
for (j = 0; j < inherit_count; ++j) {
GroupSettings *inherited_group = NULL;
const char *groupname = config_setting_get_string_elem(inherit, j);
if (groupname == NULL) {
ShowConfigWarning(inherit, "pc_groups:read_config: \"inherit\" array member #%d is not a name, removing...", j);
config_setting_remove_elem(inherit,j);
continue;
}
if ((inherited_group = name2group(groupname)) == NULL) {
ShowConfigWarning(inherit, "pc_groups:read_config: non-existent group name \"%s\", removing...", groupname);
config_setting_remove_elem(inherit,j);
continue;
}
if (!inherited_group->inheritance_done)
continue; // we need to do that group first
// Copy settings (commands/permissions) that are not defined yet
if (inherited_group->commands != NULL) {
int l = 0, commands_count = config_setting_length(inherited_group->commands);
for (l = 0; l < commands_count; ++l)
config_setting_copy(commands, config_setting_get_elem(inherited_group->commands, l));
}
if (inherited_group->permissions != NULL) {
int l = 0, permissions_count = config_setting_length(inherited_group->permissions);
for (l = 0; l < permissions_count; ++l)
config_setting_copy(permissions, config_setting_get_elem(inherited_group->permissions, l));
}
++done; // copied commands and permissions from one of inherited groups
}
if (done == inherit_count) { // copied commands from all of inherited groups
++i;
group_settings->inheritance_done = true; // we're done with this group
}
}
dbi_destroy(iter);
if (++loop > group_count) {
ShowWarning("pc_groups:read_config: Could not process inheritance rules, check your config '%s' for cycles...\n",
config_filename);
break;
}
} // while(i < group_count)
// Pack permissions into GroupSettings.e_permissions for faster checking
iter = db_iterator(pc_group_db);
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
config_setting_t *permissions = group_settings->permissions;
int c, count = config_setting_length(permissions);
for (c = 0; c < count; ++c) {
config_setting_t *perm = config_setting_get_elem(permissions, c);
const char *name = config_setting_name(perm);
int val = config_setting_get_bool(perm);
int j;
if (val == 0) // does not have this permission
continue;
ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), j, strcmp(pc_g_permission_name[j].name, name) == 0);
group_settings->e_permissions |= pc_g_permission_name[j].permission;
}
}
dbi_destroy(iter);
}
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' groups in '"CL_WHITE"%s"CL_RESET"'.\n", group_count, config_filename);
if( ( pc_group_max = group_count ) ) {
DBIterator *iter = db_iterator(pc_group_db);
GroupSettings *group_settings = NULL;
int* group_ids = aMalloc( pc_group_max * sizeof(int) );
int i = 0;
for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) {
group_ids[i++] = group_settings->id;
}
atcommand_db_load_groups(group_ids);
aFree(group_ids);
dbi_destroy(iter);
}
}
/*********************
return RET_NOK on error
*********************/
ret_code_t entry_copy_config(config_setting_t * source, config_setting_t * dest)
{
config_setting_t * new_source;
config_setting_t * new_dest;
int index = -1;
int int_value;
long long long_value;
double double_value;
const char * string;
while((new_source=config_setting_get_elem(source,index+1))!= NULL ) {
index++;
if(config_setting_is_group(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_GROUP)) {
return RET_NOK;
}
}
else if(config_setting_is_array(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_ARRAY)) {
return RET_NOK;
}
}
else if(config_setting_is_list(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_LIST)) {
return RET_NOK;
}
}
else {
switch(config_setting_type(new_source)) {
case CONFIG_TYPE_INT:
int_value = config_setting_get_int(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT);
config_setting_set_int(new_dest,int_value);
continue;
case CONFIG_TYPE_INT64:
long_value = config_setting_get_int64(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT64);
config_setting_set_int64(new_dest,long_value);
continue;
case CONFIG_TYPE_FLOAT:
double_value = config_setting_get_float(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_FLOAT);
config_setting_set_float(new_dest,double_value);
continue;
case CONFIG_TYPE_BOOL:
int_value = config_setting_get_bool(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_BOOL);
config_setting_set_bool(new_dest,int_value);
continue;
case CONFIG_TYPE_STRING:
string = config_setting_get_string(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_STRING);
config_setting_set_string(new_dest,string);
continue;
default:
return RET_NOK;
}
}
}
return RET_OK;
}
int read_versioning_config(config_t * config)
{
config_setting_t * setting_versioning = config_lookup(config, "versioning");
if (setting_versioning == NULL)
{
message(LOG_INFO, FACILITY_CONFIG, "No versioning section was found in local config.\n");
return CONFIG_TRUE;
}
config_setting_t * member;
/* versioning::enable */
member = config_setting_get_member(setting_versioning, "enable");
if (member != NULL)
{
if (config_setting_type(member) != CONFIG_TYPE_BOOL)
{
message(LOG_ERROR, FACILITY_CONFIG, "Failed to read versoning::enable, enable has wrong type,\n");
return CONFIG_FALSE;
}
zfs_config.versions.versioning = config_setting_get_bool(member);
}
/* versioning::display */
member = config_setting_get_member(setting_versioning, "display");
if (member != NULL)
{
if (config_setting_type(member) != CONFIG_TYPE_BOOL)
{
message(LOG_ERROR, FACILITY_CONFIG, "Failed to read versoning::display, enable has wrong type,\n");
return CONFIG_FALSE;
}
zfs_config.versions.verdisplay = config_setting_get_bool(member);
}
/* versioning::retention_age */
config_setting_t * setting_age = config_setting_get_member(setting_versioning, "retention_age");
if (setting_age != NULL)
{
int rv = read_interval_setting(setting_age, &(zfs_config.versions.retention_age_min),
&(zfs_config.versions.retention_age_max));
if (rv != CONFIG_TRUE)
{
message(LOG_ERROR, FACILITY_CONFIG, "Failed to read versioning::retention age.\n");
return CONFIG_FALSE;
}
}
/* versioning::retention_num */
config_setting_t * setting_num = config_setting_get_member(setting_versioning, "retention_num");
if (setting_num != NULL)
{
int rv = read_interval_setting(setting_num, &(zfs_config.versions.retention_num_min),
&(zfs_config.versions.retention_num_max));
if (rv != CONFIG_TRUE)
{
message(LOG_ERROR, FACILITY_CONFIG, "Failed to read versioning::retention num.\n");
return CONFIG_FALSE;
}
}
return CONFIG_TRUE;
}
