static int log_cfg_read(config_file_t config, void *module_config,
char *msg_out)
{
int rc, tmpval;
char tmpstr[1024];
log_config_t *conf = (log_config_t *) module_config;
config_item_t log_block;
/* all allowed parameters names */
static const char * const allowed_params[] = {
"debug_level", "log_file", "report_file",
"alert_file", "alert_mail", "stats_interval", "batch_alert_max",
"alert_show_attrs", "syslog_facility", "log_procname", "log_hostname",
#ifdef HAVE_CHANGELOGS
"changelogs_file",
#endif
NULL
};
/* std parameters */
const cfg_param_t cfg_params[] = {
{"log_file", PT_STRING,
PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS | PFLG_STDIO_ALLOWED,
conf->log_file, sizeof(conf->log_file)}
,
{"report_file", PT_STRING,
PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS | PFLG_STDIO_ALLOWED,
conf->report_file, sizeof(conf->report_file)}
,
{"alert_file", PT_STRING,
PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS | PFLG_STDIO_ALLOWED,
conf->alert_file, sizeof(conf->alert_file)}
,
{"alert_mail", PT_STRING, PFLG_MAIL,
conf->alert_mail, sizeof(conf->alert_mail)}
,
#ifdef HAVE_CHANGELOGS
{"changelogs_file", PT_STRING,
PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS | PFLG_STDIO_ALLOWED,
conf->changelogs_file, sizeof(conf->changelogs_file)}
,
#endif
/* TODO add cfg flag: clean if not found */
{"stats_interval", PT_DURATION, PFLG_POSITIVE | PFLG_NOT_NULL,
&conf->stats_interval, 0}
,
{"batch_alert_max", PT_INT, PFLG_POSITIVE, &conf->batch_alert_max, 0}
,
{"alert_show_attrs", PT_BOOL, 0, &conf->alert_show_attrs, 0}
,
{"log_procname", PT_BOOL, 0, &conf->log_process, 0}
,
{"log_hostname", PT_BOOL, 0, &conf->log_host, 0}
,
{NULL, 0, 0, NULL, 0}
};
/* get Log block */
rc = get_cfg_block(config, RBH_LOG_CONFIG_BLOCK, &log_block, msg_out);
if (rc)
return rc == ENOENT ? 0 : rc; /* not mandatory */
/* read std parameters */
rc = read_scalar_params(log_block, RBH_LOG_CONFIG_BLOCK, cfg_params,
msg_out);
if (rc)
return rc;
/* read specific parameters */
rc = GetStringParam(log_block, RBH_LOG_CONFIG_BLOCK, "debug_level",
PFLG_NO_WILDCARDS, tmpstr, 1024, NULL, NULL, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc != ENOENT) {
tmpval = str2debuglevel(tmpstr);
if (tmpval < 0) {
sprintf(msg_out,
"Invalid value for " RBH_LOG_CONFIG_BLOCK
"::debug_level: '%s'. CRIT, MAJOR, EVENT, VERB, DEBUG or FULL expected",
tmpstr);
return EINVAL;
} else
conf->debug_level = tmpval;
}
rc = GetStringParam(log_block, RBH_LOG_CONFIG_BLOCK, "syslog_facility",
PFLG_NO_WILDCARDS, tmpstr, 1024, NULL, NULL, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc == 0) {
rc = check_syslog_facility(tmpstr, &conf->syslog_facility,
&conf->syslog_priority);
if (rc) {
sprintf(msg_out,
"Invalid syslog channel '%s': expected syntax: <facility>[.<priority>]",
tmpstr);
return rc;
}
}
CheckUnknownParameters(log_block, RBH_LOG_CONFIG_BLOCK, allowed_params);
return 0;
}
static int lmgr_cfg_read(config_file_t config, void *module_config,
char *msg_out)
{
int rc;
bool bval;
lmgr_config_t *conf = (lmgr_config_t *) module_config;
char **options = NULL;
unsigned int nb_options = 0;
char tmpstr[1024];
config_item_t lmgr_block;
config_item_t db_block;
static const char *lmgr_allowed[] = {
"commit_behavior", "connect_retry_interval_min",
"connect_retry_interval_max", "accounting",
MYSQL_CONFIG_BLOCK, SQLITE_CONFIG_BLOCK,
"user_acct", "group_acct", /* deprecated => accounting */
NULL
};
const cfg_param_t cfg_params[] = {
{"connect_retry_interval_min", PT_DURATION, PFLG_POSITIVE |
PFLG_NOT_NULL, &conf->connect_retry_min, 0},
{"connect_retry_interval_max", PT_DURATION, PFLG_POSITIVE |
PFLG_NOT_NULL, &conf->connect_retry_max, 0},
{"accounting", PT_BOOL, 0, &conf->acct, 0},
END_OF_PARAMS
};
#ifdef _MYSQL
static const char *db_allowed[] = {
"server", "db", "user", "password", "password_file", "port", "socket",
"engine", "tokudb_compression", NULL
};
const cfg_param_t db_params[] = {
{"server", PT_STRING, PFLG_NO_WILDCARDS,
conf->db_config.server, sizeof(conf->db_config.server)}
,
{"db", PT_STRING, PFLG_MANDATORY | PFLG_NO_WILDCARDS,
conf->db_config.db, sizeof(conf->db_config.db)}
,
{"user", PT_STRING, PFLG_NO_WILDCARDS, conf->db_config.user,
sizeof(conf->db_config.user)}
,
{"port", PT_INT, PFLG_POSITIVE | PFLG_NOT_NULL,
(int *)&conf->db_config.port, 0},
{"socket", PT_STRING, PFLG_NO_WILDCARDS | PFLG_ABSOLUTE_PATH,
conf->db_config.socket, sizeof(conf->db_config.socket)}
,
{"engine", PT_STRING, PFLG_NO_WILDCARDS | PFLG_NOT_EMPTY,
conf->db_config.engine, sizeof(conf->db_config.engine)}
,
{"tokudb_compression", PT_STRING, PFLG_NO_WILDCARDS,
conf->db_config.tokudb_compression,
sizeof(conf->db_config.tokudb_compression)}
,
END_OF_PARAMS
};
#elif defined(_SQLITE)
static const char *db_allowed[] = {
"db_file", "retry_delay_microsec",
NULL
};
const cfg_param_t db_params[] = {
{"db_file", PT_STRING, PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS,
conf->db_config.filepath, sizeof(conf->db_config.filepath)}
,
{"retry_delay_microsec", PT_INT, PFLG_POSITIVE | PFLG_NOT_NULL,
(int *)&conf->db_config.retry_delay_microsec, 0},
END_OF_PARAMS
};
#endif
/* get ListManager block */
rc = get_cfg_block(config, LMGR_CONFIG_BLOCK, &lmgr_block, msg_out);
if (rc)
return rc;
/* retrieve std parameters */
rc = read_scalar_params(lmgr_block, LMGR_CONFIG_BLOCK, cfg_params, msg_out);
if (rc)
return rc;
/* commit_behavior */
rc = GetStringParam(lmgr_block, LMGR_CONFIG_BLOCK, "commit_behavior",
PFLG_NO_WILDCARDS, tmpstr, sizeof(tmpstr), &options,
&nb_options, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc != ENOENT) {
if (!strcasecmp(tmpstr, "autocommit"))
conf->commit_behavior = 0;
else if (!strcasecmp(tmpstr, "transaction"))
conf->commit_behavior = 1;
else if (!strcasecmp(tmpstr, "periodic")) {
if ((nb_options != 1) || !options || !options[0]) {
strcpy(msg_out,
"A single argument is expected for periodic commit behavior. Eg: commit_behavior = periodic(1000)");
return EINVAL;
}
conf->commit_behavior = atoi(options[0]);
if (conf->commit_behavior == 0) {
strcpy(msg_out,
"The argument for \"" LMGR_CONFIG_BLOCK
"::commit_behavior = periodic\" must be a positive integer. Eg: commit_behavior = periodic(1000)");
return EINVAL;
}
} else {
sprintf(msg_out,
"Invalid commit behavior '%s' (expected: autocommit, "
"transaction, periodic(<count>))", tmpstr);
return EINVAL;
}
}
/* manage deprecated parameters */
rc = GetBoolParam(lmgr_block, LMGR_CONFIG_BLOCK, "user_acct", 0, &bval,
NULL, NULL, msg_out);
if (rc == 0) {
DisplayLog(LVL_CRIT, TAG,
"WARNING: parameter %s::%s' is deprecated. Specify 'accounting = yes/no' instead.",
LMGR_CONFIG_BLOCK, "user_acct");
DisplayLog(LVL_MAJOR, TAG,
"Setting 'accounting = %s' for compatibility.",
bool2str(bval));
conf->acct = bval;
}
rc = GetBoolParam(lmgr_block, LMGR_CONFIG_BLOCK, "group_acct", 0, &bval,
NULL, NULL, msg_out);
if (rc == 0) {
DisplayLog(LVL_CRIT, TAG,
"WARNING: parameter %s::%s' is deprecated. Specify 'accounting = yes/no' instead.",
LMGR_CONFIG_BLOCK, "group_acct");
DisplayLog(LVL_MAJOR, TAG,
"Setting 'accounting = %s' for compatibility.",
bool2str(bval));
conf->acct = bval;
}
CheckUnknownParameters(lmgr_block, LMGR_CONFIG_BLOCK, lmgr_allowed);
/* Database parameters */
#ifdef _MYSQL
/* get MySQL block */
rc = get_cfg_block(config, LMGR_CONFIG_BLOCK "::" MYSQL_CONFIG_BLOCK,
&db_block, msg_out);
if (rc)
return rc;
/* DB std params */
rc = read_scalar_params(db_block, MYSQL_CONFIG_BLOCK, db_params, msg_out);
if (rc)
return rc;
/* DB params with specific type */
rc = GetStringParam(db_block, MYSQL_CONFIG_BLOCK, "password",
0, conf->db_config.password, 256, NULL, NULL, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc == ENOENT) {
FILE *passfile;
char errstr[1024];
rc = GetStringParam(db_block, MYSQL_CONFIG_BLOCK,
"password_file",
PFLG_ABSOLUTE_PATH | PFLG_NO_WILDCARDS,
tmpstr, sizeof(tmpstr), NULL, NULL, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc == ENOENT) {
strcpy(msg_out,
MYSQL_CONFIG_BLOCK "::password or "
MYSQL_CONFIG_BLOCK "::password_file must be provided");
return ENOENT;
}
/* read password file and @TODO check its rights */
passfile = fopen(tmpstr, "r");
if (!passfile) {
rc = errno;
sprintf(msg_out, "Error opening password file %s : %s", tmpstr,
strerror(errno));
return rc;
}
rc = fscanf(passfile, "%1023s", tmpstr);
if (ferror(passfile) || rc < 1) {
rc = errno;
if (strerror_r(rc, errstr, sizeof(errstr))) {
snprintf(errstr, sizeof(errstr), "%d", rc);
}
sprintf(msg_out, "Error reading password file %s : %s", tmpstr,
errstr);
return rc;
}
fclose(passfile);
rh_strncpy(conf->db_config.password, tmpstr, 256);
}
CheckUnknownParameters(db_block, MYSQL_CONFIG_BLOCK, db_allowed);
#elif defined(_SQLITE)
/* get SQLite block */
rc = get_cfg_block(config, LMGR_CONFIG_BLOCK "::" SQLITE_CONFIG_BLOCK,
&db_block, msg_out);
if (rc)
return rc;
rc = read_scalar_params(db_block, SQLITE_CONFIG_BLOCK, db_params, msg_out);
if (rc)
return rc;
CheckUnknownParameters(db_block, SQLITE_CONFIG_BLOCK, db_allowed);
#endif
return 0;
}
static int polrun_read_config(config_file_t config, const char *policy_name,
const struct sm_instance *smi,
policy_run_config_t *conf, char *msg_out)
{
int rc;
char block_name[1024];
char tmp[1024];
config_item_t param_block, action_params_block;
char **extra = NULL;
unsigned int extra_cnt = 0;
/* parameter for CheckUnknownParams() */
static const char *allowed[] = {
"lru_sort_attr", "max_action_count",
"max_action_volume", "nb_threads", "suspend_error_pct",
"suspend_error_min", "report_interval", "action_timeout",
"check_actions_interval", "check_actions_on_startup",
"recheck_ignored_entries", "report_actions",
"pre_maintenance_window", "maint_min_apply_delay", "queue_size",
"db_result_size_max", "action_params", "action",
"recheck_ignored_classes", /* for compat */
NULL
};
/* parameter for read_scalar_params() */
const cfg_param_t cfg_params[] = {
{ "max_action_count", PT_INT, PFLG_POSITIVE,
&conf->max_action_nbr, 0
},
{ "max_action_volume", PT_SIZE, PFLG_POSITIVE,
&conf->max_action_vol, 0
},
{ "nb_threads", PT_INT, PFLG_POSITIVE | PFLG_NOT_NULL,
&conf->nb_threads, 0
},
{ "suspend_error_pct", PT_FLOAT, PFLG_POSITIVE | PFLG_ALLOW_PCT_SIGN,
&conf->suspend_error_pct, 0
},
{ "suspend_error_min", PT_INT, PFLG_POSITIVE,
&conf->suspend_error_min, 0
},
{ "report_interval", PT_DURATION, PFLG_POSITIVE | PFLG_NOT_NULL,
&conf->report_interval, 0
},
{ "action_timeout", PT_DURATION, PFLG_POSITIVE,
&conf->action_timeout, 0
},
{ "check_actions_interval", PT_DURATION, PFLG_POSITIVE,
&conf->check_action_status_delay, 0
},
{ "check_actions_on_startup", PT_BOOL, 0,
&conf->check_action_status_on_startup, 0
},
{ "recheck_ignored_entries", PT_BOOL, 0,
&conf->recheck_ignored_entries, 0
},
{"report_actions", PT_BOOL, 0, &conf->report_actions, 0},
{ "pre_maintenance_window", PT_DURATION, PFLG_POSITIVE,
&conf->pre_maintenance_window, 0
},
{ "maint_min_apply_delay", PT_DURATION, PFLG_POSITIVE,
&conf->maint_min_apply_delay, 0
},
{ "queue_size", PT_INT, PFLG_POSITIVE | PFLG_NOT_NULL,
&conf->queue_size, 0
},
{ "db_result_size_max", PT_INT, PFLG_POSITIVE,
&conf->db_request_limit, 0
},
{NULL, 0, 0, NULL, 0}
};
snprintf(block_name, sizeof(block_name), "%s" PARAM_SUFFIX, policy_name);
/* get <policy>_parameters block */
rc = get_cfg_block(config, block_name, ¶m_block, msg_out);
if (rc)
return rc == ENOENT ? 0 : rc; /* not mandatory */
/* check deprecated parameters */
rc = GetBoolParam(param_block, block_name, "recheck_ignored_classes", 0,
&conf->recheck_ignored_entries, NULL, NULL, msg_out);
if (rc == 0)
DisplayLog(LVL_CRIT, TAG, "WARNING: parameter %s::%s' is deprecated. "
"Use 'recheck_ignored_entries' instead.",
block_name, "recheck_ignored_classes");
/* read all scalar params */
rc = read_scalar_params(param_block, block_name, cfg_params, msg_out);
if (rc)
return rc;
/* read specific parameters */
/* 'lru_sort_attr' overrides 'default_lru_sort_attr' from 'define_policy' */
rc = GetStringParam(param_block, block_name, "lru_sort_attr",
PFLG_NO_WILDCARDS, tmp, sizeof(tmp), NULL, NULL,
msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc != ENOENT) {
/* is it a time attribute? */
rc = str2lru_attr(tmp, smi);
if (rc == LRU_ATTR_INVAL) {
strcpy(msg_out, "time attribute expected for 'lru_sort_attr': "
ALLOWED_LRU_ATTRS_STR "...");
return EINVAL;
} else
conf->lru_sort_attr = rc;
}
/* 'action' overrides 'default_action' from 'define_policy' */
rc = GetStringParam(param_block, block_name, "action",
0, tmp, sizeof(tmp), &extra, &extra_cnt, msg_out);
if ((rc != 0) && (rc != ENOENT))
return rc;
else if (rc != ENOENT) {
rc = parse_policy_action("action", tmp, extra, extra_cnt,
&conf->action, &conf->run_attr_mask, msg_out);
if (rc)
return rc;
}
/* get subblock */
bool unique = true;
action_params_block =
rh_config_GetItemByName(param_block, "action_params", &unique);
if (action_params_block != NULL) {
if (!unique) {
sprintf(msg_out, "Found duplicate block '%s' in '%s' line %d.",
"action_params", block_name,
rh_config_GetItemLine(action_params_block));
return EEXIST;
}
if (rh_config_ItemType(action_params_block) != CONFIG_ITEM_BLOCK) {
sprintf(msg_out,
"A block is expected for configuration item '%s::action_params', line %d.",
block_name, rh_config_GetItemLine(action_params_block));
return EINVAL;
}
#ifdef _DEBUG_POLICIES
fprintf(stderr, "processing parameters in '%s'\n", block_name);
#endif
rc = read_action_params(action_params_block, &conf->action_params,
&conf->run_attr_mask, msg_out);
if (rc)
return rc;
}
/* warn for unknown parameters */
CheckUnknownParameters(param_block, block_name, allowed);
return 0;
}
