static int call_modsingle(int component, modsingle *sp, REQUEST *request,
int default_result)
{
int myresult = default_result;
DEBUG3(" modsingle[%s]: calling %s (%s) for request %d",
comp2str[component], sp->modinst->name,
sp->modinst->entry->name, request->number);
safe_lock(sp->modinst);
myresult = sp->modinst->entry->module->methods[component](
sp->modinst->insthandle, request);
safe_unlock(sp->modinst);
DEBUG3(" modsingle[%s]: returned from %s (%s) for request %d",
comp2str[component], sp->modinst->name,
sp->modinst->entry->name, request->number);
return myresult;
}
static unlang_action_t unlang_module_resume(REQUEST *request, rlm_rcode_t *presult, UNUSED void *rctx)
{
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame = &stack->frame[stack->depth];
unlang_t *instruction = frame->instruction;
unlang_resume_t *mr = unlang_generic_to_resume(instruction);
unlang_module_t *mc = unlang_generic_to_module(mr->parent);
int stack_depth = stack->depth;
char const *caller;
unlang_frame_state_module_t *ms = NULL;
rad_assert(mr->parent->type == UNLANG_TYPE_MODULE);
ms = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
/*
* Lock is noop unless instance->mutex is set.
*/
caller = request->module;
request->module = mc->module_instance->name;
safe_lock(mc->module_instance);
*presult = request->rcode = ((fr_unlang_module_resume_t)mr->resume)(request,
mc->module_instance->dl_inst->data,
ms->thread->data, mr->rctx);
safe_unlock(mc->module_instance);
request->module = caller;
if (*presult != RLM_MODULE_YIELD) ms->thread->active_callers--;
RDEBUG2("%s (%s)", instruction->name ? instruction->name : "",
fr_int2str(mod_rcode_table, *presult, "<invalid>"));
switch (*presult) {
case RLM_MODULE_YIELD:
if (stack_depth < stack->depth) return UNLANG_ACTION_PUSHED_CHILD;
rad_assert(stack_depth == stack->depth);
return UNLANG_ACTION_YIELD;
default:
return UNLANG_ACTION_CALCULATE_RESULT;
}
}
static unlang_action_t unlang_module(REQUEST *request,
rlm_rcode_t *presult, int *priority)
{
unlang_module_t *sp;
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame = &stack->frame[stack->depth];
unlang_t *instruction = frame->instruction;
unlang_frame_state_module_t *ms;
int stack_depth = stack->depth;
char const *caller;
#ifndef NDEBUG
int unlang_indent = request->log.unlang_indent;
#endif
/*
* Process a stand-alone child, and fall through
* to dealing with it's parent.
*/
sp = unlang_generic_to_module(instruction);
rad_assert(sp);
RDEBUG4("[%i] %s - %s (%s)", stack->depth, __FUNCTION__,
sp->module_instance->name, sp->module_instance->module->name);
/*
* Return administratively configured return code
*/
if (sp->module_instance->force) {
*presult = request->rcode = sp->module_instance->code;
goto done;
}
frame->state = ms = talloc_zero(stack, unlang_frame_state_module_t);
/*
* Grab the thread/module specific data if any exists.
*/
ms->thread = module_thread_instance_find(sp->module_instance);
rad_assert(ms->thread != NULL);
/*
* For logging unresponsive children.
*/
ms->thread->total_calls++;
caller = request->module;
request->module = sp->module_instance->name;
safe_lock(sp->module_instance); /* Noop unless instance->mutex set */
*presult = sp->method(sp->module_instance->dl_inst->data, ms->thread->data, request);
safe_unlock(sp->module_instance);
request->module = caller;
/*
* Is now marked as "stop" when it wasn't before, we must have been blocked.
*/
if (request->master_state == REQUEST_STOP_PROCESSING) {
RWARN("Module %s became unblocked", sp->module_instance->module->name);
return UNLANG_ACTION_STOP_PROCESSING;
}
if (*presult == RLM_MODULE_YIELD) {
ms->thread->active_callers++;
goto done;
}
/*
* Module execution finished, ident should be the same.
*/
rad_assert(unlang_indent == request->log.unlang_indent);
rad_assert(*presult >= RLM_MODULE_REJECT);
rad_assert(*presult < RLM_MODULE_NUMCODES);
*priority = instruction->actions[*presult];
request->rcode = *presult;
done:
/*
* Must be left at RDEBUG() level otherwise RDEBUG becomes pointless
*/
RDEBUG("%s (%s)", instruction->name ? instruction->name : "",
fr_int2str(mod_rcode_table, *presult, "<invalid>"));
switch (*presult) {
case RLM_MODULE_YIELD:
if (stack_depth < stack->depth) return UNLANG_ACTION_PUSHED_CHILD;
rad_assert(stack_depth == stack->depth);
return UNLANG_ACTION_YIELD;
default:
return UNLANG_ACTION_CALCULATE_RESULT;
}
}