/**
* \brief Parse an audio command [Level 2]
* \param tokens Command tokens.
* \param cmd Cmd structure.
* \return The error result.
*/
static TuxDrvError
parse_tux_audio_command(tokens_t tokens, delay_cmd_t *cmd)
{
TuxDrvError ret = E_TUXDRV_INVALIDCOMMAND;
if (strcmp(tokens[2], "CHANNEL_GENERAL") == 0)
{
cmd->sub_command = CHANNEL_GENERAL;
ret = E_TUXDRV_NOERROR;
}
else if (strcmp(tokens[2], "CHANNEL_TTS") == 0)
{
cmd->sub_command = CHANNEL_TTS;
ret = E_TUXDRV_NOERROR;
}
else if (strcmp(tokens[2], "MUTE") == 0)
{
cmd->sub_command = MUTE;
if (str_to_bool(tokens[3], &cmd->audio_mute_parameters.muteflag))
{
// write to struct
ret = E_TUXDRV_NOERROR;
}
}
return ret;
}
static bool get_bool(const char *name, const char *arg)
{
bool b = str_to_bool(arg);
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> %s\n", name,
b ? "Yes" : "No");
return b;
}
bool Config_GetValue_Bool(const char *KeyName, bool* Value)
{
const tConfigValue* val = Config_int_GetValue(KeyName, 0);
if(!val) return false;
*Value = str_to_bool(val->Data);
return true;
}
static int set_general_bool(struct arguments *args, enum general_module module, __u8 type,
char *value)
{
__u8 tmp;
int error;
error = str_to_bool(value, &tmp);
if (error)
return error;
return set_general_arg(args, module, type, sizeof(tmp), &tmp);
}
void ufwiclient_use_config()
{
char *value;
default_hostname = ufwiclient_config_table_get("nuauth_ip");
default_port = ufwiclient_config_table_get("nuauth_port");
default_tls_ca = ufwiclient_config_table_get("nuauth_tls_ca");
default_tls_cert = ufwiclient_config_table_get("nuauth_tls_cert");
default_tls_key = ufwiclient_config_table_get("nuauth_tls_key");
default_tls_crl = ufwiclient_config_table_get("nuauth_tls_crl");
value = ufwiclient_config_table_get("nuauth_suppress_fqdn_verif");
if (value) {
default_suppress_fqdn_verif = str_to_bool(value,1);
}
}
static GtkSourceContextFlags
get_context_flags (ParserState *parser_state)
{
guint i;
xmlChar *value;
GtkSourceContextFlags flags = GTK_SOURCE_CONTEXT_EXTEND_PARENT;
const gchar *names[] = {
"extend-parent", "end-parent", "end-at-line-end",
"first-line-only", "once-only", "style-inside"
};
GtkSourceContextFlags values[] = {
GTK_SOURCE_CONTEXT_EXTEND_PARENT,
GTK_SOURCE_CONTEXT_END_PARENT,
GTK_SOURCE_CONTEXT_END_AT_LINE_END,
GTK_SOURCE_CONTEXT_FIRST_LINE_ONLY,
GTK_SOURCE_CONTEXT_ONCE_ONLY,
GTK_SOURCE_CONTEXT_STYLE_INSIDE
};
g_assert (G_N_ELEMENTS (names) == G_N_ELEMENTS (values));
for (i = 0; i < G_N_ELEMENTS (names); ++i)
{
value = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST names[i]);
if (value != NULL)
{
if (str_to_bool (value))
flags |= values[i];
else
flags &= ~values[i];
}
xmlFree (value);
}
return flags;
}
static GRegexCompileFlags
update_regex_flags (GRegexCompileFlags flags,
const xmlChar *option_name,
const xmlChar *value)
{
GRegexCompileFlags single_flag;
gboolean set_flag;
DEBUG (g_message ("setting the '%s' regex flag to %s", option_name, value));
set_flag = str_to_bool (value);
if (xmlStrcmp (BAD_CAST "case-sensitive", option_name) == 0)
{
single_flag = G_REGEX_CASELESS;
set_flag = !set_flag;
}
else if (xmlStrcmp (BAD_CAST "extended", option_name) == 0)
{
single_flag = G_REGEX_EXTENDED;
}
else if (xmlStrcmp (BAD_CAST "dupnames", option_name) == 0)
{
single_flag = G_REGEX_DUPNAMES;
}
else
{
return flags;
}
if (set_flag)
flags |= single_flag;
else
flags &= ~single_flag;
return flags;
}
/*
* PARSER. Field 2 in ARGP.
*/
static int parse_opt(int key, char *arg, struct argp_state *state)
{
struct arguments *arguments = state->input;
int error = 0;
__u16 temp;
switch (key) {
case ARGP_POOL6:
arguments->mode = MODE_POOL6;
break;
case ARGP_POOL4:
arguments->mode = MODE_POOL4;
break;
case ARGP_BIB:
arguments->mode = MODE_BIB;
break;
case ARGP_SESSION:
arguments->mode = MODE_SESSION;
break;
case ARGP_FILTERING:
arguments->mode = MODE_FILTERING;
break;
case ARGP_TRANSLATE:
arguments->mode = MODE_TRANSLATE;
break;
case ARGP_DISPLAY:
arguments->operation = OP_DISPLAY;
break;
case ARGP_ADD:
arguments->operation = OP_ADD;
break;
case ARGP_REMOVE:
arguments->operation = OP_REMOVE;
break;
case ARGP_UDP:
arguments->udp = true;
break;
case ARGP_TCP:
arguments->tcp = true;
break;
case ARGP_ICMP:
arguments->icmp = true;
break;
case ARGP_ADDRESS:
error = str_to_addr4(arg, &arguments->pool4_addr);
arguments->pool4_addr_set = true;
break;
case ARGP_PREFIX:
error = str_to_prefix(arg, &arguments->pool6_prefix);
arguments->pool6_prefix_set = true;
break;
// case ARGP_STATIC:
// arguments->static_entries = true;
// break;
// case ARGP_DYNAMIC:
// arguments->dynamic_entries = true;
// break;
//
// case ARGP_IPV6:
// error = str_to_addr6_port(arg, &arguments->bib_addr6);
// arguments->bib_addr6_set = true;
// break;
// case ARGP_IPV4:
// error = str_to_addr4_port(arg, &arguments->bib_addr4);
// arguments->bib_addr4_set = true;
// break;
case ARGP_REMOTE6:
error = str_to_addr6_port(arg, &arguments->session_pair6.remote);
arguments->session_pair6_remote_set = true;
break;
case ARGP_LOCAL6:
error = str_to_addr6_port(arg, &arguments->session_pair6.local);
arguments->session_pair6_local_set = true;
break;
case ARGP_LOCAL4:
error = str_to_addr4_port(arg, &arguments->session_pair4.local);
arguments->session_pair4_local_set = true;
break;
case ARGP_REMOTE4:
error = str_to_addr4_port(arg, &arguments->session_pair4.remote);
arguments->session_pair4_remote_set = true;
break;
case ARGP_DROP_ADDR:
arguments->mode = MODE_FILTERING;
arguments->operation |= DROP_BY_ADDR_MASK;
error = str_to_bool(arg, &arguments->filtering.drop_by_addr);
break;
case ARGP_DROP_INFO:
arguments->mode = MODE_FILTERING;
arguments->operation |= DROP_ICMP6_INFO_MASK;
error = str_to_bool(arg, &arguments->filtering.drop_icmp6_info);
break;
// case ARGP_DROP_TCP:
// arguments->mode = MODE_FILTERING;
// arguments->operation |= DROP_EXTERNAL_TCP_MASK;
// error = str_to_bool(arg, &arguments->filtering.drop_external_tcp);
// break;
case ARGP_UDP_TO:
arguments->mode = MODE_FILTERING;
arguments->operation |= UDP_TIMEOUT_MASK;
error = str_to_u16(arg, &temp, UDP_MIN, 0xFFFF);
arguments->filtering.to.udp = temp;
break;
case ARGP_ICMP_TO:
arguments->mode = MODE_FILTERING;
arguments->operation |= ICMP_TIMEOUT_MASK;
error = str_to_u16(arg, &temp, 0, 0xFFFF);
arguments->filtering.to.icmp = temp;
break;
case ARGP_TCP_TO:
arguments->mode = MODE_FILTERING;
arguments->operation |= TCP_EST_TIMEOUT_MASK;
error = str_to_u16(arg, &temp, TCP_EST, 0xFFFF);
arguments->filtering.to.tcp_est = temp;
break;
case ARGP_TCP_TRANS_TO:
arguments->mode = MODE_FILTERING;
arguments->operation |= TCP_TRANS_TIMEOUT_MASK;
error = str_to_u16(arg, &temp, TCP_TRANS, 0xFFFF);
arguments->filtering.to.tcp_trans = temp;
break;
case ARGP_HEAD:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= SKB_HEAD_ROOM_MASK;
error = str_to_u16(arg, &arguments->translate.skb_head_room, 0, 0xFFFF);
break;
case ARGP_TAIL:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= SKB_TAIL_ROOM_MASK;
error = str_to_u16(arg, &arguments->translate.skb_tail_room, 0, 0xFFFF);
break;
case ARGP_RESET_TCLASS:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= RESET_TCLASS_MASK;
error = str_to_bool(arg, &arguments->translate.reset_traffic_class);
break;
case ARGP_RESET_TOS:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= RESET_TOS_MASK;
error = str_to_bool(arg, &arguments->translate.reset_tos);
break;
case ARGP_NEW_TOS:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= NEW_TOS_MASK;
error = str_to_u8(arg, &arguments->translate.new_tos, 0, 0xFF);
break;
case ARGP_DF:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= DF_ALWAYS_ON_MASK;
error = str_to_bool(arg, &arguments->translate.df_always_on);
break;
case ARGP_BUILD_ID:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= BUILD_IPV4_ID_MASK;
error = str_to_bool(arg, &arguments->translate.build_ipv4_id);
break;
case ARGP_LOWER_MTU_FAIL:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= LOWER_MTU_FAIL_MASK;
error = str_to_bool(arg, &arguments->translate.lower_mtu_fail);
break;
case ARGP_NEXT_MTU6:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= IPV6_NEXTHOP_MTU_MASK;
error = str_to_u16(arg, &arguments->translate.ipv6_nexthop_mtu, 0, 0xFFFF);
break;
case ARGP_NEXT_MTU4:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= IPV4_NEXTHOP_MTU_MASK;
error = str_to_u16(arg, &arguments->translate.ipv4_nexthop_mtu, 0, 0xFFFF);
break;
case ARGP_PLATEAUS:
arguments->mode = MODE_TRANSLATE;
arguments->operation |= MTU_PLATEAUS_MASK;
error = str_to_u16_array(arg, &arguments->translate.mtu_plateaus,
&arguments->translate.mtu_plateau_count);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return error;
}
/******************************************************************************
* @brief Read the VIC model global control file, getting values for
* global parameters, model options, and debugging controls.
*****************************************************************************/
void
get_global_param(FILE *gp)
{
extern option_struct options;
extern global_param_struct global_param;
extern param_set_struct param_set;
extern filenames_struct filenames;
char cmdstr[MAXSTRING];
char optstr[MAXSTRING];
char flgstr[MAXSTRING];
char flgstr2[MAXSTRING];
/** Read through global control file to find parameters **/
rewind(gp);
fgets(cmdstr, MAXSTRING, gp);
while (!feof(gp)) {
if (cmdstr[0] != '#' && cmdstr[0] != '\n' && cmdstr[0] != '\0') {
sscanf(cmdstr, "%s", optstr);
/* Handle case of comment line in which '#' is indented */
if (optstr[0] == '#') {
fgets(cmdstr, MAXSTRING, gp);
continue;
}
/*************************************
Get Model Global Parameters
*************************************/
if (strcasecmp("NLAYER", optstr) == 0) {
sscanf(cmdstr, "%*s %zu", &options.Nlayer);
}
else if (strcasecmp("NODES", optstr) == 0) {
sscanf(cmdstr, "%*s %zu", &options.Nnode);
}
else if (strcasecmp("OUT_TIME_UNITS", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
global_param.time_units = str_to_timeunits(flgstr);
}
else if (strcasecmp("FULL_ENERGY", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.FULL_ENERGY = str_to_bool(flgstr);
if (options.FULL_ENERGY == false) {
log_warn("FULL_ENERGY is set to FALSE. Please double check "
"that this is the setting you intended.");
}
}
else if (strcasecmp("FROZEN_SOIL", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.FROZEN_SOIL = str_to_bool(flgstr);
// TODO: move these steps to a option validation
if (options.FROZEN_SOIL) {
options.QUICK_FLUX = false;
}
else {
options.IMPLICIT = false;
options.EXP_TRANS = false;
}
}
else if (strcasecmp("QUICK_FLUX", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.QUICK_FLUX = str_to_bool(flgstr);
}
else if (strcasecmp("QUICK_SOLVE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.QUICK_SOLVE = str_to_bool(flgstr);
}
else if ((strcasecmp("NOFLUX",
optstr) == 0) ||
(strcasecmp("NO_FLUX", optstr) == 0)) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("TRUE", flgstr) == 0) {
options.NOFLUX = str_to_bool(flgstr);
}
}
else if (strcasecmp("IMPLICIT", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.IMPLICIT = str_to_bool(flgstr);
}
else if (strcasecmp("EXP_TRANS", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.EXP_TRANS = str_to_bool(flgstr);
}
else if (strcasecmp("SNOW_DENSITY", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("DENS_SNTHRM", flgstr) == 0) {
options.SNOW_DENSITY = DENS_SNTHRM;
}
else if (strcasecmp("DENS_BRAS", flgstr) == 0) {
options.SNOW_DENSITY = DENS_BRAS;
}
else {
log_err("Unknown SNOW_DENSITY option: %s", flgstr);
}
}
else if (strcasecmp("BLOWING", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING = str_to_bool(flgstr);
}
else if (strcasecmp("BLOWING_VAR_THRESHOLD", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING_VAR_THRESHOLD = str_to_bool(flgstr);
}
else if (strcasecmp("BLOWING_CALC_PROB", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING_CALC_PROB = str_to_bool(flgstr);
}
else if (strcasecmp("BLOWING_SIMPLE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING_SIMPLE = str_to_bool(flgstr);
}
else if (strcasecmp("BLOWING_FETCH", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING_FETCH = str_to_bool(flgstr);
}
else if (strcasecmp("BLOWING_SPATIAL_WIND", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.BLOWING_SPATIAL_WIND = str_to_bool(flgstr);
}
else if (strcasecmp("CORRPREC", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.CORRPREC = str_to_bool(flgstr);
}
else if (strcasecmp("CLOSE_ENERGY", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.CLOSE_ENERGY = str_to_bool(flgstr);
}
else if (strcasecmp("COMPUTE_TREELINE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FALSE", flgstr) == 0) {
options.COMPUTE_TREELINE = false;
}
else {
options.COMPUTE_TREELINE = true;
options.AboveTreelineVeg = atoi(flgstr);
}
}
else if (strcasecmp("AERO_RESIST_CANSNOW", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("AR_406", flgstr) == 0) {
options.AERO_RESIST_CANSNOW = AR_406;
}
else if (strcasecmp("AR_406_LS", flgstr) == 0) {
options.AERO_RESIST_CANSNOW = AR_406_LS;
}
else if (strcasecmp("AR_406_FULL", flgstr) == 0) {
options.AERO_RESIST_CANSNOW = AR_406_FULL;
}
else if (strcasecmp("AR_410", flgstr) == 0) {
options.AERO_RESIST_CANSNOW = AR_410;
}
else {
log_err("Unknown AERO_RESIST_CANSNOW option: %s", flgstr);
}
}
else if (strcasecmp("GRND_FLUX_TYPE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("GF_406", flgstr) == 0) {
options.GRND_FLUX_TYPE = GF_406;
}
else if (strcasecmp("GF_410", flgstr) == 0) {
options.GRND_FLUX_TYPE = GF_410;
}
else {
log_err("Unknown GRND_FLUX_TYPE option: %s", flgstr);
}
}
else if (strcasecmp("SPATIAL_FROST", optstr) == 0) {
sscanf(cmdstr, "%*s %s %s", flgstr, flgstr2);
if (strcasecmp("TRUE", flgstr) == 0) {
options.SPATIAL_FROST = true;
options.Nfrost = atoi(flgstr2);
}
else {
options.SPATIAL_FROST = false;
}
}
else if (strcasecmp("SPATIAL_SNOW", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.SPATIAL_SNOW = str_to_bool(flgstr);
}
else if (strcasecmp("TFALLBACK", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.TFALLBACK = str_to_bool(flgstr);
}
else if (strcasecmp("SHARE_LAYER_MOIST", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.SHARE_LAYER_MOIST = str_to_bool(flgstr);
}
else if (strcasecmp("CANOPY_LAYERS", optstr) == 0) {
sscanf(cmdstr, "%*s %zu", &options.Ncanopy);
}
else if (strcasecmp("CARBON", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.CARBON = str_to_bool(flgstr);
}
else if (strcasecmp("RC_MODE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("RC_PHOTO", flgstr) == 0) {
options.RC_MODE = RC_PHOTO;
}
else if (strcasecmp("RC_JARVIS", flgstr) == 0) {
options.RC_MODE = RC_JARVIS;
}
else {
log_err("Unknown RC_MODE option: %s", flgstr);
}
}
/*************************************
Define log directory
*************************************/
else if (strcasecmp("LOG_DIR", optstr) == 0) {
sscanf(cmdstr, "%*s %s", filenames.log_path);
}
else if (strcasecmp("INIT_STATE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FALSE", flgstr) == 0) {
options.INIT_STATE = false;
}
else {
options.INIT_STATE = true;
strcpy(filenames.init_state.nc_filename, flgstr);
}
}
// Define state file format
else if (strcasecmp("STATE_FORMAT", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("NETCDF3_CLASSIC", flgstr) == 0) {
options.STATE_FORMAT = NETCDF3_CLASSIC;
}
else if (strcasecmp("NETCDF3_64BIT_OFFSET", flgstr) == 0) {
options.STATE_FORMAT = NETCDF3_64BIT_OFFSET;
}
else if (strcasecmp("NETCDF4_CLASSIC", flgstr) == 0) {
options.STATE_FORMAT = NETCDF4_CLASSIC;
}
else if (strcasecmp("NETCDF4", flgstr) == 0) {
options.STATE_FORMAT = NETCDF4;
}
else {
log_err("STATE_FORMAT must be either NETCDF3_CLASSIC, "
"NETCDF3_64BIT_OFFSET, NETCDF4_CLASSIC, or NETCDF4.");
}
}
/*************************************
Define parameter files
*************************************/
else if (strcasecmp("CONSTANTS", optstr) == 0) {
sscanf(cmdstr, "%*s %s", filenames.constants);
}
else if (strcasecmp("DOMAIN", optstr) == 0) {
sscanf(cmdstr, "%*s %s", filenames.domain.nc_filename);
}
else if (strcasecmp("DOMAIN_TYPE", optstr) == 0) {
get_domain_type(cmdstr);
}
else if (strcasecmp("PARAMETERS", optstr) == 0) {
sscanf(cmdstr, "%*s %s", filenames.params.nc_filename);
}
else if (strcasecmp("ARNO_PARAMS", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("TRUE", flgstr) == 0) {
log_err("Please change \"ARNO_PARAMS TRUE\" to \"BASEFLOW "
"NIJSSEN2001\" in your global parameter file.");
}
else {
log_err("Please change \"ARNO_PARAMS FALSE\" to \"BASEFLOW "
"ARNO\" in your global parameter file.");
}
}
else if (strcasecmp("NIJSSEN2001_BASEFLOW", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("TRUE", flgstr) == 0) {
log_err("Please change \"NIJSSEN2001_BASEFLOW TRUE\" to "
"\"BASEFLOW NIJSSEN2001\" in your global "
"parameter file.");
}
else {
log_err("Please change \"NIJSSEN2001_BASEFLOW FALSE\" to "
"\"BASEFLOW ARNO\" in your global parameter file.");
}
}
else if (strcasecmp("BASEFLOW", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("NIJSSEN2001", flgstr) == 0) {
options.BASEFLOW = NIJSSEN2001;
}
else if (strcasecmp("ARNO", flgstr) == 0) {
options.BASEFLOW = ARNO;
}
else {
log_err("Unknown BASEFLOW option: %s", flgstr);
}
}
else if (strcasecmp("JULY_TAVG_SUPPLIED", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.JULY_TAVG_SUPPLIED = str_to_bool(flgstr);
}
else if (strcasecmp("ORGANIC_FRACT", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.ORGANIC_FRACT = str_to_bool(flgstr);
}
else if (strcasecmp("VEGLIB_PHOTO", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.VEGLIB_PHOTO = str_to_bool(flgstr);
}
else if (strcasecmp("LAI_SRC", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FROM_VEGHIST", flgstr) == 0) {
options.LAI_SRC = FROM_VEGHIST;
}
else if (strcasecmp("FROM_VEGPARAM", flgstr) == 0) {
options.LAI_SRC = FROM_VEGPARAM;
}
else if (strcasecmp("FROM_VEGLIB", flgstr) == 0) {
options.LAI_SRC = FROM_VEGLIB;
}
else {
log_err("Unrecognized value of LAI_SRC in the global "
"control file.");
}
}
else if (strcasecmp("FCAN_SRC", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FROM_VEGHIST", flgstr) == 0) {
options.FCAN_SRC = FROM_VEGHIST;
}
else if (strcasecmp("FROM_VEGPARAM", flgstr) == 0) {
options.FCAN_SRC = FROM_VEGPARAM;
}
else if (strcasecmp("FROM_VEGLIB", flgstr) == 0) {
options.FCAN_SRC = FROM_VEGLIB;
}
else if (strcasecmp("FROM_DEFAULT", flgstr) == 0) {
options.FCAN_SRC = FROM_DEFAULT;
}
else {
log_err("Unrecognized value of FCAN_SRC in the global "
"control file.");
}
}
else if (strcasecmp("ALB_SRC", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FROM_VEGHIST", flgstr) == 0) {
options.ALB_SRC = FROM_VEGHIST;
}
else if (strcasecmp("FROM_VEGPARAM", flgstr) == 0) {
options.ALB_SRC = FROM_VEGPARAM;
}
else if (strcasecmp("FROM_VEGLIB", flgstr) == 0) {
options.ALB_SRC = FROM_VEGLIB;
}
else {
log_err("Unrecognized value of ALB_SRC in the global "
"control file.");
}
}
else if (strcasecmp("SNOW_BAND", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (str_to_bool(flgstr)) {
options.SNOW_BAND = SNOW_BAND_TRUE_BUT_UNSET;
}
}
else if (strcasecmp("LAKES", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
if (strcasecmp("FALSE", flgstr) == 0) {
options.LAKES = false;
}
else {
options.LAKES = true;
}
}
else if (strcasecmp("LAKE_PROFILE", optstr) == 0) {
sscanf(cmdstr, "%*s %s", flgstr);
options.LAKE_PROFILE = str_to_bool(flgstr);
}
/*************************************
Define output files
*************************************/
else if (strcasecmp("RESULT_DIR", optstr) == 0) {
sscanf(cmdstr, "%*s %s", filenames.result_dir);
}
/*************************************
Define output file contents
*************************************/
else if (strcasecmp("OUTFILE", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("OUTVAR", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("AGGFREQ", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("OUTPUT_STEPS_PER_DAY", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("SKIPYEAR", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("COMPRESS", optstr) == 0) {
; // do nothing
}
else if (strcasecmp("OUT_FORMAT", optstr) == 0) {
; // do nothing
}
// vegetation history not yet implemented in image mode
// TBD: feature in VIC 4.2 that has been ported to classic
// mode, but that does not exist in image mode (yet)
else if (strcasecmp("ALBEDO", optstr) == 0 ||
strcasecmp("LAI", optstr) == 0 ||
strcasecmp("FCANOPY", optstr) == 0) {
log_err("Time-varying vegetation parameters not implemented "
"in CESM driver");
}
/***********************************
Unrecognized Global Parameter Flag
***********************************/
else {
log_warn("Unrecognized option in the global parameter file: %s"
"\n - check your spelling", optstr);
}
}
fgets(cmdstr, MAXSTRING, gp);
}
// Output major options
display_current_settings(DISP_VERSION);
}
static void
handle_context_element (ParserState *parser_state)
{
gchar *id, *parent_id, *style_ref;
xmlChar *ref, *sub_pattern, *tmp;
int is_empty;
gboolean success;
gboolean ignore_style = FALSE;
GtkSourceContextRefOptions options = 0;
GSList *context_classes;
GError *tmp_error = NULL;
g_return_if_fail (parser_state->error == NULL);
ref = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "ref");
sub_pattern = xmlTextReaderGetAttribute (parser_state->reader,
BAD_CAST "sub-pattern");
tmp = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "ignore-style");
if (tmp != NULL && str_to_bool (tmp))
ignore_style = TRUE;
xmlFree (tmp);
tmp = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "style-ref");
if (tmp == NULL || id_is_decorated ((gchar*) tmp, NULL))
style_ref = g_strdup ((gchar*) tmp);
else
style_ref = decorate_id (parser_state, (gchar*) tmp);
xmlFree (tmp);
if (ignore_style && ref == NULL)
{
g_set_error (&parser_state->error,
PARSER_ERROR,
PARSER_ERROR_WRONG_STYLE,
"ignore-style used not in a reference to context");
xmlFree (ref);
g_free (style_ref);
return;
}
if (ignore_style)
{
options |= GTK_SOURCE_CONTEXT_IGNORE_STYLE;
if (style_ref != NULL)
g_warning ("in file %s: style-ref and ignore-style used simultaneously",
parser_state->filename);
}
/* XXX */
if (!ignore_style && style_ref != NULL &&
g_hash_table_lookup (parser_state->styles_mapping, style_ref) == NULL)
{
g_warning ("in file %s: style '%s' not defined", parser_state->filename, style_ref);
}
context_classes = parse_classes (parser_state);
if (ref != NULL)
{
tmp = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "original");
if (tmp != NULL && str_to_bool (tmp))
options |= GTK_SOURCE_CONTEXT_REF_ORIGINAL;
xmlFree (tmp);
if (style_ref != NULL)
options |= GTK_SOURCE_CONTEXT_OVERRIDE_STYLE;
add_ref (parser_state,
(gchar*) ref,
options,
style_ref,
&tmp_error);
}
else
{
char *freeme = NULL;
tmp = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "id");
if (tmp == NULL)
{
freeme = generate_new_id (parser_state);
tmp = xmlStrdup (BAD_CAST freeme);
}
if (id_is_decorated ((gchar*) tmp, NULL))
id = g_strdup ((gchar*) tmp);
else
id = decorate_id (parser_state, (gchar*) tmp);
g_free (freeme);
xmlFree (tmp);
if (parser_state->ctx_data != NULL)
{
if (sub_pattern != NULL)
{
create_sub_pattern (parser_state,
id,
(gchar *)sub_pattern,
style_ref,
context_classes,
&tmp_error);
}
else
{
parent_id = g_queue_peek_head (
parser_state->curr_parents);
is_empty = xmlTextReaderIsEmptyElement (
parser_state->reader);
if (is_empty)
success = _gtk_source_context_data_define_context (parser_state->ctx_data,
id,
parent_id,
"$^",
NULL,
NULL,
NULL,
NULL,
0,
&tmp_error);
else
success = create_definition (parser_state,
id,
parent_id,
style_ref,
context_classes,
&tmp_error);
if (success && !is_empty)
{
/* Push the new context in the curr_parents
* stack only if other contexts can be
* defined inside it */
g_queue_push_head (parser_state->curr_parents,
g_strdup (id));
}
}
}
g_free (id);
}
g_slist_free_full (context_classes, (GDestroyNotify)gtk_source_context_class_free);
g_free (style_ref);
xmlFree (sub_pattern);
xmlFree (ref);
if (tmp_error != NULL)
g_propagate_error (&parser_state->error, tmp_error);
}
int process_arg(int option, const char *name, const char *val, priority_t precedence, arg_pass_t pass)
{
int count = 0;
(void) precedence; /* suppress compiler warning */
(void) pass; /* suppress compiler warning */
switch (option) {
case '?':
fprintf(stderr, "Unknown option '%s'.\n", name);
break;
case 'd':
flag = M_DUMP;
count += 1;
ds_file = val;
break;
case O_CONFIG_FILE:
read_config_file(val, false, false, PR_COMMAND, longopts_bogoutil);
/*@fallthrough@*/
/* fall through to suppress reading config files */
case 'C':
suppress_config_file = true;
break;
case 'k':
db_cachesize=(uint) atoi(val);
break;
case 'l':
flag = M_LOAD;
count += 1;
ds_file = val;
break;
case 'm':
flag = M_MAINTAIN;
count += 1;
ds_file = val;
break;
case 'p':
prob = true;
/*@fallthrough@*/
case 'w':
flag = M_WORD;
count += 1;
ds_file = val;
break;
case O_DB_PRINT_LEAFPAGE_COUNT:
flag = M_LEAFPAGES;
count += 1;
ds_file = val;
break;
case O_DB_PRINT_PAGESIZE:
flag = M_PAGESIZE;
count += 1;
ds_file = val;
break;
case 'r':
onlyprint = true;
case 'R':
flag = M_ROBX;
count += 1;
ds_file = val;
break;
case 'u':
upgrade_wordlist_version = true;
flag = M_MAINTAIN;
count += 1;
ds_file = val;
break;
case 'v':
verbose++;
break;
case ':':
fprintf(stderr, "Option %s requires an argument.\n", name);
exit(EX_ERROR);
case 'h':
help(stdout);
exit(EX_OK);
case 'H':
flag = M_HIST;
count += 1;
ds_file = val;
break;
case 'V':
print_version();
exit(EX_OK);
case 'x':
set_debug_mask(val);
break;
case 'X':
set_bogotest(val);
break;
case 'a':
maintain = true;
thresh_date = string_to_date(val);
break;
case 'c':
maintain = true;
thresh_count = (uint) atoi(val);
break;
case 's':
{
unsigned long mi, ma;
maintain = true;
if (2 == sscanf(val, "%lu,%lu", &mi, &ma)) {
size_min = mi;
size_max = ma;
} else {
fprintf(stderr, "syntax error in argument \"%s\" of -s\n.",
val);
exit(EX_ERROR);
}
}
break;
case 'n':
maintain = true;
replace_nonascii_characters ^= true;
break;
case 'y': /* date as YYYYMMDD */
{
YYYYMMDD date = string_to_date(val);
maintain = true;
if (date != 0 && date < 19990000) {
fprintf(stderr, "Date format for '-y' option is YYYYMMDD\n");
exit(EX_ERROR);
}
set_date( date );
break;
}
case 'I':
fpin = fopen(val, "r");
if (fpin == NULL) {
fprintf(stderr, "Can't read file '%s'\n", val);
exit(EX_ERROR);
}
break;
case 'O':
fpo = fopen(val, "wt");
if (fpo == NULL) {
fprintf(stderr, "Can't write file '%s'\n", val);
exit(EX_ERROR);
}
break;
case 'D':
dbgout = stdout;
break;
case O_DB_VERIFY:
flag = M_VERIFY;
count += 1;
ds_file = val;
break;
case O_UNICODE:
encoding = str_to_bool(val) ? E_UNICODE : E_RAW;
break;
case O_MAX_TOKEN_LEN:
max_token_len = atoi(val);
break;
case O_MIN_TOKEN_LEN:
min_token_len = atoi(val);
break;
case O_MAX_MULTI_TOKEN_LEN:
max_multi_token_len=atoi(val);
break;
case O_MULTI_TOKEN_COUNT:
multi_token_count=atoi(val);
break;
default:
if (!dsm_options_bogoutil(option, &flag, &count, &ds_file, name, val)) {
fprintf(stderr, "Invalid option '%s'\n", name);
exit(EX_ERROR);
}
}
return count;
}
/**
* @brief Read the configuration for the Cache inode layer
*
* @param[in] config Configuration file handle
* @param[out] param Read parameters
*
* @retval CACHE_INODE_SUCCESS on success.
* @retval CACHE_INODE_NOT_FOUND if stanza not present
* @retval CACHE_INODE_INVALID_ARGUMENT otherwise
*/
cache_inode_status_t
cache_inode_read_conf_parameter(config_file_t config,
cache_inode_parameter_t *param)
{
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
config_item_t block;
/* Get the config BLOCK */
block = config_FindItemByName(config, CONF_LABEL_CACHE_INODE);
if (block == NULL) {
LogDebug(COMPONENT_CONFIG,
"Cannot read item \"%s\" from configuration file",
CONF_LABEL_CACHE_INODE);
return CACHE_INODE_NOT_FOUND;
} else if (config_ItemType(block) != CONFIG_ITEM_BLOCK) {
/* Expected to be a block */
LogCrit(COMPONENT_CONFIG,
"Item \"%s\" is expected to be a block",
CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
var_max = config_GetNbItems(block);
for (var_index = 0; var_index < var_max; var_index++) {
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
err = config_GetKeyValue(item, &key_name, &key_value);
if (err != 0) {
LogCrit(COMPONENT_CONFIG,
"Error reading key[%d] from section \"%s\" of "
"configuration file.",
var_index, CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
else if (!strcasecmp(key_name, "NParts")) {
param->nparts = atoi(key_value);
} else if (!strcasecmp(key_name, "Attr_Expiration_Time")) {
err =
parse_cache_expire(¶m->expire_type_attr,
¶m->grace_period_attr,
key_value);
if (err != CACHE_INODE_SUCCESS)
return err;
} else
if (!strcasecmp
(key_name, "Use_Getattr_Directory_Invalidation")) {
param->getattr_dir_invalidation =
str_to_bool(key_value);
} else if (!strcasecmp(key_name, "Entries_HWMark")) {
param->entries_hwmark = atoi(key_value);
} else if (!strcasecmp(key_name, "LRU_Run_Interval")) {
param->lru_run_interval = atoi(key_value);
} else if (!strcasecmp(key_name, "Cache_FDs")) {
param->use_fd_cache = str_to_bool(key_value);
} else if (!strcasecmp(key_name, "FD_Limit_Percent")) {
param->fd_limit_percent = atoi(key_value);
} else if (!strcasecmp(key_name, "FD_HWMark_Percent")) {
param->fd_hwmark_percent = atoi(key_value);
} else if (!strcasecmp(key_name, "FD_LWMark_Percent")) {
param->fd_lwmark_percent = atoi(key_value);
} else if (!strcasecmp(key_name, "Reaper_Work")) {
param->reaper_work = atoi(key_value);
} else if (!strcasecmp(key_name, "Biggest_Window")) {
param->biggest_window = atoi(key_value);
} else if (!strcasecmp(key_name, "Required_Progress")) {
param->required_progress = atoi(key_value);
} else if (!strcasecmp(key_name, "Futility_Count")) {
param->futility_count = atoi(key_value);
} else if (!strcasecmp(key_name, "DebugLevel")
|| !strcasecmp(key_name, "LogFile")) {
LogWarn(COMPONENT_CONFIG,
"Deprecated %s option %s=\'%s\'",
CONF_LABEL_CACHE_INODE, key_name, key_value);
} else {
LogCrit(COMPONENT_CONFIG,
"Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
}
return CACHE_INODE_SUCCESS;
}
static int
set_param(char *name, char *value)
{
struct param_ptr *p;
double ppc;
if (value == NULL)
return 0;
p = search_param(name);
if (p == NULL)
return 0;
switch (p->type) {
case P_INT:
if (atoi(value) >= 0)
*(int *)p->varptr = (p->inputtype == PI_ONOFF)
? str_to_bool(value, *(int *)p->varptr) : atoi(value);
break;
case P_NZINT:
if (atoi(value) > 0)
*(int *)p->varptr = atoi(value);
break;
case P_SHORT:
*(short *)p->varptr = (p->inputtype == PI_ONOFF)
? str_to_bool(value, *(short *)p->varptr) : atoi(value);
break;
case P_CHARINT:
*(char *)p->varptr = (p->inputtype == PI_ONOFF)
? str_to_bool(value, *(char *)p->varptr) : atoi(value);
break;
case P_CHAR:
*(char *)p->varptr = value[0];
break;
case P_STRING:
*(char **)p->varptr = value;
break;
#if defined(USE_SSL) && defined(USE_SSL_VERIFY)
case P_SSLPATH:
if (value != NULL && value[0] != '\0')
*(char **)p->varptr = rcFile(value);
else
*(char **)p->varptr = NULL;
ssl_path_modified = 1;
break;
#endif
#ifdef USE_COLOR
case P_COLOR:
*(int *)p->varptr = str_to_color(value);
break;
#endif
#ifdef USE_M17N
case P_CODE:
*(wc_ces *) p->varptr =
wc_guess_charset_short(value, *(wc_ces *) p->varptr);
break;
#endif
case P_PIXELS:
ppc = atof(value);
if (ppc >= MINIMUM_PIXEL_PER_CHAR && ppc <= MAXIMUM_PIXEL_PER_CHAR * 2)
*(double *)p->varptr = ppc;
break;
case P_SCALE:
ppc = atof(value);
if (ppc >= 10 && ppc <= 1000)
*(double *)p->varptr = ppc;
break;
}
return 1;
}
OpspacePlanarController * OpspacePlanarController::
create(std::string const & param_root,
jspace::Vector const & default_kp,
jspace::Vector const & default_kd)
{
ros::NodeHandle nn("~");
OpspacePlanarController * controller(0);
try {
std::string q1_name;
if ( ! nn.getParam(param_root + "/q1_name", q1_name)) {
throw std::runtime_error("missing q1_name parameter");
}
std::string tmp;
bool q1_inverted(false);
if (nn.getParam(param_root + "/q1_inverted", tmp)) {
q1_inverted = str_to_bool(param_root + "/q1_inverted", tmp, false);
}
double l1_length;
if ( ! nn.getParam(param_root + "/l1_length", l1_length)) {
throw std::runtime_error("missing l1_length parameter");
}
std::string q2_name;
if ( ! nn.getParam(param_root + "/q2_name", q2_name)) {
throw std::runtime_error("missing q2_name parameter");
}
bool q2_inverted(false);
if (nn.getParam(param_root + "/q2_inverted", tmp)) {
q2_inverted = str_to_bool(param_root + "/q2_inverted", tmp, false);
}
double l2_length;
if ( ! nn.getParam(param_root + "/l2_length", l2_length)) {
throw std::runtime_error("missing l2_length parameter");
}
double op_kp;
if ( ! nn.getParam(param_root + "/op_kp", op_kp)) {
throw std::runtime_error("missing op_kp parameter");
}
double op_kd;
if ( ! nn.getParam(param_root + "/op_kd", op_kd)) {
throw std::runtime_error("missing op_kd parameter");
}
double op_vmax;
if ( ! nn.getParam(param_root + "/op_vmax", op_vmax)) {
throw std::runtime_error("missing op_vmax parameter");
}
controller = new OpspacePlanarController(q1_name, q1_inverted, l1_length,
q2_name, q2_inverted, l2_length,
op_kp, op_kd, op_vmax,
default_kp, default_kd);
}
catch (std::exception const & ee) {
ROS_ERROR ("OpspacePlanarController::create(`%s'): EXCEPTION: %s", param_root.c_str(), ee.what());
delete controller;
controller = 0;
}
return controller;
}
static bool process_config_parameter(const parm_desc *arg, char *val, priority_t precedence)
/* returns true if ok, false if error */
{
bool ok = true;
if (arg->addr.v == NULL)
return ok;
switch (arg->type)
{
case CP_BOOLEAN:
{
*arg->addr.b = str_to_bool(val);
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> %s\n", arg->name,
*arg->addr.b ? "Yes" : "No");
break;
}
case CP_INTEGER:
{
remove_comment(val);
if (!xatoi(arg->addr.i, val))
return false;
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> %d\n", arg->name, *arg->addr.i);
break;
}
case CP_DOUBLE:
{
remove_comment(val);
if (!xatof(arg->addr.d, val))
return false;
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> %f\n", arg->name, *arg->addr.d);
break;
}
case CP_CHAR:
{
*arg->addr.c = *val;
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> '%c'\n", arg->name, *arg->addr.c);
break;
}
case CP_STRING:
{
*arg->addr.s = xstrdup(val);
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> '%s'\n", arg->name, *arg->addr.s);
break;
}
case CP_DIRECTORY:
{
char *dir = tildeexpand(val, true);
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> '%s'\n", arg->name, dir);
if (setup_wordlists(dir, precedence) != 0)
exit(EX_ERROR);
xfree(dir);
break;
}
case CP_FUNCTION:
{
ok = (*arg->addr.f)((unsigned char *)val);
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> '%s'\n", arg->name, val);
break;
}
case CP_WORDLIST:
{
char c = *val;
switch (c) {
case 'c': wl_mode = WL_M_COMBINED; break;
case 's': wl_mode = WL_M_SEPARATE; break;
default:
fprintf(stderr, "Unknown wordlist type - '%s'.\n", val);
exit(EX_ERROR);
}
if (DEBUG_CONFIG(2))
fprintf(dbgout, "%s -> '%s'\n", arg->name, val);
break;
}
default:
{
ok = false;
break;
}
}
return ok;
}
void parse_config(const char *conf_file, struct options *opt)
{
FILE *fh;
struct buffer line;
unsigned int lineno = 1;
int errors = 0;
/* Journal hasn't been opened yet */
printf("Reading configuration file at \"%s\"...\n", conf_file);
if (opt->strict) {
security_conf_file_check(conf_file);
}
fh = fopen(conf_file, "r");
if (fh == NULL) {
fprintf(stderr, "Unable to open configuration file \"%s\": %s.\n",
conf_file, strerror(errno));
cleanup(EXIT_IO, true);
}
#if DEBUG
printf("Raw key/value pairs from config file:\n");
#endif /* DEBUG */
while (file_read_line(fh, conf_file, &lineno, &line)) {
struct buffer key, val;
bool success;
int ch;
if (!read_key_and_value(conf_file, lineno, &line, &key, &val)) {
if (key.length) {
errors++;
}
continue;
}
/* Check each possible option */
if (!strcasecmp(key.data, "Daemonize")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->daemonize = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "TransportProtocol")) {
if (!strcasecmp(val.data, "tcp")) {
opt->tproto = PROTOCOL_TCP;
} else if (!strcasecmp(val.data, "udp")) {
opt->tproto = PROTOCOL_UDP;
} else {
fprintf(stderr, "%s:%d: invalid transport protocol: \"%s\"\n",
conf_file, lineno, val.data);
errors++;
}
} else if (!strcasecmp(key.data, "InternetProtocol")) {
if (!strcasecmp(val.data, "both")) {
opt->iproto = PROTOCOL_BOTH;
} else if (!strcasecmp(val.data, "ipv4")) {
opt->iproto = PROTOCOL_IPv4;
} else if (!strcasecmp(val.data, "ipv6")) {
opt->iproto = PROTOCOL_IPv6;
} else {
fprintf(stderr, "%s:%d: invalid internet protocol: \"%s\"\n",
conf_file, lineno, val.data);
errors++;
}
} else if (!strcasecmp(key.data, "Port")) {
/* atoi is ok because it returns 0 in case of failure, and 0 isn't a valid port */
int port = atoi(val.data);
if (0 >= port || port > PORT_MAX) {
fprintf(stderr, "%s:%d: invalid port number: \"%s\"\n",
conf_file, lineno, val.data);
errors++;
} else {
opt->port = port;
}
} else if (!strcasecmp(key.data, "StrictChecking")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->strict = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "DropPrivileges")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->drop_privileges = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "PidFile")) {
if (!strcmp(val.data, "none")) {
opt->pid_file = NULL;
continue;
}
opt->pid_file = strdup(val.data);
if (unlikely(!opt->pid_file)) {
perror("Unable to allocate memory for config value");
fclose(fh);
cleanup(EXIT_MEMORY, true);
}
} else if (!strcasecmp(key.data, "RequirePidFile")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->require_pidfile = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "JournalFile")) {
if (!strcmp(val.data, "-")) {
opt->journal_file = NULL;
} else if (strcmp(val.data, "none") != 0) {
opt->journal_file = strdup(val.data);
if (unlikely(!opt->journal_file)) {
perror("Unable to allocate memory for config value");
fclose(fh);
cleanup(EXIT_MEMORY, true);
}
}
} else if (!strcasecmp(key.data, "QuotesFile")) {
opt->quotes_file = strdup(val.data);
if (unlikely(!opt->quotes_file)) {
perror("Unable to allocate memory for config value");
fclose(fh);
cleanup(EXIT_MEMORY, true);
}
} else if (!strcasecmp(key.data, "QuoteDivider")) {
if (!strcasecmp(val.data, "line")) {
opt->linediv = DIV_EVERYLINE;
} else if (!strcasecmp(val.data, "percent")) {
opt->linediv = DIV_PERCENT;
} else if (!strcasecmp(val.data, "file")) {
opt->linediv = DIV_WHOLEFILE;
} else {
fprintf(stderr,
"%s:%d: unsupported division type: \"%s\"\n",
conf_file, lineno, val.data);
errors++;
}
} else if (!strcasecmp(key.data, "PadQuotes")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->pad_quotes = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "DailyQuotes")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->is_daily = ch;
} else {
errors++;
}
} else if (!strcasecmp(key.data, "AllowBigQuotes")) {
ch = str_to_bool(val.data, conf_file, lineno, &success);
if (likely(success)) {
opt->allow_big = ch;
} else {
errors++;
}
} else {
fprintf(stderr, "%s:%d: unknown conf option: \"%s\"\n",
conf_file, lineno, key.data);
errors++;
}
lineno++;
}
fclose(fh);
if (opt->strict && errors) {
fprintf(stderr,
"Your configuration file has %d issue%s. The daemon will not start.\n"
"(To disable this behavior, use the --lax flag when running).\n",
errors, PLURAL(errors));
cleanup(EXIT_SECURITY, true);
}
}
fsal_status_t
load_FS_common_parameters_from_conf(config_file_t in_config,
struct fsal_fs_params *common_info)
{
int err;
int var_max, var_index;
char *key_name;
char *key_value;
config_item_t block;
block = config_FindItemByName(in_config, CONF_LABEL_FS_COMMON);
/* cannot read item */
if (block == NULL) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: Cannot read item \"%s\" from configuration file",
CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_NOENT, 0);
} else if (config_ItemType(block) != CONFIG_ITEM_BLOCK) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: Item \"%s\" is expected to be a block",
CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_INVAL, 0);
}
var_max = config_GetNbItems(block);
for (var_index = 0; var_index < var_max; var_index++) {
config_item_t item;
item = config_GetItemByIndex(block, var_index);
err = config_GetKeyValue(item, &key_name, &key_value);
if (err) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR reading key[%d] from section \"%s\" of configuration file.",
var_index, CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_SERVERFAULT, err);
}
/* does the variable exists ? */
if (!STRCMP(key_name, "link_support")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, link_support,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "symlink_support")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, symlink_support,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "cansettime")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: 0 or 1 expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* if set to false, force value to false.
* else keep fs default.
*/
SET_INIT_INFO(common_info, cansettime,
FSAL_INIT_MAX_LIMIT, val);
} else if (!STRCMP(key_name, "maxread")) {
int size;
size = s_read_int(key_value);
SET_INIT_INFO(common_info, maxread,
FSAL_INIT_FORCE_VALUE, size);
} else if (!STRCMP(key_name, "maxwrite")) {
uint32_t size;
size = s_read_int(key_value);
SET_INIT_INFO(common_info, maxwrite,
FSAL_INIT_FORCE_VALUE, size);
} else if (!STRCMP(key_name, "umask")) {
int mode = s_read_octal(key_value);
if (mode < 0) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: octal expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, umask, FSAL_INIT_FORCE_VALUE,
unix2fsal_mode(mode));
} else if (!STRCMP(key_name, "auth_xdev_export")) {
int val = str_to_bool(key_value);
if (val == -1) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: boolean expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, auth_exportpath_xdev,
FSAL_INIT_FORCE_VALUE, val);
} else if (!STRCMP(key_name, "xattr_access_rights")) {
int mode = s_read_octal(key_value);
if (mode < 0) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: octal expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
SET_INIT_INFO(common_info, xattr_access_rights,
FSAL_INIT_FORCE_VALUE,
unix2fsal_mode(mode));
} else {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_FS_COMMON);
return fsalstat(ERR_FSAL_INVAL, 0);
}
}
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
