int get_cfg_block(config_file_t config, const char *name, config_item_t *item, char *msg_out) { bool unique = true; config_item_t block = rh_config_FindItemByName(config, name, &unique); *item = NULL; if (block == NULL) { sprintf(msg_out, "Missing configuration block '%s'", name); return ENOENT; } else if (!unique) { sprintf(msg_out, "Found duplicate of block '%s' line %d.", name, rh_config_GetItemLine(block)); return EEXIST; } if (rh_config_ItemType(block) != CONFIG_ITEM_BLOCK) { sprintf(msg_out, "A block is expected for '%s' item, line %d", name, rh_config_GetItemLine(block)); return EINVAL; } *item = block; return 0; }
int Read_Rmdir_Config( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc; bool bval; rmdir_config_t *conf = ( rmdir_config_t * ) module_config; static const char * rmdir_allowed[] = { "runtime_interval", "nb_threads_rmdir", "rmdir_queue_size", NULL }; /* get RMDIR_PARAM block */ config_item_t param_block = rh_config_FindItemByName( config, RMDIR_PARAM_BLOCK ); if ( param_block == NULL ) { /* no error, because no parameter is mandatory */ return 0; } /* check this is a block... */ if ( rh_config_ItemType( param_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" RMDIR_PARAM_BLOCK "' item" ); return EINVAL; } /* parse parameters */ rc = GetDurationParam(param_block, RMDIR_PARAM_BLOCK, "runtime_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, &conf->runtime_interval, NULL, NULL, msg_out); if ((rc != 0) && (rc != ENOENT)) return rc; rc = GetIntParam( param_block, RMDIR_PARAM_BLOCK, "nb_threads_rmdir", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_threads_rmdir, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( param_block, RMDIR_PARAM_BLOCK, "rmdir_queue_size", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->rmdir_queue_size, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam(param_block, RMDIR_PARAM_BLOCK, "simulation_mode", 0, &bval, NULL, NULL, msg_out); if (rc != ENOENT) { DisplayLog( LVL_EVENT, "RmdirConfig", "WARNING: deprecated parameter 'simulation_mode'. Use '--dry-run' option instead."); } CheckUnknownParameters( param_block, RMDIR_PARAM_BLOCK, rmdir_allowed ); return 0; }
int ReadLmgrConfig( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc; lmgr_config_t *conf = ( lmgr_config_t * ) module_config; char **options = NULL; unsigned int nb_options = 0; char tmpstr[1024]; config_item_t db_block; static const char *lmgr_allowed[] = { "commit_behavior", "connect_retry_interval_min", "connect_retry_interval_max", "user_acct", "group_acct", MYSQL_CONFIG_BLOCK, SQLITE_CONFIG_BLOCK, NULL }; #ifdef _MYSQL static const char *db_allowed[] = { "server", "db", "user", "password", "password_file", "port", "socket", "innodb", NULL }; #elif defined (_SQLITE) static const char *db_allowed[] = { "db_file", "retry_delay_microsec", NULL }; #endif /* get ListManager block */ config_item_t lmgr_block = rh_config_FindItemByName( config, LMGR_CONFIG_BLOCK ); if ( lmgr_block == NULL ) { strcpy( msg_out, "Missing configuration block '" LMGR_CONFIG_BLOCK "'" ); return ENOENT; } if ( rh_config_ItemType( lmgr_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" LMGR_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ /* 1) commit_behavior */ rc = GetStringParam( lmgr_block, LMGR_CONFIG_BLOCK, "commit_behavior", STR_PARAM_NO_WILDCARDS, tmpstr, 1024, &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, "periodical" ) /* for backward compatibility */ || !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 = periodical\" 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; } } /* 2) connect_retry_interval_min and connect_retry_interval_max */ rc = GetDurationParam( lmgr_block, LMGR_CONFIG_BLOCK, "connect_retry_interval_min", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->connect_retry_min, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( lmgr_block, LMGR_CONFIG_BLOCK, "connect_retry_interval_max", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->connect_retry_max, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* 3) ACCT configuration*/ rc = GetBoolParam( lmgr_block, LMGR_CONFIG_BLOCK, "user_acct", 0, &conf->user_acct, NULL, NULL, msg_out); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( lmgr_block, LMGR_CONFIG_BLOCK, "group_acct", 0, &conf->group_acct, NULL, NULL, msg_out); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; CheckUnknownParameters( lmgr_block, LMGR_CONFIG_BLOCK, lmgr_allowed ); /* Database specific parameters */ #ifdef _MYSQL /* get MySQL block */ db_block = rh_config_GetItemByName( lmgr_block, MYSQL_CONFIG_BLOCK ); if ( db_block == NULL ) { strcpy( msg_out, "Missing configuration block '" LMGR_CONFIG_BLOCK "::" MYSQL_CONFIG_BLOCK "'" ); return ENOENT; } if ( rh_config_ItemType( db_block ) != CONFIG_ITEM_BLOCK ) { sprintf( msg_out, "A block is expected for '" LMGR_CONFIG_BLOCK "::" MYSQL_CONFIG_BLOCK "' item, line %d", rh_config_GetItemLine( db_block ) ); return EINVAL; } rc = GetStringParam( db_block, MYSQL_CONFIG_BLOCK, "server", STR_PARAM_NO_WILDCARDS, conf->db_config.server, 256, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( db_block, MYSQL_CONFIG_BLOCK, "db", PARAM_MANDATORY | STR_PARAM_NO_WILDCARDS, conf->db_config.db, 256, NULL, NULL, msg_out ); if ( rc ) return rc; rc = GetStringParam( db_block, MYSQL_CONFIG_BLOCK, "user", STR_PARAM_NO_WILDCARDS, conf->db_config.user, 256, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; 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", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS, tmpstr, 1024, 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 openning password file %s : %s", tmpstr, strerror(errno) ); return rc; } fscanf( passfile, "%1024s", tmpstr ); if ( ferror( passfile ) ) { rc = errno; strerror_r( rc, errstr, 1024 ); sprintf( msg_out, "Error reading password file %s : %s", tmpstr, errstr ); return rc; } fclose( passfile ); strncpy( conf->db_config.password, tmpstr, 256 ); } rc = GetIntParam( db_block, MYSQL_CONFIG_BLOCK, "port", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, (int*)&conf->db_config.port, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( db_block, MYSQL_CONFIG_BLOCK, "socket", STR_PARAM_NO_WILDCARDS | STR_PARAM_ABSOLUTE_PATH, conf->db_config.socket, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( db_block, MYSQL_CONFIG_BLOCK, "innodb", 0, &conf->db_config.innodb, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; CheckUnknownParameters( db_block, MYSQL_CONFIG_BLOCK, db_allowed ); #elif defined (_SQLITE) /* get SQLite block */ db_block = rh_config_GetItemByName( lmgr_block, SQLITE_CONFIG_BLOCK ); if ( db_block == NULL ) { strcpy( msg_out, "Missing configuration block '" LMGR_CONFIG_BLOCK "::" SQLITE_CONFIG_BLOCK "'" ); return ENOENT; } if ( rh_config_ItemType( db_block ) != CONFIG_ITEM_BLOCK ) { sprintf( msg_out, "A block is expected for '" LMGR_CONFIG_BLOCK "::" SQLITE_CONFIG_BLOCK "' item, line %d", rh_config_GetItemLine( db_block ) ); return EINVAL; } rc = GetStringParam( db_block, SQLITE_CONFIG_BLOCK, "db_file", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS, conf->db_config.filepath, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( db_block, SQLITE_CONFIG_BLOCK, "retry_delay_microsec", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, (int*)&conf->db_config.retry_delay_microsec, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; CheckUnknownParameters( db_block, SQLITE_CONFIG_BLOCK, db_allowed ); #endif return 0; }
int Read_ResourceMon_Config( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc; int intval; resource_monitor_config_t *conf = ( resource_monitor_config_t * ) module_config; unsigned int blc_index; static const char *purge_allowed[] = { "nb_threads_purge", "post_purge_df_latency", "purge_queue_size", "db_result_size_max", #ifdef ATTR_INDEX_status "check_purge_status_on_startup", #endif "recheck_ignored_classes", #ifdef _TMP_FS_MGR "purge_command", #endif NULL }; /* get PURGE_PARAM block */ config_item_t param_block = rh_config_FindItemByName( config, PURGE_PARAM_BLOCK ); if ( param_block != NULL ) { /* no error, because no parameter is mandatory */ /* check this is a block... */ if ( rh_config_ItemType( param_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" PURGE_PARAM_BLOCK "' item" ); return EINVAL; } /* parse parameters */ rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "nb_threads_purge", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_threads_purge, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( param_block, PURGE_PARAM_BLOCK, "post_purge_df_latency", INT_PARAM_POSITIVE, /* 0 is authorized: no delay */ &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->post_purge_df_latency = intval; rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "purge_queue_size", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->purge_queue_size, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "db_result_size_max", INT_PARAM_POSITIVE, ( int * ) &conf->db_request_limit, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; #ifdef ATTR_INDEX_status rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "check_purge_status_on_startup", 0, &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->check_purge_status_on_startup = intval; #endif rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "recheck_ignored_classes", 0, &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->recheck_ignored_classes = intval; rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "simulation_mode", 0, &intval, NULL, NULL, msg_out ); if ( rc == 0 ) { DisplayLog( LVL_CRIT, RESMONCFG_TAG, "WARNING: 'simulation_mode' parameter is deprecated. Use '--dry-run' option instead."); } #ifdef _TMP_FS_MGR rc = GetStringParam(param_block, PURGE_PARAM_BLOCK, "purge_command", STR_PARAM_ABSOLUTE_PATH, /* can contain wildcards: {path}, {fid}, {fsname} */ conf->purge_command, RBH_PATH_MAX, NULL, NULL, msg_out); if ((rc != 0) && (rc != ENOENT)) return rc; #endif CheckUnknownParameters( param_block, PURGE_PARAM_BLOCK, purge_allowed ); } /* end of purge parameters */ /* get PURGE_TRIGGER blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbBlocks( config ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetBlockByIndex( config, blc_index ); critical_err_check( curr_item, "root" ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( block_name, "root" ); if ( !strcasecmp( block_name, TRIGGER_BLOCK ) ) { if ( conf->trigger_count == 0 ) conf->trigger_list = ( trigger_item_t * ) malloc( sizeof( trigger_item_t ) ); else conf->trigger_list = ( trigger_item_t * ) realloc( conf->trigger_list, ( conf->trigger_count + 1 ) * sizeof( trigger_item_t ) ); conf->trigger_count++; /* analyze trigger block */ rc = parse_trigger_block( curr_item, block_name, &conf->trigger_list[conf->trigger_count - 1], msg_out ); if ( rc ) return rc; } } return 0; }
int ReadGlobalConfig( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, tmpval; global_config_t *conf = ( global_config_t * ) module_config; static const char *allowed_params[] = { "fs_path", "fs_type", "lock_file", "stay_in_fs", "check_mounted", "direct_mds_stat", "fs_key", NULL }; /* get GENERAL block */ config_item_t general_block = rh_config_FindItemByName( config, GLOBAL_CONFIG_BLOCK ); if ( general_block == NULL ) { strcpy( msg_out, "Missing configuration block '" GLOBAL_CONFIG_BLOCK "'" ); return ENOENT; } if ( rh_config_ItemType( general_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" GLOBAL_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ rc = GetStringParam( general_block, GLOBAL_CONFIG_BLOCK, "fs_path", PARAM_MANDATORY | STR_PARAM_ABSOLUTE_PATH | STR_PARAM_REMOVE_FINAL_SLASH | STR_PARAM_NO_WILDCARDS, conf->fs_path, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( rc ) return rc; #ifdef _HAVE_FID rc = GetStringParam( general_block, GLOBAL_CONFIG_BLOCK, "fs_type", PARAM_MANDATORY, conf->fs_type, RBH_NAME_MAX, NULL, NULL, msg_out ); if ( ( rc != ENOENT ) && strcmp( conf->fs_type, "lustre" ) ) { #ifdef _LUSTRE_HSM strcpy( msg_out, "Only \"lustre\" filesystem type is allowed for Lustre-HSM purpose" ); #else strcpy( msg_out, "Robinhood is compiled for Lustre filesystem support only" ); #endif return EINVAL; } #else rc = GetStringParam( general_block, GLOBAL_CONFIG_BLOCK, "fs_type", PARAM_MANDATORY, conf->fs_type, RBH_NAME_MAX, NULL, NULL, msg_out ); if ( rc ) return rc; #endif rc = GetStringParam( general_block, GLOBAL_CONFIG_BLOCK, "lock_file", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS, conf->lock_file, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* /!\ stay_in_fs is a piece of bit field, it should not be passed directly: using tmpval instead */ rc = GetBoolParam( general_block, GLOBAL_CONFIG_BLOCK, "stay_in_fs", 0, &tmpval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->stay_in_fs = tmpval; /* /!\ idem for check_mounted */ rc = GetBoolParam( general_block, GLOBAL_CONFIG_BLOCK, "check_mounted", 0, &tmpval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->check_mounted = tmpval; /* fs_key param */ char tmpstr[128]; rc = GetStringParam( general_block, GLOBAL_CONFIG_BLOCK, "fs_key", STR_PARAM_NO_WILDCARDS, tmpstr, 128, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if (rc == 0) { conf->fs_key = name2fskey(tmpstr); if (conf->fs_key == FSKEY_ERROR) { sprintf( msg_out, "Invalid type for fs_key: '%s' ('fsname', 'devid' or 'fsid' expected)", tmpstr ); return EINVAL; } } #if defined( _LUSTRE ) && defined( _MDS_STAT_SUPPORT ) rc = GetBoolParam( general_block, GLOBAL_CONFIG_BLOCK, "direct_mds_stat",0, &conf->direct_mds_stat, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; #endif /* check unknown parameters */ CheckUnknownParameters( general_block, GLOBAL_CONFIG_BLOCK, allowed_params ); return 0; }
int Read_EntryProc_Config( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, blc_index, i; int tmpval; entry_proc_config_t *conf = ( entry_proc_config_t * ) module_config; char pipeline_names[PIPELINE_STAGE_COUNT][256]; char *entry_proc_allowed[PIPELINE_STAGE_COUNT + 5]; entry_proc_allowed[0] = "nb_threads"; entry_proc_allowed[1] = "max_pending_operations"; entry_proc_allowed[2] = "match_classes"; entry_proc_allowed[3] = ALERT_BLOCK; entry_proc_allowed[PIPELINE_STAGE_COUNT + 4] = NULL; /* PIPELINE_STAGE_COUNT+4 = last slot */ /* get EntryProcessor block */ config_item_t entryproc_block = rh_config_FindItemByName( config, ENTRYPROC_CONFIG_BLOCK ); if ( entryproc_block == NULL ) { strcpy( msg_out, "Missing configuration block '" ENTRYPROC_CONFIG_BLOCK "'" ); /* No error because no parameter is mandatory */ return 0; } if ( rh_config_ItemType( entryproc_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" ENTRYPROC_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "nb_threads", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_thread, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "max_pending_operations", INT_PARAM_POSITIVE, ( int * ) &conf->max_pending_operations, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "match_classes", 0, &conf->match_classes, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* look for '<stage>_thread_max' parameters */ for ( i = 0; i < PIPELINE_STAGE_COUNT; i++ ) { char varname[256]; snprintf( varname, 256, "%s_threads_max", entry_proc_pipeline[i].stage_name ); strncpy( pipeline_names[i], varname, 256 ); entry_proc_allowed[i + 4] = pipeline_names[i]; rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, varname, INT_PARAM_POSITIVE, &tmpval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( ( rc != ENOENT ) && ( tmpval > 0 ) ) /* 0: keep default */ { if ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_MAX_THREADS ) entry_proc_pipeline[i].max_thread_count = MIN2( entry_proc_pipeline[i].max_thread_count, tmpval ); else if ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_PARALLEL ) { /* the stqge is no more parallel, it has a limited number of threads */ entry_proc_pipeline[i].stage_flags &= ~STAGE_FLAG_PARALLEL; entry_proc_pipeline[i].stage_flags |= STAGE_FLAG_MAX_THREADS; entry_proc_pipeline[i].max_thread_count = tmpval; } else if ( ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_SEQUENTIAL ) && ( tmpval != 1 ) ) { sprintf( msg_out, "%s is sequential. Cannot use %u threads at this stage.", entry_proc_pipeline[i].stage_name, tmpval ); return EINVAL; } } } /* Find and parse "Alert" blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbItems( entryproc_block ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetItemByIndex( entryproc_block, blc_index ); critical_err_check( curr_item, ENTRYPROC_CONFIG_BLOCK ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( curr_item, ENTRYPROC_CONFIG_BLOCK ); if ( !strcasecmp( block_name, ALERT_BLOCK ) ) { char * alert_title = NULL; if ( conf->alert_count == 0 ) conf->alert_list = ( alert_item_t * ) malloc( sizeof( alert_item_t ) ); else conf->alert_list = ( alert_item_t * ) realloc( conf->alert_list, ( conf->alert_count + 1 ) * sizeof( alert_item_t ) ); conf->alert_count++; alert_title = rh_config_GetBlockId( curr_item ); if ( alert_title != NULL ) strncpy( conf->alert_list[conf->alert_count - 1].title, alert_title, ALERT_TITLE_MAX ); else conf->alert_list[conf->alert_count - 1].title[0] = '\0'; /* analyze boolean expression */ rc = GetBoolExpr( curr_item, block_name, &conf->alert_list[conf->alert_count - 1].boolexpr, &conf->alert_list[conf->alert_count - 1].attr_mask, msg_out ); if ( rc ) return rc; conf->alert_attr_mask |= conf->alert_list[conf->alert_count - 1].attr_mask; } } /* Loop on subblocks */ CheckUnknownParameters( entryproc_block, ENTRYPROC_CONFIG_BLOCK, ( const char ** ) entry_proc_allowed ); return 0; }
int ReadLogConfig( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, tmpval; char tmpstr[1024]; log_config_t *conf = ( log_config_t * ) module_config; static const char *allowed_params[] = { "debug_level", "log_file", "report_file", "alert_file", "alert_mail", "stats_interval", "batch_alert_max", "alert_show_attrs", "syslog_facility", NULL }; /* get Log block */ config_item_t log_block = rh_config_FindItemByName( config, RBH_LOG_CONFIG_BLOCK ); if ( log_block == NULL ) { strcpy( msg_out, "Missing configuration block '" RBH_LOG_CONFIG_BLOCK "'" ); /* no parameter is mandatory => Not an error */ return 0; } if ( rh_config_ItemType( log_block ) != CONFIG_ITEM_BLOCK ) { sprintf( msg_out, "A block is expected for '" RBH_LOG_CONFIG_BLOCK "' item, line %d", rh_config_GetItemLine( log_block ) ); return EINVAL; } /* retrieve parameters */ rc = GetStringParam( log_block, RBH_LOG_CONFIG_BLOCK, "debug_level", STR_PARAM_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, "log_file", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS | STDIO_ALLOWED, conf->log_file, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( log_block, RBH_LOG_CONFIG_BLOCK, "report_file", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS | STDIO_ALLOWED, conf->report_file, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( log_block, RBH_LOG_CONFIG_BLOCK, "alert_file", STR_PARAM_ABSOLUTE_PATH | STR_PARAM_NO_WILDCARDS | STDIO_ALLOWED, conf->alert_file, 1024, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == ENOENT ) conf->alert_file[0] = '\0'; rc = GetStringParam( log_block, RBH_LOG_CONFIG_BLOCK, "syslog_facility", STR_PARAM_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; } } rc = GetStringParam( log_block, RBH_LOG_CONFIG_BLOCK, "alert_mail", STR_PARAM_MAIL, conf->alert_mail, 256, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == ENOENT ) conf->alert_mail[0] = '\0'; rc = GetDurationParam( log_block, RBH_LOG_CONFIG_BLOCK, "stats_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, &tmpval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->stats_interval = tmpval; rc = GetIntParam( log_block, RBH_LOG_CONFIG_BLOCK, "batch_alert_max", INT_PARAM_POSITIVE, (int *)&conf->batch_alert_max, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( log_block, RBH_LOG_CONFIG_BLOCK, "alert_show_attrs", INT_PARAM_POSITIVE, &conf->alert_show_attrs, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; CheckUnknownParameters( log_block, RBH_LOG_CONFIG_BLOCK, allowed_params ); return 0; }
int FSScan_ReadConfig( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, blc_index; fs_scan_config_t *conf = ( fs_scan_config_t * ) module_config; int scan_intl_set = FALSE; int scan_intl = 0; static const char * fsscan_allowed[] = { "scan_interval", "min_scan_interval", "max_scan_interval", "scan_retry_delay", "nb_threads_scan", "scan_op_timeout", "exit_on_timeout", "spooler_check_interval", "nb_prealloc_tasks", "completion_command", IGNORE_BLOCK, NULL }; /* get FS Scan block */ config_item_t fsscan_block = rh_config_FindItemByName( config, FSSCAN_CONFIG_BLOCK ); if ( fsscan_block == NULL ) { strcpy( msg_out, "Missing configuration block '" FSSCAN_CONFIG_BLOCK "'" ); /* No error because no parameter is mandatory */ return 0; } if ( rh_config_ItemType( fsscan_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" FSSCAN_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "min_scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->min_scan_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) scan_intl_set = TRUE; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "max_scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->max_scan_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) scan_intl_set = TRUE; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, &scan_intl, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) { if (scan_intl_set) { strcpy( msg_out, "scan_interval parameter cannot be used with min/max_scan_interval" ); return EINVAL; } conf->min_scan_interval = scan_intl; conf->max_scan_interval = scan_intl; } rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_retry_delay", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->scan_retry_delay, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "nb_threads_scan", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_threads_scan, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_op_timeout", INT_PARAM_POSITIVE, /* 0 is authorized => no timeout */ ( int * ) &conf->scan_op_timeout, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "exit_on_timeout", 0, (int*)&conf->exit_on_timeout, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "spooler_check_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->spooler_check_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "nb_prealloc_tasks", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_prealloc_tasks, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "completion_command", STR_PARAM_ABSOLUTE_PATH, /* can contain wildcards: {cfg} or {fspath} */ conf->completion_command, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* Find and parse "ignore" blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbItems( fsscan_block ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetItemByIndex( fsscan_block, blc_index ); critical_err_check( curr_item, FSSCAN_CONFIG_BLOCK ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( curr_item, FSSCAN_CONFIG_BLOCK ); if ( !strcasecmp( block_name, IGNORE_BLOCK ) ) { if ( conf->ignore_count == 0 ) conf->ignore_list = ( whitelist_item_t * ) malloc( sizeof( whitelist_item_t ) ); else conf->ignore_list = ( whitelist_item_t * ) realloc( conf->ignore_list, ( conf->ignore_count + 1 ) * sizeof( whitelist_item_t ) ); conf->ignore_count++; /* analyze boolean expression */ rc = GetBoolExpr( curr_item, block_name, &conf->ignore_list[conf->ignore_count - 1].bool_expr, &conf->ignore_list[conf->ignore_count - 1].attr_mask, msg_out ); if ( rc ) return rc; } } /* Loop on subblocks */ CheckUnknownParameters( fsscan_block, FSSCAN_CONFIG_BLOCK, fsscan_allowed ); return 0; }