static void indexed_modcallable_free(void *data)
{
indexed_modcallable *c = data;
modcallable_free(&c->modulelist);
free(c);
}
static int indexed_modcallable_free(void *ctx)
{
indexed_modcallable *this;
this = talloc_get_type_abort(ctx, indexed_modcallable);
modcallable_free(&this->modulelist);
return 0;
}
static void indexed_modcallable_free(indexed_modcallable **cf)
{
indexed_modcallable *c, *next;
c = *cf;
while (c) {
next = c->next;
modcallable_free(&c->modulelist);
free(c);
c = next;
}
*cf = NULL;
}
/* Load a flat module list, as found inside an authtype{} block */
static void load_subcomponent_section(CONF_SECTION *cs, int comp,
const char *filename)
{
int idx;
indexed_modcallable *subcomp;
modcallable *ml;
DICT_VALUE *dval;
static int meaningless_counter = 1;
ml = compile_modgroup(comp, cs, filename);
/* We must assign a numeric index to this subcomponent. For
* auth, it is generated and placed in the dictionary by
* new_sectiontype_value(). The others are just numbers that are pulled
* out of thin air, and the names are neither put into the dictionary
* nor checked for uniqueness, but all that could be fixed in a few
* minutes, if anyone finds a real use for indexed config of
* components other than auth. */
dval = NULL;
if (comp==RLM_COMPONENT_AUTH) {
dval = dict_valbyname(PW_AUTH_TYPE, cf_section_name2(cs));
} else if (comp == RLM_COMPONENT_AUTZ) {
dval = dict_valbyname(PW_AUTZ_TYPE, cf_section_name2(cs));
} else if (comp == RLM_COMPONENT_ACCT) {
dval = dict_valbyname(PW_ACCT_TYPE, cf_section_name2(cs));
} else if (comp == RLM_COMPONENT_SESS) {
dval = dict_valbyname(PW_SESSION_TYPE, cf_section_name2(cs));
} else if (comp == RLM_COMPONENT_POST_AUTH) {
dval = dict_valbyname(PW_POST_AUTH_TYPE, cf_section_name2(cs));
}
if (dval) {
idx = dval->value;
} else {
idx = meaningless_counter++;
}
subcomp = new_sublist(comp, idx);
if (!subcomp) {
radlog(L_ERR|L_CONS,
"%s[%d] %s %s already configured - skipping",
filename, cf_section_lineno(cs),
subcomponent_names[comp], cf_section_name2(cs));
modcallable_free(&ml);
return;
}
subcomp->modulelist = ml;
}
static void load_component_section(CONF_SECTION *cs, int comp, const char *filename)
{
modcallable *this;
CONF_ITEM *modref;
int modreflineno;
int idx;
indexed_modcallable *subcomp;
const char *modname;
char *visiblename;
for (modref=cf_item_find_next(cs, NULL);
modref != NULL;
modref=cf_item_find_next(cs, modref)) {
if (cf_item_is_section(modref)) {
CONF_SECTION *scs;
scs = cf_itemtosection(modref);
if (strcmp(cf_section_name1(scs),
subcomponent_names[comp]) == 0) {
load_subcomponent_section(scs, comp, filename);
continue;
}
/*
* Allow old names, too.
*/
if (strcmp(cf_section_name1(scs),
old_subcomponent_names[comp]) == 0) {
load_subcomponent_section(scs, comp, filename);
continue;
}
modreflineno = cf_section_lineno(scs);
} else {
CONF_PAIR *cp;
cp = cf_itemtopair(modref);
modreflineno = cf_pair_lineno(cp);
}
this = compile_modsingle(comp, modref, filename, &modname);
if (comp == RLM_COMPONENT_AUTH) {
DICT_VALUE *dval;
dval = dict_valbyname(PW_AUTH_TYPE, modname);
rad_assert(dval != NULL);
idx = dval->value;
} else {
/* See the comment in new_sublist() for explanation
* of the special index 0 */
idx = 0;
}
subcomp = new_sublist(comp, idx);
if (subcomp == NULL) {
radlog(L_ERR|L_CONS,
"%s %s %s already configured - skipping",
filename, subcomponent_names[comp],
modname);
modcallable_free(&this);
continue;
}
/* If subcomp->modulelist is NULL, add_to_modcallable will
* create it */
visiblename = cf_section_name2(cs);
if (visiblename == NULL)
visiblename = cf_section_name1(cs);
add_to_modcallable(&subcomp->modulelist, this,
comp, visiblename);
}
}
/*
* The "free" functions are here, for no particular reason.
*/
void rlm_policy_free_item(policy_item_t *item)
{
while (item) {
policy_item_t *next = item->next;
switch (item->type) {
default:
case POLICY_TYPE_BAD:
break;
case POLICY_TYPE_ASSIGNMENT:
{
policy_assignment_t *this;
this = (policy_assignment_t *) item;
if (this->lhs) free(this->lhs);
if (this->rhs) free(this->rhs);
}
break;
case POLICY_TYPE_CONDITIONAL:
{
policy_condition_t *this;
this = (policy_condition_t *) item;
if (this->lhs) free(this->lhs);
if (this->rhs) free(this->rhs);
if (this->child) {
rlm_policy_free_item(this->child);
this->child = NULL;
}
}
break;
case POLICY_TYPE_IF:
{
policy_if_t *this;
this = (policy_if_t *) item;
if (this->condition) {
rlm_policy_free_item(this->condition);
this->condition = NULL;
}
if (this->if_true) {
rlm_policy_free_item(this->if_true);
this->if_true = NULL;
}
if (this->if_false) {
rlm_policy_free_item(this->if_false);
this->if_false = NULL;
}
}
break;
case POLICY_TYPE_ATTRIBUTE_LIST:
{
policy_attributes_t *this;
this = (policy_attributes_t *) item;
rlm_policy_free_item(this->attributes);
}
break;
case POLICY_TYPE_NAMED_POLICY:
{
policy_named_t *this;
this = (policy_named_t *) item;
rad_assert(this->name != NULL);
free(this->name);
rlm_policy_free_item(this->policy);
}
break;
case POLICY_TYPE_CALL:
{
policy_call_t *this;
this = (policy_call_t *) item;
if (this->name) free(this->name);
}
break;
case POLICY_TYPE_RETURN:
break; /* do nothing */
case POLICY_TYPE_MODULE:
{
policy_module_t *this;
this = (policy_module_t *) item;
if (this->cs) cf_section_free(&this->cs);
if (this->mc) modcallable_free(&this->mc);
}
break;
} /* switch over type */
item->next = NULL; /* for debugging & sanity checks */
item->type = POLICY_TYPE_BAD;
free(item);
item = next;
}
}
