The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
module.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: b7a74b4d3f76f84a86aea9e7c37bc7e46b3c8d4d $
19 *
20 * @file unlang/module.c
21 * @brief Defines functions for calling modules asynchronously
22 *
23 * @copyright 2018 The FreeRADIUS server project
24 * @copyright 2018 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
25 */
26RCSID("$Id: b7a74b4d3f76f84a86aea9e7c37bc7e46b3c8d4d $")
27
28#include <freeradius-devel/server/modpriv.h>
29#include <freeradius-devel/server/request_data.h>
30
31#include "module_priv.h"
32
33#include "tmpl.h"
34
37
38/** Push a module or submodule onto the stack for evaluation
39 *
40 * @param[out] p_result Where to write the result of calling the module.
41 * @param[in] request The current request.
42 * @param[in] mi Instance of the module to call.
43 * @param[in] method to call.
44 * @param[in] top_frame Set to UNLANG_TOP_FRAME if the interpreter should return.
45 * Set to UNLANG_SUB_FRAME if the interprer should continue.
46 * @return
47 * - 0 on success.
48 * - -1 on failure.
49 */
51 module_instance_t *mi, module_method_t method, bool top_frame)
52{
53 unlang_stack_t *stack = request->stack;
57
58 /*
59 * We need to have a unlang_module_t to push on the
60 * stack. The only sane way to do it is to attach it to
61 * the frame state.
62 */
63 MEM(mc = talloc(stack, unlang_module_t)); /* Still gets allocated from the stack pool */
64 *mc = (unlang_module_t){
65 .self = {
67 .name = mi->name,
68 .debug_name = mi->name,
69 .actions = {
70 .actions = {
72 [RLM_MODULE_FAIL] = MOD_ACTION_RETURN, /* Exit out of nested levels */
73 [RLM_MODULE_OK] = 0,
78 [RLM_MODULE_NOOP] = 0,
80 [RLM_MODULE_TIMEOUT] = MOD_ACTION_RETURN, /* Exit out of nested levels */
81 },
82 .retry = RETRY_INIT,
83 },
84 },
85 .mmc = {
86 .mi = mi,
87 .mmb = {
88 .method = method
89 }
90 }
91 };
92
93 /*
94 * Push a new module frame onto the stack
95 */
96 if (unlang_interpret_push(p_result, request, unlang_module_to_generic(mc),
98 return -1;
99 }
100
101 frame = &stack->frame[stack->depth];
102 state = frame->state;
104 .thread = module_thread(mi)
105 };
106
107 /*
108 * Bind the temporary unlang_module_t to the frame state.
109 *
110 * There aren't _that_ many children in the stack context.
111 * so we should be ok.
112 *
113 * Hopefully in future versions of talloc the O(n) problem
114 * will be fixed for stealing.
115 */
116 talloc_steal(state, mc);
117
118 return 0;
119}
120
121/** Change the resume function of a module.
122 *
123 * @param[in] request The current request.
124 * @param[in] resume function to call when the XLAT expansion is complete.
125 * @return
126 * - <0 on error
127 * - 0 on success
128 */
130{
131 unlang_stack_t *stack = request->stack;
132 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
134
135 /*
136 * Can't resume if it isn't yielded.
137 */
138 if (!is_yielded(frame)) return -1;
139
140 /*
141 * It must be yielded in a module.
142 */
143 if (frame->instruction->type != UNLANG_TYPE_MODULE) return -1;
144
145 state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
146 state->resume = resume;
147
148 return 0;
149}
150
151/** Push a pre-compiled xlat and resumption state onto the stack for evaluation
152 *
153 * In order to use the async unlang processor the calling module needs to establish
154 * a resumption point, as the call to an xlat function may require yielding control
155 * back to the interpreter.
156 *
157 * To simplify the calling conventions, this function is provided to first push a
158 * resumption stack frame for the module, and then push an xlat stack frame.
159 *
160 * After pushing those frames the function updates the stack pointer to jump over
161 * the resumption frame and execute the xlat interpreter.
162 *
163 * When the xlat interpreter finishes, and pops the xlat frame, the unlang interpreter
164 * will then call the module resumption frame, allowing the module to continue execution.
165 *
166 * @param[in] ctx To allocate talloc value boxes and values in.
167 * @param[out] p_result Whether xlat evaluation was successful.
168 * @param[out] out Where to write the result of the expansion.
169 * @param[in] request The current request.
170 * @param[in] exp XLAT expansion to evaluate.
171 * @param[in] resume function to call when the XLAT expansion is complete.
172 * @param[in] signal function to call if a signal is received.
173 * @param[in] sigmask Set of signals to block. For example if we wanted to only allow
174 * FR_SIGNAL_CANCEL, we'd pass ~FR_SIGNAL_CANCEL to block the other
175 * signals.
176 * @param[in] rctx to pass to the resume() and signal() callbacks.
177 * @return
178 * - UNLANG_ACTION_PUSHED_CHILD
179 */
180unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out,
181 request_t *request, xlat_exp_head_t const *exp,
182 module_method_t resume,
183 unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
184{
185 /*
186 * Push the resumption point BEFORE pushing the xlat onto
187 * the parents stack.
188 */
189 (void) unlang_module_yield(request, resume, signal, sigmask, rctx);
190
191 /*
192 * Push the xlat function
193 */
194 if (unlang_xlat_push(ctx, p_result, out, request, exp, false) < 0) return UNLANG_ACTION_STOP_PROCESSING;
195
197}
198
199/** Push a pre-compiled tmpl and resumption state onto the stack for evaluation
200 *
201 * In order to use the async unlang processor the calling module needs to establish
202 * a resumption point, as the call to an xlat function may require yielding control
203 * back to the interpreter.
204 *
205 * To simplify the calling conventions, this function is provided to first push a
206 * resumption stack frame for the module, and then push a tmpl stack frame.
207 *
208 * After pushing those frames the function updates the stack pointer to jump over
209 * the resumption frame and execute the tmpl expansion.
210 *
211 * When the tmpl interpreter finishes, and pops the tmpl frame, the unlang interpreter
212 * will then call the module resumption frame, allowing the module to continue execution.
213 *
214 * @param[in] ctx To allocate talloc value boxes and values in.
215 * @param[out] out Where to write the result of the expansion.
216 * @param[in] request The current request.
217 * @param[in] vpt the tmpl to expand
218 * @param[in] args Arguments which control how to evaluate the various
219 * types of xlats.
220 * @param[in] resume function to call when the XLAT expansion is complete.
221 * @param[in] signal function to call if a signal is received.
222 * @param[in] sigmask Set of signals to block. For example if we wanted to only allow
223 * FR_SIGNAL_CANCEL, we'd pass ~FR_SIGNAL_CANCEL to block the other
224 * signals.
225 * @param[in] rctx to pass to the resume() and signal() callbacks.
226 * @return
227 * - UNLANG_ACTION_PUSHED_CHILD
228 */
229unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, fr_value_box_list_t *out,
230 request_t *request, tmpl_t const *vpt,
232 module_method_t resume,
233 unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
234{
235 /*
236 * Push the resumption point BEFORE pushing the xlat onto
237 * the parents stack.
238 */
239 (void) unlang_module_yield(request, resume, signal, sigmask, rctx);
240
241 /*
242 * Push the xlat function
243 */
244 if (unlang_tmpl_push(ctx, out, request, vpt, args) < 0) return UNLANG_ACTION_FAIL;
245
247}
248
250 request_t *request, CONF_SECTION *subcs,
251 rlm_rcode_t default_rcode,
252 module_method_t resume,
253 unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
254{
255 if (!subcs) {
256 unlang_stack_t *stack = request->stack;
257 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
260
263
264 /*
265 * Pretend as if we called the section
266 * and used the default rcode value.
267 */
268 frame->scratch_result.rcode = default_rcode;
269
270 state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
271
272 /*
273 * We must pass a pointer to the scratch
274 * rcode here, as we're pretending we're
275 * executing the resume function using the
276 * interpreter, which means it must modify
277 * the scratch result for the frame, and
278 * _NOT_ what was passed in for p_result.
279 */
280 return resume(&frame->scratch_result,
282 state->env_data, rctx),
283 request);
284 }
285
286 /*
287 * Push the resumption point BEFORE adding the subsection
288 * to the parents stack.
289 */
290 (void) unlang_module_yield(request, resume, signal, sigmask, rctx);
291
292 if (unlang_interpret_push_section(p_result, request, subcs,
293 FRAME_CONF(default_rcode, UNLANG_SUB_FRAME)) < 0) return UNLANG_ACTION_STOP_PROCESSING;
294
296}
297
298/** Run the retry handler. Called from an async signal handler.
299 *
300 */
302{
303 unlang_stack_t *stack = request->stack;
304 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
305 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
306
307 if (!state->retry_cb) return;
308
309 /*
310 * Assert that we have the right things. Note that this function should only be called when the
311 * retry is being used as an expiry time, i.e. mrc==1. If the module has its own retry handlers,
312 * then this function must not be called.
313 */
314 fr_assert(state->retry.config != NULL);
315 fr_assert(state->retry.config->mrc == 1);
316 fr_assert(state->rctx == mctx->rctx);
317 fr_assert(state->request == request);
318
319 /*
320 * Update the time as to when the retry is being called. This is the main purpose of the
321 * function.
322 */
323 state->retry.updated = fr_time();
324
325 state->retry_cb(mctx, request, &state->retry);
326
327}
328
329/** Cancel the retry timer on resume
330 *
331 */
333{
334 unlang_stack_t *stack = request->stack;
335 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
336 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
337
338 /*
339 * Cancel the timers, and clean up any associated retry configuration.
340 */
341 talloc_const_free(state->ev);
342 state->ev = NULL;
343 state->retry_cb = NULL;
344 state->retry.config = NULL;
345
346 return state->retry_resume(p_result, mctx, request);
347}
348
349/** Yield a request back to the interpreter, with retries
350 *
351 * This passes control of the request back to the unlang interpreter, setting
352 * callbacks to execute when the request is 'signalled' asynchronously, or when
353 * the retry timer hits.
354 *
355 * @note The module function which calls #unlang_module_yield_to_retry should return control
356 * of the C stack to the unlang interpreter immediately after calling #unlang_module_yield_to_retry.
357 * A common pattern is to use ``return unlang_module_yield_to_retry(...)``.
358 *
359 * @param[in] request The current request.
360 * @param[in] resume Called on unlang_interpret_mark_runnable().
361 * @param[in] retry Called on when a retry timer hits
362 * @param[in] signal Called on unlang_action().
363 * @param[in] sigmask Set of signals to block. For example if we wanted to only allow
364 * FR_SIGNAL_CANCEL, we'd pass ~FR_SIGNAL_CANCEL to block the other
365 * signals.
366 * @param[in] rctx to pass to the callbacks.
367 * @param[in] retry_cfg to set up the retries
368 * @return
369 * - UNLANG_ACTION_YIELD on success
370 * - UNLANG_ACTION_FAIL on failure
371 */
373 unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx,
374 fr_retry_config_t const *retry_cfg)
375{
376 unlang_stack_t *stack = request->stack;
377 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
379 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
380
381 fr_assert(stack->depth > 0);
384
385 fr_assert(!state->retry_cb);
386
387 state->retry_cb = retry;
388 state->retry_resume = resume; // so that we can cancel the retry timer
389 state->rctx = rctx;
390
391 state->request = request;
392 state->mi = m->mmc.mi;
393
394 /*
395 * Allow unlang statements to override the module configuration. i.e. if we already have a
396 * timer from unlang, then just use that.
397 */
398 if (!state->retry.config) {
399 fr_retry_init(&state->retry, fr_time(), retry_cfg);
400
401 if (fr_timer_at(state, unlang_interpret_event_list(request)->tl, &state->ev,
402 state->retry.next,
403 false, unlang_module_event_retry_handler, request) < 0) {
404 RPEDEBUG("Failed inserting event");
405 return UNLANG_ACTION_FAIL;
406 }
407 }
408
409 return unlang_module_yield(request, unlang_module_retry_resume, signal, sigmask, rctx);
410}
411
412
413/** Yield a request back to the interpreter from within a module
414 *
415 * This passes control of the request back to the unlang interpreter, setting
416 * callbacks to execute when the request is 'signalled' asynchronously, or whatever
417 * timer or I/O event the module was waiting for occurs.
418 *
419 * @note The module function which calls #unlang_module_yield should return control
420 * of the C stack to the unlang interpreter immediately after calling #unlang_module_yield.
421 * A common pattern is to use ``return unlang_module_yield(...)``.
422 *
423 * @param[in] request The current request.
424 * @param[in] resume Called on unlang_interpret_mark_runnable().
425 * @param[in] signal Called on unlang_action().
426 * @param[in] sigmask Set of signals to block. For example if we wanted to only allow
427 * FR_SIGNAL_CANCEL, we'd pass ~FR_SIGNAL_CANCEL to block the other
428 * signals.
429 * @param[in] rctx to pass to the callbacks.
430 * @return
431 * - UNLANG_ACTION_YIELD.
432 * - UNLANG_ACTION_FAIL if this is not a module frame.
433 */
435 module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
436{
437 unlang_stack_t *stack = request->stack;
438 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
440
441 REQUEST_VERIFY(request); /* Check the yielded request is sane */
442
443 if (frame->instruction->type != UNLANG_TYPE_MODULE) {
444 fr_assert_msg(0, "unlang_module_yield called on a non-module frame");
445 return UNLANG_ACTION_FAIL;
446 }
447
448 state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
449
450 state->rctx = rctx;
451 state->resume = resume;
452
453#ifndef NDEBUG
454 /*
455 * We can't do asynchronous signals if the module is not thread safe.
456 *
457 * Right now, none of the modules marked THREAD_UNSAFE call yield, or set signal callbacks.
458 * Which means that this code doesn't affect anything.
459 *
460 * At some point if we do have modules which take signals and which are not thread safe, then
461 * those modules have to ensure that their signal handlers do any locking necessary.
462 */
463 if (signal) {
465
467 fr_assert(m);
468
470 }
471#endif
472
473 state->signal = signal;
474 state->sigmask = sigmask;
475
476 /*
477 * We set the repeatable flag here,
478 * so that the resume function is always
479 * called going back up the stack.
480 */
482
483 return UNLANG_ACTION_YIELD;
484}
485
486/*
487 * Lock the mutex for the module
488 */
489static inline CC_HINT(always_inline) void safe_lock(module_instance_t *mi)
490{
491 if ((mi->exported->flags & MODULE_TYPE_THREAD_UNSAFE) != 0) pthread_mutex_lock(&mi->mutex);
492}
493
494/*
495 * Unlock the mutex for the module
496 */
497static inline CC_HINT(always_inline) void safe_unlock(module_instance_t *mi)
498{
499 if ((mi->exported->flags & MODULE_TYPE_THREAD_UNSAFE) != 0) pthread_mutex_unlock(&mi->mutex);
500}
501
502/** Send a signal (usually stop) to a request
503 *
504 * This is typically called via an "async" action, i.e. an action
505 * outside of the normal processing of the request.
506 *
507 * If there is no #unlang_module_signal_t callback defined, the action is ignored.
508 *
509 * @param[in] request The current request.
510 * @param[in] frame current stack frame.
511 * @param[in] action to signal.
512 */
514{
515 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
517 char const *caller;
518
519 if (!state->signal) return;
520
521 if (action == FR_SIGNAL_CANCEL) {
522 /*
523 * Cancel the retry timer, if it is set.
524 *
525 * Because cancellation functions and actual unwinding are done separately
526 * the retry timer can fire after the module has been cancelled.
527 */
528 TALLOC_FREE(state->ev);
529 }
530
531 /*
532 * Async calls can't push anything onto the unlang stack, so we just use a local "caller" here.
533 */
534 caller = request->module;
535 request->module = m->mmc.mi->name;
536
537 /*
538 * Call the signal routines. Note that signals are
539 * explicitely asynchronous, even if the module has
540 * declared itself to be MODULE_TYPE_THREAD_UNSAFE.
541 */
542 if (!(action & state->sigmask)) state->signal(MODULE_CTX(m->mmc.mi, state->thread->data, state->env_data, state->rctx), request, action);
543
544 if (action == FR_SIGNAL_CANCEL) {
545 /*
546 * One fewer caller for this module. Since this module
547 * has been cancelled, decrement the active callers and
548 * ignore any future signals.
549 */
550 state->thread->active_callers--;
551 state->signal = NULL;
552 }
553
554 request->module = caller;
555
556}
557
558/** Cleanup after a module completes
559 *
560 */
562{
563 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
564
565#ifndef NDEBUG
566 fr_assert(state->unlang_indent == request->log.indent.unlang);
567#endif
568
569 fr_assert(p_result->rcode >= RLM_MODULE_REJECT);
571
572 RDEBUG("%s (%s)", frame->instruction->name ? frame->instruction->name : "",
573 fr_table_str_by_value(mod_rcode_table, p_result->rcode, "<invalid>"));
574
575 request->module = state->previous_module;
576
578}
579
580/** Cleanup after a yielded module completes
581 *
582 */
584{
585 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
586
587 state->thread->active_callers--;
588
589 return unlang_module_done(p_result, request, frame);
590}
591
592/** Wrapper to call a module's resumption function
593 *
594 * This is called _after_ the module first yields, and again after any
595 * other yields.
596 */
598{
599 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
601 module_method_t resume;
603
604 fr_assert(state->resume != NULL);
605
606 resume = state->resume;
607
608 /*
609 * The module *MUST* explicitly set the resume
610 * function when yielding or pushing children
611 * if it wants to be called again later.
612 */
613 state->resume = NULL;
614
615 /*
616 * Lock is noop unless instance->mutex is set.
617 */
618 safe_lock(m->mmc.mi);
619 ua = resume(p_result, MODULE_CTX(m->mmc.mi, state->thread->data,
620 state->env_data, state->rctx), request);
621 safe_unlock(m->mmc.mi);
622
623 if (request->master_state == REQUEST_STOP_PROCESSING) ua = UNLANG_ACTION_STOP_PROCESSING;
624
625 switch (ua) {
627 RWARN("Module %s or worker signalled to stop processing request", m->mmc.mi->name);
628 state->thread->active_callers--;
629 request->module = state->previous_module;
630 p_result->rcode = RLM_MODULE_NOT_SET;
631 p_result->priority = MOD_ACTION_NOT_SET;
633
635 /*
636 * The module yielded but didn't set a
637 * resume function, this means it's done
638 * and when the I/O operation completes
639 * it shouldn't be called again.
640 */
641 if (!state->resume) {
643 } else {
644 repeatable_set(frame);
645 }
646 return UNLANG_ACTION_YIELD;
647
648 /*
649 * The module is done (for now).
650 * But, running it pushed one or more asynchronous
651 * calls onto the stack for evaluation.
652 * These need to be run before the module resumes
653 * or the next unlang instruction is processed.
654 */
656 /*
657 * The module pushed a child and didn't
658 * set a resume function, this means
659 * it's done, and we won't call it again
660 * but we still need to do some cleanup
661 * after the child returns.
662 */
663 if (!state->resume) {
665 } else {
666 repeatable_set(frame);
667 }
669
671 /*
672 * Module set a resume function but
673 * didn't yield or push additional
674 * children.
675 *
676 * Evaluate the function now and
677 * use the result as the final result.
678 */
679 if (state->resume) return unlang_module_resume(p_result, request, frame);
680 request->module = state->previous_module;
681 break;
682
684 p_result->rcode = RLM_MODULE_FAIL;
685 request->module = state->previous_module;
686 break;
687
688 /*
689 * Module indicates we shouldn't process its rcode
690 */
692 break;
693 }
694
695 unlang_module_resume_done(p_result, request, frame);
696 request->module = state->previous_module;
697
698 return ua;
699}
700
701/** Call the callback registered for a retry event
702 *
703 * @param[in] tl the event timer was inserted into.
704 * @param[in] now The current time, as held by the event_list.
705 * @param[in] ctx the stack frame
706 *
707 */
709{
710 request_t *request = talloc_get_type_abort(ctx, request_t);
711 unlang_stack_t *stack = request->stack;
712 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
713 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
714
715 switch (fr_retry_next(&state->retry, now)) {
717 if (state->retry_cb) {
718 /*
719 * Call the module retry handler, with the state of the retry. On MRD / MRC, the
720 * module is made runnable again, and the "resume" function is called.
721 */
722 state->retry_cb(MODULE_CTX(state->mi, state->thread, state->env_data, state->rctx), state->request, &state->retry);
723 } else {
724 /*
725 * For signals, the module will get either a RETRY
726 * signal, or a TIMEOUT signal (also for max count).
727 *
728 * The signal handler should generally change the resume
729 * function, and mark the request as runnable. We
730 * probably don't want the module to do tons of work in
731 * the signal handler, as it's called from the event
732 * loop. And doing so could affect the other event
733 * timers.
734 *
735 * Note also that we call frame->signal(), and not
736 * unlang_interpret_signal(). That is because we want to
737 * signal only the module. We know that the other frames
738 * on the stack can't handle this particular signal. So
739 * there's no point in calling them. Or, if sections
740 * have their own retry handlers, then we don't want to
741 * signal those _other_ retry handlers with _our_ signal.
742 */
743 frame->signal(request, frame, FR_SIGNAL_RETRY);
744 }
745
746 /*
747 * Reset the timer.
748 */
749 if (fr_timer_at(state, unlang_interpret_event_list(request)->tl, &state->ev, state->retry.next,
750 false, unlang_module_event_retry_handler, request) < 0) {
751 RPEDEBUG("Failed inserting event");
752 unlang_interpret_mark_runnable(request); /* and let the caller figure out what's up */
753 }
754 return;
755
756 case FR_RETRY_MRD:
757 RDEBUG("Reached max_rtx_duration (%pVs > %pVs) - sending timeout",
759 break;
760
761 case FR_RETRY_MRC:
762 RDEBUG("Reached max_rtx_count %u- sending timeout",
763 state->retry.config->mrc);
764 break;
765 }
766
767 /*
768 * Run the retry handler on MRD / MRC, too.
769 */
770 if (state->retry_cb) {
771 state->retry_cb(MODULE_CTX(state->mi, state->thread, state->env_data, state->rctx), state->request, &state->retry);
772 } else {
773 frame->signal(request, frame, FR_SIGNAL_TIMEOUT);
774 }
775
776 /*
777 * On final timeout, always mark the request as runnable.
778 */
780}
781
783{
785 unlang_frame_state_module_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
787 fr_time_t now = fr_time_wrap(0);
788
789 p_result->rcode = RLM_MODULE_NOOP;
790 state->previous_module = request->module;
791
792#ifndef NDEBUG
793 state->unlang_indent = request->log.indent.unlang;
794#endif
795 /*
796 * Process a stand-alone child, and fall through
797 * to dealing with it's parent.
798 */
800 fr_assert(m);
801
802 RDEBUG4("[%i] %s - %s (%s)", stack_depth_current(request), __FUNCTION__,
803 m->mmc.mi->module->exported->name, m->mmc.mi->name);
804
805 /*
806 * Return administratively configured return code
807 */
808 if (m->mmc.mi->force) {
809 p_result->rcode = m->mmc.mi->code;
811 goto done;
812 }
813
814 if (m->mmc.mmb.method_env) {
815 if (!state->env_data) {
816 ua = call_env_expand(state, request, &state->env_result, &state->env_data, m->call_env);
817 switch (ua) {
819 goto fail;
820
824
825 default:
826 break;
827 }
828 }
829
830 /*
831 * Fail the module call on callenv failure
832 */
833 if (state->env_result != CALL_ENV_SUCCESS) return UNLANG_ACTION_FAIL;
834 }
835
836 /*
837 * Grab the thread/module specific data if any exists.
838 */
839 state->thread = module_thread(m->mmc.mi);
840 fr_assert(state->thread != NULL);
841
842 /*
843 * For logging unresponsive children.
844 */
845 state->thread->total_calls++;
846
847 /*
848 * If we're doing retries, remember when we started
849 * running the module.
850 */
852
853 /*
854 * Pre-allocate an rctx for the module, if it has one.
855 */
856 fr_assert_msg(state->rctx == NULL, "rctx should be NULL for initial module call");
857 {
858 size_t size = 0;
859 char const *type;
860
861 /*
862 * Use the module method binding's rctx size in preference
863 * to the one set for the module as a whole.
864 */
865 if (m->mmc.mmb.rctx_size) {
866 size = m->mmc.mmb.rctx_size;
867 type = m->mmc.mmb.rctx_type;
868 /*
869 * Use the rctx from the module_t
870 *
871 * The module is still fine to allocate the rctx itself
872 * in the first module method call.
873 */
874 } else if(m->mmc.mi->exported->rctx_size) {
875 size = m->mmc.mi->exported->rctx_size;
877 }
878
879 if (size > 0) {
880 MEM(state->rctx = talloc_zero_array(state, uint8_t, size));
881 if (!type) {
882 talloc_set_name(state->rctx, "%s_rctx_t", m->mmc.mi->name);
883 } else {
884 talloc_set_name_const(state->rctx, type);
885 }
886 }
887 }
888
889 request->module = m->mmc.mi->name;
890 safe_lock(m->mmc.mi); /* Noop unless instance->mutex set */
891 ua = m->mmc.mmb.method(p_result,
892 MODULE_CTX(m->mmc.mi, state->thread->data, state->env_data, state->rctx),
893 request);
894 safe_unlock(m->mmc.mi);
895
896 if (request->master_state == REQUEST_STOP_PROCESSING) ua = UNLANG_ACTION_STOP_PROCESSING;
897
898 switch (ua) {
899 /*
900 * It is now marked as "stop" when it wasn't before, we
901 * must have been blocked.
902 */
904 RWARN("Module %s became unblocked", m->mmc.mi->name);
905 request->module = state->previous_module;
907
909 state->thread->active_callers++;
910
911 /*
912 * The module yielded but didn't set a
913 * resume function, this means it's done
914 * and when the I/O operation completes
915 * it shouldn't be called again.
916 */
917 if (!state->resume) {
919 } else {
921 }
922
923 /*
924 * If we have retry timers, then start the retries.
925 */
928
929 fr_retry_init(&state->retry, now, &frame->instruction->actions.retry);
930
931 if (fr_timer_at(state, unlang_interpret_event_list(request)->tl,
932 &state->ev, state->retry.next,
933 false, unlang_module_event_retry_handler, request) < 0) {
934 RPEDEBUG("Failed inserting event");
935 goto fail;
936 }
937 }
938
939 return UNLANG_ACTION_YIELD;
940
941 /*
942 * The module is done (for now).
943 * But, running it pushed one or more asynchronous
944 * calls onto the stack for evaluation.
945 * These need to be run before the module resumes
946 * or the next unlang instruction is processed.
947 */
949 /*
950 * The module pushed a child and didn't
951 * set a resume function, this means
952 * it's done, and we won't call it again
953 * but we still need to do some cleanup
954 * after the child returns.
955 */
956 if (!state->resume) {
958 } else {
959 repeatable_set(frame);
960 }
962
964 /*
965 * Module set a resume function but
966 * didn't yield or push additional
967 * children.
968 *
969 * Evaluate the function now and
970 * use the result as the final result.
971 */
972 if (state->resume) {
973 frame->process = unlang_module_resume; /* unlang_module_resume will assume this is set */
974 return unlang_module_resume(p_result, request, frame);
975 }
976 break;
977
979 fail:
980 p_result->rcode = RLM_MODULE_FAIL;
981 break;
982
983 /*
984 * Module indicates we shouldn't process its rcode
985 */
987 break;
988 }
989
990done:
991 request->module = state->previous_module;
992 unlang_module_done(p_result, request, frame);
993 return ua;
994}
995
997{
999 &(unlang_op_t){
1000 .name = "module",
1001 .interpret = unlang_module,
1002 /*
1003 * - UNLANG_OP_FLAG_RCODE_SET
1004 * Set request->rcode to be the rcode from the module.
1005 * - UNLANG_OP_FLAG_RETURN_POINT
1006 * Set the return point to be the module.
1007 */
1008 .flag = UNLANG_OP_FLAG_RCODE_SET |
1010 .signal = unlang_module_signal,
1011 .frame_state_size = sizeof(unlang_frame_state_module_t),
1012 .frame_state_type = "unlang_frame_state_module_t",
1013 });
1014}
unlang_action_t
Returned by unlang_op_t calls, determine the next action of the interpreter.
Definition action.h:35
@ UNLANG_ACTION_PUSHED_CHILD
unlang_t pushed a new child onto the stack, execute it instead of continuing.
Definition action.h:39
@ UNLANG_ACTION_EXECUTE_NEXT
Execute the next unlang_t.
Definition action.h:38
@ UNLANG_ACTION_STOP_PROCESSING
Break out of processing the current request (unwind).
Definition action.h:42
@ UNLANG_ACTION_FAIL
Encountered an unexpected error.
Definition action.h:36
@ UNLANG_ACTION_CALCULATE_RESULT
Calculate a new section rlm_rcode_t value.
Definition action.h:37
@ UNLANG_ACTION_YIELD
Temporarily pause execution until an event occurs.
Definition action.h:41
va_list args
Definition acutest.h:770
#define RCSID(id)
Definition build.h:485
#define UNUSED
Definition build.h:317
unlang_action_t call_env_expand(TALLOC_CTX *ctx, request_t *request, call_env_result_t *env_result, void **env_data, call_env_t const *call_env)
Initialise the expansion of a call environment.
Definition call_env.c:310
@ CALL_ENV_SUCCESS
Definition call_env.h:52
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:78
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:210
#define MEM(x)
Definition debug.h:36
void unlang_interpret_mark_runnable(request_t *request)
Mark a request as resumable.
Definition interpret.c:1616
int unlang_interpret_push_section(unlang_result_t *p_result, request_t *request, CONF_SECTION *cs, unlang_frame_conf_t const *conf)
Push a configuration section onto the request stack for later interpretation.
Definition interpret.c:1143
int unlang_interpret_push(unlang_result_t *result_p, request_t *request, unlang_t const *instruction, unlang_frame_conf_t const *conf, bool do_next_sibling)
Push a new frame onto the stack.
Definition interpret.c:283
fr_event_list_t * unlang_interpret_event_list(request_t *request)
Get the event list for the current interpreter.
Definition interpret.c:2013
unlang_mod_action_t priority
The priority or action for that rcode.
Definition interpret.h:136
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:153
#define UNLANG_SUB_FRAME
Definition interpret.h:37
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
#define RWARN(fmt,...)
Definition log.h:297
#define RPEDEBUG(fmt,...)
Definition log.h:376
#define RDEBUG4(fmt,...)
Definition log.h:344
void unlang_register(int type, unlang_op_t *op)
Register an operation with the interpreter.
Definition base.c:63
static char * stack[MAX_STACK]
Definition radmin.c:159
unsigned char uint8_t
@ MOD_ACTION_NOT_SET
Definition mod_action.h:40
@ MOD_ACTION_RETURN
Definition mod_action.h:43
fr_retry_config_t retry
Definition mod_action.h:65
void * rctx
Resume ctx that a module previously set.
Definition module_ctx.h:45
#define MODULE_CTX(_mi, _thread, _env_data, _rctx)
Wrapper to create a module_ctx_t as a compound literal.
Definition module_ctx.h:128
Temporary structure to hold arguments for module calls.
Definition module_ctx.h:41
Declarations for the unlang module interface.
fr_timer_t * ev
retry timer just for this module.
Definition module_priv.h:79
static unlang_t * unlang_module_to_generic(unlang_module_t *p)
Definition module_priv.h:92
static unlang_module_t * unlang_generic_to_module(unlang_t const *p)
Definition module_priv.h:86
module_instance_t const * mi
Module instance to pass to callbacks.
Definition module_priv.h:76
module_method_t resume
resumption handler
Definition module_priv.h:64
char const * previous_module
old request->module
Definition module_priv.h:46
fr_signal_t sigmask
Signals to block.
Definition module_priv.h:66
module_method_t retry_resume
which stops retries on resume
Definition module_priv.h:73
call_env_result_t env_result
Result of the previous call environment expansion.
Definition module_priv.h:52
module_method_call_t mmc
Everything needed to call a module method.
Definition module_priv.h:38
fr_retry_t retry
retry timers, etc.
Definition module_priv.h:80
void * env_data
Expanded per call "call environment" tmpls.
Definition module_priv.h:53
module_thread_instance_t * thread
thread-local data for this module.
Definition module_priv.h:47
unlang_t self
Common fields in all unlang_t tree nodes.
Definition module_priv.h:36
unlang_module_signal_t signal
for signal handlers
Definition module_priv.h:65
int unlang_indent
Record what this was when we entered the module.
Definition module_priv.h:56
void * rctx
for resume / signal
Definition module_priv.h:63
call_env_t const * call_env
The per call parsed call environment.
Definition module_priv.h:37
unlang_module_retry_t retry_cb
callback to run on timeout
Definition module_priv.h:74
A module stack entry.
Definition module_priv.h:45
A call to a module method.
Definition module_priv.h:35
module_instance_t * mi
The process modules also push module calls onto the stack for execution.
Definition module_rlm.h:63
module_method_binding_t mmb
Method we're calling.
Definition module_rlm.h:70
#define fr_assert(_expr)
Definition rad_assert.h:38
static bool done
Definition radclient.c:81
#define RDEBUG(fmt,...)
Definition radclient.h:53
rlm_rcode_t
Return codes indicating the result of the module call.
Definition rcode.h:40
@ RLM_MODULE_INVALID
The module considers the request invalid.
Definition rcode.h:45
@ RLM_MODULE_OK
The module is OK, continue.
Definition rcode.h:43
@ RLM_MODULE_FAIL
Module failed, don't reply.
Definition rcode.h:42
@ RLM_MODULE_DISALLOW
Reject the request (user is locked out).
Definition rcode.h:46
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:41
@ RLM_MODULE_TIMEOUT
Module (or section) timed out.
Definition rcode.h:50
@ RLM_MODULE_NOTFOUND
User not found.
Definition rcode.h:47
@ RLM_MODULE_UPDATED
OK (pairs modified).
Definition rcode.h:49
@ RLM_MODULE_NOT_SET
Error resolving rcode (should not be returned by modules).
Definition rcode.h:52
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:48
@ RLM_MODULE_HANDLED
The module handled the request, so stop.
Definition rcode.h:44
#define REQUEST_VERIFY(_x)
Definition request.h:305
@ REQUEST_STOP_PROCESSING
Request has been signalled to stop.
Definition request.h:88
size_t rctx_size
Size of the module's thread-specific data.
Definition module.h:247
char const * name
Instance name e.g. user_database.
Definition module.h:355
@ MODULE_TYPE_THREAD_UNSAFE
Module is not threadsafe.
Definition module.h:49
module_flags_t flags
Flags that control how a module starts up and how a module is called.
Definition module.h:236
uint64_t active_callers
total number of times we've been called
Definition module.h:379
bool force
Force the module to return a specific code.
Definition module.h:317
unlang_action_t(* module_method_t)(unlang_result_t *p_result, module_ctx_t const *mctx, request_t *request)
Module section callback.
Definition module.h:69
char const * rctx_type
talloc type to assign to thread instance data.
Definition module.h:248
module_method_t method
Module method to call.
Definition module.h:177
void * data
Thread specific instance data.
Definition module.h:372
rlm_rcode_t code
Code module will return when 'force' has has been set to true.
Definition module.h:320
call_env_method_t const * method_env
Method specific call_env.
Definition module.h:178
static module_thread_instance_t * module_thread(module_instance_t const *mi)
Retrieve module/thread specific instance for a module.
Definition module.h:501
size_t rctx_size
If set, this overrides the module_t rctx_size.
Definition module.h:180
char const * rctx_type
If rctx_size is used from the mmb, this sets the type of the rctx.
Definition module.h:184
module_t * exported
Public module structure.
Definition module.h:296
pthread_mutex_t mutex
Used prevent multiple threads entering a thread unsafe module simultaneously.
Definition module.h:303
Module instance data.
Definition module.h:285
static fr_slen_t vpt
Definition tmpl.h:1269
fr_signal_t
Signals that can be generated/processed by request signal handlers.
Definition signal.h:38
@ FR_SIGNAL_RETRY
a retry timer has hit
Definition signal.h:46
@ FR_SIGNAL_TIMEOUT
a retry timeout or max count has hit
Definition signal.h:47
@ FR_SIGNAL_CANCEL
Request has been cancelled.
Definition signal.h:40
int unlang_module_set_resume(request_t *request, module_method_t resume)
Change the resume function of a module.
Definition module.c:129
static unlang_action_t unlang_module(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Definition module.c:782
static void safe_lock(module_instance_t *mi)
Definition module.c:489
static void unlang_module_event_retry_handler(UNUSED fr_timer_list_t *tl, fr_time_t now, void *ctx)
Call the callback registered for a retry event.
Definition module.c:708
unlang_action_t unlang_module_yield(request_t *request, module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
Yield a request back to the interpreter from within a module.
Definition module.c:434
unlang_action_t unlang_module_yield_to_retry(request_t *request, module_method_t resume, unlang_module_retry_t retry, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx, fr_retry_config_t const *retry_cfg)
Yield a request back to the interpreter, with retries.
Definition module.c:372
void unlang_module_init(void)
Definition module.c:996
static unlang_action_t unlang_module_done(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Cleanup after a module completes.
Definition module.c:561
static unlang_action_t unlang_module_resume(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Wrapper to call a module's resumption function.
Definition module.c:597
void unlang_module_retry_now(module_ctx_t const *mctx, request_t *request)
Run the retry handler.
Definition module.c:301
static unlang_action_t unlang_module_resume_done(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Cleanup after a yielded module completes.
Definition module.c:583
unlang_action_t unlang_module_yield_to_section(unlang_result_t *p_result, request_t *request, CONF_SECTION *subcs, rlm_rcode_t default_rcode, module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
Definition module.c:249
static unlang_action_t unlang_module_retry_resume(unlang_result_t *p_result, module_ctx_t const *mctx, request_t *request)
Cancel the retry timer on resume.
Definition module.c:332
unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt, unlang_tmpl_args_t *args, module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
Push a pre-compiled tmpl and resumption state onto the stack for evaluation.
Definition module.c:229
int unlang_module_push(unlang_result_t *p_result, request_t *request, module_instance_t *mi, module_method_t method, bool top_frame)
Push a module or submodule onto the stack for evaluation.
Definition module.c:50
static void safe_unlock(module_instance_t *mi)
Definition module.c:497
unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *exp, module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
Push a pre-compiled xlat and resumption state onto the stack for evaluation.
Definition module.c:180
static void unlang_module_signal(request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition module.c:513
fr_aka_sim_id_type_t type
#define fr_time()
Allow us to arbitrarily manipulate time.
Definition state_test.c:8
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
static int talloc_const_free(void const *ptr)
Free const'd memory.
Definition talloc.h:229
#define fr_time_wrap(_time)
Definition time.h:145
#define fr_time_delta_ispos(_a)
Definition time.h:290
#define fr_time_gt(_a, _b)
Definition time.h:237
#define fr_time_sub(_a, _b)
Subtract one time from another.
Definition time.h:229
"server local" time.
Definition time.h:69
An event timer list.
Definition timer.c:50
#define fr_timer_at(...)
Definition timer.h:81
int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args)
Push a tmpl onto the stack for evaluation.
Definition tmpl.c:254
void(* unlang_module_retry_t)(module_ctx_t const *mctx, request_t *request, fr_retry_t const *retry)
A callback when a retry happens.
Definition module.h:53
void(* unlang_module_signal_t)(module_ctx_t const *mctx, request_t *request, fr_signal_t action)
A callback when the request gets a fr_signal_t.
Definition module.h:81
Functions to allow tmpls to push resumption frames onto the stack and inform the interpreter about th...
Arguments for evaluating different types of tmpls.
Definition tmpl.h:48
int unlang_xlat_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:282
unlang_signal_t signal
function to call when signalling this stack frame
void * state
Stack frame specialisations.
unlang_mod_actions_t actions
Priorities, etc. for the various return codes.
#define UNLANG_NEXT_STOP
Definition unlang_priv.h:97
unlang_result_t scratch_result
The result of executing the current instruction.
char const * name
Unknown...
static int stack_depth_current(request_t *request)
@ UNLANG_TYPE_MODULE
Module method.
Definition unlang_priv.h:47
static void frame_repeat(unlang_stack_frame_t *frame, unlang_process_t process)
Mark the current stack frame up for repeat, and set a new process function.
unlang_t const * instruction
The unlang node we're evaluating.
static bool is_yielded(unlang_stack_frame_t const *frame)
@ UNLANG_OP_FLAG_RETURN_POINT
Return point.
@ UNLANG_OP_FLAG_RCODE_SET
Set request->rcode to the result of this operation.
static void repeatable_set(unlang_stack_frame_t *frame)
unlang_process_t process
function to call for interpreting this stack frame
unlang_type_t type
The specialisation of this node.
An unlang operation.
Our interpreter stack, as distinct from the C stack.
An unlang stack associated with a request.
fr_retry_state_t fr_retry_next(fr_retry_t *r, fr_time_t now)
Initialize a retransmission counter.
Definition retry.c:108
void fr_retry_init(fr_retry_t *r, fr_time_t now, fr_retry_config_t const *config)
Initialize a retransmission counter.
Definition retry.c:36
fr_time_t start
when we started the retransmission
Definition retry.h:53
fr_time_delta_t irt
Initial transmission time.
Definition retry.h:33
#define RETRY_INIT
Definition retry.h:39
uint32_t mrc
Maximum retransmission count.
Definition retry.h:36
fr_retry_config_t const * config
master configuration
Definition retry.h:52
@ FR_RETRY_MRC
reached maximum retransmission count
Definition retry.h:47
@ FR_RETRY_CONTINUE
Definition retry.h:46
@ FR_RETRY_MRD
reached maximum retransmission duration
Definition retry.h:48
fr_time_delta_t mrd
Maximum retransmission duration.
Definition retry.h:35
fr_time_t updated
last update, really a cached "now".
Definition retry.h:56
fr_time_t next
when the next timer should be set
Definition retry.h:55
#define fr_box_time_delta(_val)
Definition value.h:362
static size_t char ** out
Definition value.h:1020