int
auksd_engine_init_from_config_file(auksd_engine_t * engine,
char *conf_file)
{
int fstatus = AUKS_ERROR;
char* l_conf_file;
char* e_conf_file;
config_file_t config;
int block_nb;
char *phost;
char *padd;
char *pport;
char *pprinc;
char *pktb;
char *shost;
char *sadd;
char *sport;
char *sprinc;
char *sktb;
char *cdir;
char *afile;
char *lfile;
char *dfile;
char *ll_str;
char *dl_str;
char *tnb_str;
char *qs_str;
char *rs_str;
char *rd_str;
char *nat_str;
char *krc_str;
long int ll, dl, tnb, qs, rs, rd;
int nat, krc;
int i;
int valid_block_nb=0;
if ( conf_file != NULL )
l_conf_file = conf_file;
else {
e_conf_file = getenv("AUKSD_CONF");
if ( e_conf_file != NULL )
l_conf_file = e_conf_file ;
else
l_conf_file = DEFAULT_AUKSD_CONF ;
}
/* parse configuration file */
config = config_ParseFile(l_conf_file);
if (!config) {
auks_error("unable to parse configuration file %s : %s",
l_conf_file, extern_errormsg);
fstatus = AUKS_ERROR_ENGINE_CONFFILE_PARSING ;
goto exit;
}
/* get conf blocks quantity */
block_nb = config_GetNbBlocks(config);
if (block_nb <= 0) {
auks_error("unable to get configuration blocks from config "
"file %s : %s", l_conf_file, extern_errormsg);
fstatus = AUKS_ERROR_ENGINE_CONFFILE_INVALID ;
goto parse_exit;
}
/* look for relevants block and add contents to engine conf */
fstatus = AUKS_ERROR_ENGINE_CONFFILE_INCOMPLETE ;
for (i = 0; i < block_nb; i++) {
char *block_name;
block_name = config_GetBlockName(config, i);
/* skip non config blocks */
if (strncmp("common", block_name, 7) != 0) {
continue;
}
auks_log
("initializing engine from 'common' block of file %s",
l_conf_file);
/* primary server conf value */
phost = config_GetKeyValueByName(config,i,"PrimaryHost");
if (phost == NULL)
phost = DEFAULT_AUKSD_PRIMARY_HOST;
padd = config_GetKeyValueByName(config,i,"PrimaryAddress");
if (padd == NULL)
padd = DEFAULT_AUKSD_PRIMARY_ADDR;
pport = config_GetKeyValueByName(config,i,"PrimaryPort");
if (pport == NULL)
pport = DEFAULT_AUKSD_PRIMARY_PORT;
pprinc = config_GetKeyValueByName(config,i,"PrimaryPrincipal");
if (pprinc == NULL)
pprinc = DEFAULT_AUKSD_PRIMARY_PRINC;
/* secondary server conf value */
shost = config_GetKeyValueByName(config,i,"SecondaryHost");
if (shost == NULL)
shost = DEFAULT_AUKSD_SECONDARY_HOST;
sadd = config_GetKeyValueByName(config,i,"SecondaryAddress");
if (sadd == NULL)
sadd = DEFAULT_AUKSD_SECONDARY_ADDR;
sport = config_GetKeyValueByName(config,i,"SecondaryPort");
if (sport == NULL)
sport = DEFAULT_AUKSD_SECONDARY_PORT;
sprinc = config_GetKeyValueByName(config,i,
"SecondaryPrincipal");
if (sprinc == NULL)
sprinc = DEFAULT_AUKSD_SECONDARY_PRINC;
/* NAT traversal mode */
nat_str =
config_GetKeyValueByName(config, i, "NAT") ;
if (nat_str == NULL)
nat = DEFAULT_AUKS_NAT_TRAVERSAL ;
else if ( strncasecmp(nat_str,"yes",4) ==0 )
nat = 1 ;
else
nat = 0 ;
valid_block_nb++;
} /* EOF for */
for (i = 0; i < block_nb; i++) {
char *block_name;
block_name = config_GetBlockName(config, i);
/* skip non config blocks */
if (strncmp("auksd", block_name, 5) != 0) {
continue;
}
auks_log
("initializing engine from 'auksd' block of file %s",
l_conf_file);
/* primary server conf value */
pktb = config_GetKeyValueByName(config,i,"PrimaryKeytab");
if (pktb == NULL)
pktb = DEFAULT_AUKSD_PRIMARY_KEYTAB;
/* secondary server conf value */
sktb = config_GetKeyValueByName(config,i,"SecondaryKeytab");
if (sktb == NULL)
sktb = DEFAULT_AUKSD_SECONDARY_KEYTAB;
/* cache dir value */
cdir = config_GetKeyValueByName(config,i,"CacheDir");
if (cdir == NULL)
cdir = DEFAULT_AUKSD_CACHEDIR;
/* acl file value */
afile = config_GetKeyValueByName(config,i,"ACLFile");
if (afile == NULL)
afile = DEFAULT_AUKSD_ACLFILE;
/* read log file value */
lfile = config_GetKeyValueByName(config,i,"LogFile");
if (lfile == NULL)
lfile = DEFAULT_AUKSD_LOGFILE;
/* read log level value */
ll_str = config_GetKeyValueByName(config,i,"LogLevel");
if (ll_str == NULL)
ll = DEFAULT_AUKSD_LOGLEVEL;
else
ll = strtol(ll_str, NULL, 10);
if (ll == LONG_MIN || ll == LONG_MAX)
ll = DEFAULT_AUKSD_LOGLEVEL;
/* read debug file value */
dfile = config_GetKeyValueByName(config,i,"DebugFile");
if (dfile == NULL)
dfile = DEFAULT_AUKSD_DEBUGFILE;
/* read debug level value */
dl_str = config_GetKeyValueByName(config,i,"DebugLevel");
if (dl_str == NULL)
dl = DEFAULT_AUKSD_DEBUGLEVEL;
else
dl = strtol(dl_str, NULL, 10);
if (dl == LONG_MIN || dl == LONG_MAX)
dl = DEFAULT_AUKSD_DEBUGLEVEL;
/* read threads nb value */
tnb_str =
config_GetKeyValueByName(config,i,"Workers");
if (tnb_str == NULL)
tnb = DEFAULT_AUKSD_THREADS_NB;
else
tnb = strtol(tnb_str, NULL, 10);
if (tnb == LONG_MIN || tnb == LONG_MAX)
tnb = DEFAULT_AUKSD_THREADS_NB;
/* read queue size */
qs_str = config_GetKeyValueByName(config,i,"QueueSize");
if (qs_str == NULL)
qs = DEFAULT_AUKSD_QUEUE_SIZE;
else
qs = strtol(qs_str, NULL, 10);
if (qs == LONG_MIN || qs == LONG_MAX)
qs = DEFAULT_AUKSD_QUEUE_SIZE;
/* read repository size */
rs_str = config_GetKeyValueByName(config,i,"RepoSize");
if (rs_str == NULL)
rs = DEFAULT_AUKSD_REPO_SIZE;
else
rs = strtol(rs_str, NULL, 10);
if (rs == LONG_MIN || rs == LONG_MAX)
rs = DEFAULT_AUKSD_REPO_SIZE;
/* clean delay */
rd_str =
config_GetKeyValueByName(config,i,"CleanDelay");
if (rd_str == NULL)
rd = DEFAULT_AUKSD_CLEAN_DELAY;
else
rd = strtol(rd_str, NULL, 10);
if (rd == LONG_MIN || rd == LONG_MAX)
rd = DEFAULT_AUKSD_CLEAN_DELAY;
/* Kerberos Replay cache mode */
krc_str =
config_GetKeyValueByName(config, i, "ReplayCache") ;
if (krc_str == NULL)
krc = DEFAULT_AUKS_REPLAY_CACHE ;
else if ( strncasecmp(krc_str,"yes",4) ==0 )
krc = 1 ;
else
krc = 0 ;
valid_block_nb++;
} /* EOF for */
if ( valid_block_nb == 2 )
fstatus = AUKS_SUCCESS;
if ( fstatus == AUKS_SUCCESS ) {
/* init auksd engine */
fstatus = auksd_engine_init(engine,
phost,padd, pport, pprinc, pktb,
shost,sadd, sport, sprinc, sktb,
cdir, afile, lfile, ll, dfile,
dl, tnb, qs, rs, rd,nat,krc);
/* init ok, break */
if (fstatus == 0) {
auks_log("initialization succeed");
} else
auks_error("initialization failed");
}
parse_exit:
/* free config file */
config_Free(config);
exit:
return fstatus;
}
int
auks_acl_init_from_config_file(auks_acl_t * p_acl, char *acl_file)
{
int fstatus = AUKS_ERROR;
config_file_t config;
int block_nb;
char *principal;
char *host;
char *role_string;
enum AUKS_ACL_ROLE role;
int i;
/* conf parsing */
config = config_ParseFile(acl_file);
if (!config) {
auks_error("unable to parse configuration file %s : %s",
acl_file, extern_errormsg);
fstatus = AUKS_ERROR_ACL_PARSING;
goto exit;
}
auks_log("configuration file (%s) successfully parsed", acl_file);
/* block nb */
block_nb = config_GetNbBlocks(config);
if (block_nb <= 0) {
auks_error("unable to get configuration blocks nb from "
"config file %s : %s", acl_file, extern_errormsg);
fstatus = AUKS_ERROR_ACL_FILE_IS_EMPTY;
goto parse_exit;
}
auks_log2("configuration blocks nb (%d) successfully extracted",
block_nb);
/* acl init */
if (auks_acl_init(p_acl, block_nb) != 0) {
auks_error("unable to init Auks ACL structure");
fstatus = AUKS_ERROR_ACL_INIT;
goto parse_exit;
}
auks_log2("Auks ACL structure successfully initialized");
/* block loop */
fstatus = 0;
for (i = 0; i < block_nb; i++) {
char *block_name;
block_name = config_GetBlockName(config, i);
/* keep only rule block */
if (strncmp("rule", block_name, 7) != 0)
continue;
role_string = config_GetKeyValueByName(config, i, "role");
principal =
config_GetKeyValueByName(config, i, "principal");
host = config_GetKeyValueByName(config, i, "host");
if (role_string == NULL) {
auks_error("no role defined in rule[%d] of %s", i,
acl_file);
continue;
}
if (strncmp("user", role_string, 5) == 0) {
role = AUKS_ACL_ROLE_USER;
} else if (strncmp("admin", role_string, 6) == 0) {
role = AUKS_ACL_ROLE_ADMIN;
} else if (strncmp("guest", role_string, 5) == 0) {
role = AUKS_ACL_ROLE_GUEST;
} else {
auks_error("invalid role for rule[%d]", i,
acl_file, extern_errormsg);
fstatus++;
continue;
}
if (auks_acl_add_rule(p_acl, principal, host, role)) {
auks_error("unable to add rule[%d] to auks_acl", i);
fstatus++;
} else {
auks_log("rule[%d] '%s:%s => %s' successfully add",
i, principal, host, role_string);
}
} /* EOF block loop */
/* clean acl if errors occured during creation */
if (fstatus) {
auks_acl_free_contents(p_acl);
fstatus = AUKS_ERROR_ACL_FILE_IS_INVALID;
}
parse_exit:
/* free config file */
config_Free(config);
exit:
return fstatus;
}
static fsal_status_t load_FSAL_parameters_from_conf(config_file_t in_config,
const char *fsal_name,
fsal_init_info_t *
init_info,
fsal_extra_arg_parser_f
extra)
{
int err;
int var_max, var_index;
char *key_name;
char *key_value;
config_item_t fsal_block, block = NULL;
int i, fsal_cnt;
fsal_block = config_FindItemByName(in_config, CONF_LABEL_FSAL);
if (fsal_block == NULL) {
LogFatal(COMPONENT_INIT,
"Cannot find item \"%s\" in configuration",
CONF_LABEL_FSAL);
return fsalstat(ERR_FSAL_NOENT, 0);
}
if (config_ItemType(fsal_block) != CONFIG_ITEM_BLOCK) {
LogFatal(COMPONENT_INIT, "\"%s\" is not a block",
CONF_LABEL_FSAL);
return fsalstat(ERR_FSAL_NOENT, 0);
}
fsal_cnt = config_GetNbItems(fsal_block);
for (i = 0; i < fsal_cnt; i++) {
block = config_GetItemByIndex(fsal_block, i);
if (config_ItemType(block) == CONFIG_ITEM_BLOCK
&& strcasecmp(config_GetBlockName(block), fsal_name) == 0) {
break;
}
}
if (i == fsal_cnt) {
LogFatal(COMPONENT_INIT,
"Cannot find the %s section of %s in the configuration file",
fsal_name, CONF_LABEL_FSAL);
return fsalstat(ERR_FSAL_NOENT, 0);
}
if (config_ItemType(block) != CONFIG_ITEM_BLOCK) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: Item \"%s\" is expected to be a block",
fsal_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
/* read variable for fsal init */
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_FSAL);
return fsalstat(ERR_FSAL_SERVERFAULT, err);
}
if (!STRCMP(key_name, "DebugLevel")
|| !STRCMP(key_name, "LogFile")) {
LogWarn(COMPONENT_CONFIG,
"Deprecated FSAL option %s=\'%s\'", key_name,
key_value);
} else if (!STRCMP(key_name, "Max_FS_calls")) {
int maxcalls = s_read_int(key_value);
if (maxcalls < 0) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: null or positive integer expected.",
key_name);
return fsalstat(ERR_FSAL_INVAL, 0);
}
} else if (strcasecmp(key_name, "FSAL_Shared_Library") == 0) {
continue; /* scanned at load time */
} else if ((extra == NULL)
||
((*extra)
(key_name, key_value, init_info, fsal_name))) {
LogCrit(COMPONENT_CONFIG,
"FSAL LOAD PARAMETER: ERROR: Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_FSAL);
return fsalstat(ERR_FSAL_INVAL, 0);
}
}
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
