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; }
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; }
/** parse a trigger block from configuration and fills a trigger item */ static int parse_trigger_block(config_item_t config_blk, const char *block_name, trigger_item_t *p_trigger_item, char *msg_out) { int rc; char tmpstr[1024]; char **arg_tab; unsigned int arg_count; config_item_t params_block; const struct trig_target_def *def; static const char *trigger_expect[] = { "trigger_on", "check_interval", "high_threshold_pct", "low_threshold_pct", "high_threshold_vol", "low_threshold_vol", "high_threshold_cnt", "low_threshold_cnt", "alert_high", "alert_low", "post_trigger_wait", "action_params", "max_action_count", "max_action_volume", NULL }; const cfg_param_t cfg_params[] = { { "max_action_count", PT_INT, PFLG_POSITIVE, &p_trigger_item->max_action_nbr, 0 }, { "max_action_volume", PT_SIZE, PFLG_POSITIVE, &p_trigger_item->max_action_vol, 0 }, { "check_interval", PT_DURATION, PFLG_POSITIVE | PFLG_NOT_NULL | PFLG_MANDATORY, &p_trigger_item->check_interval, 0 }, { "alert_high", PT_BOOL, 0, &p_trigger_item->alert_hw, 0 }, { "alert_low", PT_BOOL, 0, &p_trigger_item->alert_lw, 0 }, { "post_trigger_wait", PT_DURATION, 0, &p_trigger_item->post_trigger_wait, 0 }, END_OF_PARAMS }; memset(p_trigger_item, 0, sizeof(*p_trigger_item)); /* retrieve special parameters */ rc = GetStringParam(config_blk, block_name, "trigger_on", PFLG_MANDATORY | PFLG_NO_WILDCARDS, tmpstr, sizeof(tmpstr), &arg_tab, &arg_count, msg_out); if (rc) /* even ENOENT retruns an error because trigger_on is mandatory */ return rc; /* initialize list of optional args */ p_trigger_item->list = NULL; p_trigger_item->list_size = 0; def = str2trigger_def(tmpstr); if (def == NULL) { sprintf(msg_out, "Unexpected value for 'trigger_on' parameter: %s.", tmpstr); return EINVAL; } rc = set_trigger_target(p_trigger_item, def, arg_tab, arg_count, msg_out); if (rc) return rc; /* retrieve high and low thresholds params and check their compatibility */ rc = read_threshold_params(config_blk, block_name, "high", p_trigger_item, &p_trigger_item->hw_type, &p_trigger_item->hw_u, msg_out); if (rc) return rc; rc = read_threshold_params(config_blk, block_name, "low", p_trigger_item, &p_trigger_item->lw_type, &p_trigger_item->lw_u, msg_out); if (rc) return rc; if ((p_trigger_item->trigger_type != TRIG_ALWAYS) && (p_trigger_item->hw_type != p_trigger_item->lw_type)) { strcpy(msg_out, "Incompatible high/low threshold types"); return EINVAL; } /** FIXME RBHv3 count threshold for HSM systems should only match online * files (not released) */ /* retrieve other scalar parameters */ rc = read_scalar_params(config_blk, block_name, cfg_params, msg_out); if (rc) return rc; /* get action_params subblock */ bool unique = true; params_block = rh_config_GetItemByName(config_blk, "action_params", &unique); if (params_block != NULL) { if (!unique) { sprintf(msg_out, "Found duplicate block '%s' in '%s' line %d.", "action_params", block_name, rh_config_GetItemLine(params_block)); return EEXIST; } if (rh_config_ItemType(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(params_block)); return EINVAL; } #ifdef _DEBUG_POLICIES fprintf(stderr, "processing parameters for trigger '%s'\n", block_name); #endif rc = read_action_params(params_block, &p_trigger_item->action_params, &p_trigger_item->params_mask, msg_out); if (rc) return rc; } CheckUnknownParameters(config_blk, block_name, trigger_expect); return 0; }