The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
interpret.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: ea9d112b7a5cc6482b921bc383b5931d3a7c37a2 $
19 *
20 * @file unlang/interpret.c
21 * @brief Execute compiled unlang structures using an iterative interpret.
22 *
23 * @copyright 2006-2016 The FreeRADIUS server project
24 */
25RCSID("$Id: ea9d112b7a5cc6482b921bc383b5931d3a7c37a2 $")
26
27#include <freeradius-devel/unlang/action.h>
28#include <freeradius-devel/unlang/interpret.h>
29#include <freeradius-devel/util/timer.h>
30#include <freeradius-devel/server/base.h>
31#include <freeradius-devel/server/modpriv.h>
32#include <freeradius-devel/server/rcode.h>
33#include <freeradius-devel/unlang/xlat_func.h>
34#include <freeradius-devel/unlang/mod_action.h>
35
36#include "interpret_priv.h"
37#include "unlang_priv.h"
38#include "module_priv.h"
39
40
41/** The default interpreter instance for this thread
42 */
44
46 { L("calculate-result"), UNLANG_ACTION_CALCULATE_RESULT },
47 { L("next"), UNLANG_ACTION_EXECUTE_NEXT },
48 { L("pushed-child"), UNLANG_ACTION_PUSHED_CHILD },
50 { L("yield"), UNLANG_ACTION_YIELD }
51};
53
60
61#ifndef NDEBUG
62#include <freeradius-devel/unlang/module_priv.h>
63
72
73/** Try and figure out where p_result points to
74 *
75 * If it's somewhere other than these three locations, it's probably wrong.
76 */
77static int find_p_result_location(p_result_location_t *location, void **chunk, request_t *request, void *ptr)
78{
79 unlang_stack_t *stack = request->stack;
81 unsigned int i;
82
83 for (i = 0; i <= (unsigned int)stack->depth; i++) {
84 frame = &stack->frame[i];
85 if (frame->state && (ptr >= (void *)frame->state) &&
86 (ptr < ((void *)((uint8_t *)frame->state + talloc_get_size(frame->state))))) {
87 *location = P_RESULT_LOCATION_STATE;
88 *chunk = frame->state;
89 return i;
90 }
91
92 if (ptr == &frame->section_result) {
93 *location = P_RESULT_LOCATION_FRAME;
94 *chunk = NULL;
95 return i;
96 }
97
98 if (ptr == &frame->scratch_result) {
99 *location = P_RESULT_LOCATION_SCRATCH;
100 *chunk = NULL;
101 return i;
102 }
103
104 if (!frame->instruction) continue;
105
106 switch (frame->instruction->type) {
108 {
109 unlang_frame_state_module_t *mod_state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
110
111 if (!mod_state->rctx) continue;
112
113 if ((ptr >= (void *)mod_state->rctx) &&
114 (ptr < ((void *)((uint8_t *)mod_state->rctx + talloc_get_size(mod_state->rctx))))) {
116 *chunk = mod_state->rctx;
117 return i;
118 }
119
120 /*
121 * We don't know where the child frame is, so we can't
122 * determine where the p_result is.
123 */
124 }
125 continue;
126
127 default:
128 break;
129 }
130 }
131
132 *location = P_RESULT_LOCATION_UNKNOWN;
133 *chunk = NULL;
134 return -1;
135}
136
138 { L("frame"), P_RESULT_LOCATION_FRAME },
139 { L("module_rctx"), P_RESULT_LOCATION_MODULE_RCTX },
140 { L("scratch"), P_RESULT_LOCATION_SCRATCH },
141 { L("state"), P_RESULT_LOCATION_STATE },
142 { L("unknown"), P_RESULT_LOCATION_UNKNOWN }
143};
145
146static void instruction_dump(request_t *request, unlang_t const *instruction)
147{
148 RINDENT();
149 if (!instruction) {
150 RDEBUG2("instruction <none>");
151 REXDENT();
152 return;
153 }
154
155 RDEBUG2("type %s", unlang_ops[instruction->type].name);
156 RDEBUG2("name %s", instruction->name);
157 RDEBUG2("debug_name %s", instruction->debug_name);
158 REXDENT();
159}
160
161static void CC_HINT(nonnull) actions_dump(request_t *request, unlang_t const *instruction)
162{
163 int i;
164
165 RDEBUG2("actions");
166 RINDENT();
167 for (i = 0; i < RLM_MODULE_NUMCODES; i++) {
168 RDEBUG2("%s: %s",
169 fr_table_str_by_value(mod_rcode_table, i, "<invalid>"),
170 mod_action_name[instruction->actions.actions[i]]);
171 }
172 REXDENT();
173}
174
175static void frame_dump(request_t *request, unlang_stack_frame_t *frame, bool with_actions)
176{
177 unlang_op_t *op = NULL;
178
179 if (frame->instruction) {
180 op = &unlang_ops[frame->instruction->type];
181 instruction_dump(request, frame->instruction);
182 }
183
184 RINDENT();
185 if (frame->state) RDEBUG2("state %s (%p)", talloc_get_name(frame->state), frame->state);
186 if (frame->next) {
187 RDEBUG2("next %s", frame->next->debug_name);
188 } else {
189 RDEBUG2("next <none>");
190 }
191
193
194 if (is_private_result(frame)) {
195 int location;
197 void *chunk;
198
199 RDEBUG2("p_rcode %s", fr_table_str_by_value(mod_rcode_table, frame->p_result->rcode, "<invalid>"));
200 RDEBUG2("p_priority %s", mod_action_name[frame->p_result->priority]);
201
202 location = find_p_result_location(&type, &chunk, request, frame->p_result);
203 RDEBUG2("p_location %s [%i] %p (%s)", fr_table_str_by_value(p_result_location_table, type, "<invalid>"),
204 location, frame->p_result, chunk ? talloc_get_name(chunk) : "<none>"
205 );
206 } else {
207 RDEBUG2("sec_rcode %s", fr_table_str_by_value(mod_rcode_table, frame->section_result.rcode, "<invalid>"));
208 RDEBUG2("sec_priority %s", mod_action_name[frame->section_result.priority]);
209 }
210 RDEBUG2("scr_rcode %s", fr_table_str_by_value(mod_rcode_table, frame->scratch_result.rcode, "<invalid>"));
211 RDEBUG2("scr_priority %s", mod_action_name[frame->scratch_result.priority]);
212 RDEBUG2("top_frame %s", is_top_frame(frame) ? "yes" : "no");
213 RDEBUG2("repeat %s", is_repeatable(frame) ? "yes" : "no");
214 RDEBUG2("yielded %s", is_yielded(frame) ? "yes" : "no");
215 RDEBUG2("unwind %s", is_unwinding(frame) ? "yes" : "no");
216
217 if (frame->instruction) {
218 RDEBUG2("control %s%s%s",
219 is_break_point(frame) ? "b" : "-",
220 is_return_point(frame) ? "r" : "-",
221 is_continue_point(frame) ? "c" : "-"
222 );
223 if (with_actions) actions_dump(request, frame->instruction);
224 }
225
226 /*
227 * Call the custom frame dump function
228 */
229 if (op && op->dump) op->dump(request, frame);
230 REXDENT();
231}
232
233static void stack_dump_body(request_t *request, bool with_actions)
234{
235 int i;
236 unlang_stack_t *stack = request->stack;
237
238 RDEBUG2("----- Begin stack debug [depth %i] -----",
239 stack->depth);
240 for (i = stack->depth; i >= 0; i--) {
241 unlang_stack_frame_t *frame = &stack->frame[i];
242 RDEBUG2("[%d] Frame contents", i);
243 frame_dump(request, frame, with_actions);
244 }
245 RDEBUG2("----- End stack debug [depth %i] -------", stack->depth);
246}
247
248void stack_dump(request_t *request)
249{
250 stack_dump_body(request, false);
251}
252
254{
255 stack_dump_body(request, true);
256}
257#define DUMP_STACK if (DEBUG_ENABLED5) stack_dump(request)
258#else
259#define DUMP_STACK
260#endif
261
262/** Push a new frame onto the stack
263 *
264 * @param[in] p_result Where to write the result of evaluating the section.
265 * If NULL, results will be written to frame->section_result and will
266 * be automatically merged with the next highest frame when this one
267 * is popped.
268 * @param[in] request to push the frame onto.
269 * @param[in] instruction One or more unlang_t nodes describing the operations to execute.
270 * @param[in] conf Configuration for the frame. If NULL, the following values areused:
271 * - default result = UNLANG_RESULT_NOT_SET
272 * - top_frame = UNLANG_SUB_FRAME
273 * - no_rcode = false
274 * @param[in] do_next_sibling Whether to only execute the first node in the #unlang_t program
275 * or to execute subsequent nodes.
276 * @return
277 * - 0 on success.
278 * - -1 on call stack too deep.
279 */
281 unlang_t const *instruction, unlang_frame_conf_t const *conf, bool do_next_sibling)
282{
283 unlang_stack_t *stack = request->stack;
285
286 static unlang_frame_conf_t default_conf = {
288 .top_frame = UNLANG_SUB_FRAME
289 };
290
291 if (!conf) conf = &default_conf;
292
293 fr_assert(instruction);
294
295#ifndef NDEBUG
296 if (DEBUG_ENABLED5) RDEBUG3("unlang_interpret_push called with instruction type \"%s\" - args %s %s",
297 instruction ? instruction->debug_name : "<none>",
298 do_next_sibling ? "UNLANG_NEXT_SIBLING" : "UNLANG_NEXT_STOP",
299 conf->top_frame ? "UNLANG_TOP_FRAME" : "UNLANG_SUB_FRAME");
300#endif
301
302 /*
303 * This is not a cancellation point.
304 *
305 * If we cancel here bad things happen inside the interpret.
306 */
307 if (stack->depth >= (UNLANG_STACK_MAX - 1)) {
308 RERROR("Call stack is too deep");
309 return - 1;
310 }
311
312 stack->depth++;
313
314 /*
315 * Initialize the next stack frame.
316 */
317 frame = &stack->frame[stack->depth];
318 memset(frame, 0, sizeof(*frame));
319
320 frame->instruction = instruction;
321
322 if (do_next_sibling && instruction->list) {
323 fr_assert(instruction != NULL);
324 frame->next = unlang_list_next(instruction->list, instruction);
325 }
326 /* else frame->next MUST be NULL */
327
329 if (conf->top_frame) top_frame_set(frame);
330
331 frame->p_result = p_result ? p_result : &frame->section_result;
332 *frame->p_result = conf->default_result;
333
334 frame->indent = request->log.indent;
335
336 if (!instruction) return 0;
337
338 frame_state_init(stack, frame);
339
340 return 0;
341}
342
343typedef struct {
344 fr_dict_t const *old_dict; //!< the previous dictionary for the request
345 request_t *request; //!< the request
347
349{
350 fr_pair_t *vp, *prev;
351
352 /*
353 * Local variables are appended to the end of the list. So we remove them by walking backwards
354 * from the end of the list.
355 */
356 vp = fr_pair_list_tail(&ref->request->local_pairs);
357 while (vp) {
358 prev = fr_pair_list_prev(&ref->request->local_pairs, vp);
359 if (vp->da->dict != ref->request->local_dict) {
360 break;
361 }
362
363 (void) fr_pair_delete(&ref->request->local_pairs, vp);
364 vp = prev;
365 }
366
367 ref->request->local_dict = ref->old_dict;
368
369 return 0;
370}
371
372/** Push the children of the current frame onto a new frame onto the stack
373 *
374 * @param[out] p_result set to RLM_MOULDE_FAIL if pushing the children fails
375 * @param[in] request to push the frame onto.
376 * @param[in] default_rcode The default result.
377 * @param[in] do_next_sibling Whether to only execute the first node in the #unlang_t program
378 * or to execute subsequent nodes.
379 * @return
380 * - UNLANG_ACTION_PUSHED_CHILD on success.
381 * - UNLANG_ACTION_EXECUTE_NEXT do nothing, but just go to the next sibling instruction
382 * - UNLANG_ACTION_STOP_PROCESSING, fatal error, usually stack overflow.
383 */
385 rlm_rcode_t default_rcode, bool do_next_sibling)
386{
387 unlang_stack_t *stack = request->stack;
388 unlang_stack_frame_t *frame = &stack->frame[stack->depth]; /* Quiet static analysis */
391
393
395
396 /*
397 * The compiler catches most of these, EXCEPT for the
398 * top-level 'recv Access-Request' etc. Which can exist,
399 * and can be empty.
400 */
401 if (unlang_list_empty(&g->children)) {
402 RDEBUG2("... ignoring empty subsection ...");
404 }
405
406 if (unlang_interpret_push(p_result, request, unlang_list_head(&g->children),
407 FRAME_CONF(default_rcode, UNLANG_SUB_FRAME), do_next_sibling) < 0) {
409 }
410
412
413 /*
414 * Note that we do NOT create the variables, This way we don't have to worry about any
415 * uninitialized values. If the admin tries to use the variable without initializing it, they
416 * will get a "no such attribute" error.
417 */
418 if (!frame->state) {
419 MEM(ref = talloc(stack, unlang_variable_ref_t));
420 frame->state = ref;
421 } else {
422 MEM(ref = talloc(frame->state, unlang_variable_ref_t));
423 }
424
425 /*
426 * Set the destructor to clean up local variables.
427 */
428 ref->request = request;
429 ref->old_dict = request->local_dict;
430 request->local_dict = g->variables->dict;
431 talloc_set_destructor(ref, _local_variables_free);
432
434}
435
436static void instruction_retry_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx);
437
438/** Update the current result after each instruction, and after popping each stack frame
439 *
440 * @note Sets stack->scratch to be the the result of the frame being popped.
441 *
442 * @param[in] request The current request.
443 * @return
444 * - UNLANG_FRAME_ACTION_NEXT evaluate more instructions.
445 * - UNLANG_FRAME_ACTION_POP the final result has been calculated for this frame.
446 */
447static inline CC_HINT(always_inline)
449{
450 unlang_t const *instruction = frame->instruction;
451 unlang_stack_t *stack = request->stack;
452 unlang_result_t *frame_result = frame->p_result;
453
454 if (is_unwinding(frame)) {
455 RDEBUG4("** [%i] %s - unwinding frame", stack->depth, __FUNCTION__);
457 }
458
459 /*
460 * Don't calculate a new return code for the frame, just skip
461 * to the next instruction.
462 */
464 RDEBUG4("** [%i] %s - skipping frame, no result set",
465 stack->depth, __FUNCTION__);
467 }
468
469 fr_assert(MOD_ACTION_VALID(frame_result->priority));
471
472 RDEBUG4("** [%i] %s - have (%s %s) frame or module returned (%s %s)",
473 stack->depth, __FUNCTION__,
474 fr_table_str_by_value(mod_rcode_table, frame_result->rcode, "<invalid>"),
475 mod_action_name[frame_result->priority],
478
479 /*
480 * Update request->rcode if the instruction says we should
481 * We don't care about priorities for this.
482 *
483 * This is the field that's evaluated in unlang conditions
484 * like `if (ok)`.
485 */
486 if (is_rcode_set(frame) && (request->rcode != result->rcode)) {
487 RDEBUG3("Setting request->rcode to '%s'",
489 request->rcode = result->rcode;
490 }
491
492 /*
493 * The array holds a default priority for this return
494 * code. Grab it in preference to any unset priority.
495 */
497 result->priority = instruction->actions.actions[result->rcode];
498
500
501 RDEBUG4("** [%i] %s - using default instruction priority for %s, %s",
502 stack->depth, __FUNCTION__,
505 }
506
507 /*
508 * Deal with special priorities which indicate we need
509 * to do something in addition to modifying the frame's
510 * rcode.
511 */
512 switch (result->priority) {
513 /*
514 * The child's prioriy value indicates we
515 * should return from this frame.
516 */
518 RDEBUG4("** [%i] %s - action says to return with (%s %s)",
519 stack->depth, __FUNCTION__,
522
523 *frame_result = UNLANG_RESULT_RCODE(result->rcode);
525
526 /*
527 * Reject means we should return, but
528 * with a reject rcode. This allows the
529 * user to change normally positive rcodes
530 * into negative ones.
531 *
532 * They could also just check the rcode
533 * after the module returns...
534 */
536 RDEBUG4("** [%i] %s - action says to return with (%s %s)",
537 stack->depth, __FUNCTION__,
540
541 *frame_result = UNLANG_RESULT_RCODE(RLM_MODULE_REJECT);
543
544 case MOD_ACTION_RETRY:
545 {
546 unlang_retry_t *retry = frame->retry;
547
548 RDEBUG4("** [%i] %s - action says to retry with",
549 stack->depth, __FUNCTION__);
550
551 /*
552 * If this is the first time doing the retry,
553 * then allocate the structure and set the timer.
554 */
555 if (!retry) {
556 MEM(frame->retry = retry = talloc_zero(stack, unlang_retry_t));
557
558 retry->request = request;
559 retry->depth = stack->depth;
560 retry->state = FR_RETRY_CONTINUE;
561 retry->count = 1;
562
563 /*
564 * Set a timer which automatically fires
565 * if there's a timeout. And parent it
566 * from the retry structure, so that the
567 * timer is automatically freed when the
568 * frame is cleaned up.
569 */
570 if (fr_time_delta_ispos(instruction->actions.retry.mrd)) {
571 if (fr_timer_in(retry, unlang_interpret_event_list(request)->tl, &retry->ev, instruction->actions.retry.mrd,
572 false, instruction_retry_handler, request) < 0) {
573 RPEDEBUG("Failed inserting retry event");
574 *frame_result = UNLANG_RESULT_RCODE(RLM_MODULE_FAIL);
575 goto finalize;
576 }
577 }
578
579 } else {
580 /*
581 * We've been told to stop doing retries,
582 * probably from a timeout.
583 */
584 if (retry->state != FR_RETRY_CONTINUE) goto timeout;
585
586 /*
587 * Clamp it at the maximum count.
588 */
589 if (instruction->actions.retry.mrc > 0) {
590 retry->count++;
591
592 if (retry->count >= instruction->actions.retry.mrc) {
593 retry->state = FR_RETRY_MRC;
594
595 REDEBUG("Retries hit max_rtx_count (%u) - returning 'timeout'", instruction->actions.retry.mrc);
596
597 timeout:
599 goto finalize;
600 }
601 }
602 }
603
604 RINDENT();
605 if (instruction->actions.retry.mrc) {
606 RDEBUG("... retrying (%u/%u)", retry->count, instruction->actions.retry.mrc);
607 } else {
608 RDEBUG("... retrying");
609 }
610 REXDENT();
611
612 talloc_free(frame->state);
614 frame_state_init(stack, frame); /* Don't change p_result */
616 default:
617 break;
618 }
619 }
620
621finalize:
622 /*
623 * We're higher or equal to previous priority, remember this
624 * return code and priority.
625 */
626 if (result->priority >= frame_result->priority) {
628 fr_assert(MOD_ACTION_VALID(frame_result->priority));
629
630 RDEBUG4("** [%i] %s - overwriting existing result (%s %s) with higher priority (%s %s)",
631 stack->depth, __FUNCTION__,
632 fr_table_str_by_value(mod_rcode_table, frame_result->rcode, "<invalid>"),
633 mod_action_name[frame_result->priority],
636 *frame->p_result = *result;
637 }
638
639 /*
640 * Determine if we should continue processing siblings
641 * or pop the frame ending the section.
642 */
644}
645
646/** Function called to merge inter-stack-frame results
647 *
648 * This function is called whenever a frame is popped from the stack.
649 *
650 * 'result' is the result from the frame being popped, and 'frame' is the next highest frame in the stack.
651 *
652 * The logic here is very similar to result_eval(), with two important differences:
653 * - The priority of the lower frame is ignored, and the default priority of the higher frame is used.
654 * Unless the higher frame's priority is MOD_ACTION_NOT_SET, in which case the lower frame's priority is used.
655 */
656static inline CC_HINT(always_inline)
658{
659 unlang_stack_t *stack = request->stack;
660 unlang_result_t our_result = *result;
661
663
664 /*
665 * When a stack frame is being popped, the priority of the
666 * source (lower) frame is ignored, and the default priority
667 * of the destination (higher) frame is used.
668 *
669 * We could (easily) add support for preserving the priority
670 * from the lower frame, if the priority of the higher frame
671 * was MOD_ACTION_NOT_SET, but there are no concrete use
672 * cases for this yet.
673 */
675 fr_assert(MOD_ACTION_VALID(frame->instruction->actions.actions[result->rcode]));
676 our_result.priority = frame->instruction->actions.actions[result->rcode];
677 }
678
679 RDEBUG4("** [%i] %s - using instruction priority for higher frame (%s, %s)",
680 stack->depth, __FUNCTION__,
681 fr_table_str_by_value(mod_rcode_table, our_result.rcode, "<invalid>"),
682 mod_action_name[our_result.priority]);
683
684 return result_calculate(request, frame, &our_result);
685}
686
687static inline CC_HINT(always_inline) void instruction_done_debug(request_t *request, unlang_stack_frame_t *frame, unlang_t const *instruction)
688{
689 if (has_debug_braces(instruction)) {
690 REXDENT();
691
692 /*
693 * If we're at debug level 1, don't emit the closing
694 * brace as the opening brace wasn't emitted.
695 *
696 * Not a typo, we don't want to print the scratch_result
697 * here, aka the ones the section actually returned,
698 * vs the section result, which may have just been left
699 * at defaults.
700 */
702 RDEBUG("# %s %s%s%s", frame->instruction->debug_name,
703 frame->p_result == &frame->section_result ? "(" : "))",
705 frame->p_result == &frame->section_result ? "(" : "))");
706 } else {
707 RDEBUG2("} # %s %s%s%s", frame->instruction->debug_name,
708 frame->p_result == &frame->section_result ? "(" : "((",
710 frame->p_result == &frame->section_result ? ")" : "))");
711 }
712 }
713}
714
715/** Evaluates all the unlang nodes in a section
716 *
717 * This function interprets a list of unlang instructions at a given level using the same
718 * stack frame, and pushes additional frames onto the stack as needed.
719 *
720 * This function can be seen as moving horizontally.
721 *
722 * @param[in] request The current request.
723 * @param[in] frame The current stack frame.
724 * @return
725 * - UNLANG_FRAME_ACTION_NEXT evaluate more instructions in the current stack frame
726 * which may not be the same frame as when this function
727 * was called.
728 * - UNLANG_FRAME_ACTION_POP the final result has been calculated for this frame.
729 */
730static inline CC_HINT(always_inline)
732{
733 unlang_stack_t *stack = request->stack;
734 unlang_result_t *scratch = &frame->scratch_result;
735
736 /*
737 * Loop over all the instructions in this list.
738 */
739 while (frame->instruction) {
740 unlang_t const *instruction = frame->instruction;
743
745
746 fr_assert(instruction->debug_name != NULL); /* if this happens, all bets are off. */
747 fr_assert(unlang_ops[instruction->type].interpret != NULL);
748 fr_assert(frame->process != NULL);
749
750 REQUEST_VERIFY(request);
751
752 /*
753 * We're running this frame, so it can't possibly be yielded.
754 */
755 if (is_yielded(frame)) {
756 RDEBUG("%s - Resuming execution", instruction->debug_name);
757 yielded_clear(frame);
758 }
759
760#ifndef NDEBUG
761 /*
762 * Failure testing!
763 */
764 if (request->ins_max) {
765 request->ins_count++;
766
767 if (request->ins_count >= request->ins_max) {
768 RERROR("Failing request due to maximum instruction count %" PRIu64, request->ins_max);
769
771 }
772 }
773#endif
774
775 /*
776 * We're not re-entering this frame, this is the first
777 * time we're evaluating this instruction, so we should
778 * print debug braces and indent.
779 */
780 if (!is_repeatable(frame)) {
781 if (has_debug_braces(frame)) {
782 RDEBUG2("%s {", instruction->debug_name);
783 RINDENT();
784 }
785 /*
786 * Clear the repeatable flag so this frame
787 * won't get executed again unless it specifically
788 * requests it.
789 *
790 * The flag may still be set again during the
791 * process function to indicate that the frame
792 * should be evaluated again.
793 */
794 } else {
795 repeatable_clear(frame);
796 }
797
798 /*
799 * Execute an operation
800 */
801 RDEBUG4("** [%i] %s >> %s", stack->depth, __FUNCTION__,
802 unlang_ops[instruction->type].name);
803
805
806 /*
807 * catch plays games with the frame so we skip
808 * to the next catch section at a given depth,
809 * it's not safe to access frame->instruction
810 * after this point, and the cached instruction
811 * should be used instead.
812 */
813 ua = frame->process(&frame->scratch_result, request, frame);
814
816
817 RDEBUG4("** [%i] %s << %s (%s %s)", stack->depth, __FUNCTION__,
819 fr_table_str_by_value(mod_rcode_table, scratch->rcode, "<INVALID>"),
820 mod_action_name[scratch->priority]);
821
822 /*
823 * If the frame is cancelled we ignore the
824 * return code of the process function and
825 * pop the frame. We'll keep popping
826 * frames until we hit a non-cancelled frame
827 * or the top frame.
828 */
829 if (is_unwinding(frame)) goto calculate_result;
830
831 switch (ua) {
833 /*
834 * This marks all the cancellable
835 * frames with the unwind flag,
836 * and starts popping them.
837 */
840
841 /*
842 * The operation resulted in additional frames
843 * being pushed onto the stack, execution should
844 * now continue at the deepest frame.
845 */
847 fr_assert_msg(&stack->frame[stack->depth] > frame,
848 "Instruction %s returned UNLANG_ACTION_PUSHED_CHILD, "
849 "but stack depth was not increased",
850 instruction->name);
853
854 /*
855 * Yield control back to the scheduler, or whatever
856 * called the interpreter.
857 */
859 fr_assert_msg(&stack->frame[stack->depth] == frame,
860 "Instruction %s returned UNLANG_ACTION_YIELD, but pushed additional "
861 "frames for evaluation. Instruction should return UNLANG_ACTION_PUSHED_CHILD "
862 "instead", instruction->name);
864 yielded_set(frame);
865 RDEBUG4("** [%i] %s - yielding with current (%s %s)", stack->depth, __FUNCTION__,
866 fr_table_str_by_value(mod_rcode_table, scratch->rcode, "<invalid>"),
867 mod_action_name[scratch->priority]);
869
870 /*
871 * This action is intended to be returned by library
872 * functions. It reduces boilerplate.
873 */
875 /*
876 * Let unlang_calculate figure out if this is the final result
877 */
878 frame->scratch_result = UNLANG_RESULT_RCODE(RLM_MODULE_FAIL);
880
881 /*
882 * Instruction finished execution,
883 * check to see what we need to do next, and update
884 * the section rcode and priority.
885 */
887 calculate_result:
888 /*
889 * Merge in the scratch result _before_ printing
890 * out the rcode for the frame, so get what we'll
891 * actually return.
892 */
893 fa = result_calculate(request, frame, &frame->scratch_result);
894
895 instruction_done_debug(request, frame, instruction);
896
897 switch (fa) {
899 goto pop;
900
902 if (has_debug_braces(instruction)) {
903 REXDENT();
904 RDEBUG2("} # retrying the same section");
905 }
906 continue; /* with the current instruction */
907
908 default:
909 break;
910 }
911 break;
912
913 /*
914 * Execute the next instruction in this frame
915 */
917 if (has_debug_braces(instruction)) {
918 REXDENT();
919 RDEBUG2("}");
920 }
921 break;
922 } /* switch over return code from the interpret function */
923
924 frame_next(stack, frame);
925 }
926
927pop:
928 fr_assert(MOD_ACTION_VALID(frame->p_result->priority));
929
930 RDEBUG4("** [%i] %s - done current subsection with (%s %s), %s",
931 stack->depth, __FUNCTION__,
932 fr_table_str_by_value(mod_rcode_table, frame->p_result->rcode, "<invalid>"),
933 mod_action_name[frame->p_result->priority],
934 frame->p_result == &(frame->section_result) ? "will set higher frame rcode" : "will NOT set higher frame rcode (p_result)");
935
937}
938
939/** Run the interpreter for a current request
940 *
941 * This function runs the interpreter for a request. It deals with popping
942 * stack frames, and calaculating the final result for the frame.
943 *
944 * @param[in] request to run. If this is an internal request
945 * the request may be freed by the interpreter.
946 * @param[in] running Is the interpreter already running.
947 * @return The final request rcode.
948 */
949CC_HINT(hot) rlm_rcode_t unlang_interpret(request_t *request, bool running)
950{
951 unlang_stack_t *stack = request->stack;
952 unlang_interpret_t *intp = stack->intp;
953 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
954
955 /*
956 * This is needed to ensure that if a frame is marked
957 * for unwinding whilst the request is yielded, we
958 * unwind the cancelled frame correctly, instead of
959 * continuing.
960 */
962
963#ifndef NDEBUG
964 if (DEBUG_ENABLED5) DEBUG("###### unlang_interpret is starting");
966#endif
967
968 fr_assert(!unlang_request_is_scheduled(request)); /* if we're running it, it can't be scheduled */
969 fr_assert_msg(intp, "request has no interpreter associated");
970
971 RDEBUG4("** [%i] %s - interpret entered", stack->depth, __FUNCTION__);
972 if (!running) intp->funcs.resume(request, intp->uctx);
973
974 for (;;) {
975 fr_assert(stack->depth > 0);
977
978 RDEBUG4("** [%i] %s - frame action %s", stack->depth, __FUNCTION__,
980 switch (fa) {
981 next:
982 RDEBUG4("** [%i] %s - frame action next", stack->depth, __FUNCTION__);
984
985 case UNLANG_FRAME_ACTION_NEXT: /* Evaluate the current frame */
986 frame = &stack->frame[stack->depth];
987 fa = frame_eval(request, frame);
988 if (fa != UNLANG_FRAME_ACTION_POP) continue;
989
990 RDEBUG4("** [%i] %s - frame action %s", stack->depth, __FUNCTION__,
993
994 case UNLANG_FRAME_ACTION_POP: /* Pop this frame and check the one beneath it */
995 {
996 bool top_frame = is_top_frame(frame);
997 bool private_result = is_private_result(frame);
998
999 unlang_result_t section_result = frame->section_result; /* record the result of the frame before we pop it*/
1000
1001 DUMP_STACK;
1002 /*
1003 * Head on back up the stack
1004 */
1005 frame_pop(request, stack);
1006 RDEBUG4("** [%i] %s - frame popped", stack->depth + 1, __FUNCTION__);
1007
1008 /*
1009 * Update the stack frame
1010 */
1011 frame = &stack->frame[stack->depth];
1012 DUMP_STACK;
1013
1014 /*
1015 * Transition back to the C stack
1016 *
1017 * We still need to merge in the previous frame's result,
1018 * but we don't care about the action, as we're returning.
1019 */
1020 if (top_frame) {
1021 if (!private_result) result_calculate(request, frame, &section_result);
1022 break; /* stop */
1023 }
1024
1025 /*
1026 * Don't process the section result for a frame if
1027 * the result is being consumed by a module.
1028 */
1029 if (private_result) {
1031 /*
1032 * Merge lower frame into higher frame.
1033 *
1034 * this _MUST_ be done, even on resume, because the
1035 * section result needs to be updated for the frame
1036 * being resumed, in case it cares about the rcode
1037 * like transaction sections.
1038 */
1039 } else {
1040 fa = result_pop(request, frame, &section_result);
1041 }
1042
1043 /*
1044 * Resume a "foreach" loop, or a "load-balance" section
1045 * or anything else that needs to be checked on the way
1046 * back on up the stack. Here we just resume evaluating
1047 * the frame, we don't advance the instruction.
1048 */
1049 if (!is_unwinding(frame) && is_repeatable(frame)) goto next;
1050
1051 /*
1052 * Close out the section we entered earlier
1053 */
1054 instruction_done_debug(request, frame, frame->instruction);
1055
1057
1058 /*
1059 * If we're continuing after popping a frame
1060 * then we advance the instruction else we
1061 * end up executing the same code over and over...
1062 */
1063 switch (fa) {
1065 DEBUG4("** [%i] %s - continuing after subsection with (%s %s)",
1066 stack->depth, __FUNCTION__,
1069 frame_next(stack, frame);
1070 goto next;
1071
1072 /*
1073 * Else if we're really done with this frame
1074 * print some helpful debug...
1075 */
1076 default:
1077 RDEBUG4("** [%i] %s - done current subsection with (%s %s)",
1078 stack->depth, __FUNCTION__,
1081 continue;
1082 }
1083
1084 }
1085
1087 /* Cannot yield from a nested call to unlang_interpret */
1088 fr_assert(!running);
1089
1090 RDEBUG4("** [%i] %s - interpret yielding", stack->depth, __FUNCTION__);
1091 intp->funcs.yield(request, intp->uctx);
1092 return RLM_MODULE_NOT_SET;
1093
1094 case UNLANG_FRAME_ACTION_RETRY: /* retry the current frame */
1095 goto next;
1096 }
1097 break;
1098 }
1099
1100 fr_assert(stack->depth >= 0);
1101
1102 /*
1103 * We're at the top frame, return the result from the
1104 * stack, and get rid of the top frame.
1105 */
1106 RDEBUG4("** [%i] %s - interpret exiting, returning (%s)", stack->depth, __FUNCTION__,
1108
1109 DUMP_STACK;
1110
1111 {
1112 rlm_rcode_t rcode;
1113 /*
1114 * Record this now as the done functions may free
1115 * the request.
1116 *
1117 * Note: We use p_result here, as that's where the
1118 * result of evaluating the frame was written.
1119 * We don't use the section_result, as that may have
1120 * been left as its default value which may be 0
1121 * (reject).
1122 */
1123 rcode = frame->p_result->rcode;
1124
1125 /*
1126 * This usually means the request is complete in its
1127 * entirety.
1128 */
1129 if ((stack->depth == 0) && !running) unlang_interpret_request_done(request);
1130
1131 return rcode;
1132 }
1133}
1134
1136 .self = {
1138 .debug_name = "empty-group",
1139 .actions = {
1140 .actions = {
1150 },
1151 .retry = RETRY_INIT,
1152 },
1153 },
1154};
1155
1156/** Push a configuration section onto the request stack for later interpretation.
1157 *
1158 */
1160{
1161 unlang_t *instruction = NULL;
1162
1163 /*
1164 * Interpretable unlang instructions are stored as CONF_DATA
1165 * associated with sections.
1166 */
1167 if (cs) {
1168 instruction = (unlang_t *)cf_data_value(cf_data_find(cs, unlang_group_t, NULL));
1169 if (!instruction) {
1170 REDEBUG("Failed to find pre-compiled unlang for section %s %s { ... }",
1172 return -1;
1173 }
1174 }
1175
1176 return unlang_interpret_push_instruction(p_result, request, instruction, conf);
1177}
1178
1179/** Push an instruction onto the request stack for later interpretation.
1180 *
1181 */
1183{
1184 unlang_stack_t *stack = request->stack;
1185
1186 if (!instruction) {
1187 instruction = unlang_group_to_generic(&empty_group);
1188 }
1189
1190 /*
1191 * Push the default action, and the instruction which has
1192 * no action.
1193 */
1194 if (unlang_interpret_push(p_result, request, instruction, conf, UNLANG_NEXT_SIBLING) < 0) {
1195 return -1;
1196 }
1197
1198 RDEBUG4("** [%i] %s - substack begins", stack->depth, __FUNCTION__);
1199
1200 return 0;
1201}
1202
1203/** Allocate a new unlang stack
1204 *
1205 * @param[in] ctx to allocate stack in.
1206 * @return
1207 * - A new stack on success.
1208 * - NULL on OOM.
1209 */
1210void *unlang_interpret_stack_alloc(TALLOC_CTX *ctx)
1211{
1212 /*
1213 * Should never be evaluated, is just here to reduce
1214 * branches, so we don't need to check for frame->instruction.
1215 */
1216 static unlang_t unlang_instruction = {
1217 .debug_name = "top",
1218 .actions = DEFAULT_MOD_ACTIONS,
1219 };
1220
1222
1223 /*
1224 * If we have talloc_pooled_object allocate the
1225 * stack as a combined chunk/pool, with memory
1226 * to hold at mutable data for at least a quarter
1227 * of the maximum number of stack frames.
1228 *
1229 * Having a dedicated pool for mutable stack data
1230 * means we don't have memory fragmentations issues
1231 * as we would if request were used as the pool.
1232 *
1233 * This number is pretty arbitrary, but it seems
1234 * like too low level to make into a tuneable.
1235 */
1236 MEM(stack = talloc_zero_pooled_object(ctx, unlang_stack_t, UNLANG_STACK_MAX, 128)); /* 128 bytes per state */
1237 stack->frame[0].p_result = &stack->frame[0].section_result;
1238 stack->frame[0].scratch_result = UNLANG_RESULT_NOT_SET;
1239 stack->frame[0].section_result = UNLANG_RESULT_NOT_SET;
1240 stack->frame[0].instruction = &unlang_instruction; /* The top frame has no instruction, so we use a dummy one */
1241
1242 return stack;
1243}
1244
1245/** Indicate to the caller of the interpreter that this request is complete
1246 *
1247 */
1249{
1250 unlang_stack_t *stack = request->stack;
1251 unlang_interpret_t *intp;
1252
1253 if (!fr_cond_assert(stack != NULL)) return;
1254
1255 intp = stack->intp;
1256
1257 request->master_state = REQUEST_DONE;
1258 switch (request->type) {
1260 intp->funcs.done_external(request, frame_current(request)->section_result.rcode, intp->uctx);
1261 break;
1262
1264 intp->funcs.done_internal(request, frame_current(request)->section_result.rcode, intp->uctx);
1265 break;
1266
1268 intp->funcs.done_detached(request, frame_current(request)->section_result.rcode, intp->uctx); /* Callback will usually free the request */
1269 break;
1270 }
1271}
1272
1273/** Tell the interpreter to detach the request
1274 *
1275 * This function should not be called directly use unlang_interpret_signal(request, FR_SIGNAL_DETACH) instead.
1276 * This will ensure all frames on the request's stack receive the detach signal.
1277 */
1278static inline CC_HINT(always_inline)
1280{
1281 unlang_stack_t *stack = request->stack;
1282 unlang_interpret_t *intp;
1283
1284 if (!fr_cond_assert(stack != NULL)) return;
1285
1286 if (!request_is_detachable(request)) return;
1287
1288 intp = stack->intp;
1289
1290 intp->funcs.detach(request, intp->uctx);
1291}
1292
1294{
1295 unlang_stack_t *stack = request->stack;
1296 unlang_interpret_t *intp;
1297
1298 if (!fr_cond_assert(stack != NULL)) return;
1299
1300 intp = stack->intp;
1301
1302 request->priority = priority;
1303
1304 if (intp->funcs.prioritise) intp->funcs.prioritise(request, intp->uctx);
1305}
1306
1307/** Delivers a frame to one or more frames in the stack
1308 *
1309 * This is typically called via an "async" action, i.e. an action outside
1310 * of the normal processing of the request.
1311 *
1312 * For FR_SIGNAL_CANCEL all frames are marked up for cancellation, but the
1313 * cancellation is handled by the interpret.
1314 *
1315 * Other signal types are delivered immediately, inrrespecitve of whether
1316 * the request is currently being processed or not.
1317 *
1318 * Signaling stops at the "limit" frame. This is so that keywords
1319 * such as "timeout" and "limit" can signal frames *lower* than theirs
1320 * to stop, but then continue with their own work.
1321 *
1322 * @note It's better (clearer) to use one of the unwind_* functions
1323 * unless the entire request is being cancelled.
1324 *
1325 * @param[in] request The current request.
1326 * @param[in] action to signal.
1327 * @param[in] limit the frame at which to stop signaling.
1328 */
1329void unlang_stack_signal(request_t *request, fr_signal_t action, int limit)
1330{
1331 unlang_stack_frame_t *frame;
1332 unlang_stack_t *stack = request->stack;
1333 int i, depth = stack->depth;
1334
1335 (void)talloc_get_type_abort(request, request_t); /* Check the request hasn't already been freed */
1336
1337 fr_assert(stack->depth >= 1);
1338
1339 /*
1340 * Does not complete the unwinding here, just marks
1341 * up the frames for unwinding. The request must
1342 * be marked as runnable to complete the cancellation.
1343 */
1344 if (action == FR_SIGNAL_CANCEL) unwind_to_depth(stack, limit);
1345
1346 /*
1347 * Walk back up the stack, calling signal handlers
1348 * to cancel any pending operations and free/release
1349 * any resources.
1350 *
1351 * There may be multiple resumption points in the
1352 * stack, as modules can push xlats and function
1353 * calls.
1354 *
1355 * Note: Slightly confusingly, a cancellation signal
1356 * can still be delivered to a frame that is not
1357 * cancellable, but the frame won't be automatically
1358 * unwound.
1359 */
1360 for (i = depth; i >= limit; i--) {
1361 frame = &stack->frame[i];
1362 if (frame->signal) {
1363 frame->signal(request, frame, action);
1364
1365 /*
1366 * Once the cancellation function has been
1367 * called, the frame is no longer in a state
1368 * where it can accept further signals.
1369 */
1370 if (action == FR_SIGNAL_CANCEL) frame->signal = NULL;
1371 }
1372 }
1373}
1374
1375/** Send a signal (usually stop) to a request
1376 *
1377 * This is typically called via an "async" action, i.e. an action
1378 * outside of the normal processing of the request.
1379 *
1380 * @note This does NOT immediately stop the request, it just deliveres
1381 * signals, and in the case of a cancel, marks up frames for unwinding
1382 * and adds it to the runnable queue if it's yielded.
1383 *
1384 * @note This function should be safe to call anywhere.
1385 *
1386 * @param[in] request The current request.
1387 * @param[in] action to signal.
1388 */
1390{
1391 unlang_stack_t *stack = request->stack;
1392
1393 switch (action) {
1394 case FR_SIGNAL_DETACH:
1395 /*
1396 * Ensure the request is able to be detached
1397 * else don't signal.
1398 */
1399 if (!fr_cond_assert(request_is_detachable(request))) return;
1400 break;
1401
1402 default:
1403 break;
1404 }
1405
1406 /*
1407 * Requests that haven't been run through the interpreter
1408 * yet should have a stack depth of zero, so we don't
1409 * need to do anything.
1410 */
1411 if (!stack || stack->depth == 0) return;
1412
1413 unlang_stack_signal(request, action, 1);
1414
1415 switch (action) {
1416 case FR_SIGNAL_CANCEL:
1417 {
1418 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1419 /*
1420 * Let anything that cares, know that the
1421 * request was forcefully stopped.
1422 */
1423 request->master_state = REQUEST_STOP_PROCESSING;
1424
1425 /*
1426 * Give cancelled requests the highest priority
1427 * to get them to release resources ASAP.
1428 */
1429 unlang_interpret_request_prioritise(request, UINT32_MAX);
1430
1431 /*
1432 * If the request is yielded, mark it as runnable
1433 *
1434 * If the request was _not_ cancelled, it means
1435 * it's not cancellable, and we need to let the
1436 * request progress normally.
1437 *
1438 * A concrete example of this, is the parent of
1439 * subrequests, which must not continue until
1440 * the subrequest is done.
1441 */
1442 if (stack && is_yielded(frame) && is_unwinding(frame) && !unlang_request_is_scheduled(request)) {
1444 }
1445 }
1446 break;
1447
1448 case FR_SIGNAL_DETACH:
1449 /*
1450 * Cleanup any cross-request pointers, and mark the
1451 * request as detached. When the request completes it
1452 * should by automatically freed.
1453 */
1455 break;
1456
1457 default:
1458 break;
1459 }
1460}
1461
1463{
1464 unlang_retry_t *retry = talloc_get_type_abort(ctx, unlang_retry_t);
1465 request_t *request = talloc_get_type_abort(retry->request, request_t);
1466
1467 RDEBUG("retry timeout reached, signalling interpreter to cancel.");
1468
1469 /*
1470 * Signal all lower frames to exit.
1471 */
1472 unlang_stack_signal(request, FR_SIGNAL_CANCEL, retry->depth);
1473
1474 retry->state = FR_RETRY_MRD;
1476}
1477
1479{
1480 request_t *request = talloc_get_type_abort(ctx, request_t);
1481
1482 RDEBUG("Maximum timeout reached, signalling interpreter to stop the request.");
1483
1484 /*
1485 * Stop the entire request.
1486 */
1488}
1489
1490
1491/** Set a timeout for a request.
1492 *
1493 * The timeout is associated with the current stack frame.
1494 *
1495 */
1497{
1498 unlang_stack_t *stack = request->stack;
1499 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1500 unlang_retry_t *retry;
1501 TALLOC_CTX *frame_ctx;
1502
1503 fr_assert(!frame->retry);
1505
1506 frame_ctx = frame->state;
1507 if (!frame_ctx) frame_ctx = stack;
1508
1509 frame->retry = retry = talloc_zero(frame_ctx, unlang_retry_t);
1510 if (!frame->retry) return -1;
1511
1512 retry->request = request;
1513 retry->depth = stack->depth;
1514 retry->state = FR_RETRY_CONTINUE;
1515 retry->count = 1;
1516
1517 return fr_timer_in(retry, unlang_interpret_event_list(request)->tl, &retry->ev, timeout,
1518 false, instruction_timeout_handler, request);
1519}
1520
1521
1522/** Return the depth of the request's stack
1523 *
1524 */
1526{
1527 unlang_stack_t *stack = request->stack;
1528
1529 return stack->depth;
1530}
1531
1532/** Get the last instruction result OR the last frame that was popped
1533 *
1534 * @param[in] request The current request.
1535 * @return the current rcode for the frame.
1536 */
1538{
1539 return frame_current(request)->p_result->rcode;
1540}
1541
1542/** Get the last instruction priority OR the last frame that was popped
1543 *
1544 * @param[in] request The current request.
1545 * @return the current rcode for the frame.
1546 */
1551
1552/** Get the last instruction result OR the last frame that was popped
1553 *
1554 * @param[in] request The current request.
1555 * @return the current result for the frame.
1556 */
1558{
1559 return frame_current(request)->p_result;
1560}
1561
1562/** Return whether a request is currently scheduled
1563 *
1564 */
1566{
1567 unlang_stack_t *stack = request->stack;
1568 unlang_interpret_t *intp = stack->intp;
1569
1570 return intp->funcs.scheduled(request, intp->uctx);
1571}
1572
1573/** Return whether a request has been cancelled
1574 */
1576{
1577 return (request->master_state == REQUEST_STOP_PROCESSING);
1578}
1579
1580/** Return whether a request has been marked done
1581 */
1583{
1584 return (request->master_state == REQUEST_DONE);
1585}
1586
1587/** Check if a request as resumable.
1588 *
1589 * @param[in] request The current request.
1590 * @return
1591 * - true if the request is resumable (i.e. has yielded)
1592 * - false if the request is not resumable (i.e. has not yielded)
1593 */
1595{
1596 unlang_stack_t *stack = request->stack;
1597 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1598
1599 return is_yielded(frame);
1600}
1601
1602/** Mark a request as resumable.
1603 *
1604 * It's not called "unlang_interpret", because it doesn't actually
1605 * resume the request, it just schedules it for resumption.
1606 *
1607 * @note that this schedules the request for resumption. It does not immediately
1608 * start running the request.
1609 *
1610 * @param[in] request The current request.
1611 */
1613{
1614 unlang_stack_t *stack = request->stack;
1615 unlang_interpret_t *intp = stack->intp;
1616 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1617
1618 bool scheduled = unlang_request_is_scheduled(request);
1619
1620 /*
1621 * The request hasn't yielded, OR it's already been
1622 * marked as runnable. Don't do anything.
1623 *
1624 * The IO code, or children have no idea where they're
1625 * being called from. They just ask to mark the parent
1626 * resumable when they're done. So we have to check here
1627 * if this request is resumable.
1628 *
1629 * If the parent called the child directly, then the
1630 * parent hasn't yielded, so it isn't resumable. When
1631 * the child is done, the parent will automatically
1632 * continue running. We therefore don't need to insert
1633 * the parent into the backlog.
1634 *
1635 * Multiple child request may also mark a parent request
1636 * runnable, before the parent request starts running.
1637 */
1638 if (!is_yielded(frame) || scheduled) {
1639 RDEBUG3("Not marking request %s as runnable due to%s%s",
1640 request->name,
1641 !is_yielded(frame) ?
1642 " it not being yielded " : "", scheduled ? " it already being scheduled" : "");
1643 return;
1644 }
1645
1646 RDEBUG3("Interpreter - Request marked as runnable");
1647
1648 intp->funcs.mark_runnable(request, intp->uctx);
1649}
1650
1651/** Get a talloc_ctx which is valid only for this frame
1652 *
1653 * @param[in] request The current request.
1654 * @return
1655 * - a TALLOC_CTX which is valid only for this stack frame
1656 */
1658{
1659 unlang_stack_t *stack = request->stack;
1660 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1661
1662 if (frame->state) return (TALLOC_CTX *)frame->state;
1663
1664 /*
1665 * If the frame doesn't ordinarily have a
1666 * state, assume the caller knows what it's
1667 * doing and allocate one.
1668 */
1669 return (TALLOC_CTX *)(frame->state = talloc_new(request));
1670}
1671
1673 { .required = false, .single = true, .type = FR_TYPE_TIME_DELTA },
1675};
1676
1677static xlat_action_t unlang_cancel_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
1678 UNUSED xlat_ctx_t const *xctx,
1679 request_t *request, fr_value_box_list_t *args);
1680
1681/** Signal the request to stop executing
1682 *
1683 * The request can't be running at this point because we're in the event
1684 * loop. This means the request is always in a consistent state when
1685 * the timeout event fires, even if that's state is waiting on I/O.
1686 */
1688{
1689 request_t *request = talloc_get_type_abort(uctx, request_t);
1690
1691 RDEBUG2("Request canceled by dynamic timeout");
1692 /*
1693 * Cleans up the memory allocated to hold
1694 * the pointer, not the event itself.
1695 */
1696 talloc_free(request_data_get(request, (void *)unlang_cancel_xlat, 0));
1697
1699}
1700
1701/** Allows a request to dynamically alter its own lifetime
1702 *
1703 * %cancel(<timeout>)
1704 *
1705 * If timeout is 0, then the request is immediately cancelled.
1706 */
1708 UNUSED xlat_ctx_t const *xctx,
1709 request_t *request, fr_value_box_list_t *args)
1710{
1711 fr_value_box_t *timeout;
1713 fr_timer_t **ev_p, **ev_p_og;
1714 fr_value_box_t *vb;
1715 fr_time_t when = fr_time_from_sec(0); /* Invalid clang complaints if we don't set this */
1716
1717 XLAT_ARGS(args, &timeout);
1718
1719 /*
1720 * No timeout means cancel immediately, so yield allowing
1721 * the interpreter to run the event we added to cancel
1722 * the request.
1723 *
1724 * We call unlang_xlat_yield to keep the interpreter happy
1725 * as it expects to see a resume function set.
1726 */
1727 if (!timeout || fr_time_delta_eq(timeout->vb_time_delta, fr_time_delta_from_sec(0))) {
1729 return XLAT_ACTION_DONE;
1730 }
1731
1732 /*
1733 * First see if we already have a timeout event
1734 * that was previously added by this xlat.
1735 */
1736 ev_p = ev_p_og = request_data_get(request, (void *)unlang_cancel_xlat, 0);
1737 if (ev_p) {
1738 if (*ev_p) when = fr_timer_when(*ev_p); /* *ev_p should never be NULL, really... */
1739 } else {
1740 /*
1741 * Must not be parented from the request
1742 * as this is freed by request data.
1743 */
1744 MEM(ev_p = talloc_zero(NULL, fr_timer_t *));
1745 }
1746
1747 if (unlikely(fr_timer_in(ev_p, el->tl, ev_p,
1748 timeout ? timeout->vb_time_delta : fr_time_delta_from_sec(0),
1749 false, unlang_cancel_event, request) < 0)) {
1750 RPERROR("Failed inserting cancellation event");
1751 talloc_free(ev_p);
1752 return XLAT_ACTION_FAIL;
1753 }
1754 if (unlikely(request_data_add(request, (void *)unlang_cancel_xlat, 0,
1755 UNCONST(fr_timer_t **, ev_p), true, true, false) < 0)) {
1756 RPERROR("Failed associating cancellation event with request");
1757 talloc_free(ev_p);
1758 return XLAT_ACTION_FAIL;
1759 }
1760
1761 if (ev_p_og) {
1762 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
1763
1764 /*
1765 * Return how long before the previous
1766 * cancel event would have fired.
1767 *
1768 * This can be useful for doing stacked
1769 * cancellations in policy.
1770 */
1771 vb->vb_time_delta = fr_time_sub(when, unlang_interpret_event_list(request)->tl->time());
1773 }
1774
1775 /*
1776 * No value if this is the first cleanup event
1777 */
1778 return XLAT_ACTION_DONE;
1779}
1780
1782 { .required = true, .single = true, .type = FR_TYPE_STRING },
1784};
1785
1786/** Get information about the interpreter state
1787 *
1788 * @ingroup xlat_functions
1789 */
1791 UNUSED xlat_ctx_t const *xctx,
1792 request_t *request, fr_value_box_list_t *in)
1793{
1794 unlang_stack_t *stack = request->stack;
1795 int depth = stack->depth;
1796 unlang_stack_frame_t *frame;
1797 unlang_t const *instruction;
1798 fr_value_box_t *arg = fr_value_box_list_head(in);
1799 char const *fmt = arg->vb_strvalue;
1800 fr_value_box_t *vb;
1801
1802 MEM(vb = fr_value_box_alloc_null(ctx));
1803
1804 /*
1805 * Find the correct stack frame.
1806 */
1807 while (*fmt == '.') {
1808 if (depth <= 1) {
1809 if (fr_value_box_bstrndup(vb, vb, NULL, "<underflow>", 11, false) < 0) {
1810 error:
1811 talloc_free(vb);
1812 return XLAT_ACTION_FAIL;
1813 }
1814 goto finish;
1815 }
1816
1817 fmt++;
1818 depth--;
1819 }
1820
1821 /*
1822 * Get the current instruction.
1823 */
1824 frame = &stack->frame[depth];
1825 instruction = frame->instruction;
1826
1827 /*
1828 * Nothing there...
1829 */
1830 if (!instruction) {
1831 talloc_free(vb);
1832 return XLAT_ACTION_DONE;
1833 }
1834
1835 /*
1836 * How deep the current stack is.
1837 */
1838 if (strcmp(fmt, "depth") == 0) {
1839 fr_value_box_int32(vb, NULL, depth, false);
1840 goto finish;
1841 }
1842
1843 /*
1844 * The current module
1845 */
1846 if (strcmp(fmt, "module") == 0) {
1847 if (fr_value_box_strdup(vb, vb, NULL, request->module, false) < 0) goto error;
1848
1849 goto finish;
1850 }
1851
1852 /*
1853 * Name of the instruction.
1854 */
1855 if (strcmp(fmt, "name") == 0) {
1856 if (fr_value_box_bstrndup(vb, vb, NULL, instruction->name,
1857 strlen(instruction->name), false) < 0) goto error;
1858 goto finish;
1859 }
1860
1861 /*
1862 * The request processing stage.
1863 */
1864 if (strcmp(fmt, "processing_stage") == 0) {
1865 if (fr_value_box_strdup(vb, vb, NULL, request->component, false) < 0) goto error;
1866
1867 goto finish;
1868 }
1869
1870 /*
1871 * The current return code.
1872 */
1873 if (strcmp(fmt, "rcode") == 0) {
1874 if (fr_value_box_strdup(vb, vb, NULL, fr_table_str_by_value(rcode_table, request->rcode, "<INVALID>"), false) < 0) goto error;
1875
1876 goto finish;
1877 }
1878
1879 /*
1880 * The virtual server handling the request
1881 */
1882 if (strcmp(fmt, "server") == 0) {
1883 if (!unlang_call_current(request)) goto finish;
1884
1885 if (fr_value_box_strdup(vb, vb, NULL, cf_section_name2(unlang_call_current(request)), false) < 0) goto error;
1886
1887 goto finish;
1888 }
1889
1890 /*
1891 * Unlang instruction type.
1892 */
1893 if (strcmp(fmt, "type") == 0) {
1894 if (fr_value_box_bstrndup(vb, vb, NULL, unlang_ops[instruction->type].name,
1895 strlen(unlang_ops[instruction->type].name), false) < 0) goto error;
1896
1897 goto finish;
1898 }
1899
1900 /*
1901 * All of the remaining things need a CONF_ITEM.
1902 */
1903 if (!instruction->ci) {
1904 if (fr_value_box_bstrndup(vb, vb, NULL, "<INVALID>", 3, false) < 0) goto error;
1905
1906 goto finish;
1907 }
1908
1909 /*
1910 * Line number of the current section.
1911 */
1912 if (strcmp(fmt, "line") == 0) {
1913 fr_value_box_int32(vb, NULL, cf_lineno(instruction->ci), false);
1914
1915 goto finish;
1916 }
1917
1918 /*
1919 * Filename of the current section.
1920 */
1921 if (strcmp(fmt, "filename") == 0) {
1922 if (fr_value_box_strdup(vb, vb, NULL, cf_filename(instruction->ci), false) < 0) goto error;
1923
1924 goto finish;
1925 }
1926
1927finish:
1928 if (vb->type != FR_TYPE_NULL) {
1930 } else {
1931 talloc_free(vb);
1932 }
1933
1934 return XLAT_ACTION_DONE;
1935}
1936
1937/** Initialize a unlang compiler / interpret.
1938 *
1939 * @param[in] ctx to bind lifetime of the interpret to.
1940 * Shouldn't be any free order issues here as
1941 * the interpret itself has no state.
1942 * But event loop should be stopped before
1943 * freeing the interpret.
1944 * @param[in] el for any timer or I/O events.
1945 * @param[in] funcs Callbacks to used to communicate request
1946 * state to our owner.
1947 * @param[in] uctx Data to pass to callbacks.
1948 */
1950 fr_event_list_t *el, unlang_request_func_t *funcs, void *uctx)
1951{
1952 unlang_interpret_t *intp;
1953
1954 fr_assert(funcs->init_internal);
1955
1956 fr_assert(funcs->done_internal);
1957 fr_assert(funcs->done_detached);
1958 fr_assert(funcs->done_external);
1959
1960 fr_assert(funcs->detach);
1961 fr_assert(funcs->yield);
1962 fr_assert(funcs->resume);
1963 fr_assert(funcs->mark_runnable);
1964 fr_assert(funcs->scheduled);
1965
1966 MEM(intp = talloc(ctx, unlang_interpret_t));
1967 *intp = (unlang_interpret_t){
1968 .el = el,
1969 .funcs = *funcs,
1970 .uctx = uctx
1971 };
1972
1973 return intp;
1974}
1975
1976/** Discard the bottom most frame on the request's stack
1977 *
1978 * This is used for cleaning up after errors. i.e. the caller
1979 * uses a push function, and experiences an error and needs to
1980 * remove the frame that was just pushed.
1981 */
1983{
1984 frame_pop(request, request->stack);
1985}
1986
1987/** Set a specific interpreter for a request
1988 *
1989 */
1991{
1992 unlang_stack_t *stack = request->stack;
1993 stack->intp = intp;
1994}
1995
1996/** Get the interpreter set for a request
1997 *
1998 */
2000{
2001 unlang_stack_t *stack = request->stack;
2002
2003 return stack->intp;
2004}
2005
2006/** Get the event list for the current interpreter
2007 *
2008 */
2010{
2011 unlang_stack_t *stack = request->stack;
2012
2013 if (!stack->intp) return NULL;
2014
2015 return stack->intp->el;
2016}
2017
2018/** Set the default interpreter for this thread
2019 *
2020 */
2022{
2023 if (intp) (void)talloc_get_type_abort(intp, unlang_interpret_t);
2024
2025 intp_thread_default = intp;
2026}
2027
2028/** Get the default interpreter for this thread
2029 *
2030 * This allows detached requests to be executed asynchronously
2031 */
2033{
2034 if (!intp_thread_default) return NULL;
2035
2036 return talloc_get_type_abort(intp_thread_default, unlang_interpret_t);
2037}
2038
2040{
2041 xlat_t *xlat;
2042 /*
2043 * Should be void, but someone decided not to register multiple xlats
2044 * breaking the convention we use everywhere else in the server...
2045 */
2046 if (unlikely((xlat = xlat_func_register(ctx, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID)) == NULL)) return -1;
2048
2049 if (unlikely((xlat = xlat_func_register(ctx, "cancel", unlang_cancel_xlat, FR_TYPE_VOID)) == NULL)) return -1;
2051
2052 return 0;
2053}
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
static int const char * fmt
Definition acutest.h:573
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSID(id)
Definition build.h:485
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
Definition build.h:324
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
#define NUM_ELEMENTS(_t)
Definition build.h:339
CONF_SECTION * unlang_call_current(request_t *request)
Return the last virtual server that was called.
Definition call.c:214
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1184
void * cf_data_value(CONF_DATA const *cd)
Return the user assigned value of CONF_DATA.
Definition cf_util.c:1762
char const * cf_section_name1(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1170
#define cf_lineno(_cf)
Definition cf_util.h:104
#define cf_data_find(_cf, _type, _name)
Definition cf_util.h:244
#define cf_filename(_cf)
Definition cf_util.h:107
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:75
static int fr_dcursor_append(fr_dcursor_t *cursor, void *v)
Insert a single item at the end of the list.
Definition dcursor.h:408
static int fr_dcursor_insert(fr_dcursor_t *cursor, void *v)
Insert directly after the current item.
Definition dcursor.h:437
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:131
#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:202
#define MEM(x)
Definition debug.h:36
#define DEBUG(fmt,...)
Definition dhcpclient.c:39
static fr_slen_t in
Definition dict.h:841
static xlat_action_t unlang_interpret_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Get information about the interpreter state.
Definition interpret.c:1790
void unlang_interpret_request_prioritise(request_t *request, uint32_t priority)
Definition interpret.c:1293
static size_t unlang_action_table_len
Definition interpret.c:52
void stack_dump_with_actions(request_t *request)
Definition interpret.c:253
static fr_table_num_ordered_t const unlang_frame_action_table[]
Definition interpret.c:54
static void unlang_interpret_request_detach(request_t *request)
Tell the interpreter to detach the request.
Definition interpret.c:1279
rlm_rcode_t unlang_interpret(request_t *request, bool running)
Run the interpreter for a current request.
Definition interpret.c:949
bool unlang_request_is_done(request_t const *request)
Return whether a request has been marked done.
Definition interpret.c:1582
static void stack_dump_body(request_t *request, bool with_actions)
Definition interpret.c:233
static unlang_group_t empty_group
Definition interpret.c:1135
unlang_result_t * unlang_interpret_result(request_t *request)
Get the last instruction result OR the last frame that was popped.
Definition interpret.c:1557
static int find_p_result_location(p_result_location_t *location, void **chunk, request_t *request, void *ptr)
Try and figure out where p_result points to.
Definition interpret.c:77
void unlang_interpet_frame_discard(request_t *request)
Discard the bottom most frame on the request's stack.
Definition interpret.c:1982
int unlang_interpret_set_timeout(request_t *request, fr_time_delta_t timeout)
Set a timeout for a request.
Definition interpret.c:1496
void unlang_interpret_request_done(request_t *request)
Indicate to the caller of the interpreter that this request is complete.
Definition interpret.c:1248
static unlang_frame_action_t frame_eval(request_t *request, unlang_stack_frame_t *frame)
Evaluates all the unlang nodes in a section.
Definition interpret.c:731
void unlang_interpret_set(request_t *request, unlang_interpret_t *intp)
Set a specific interpreter for a request.
Definition interpret.c:1990
unlang_interpret_t * unlang_interpret_get(request_t *request)
Get the interpreter set for a request.
Definition interpret.c:1999
int unlang_interpret_stack_depth(request_t *request)
Return the depth of the request's stack.
Definition interpret.c:1525
void unlang_interpret_mark_runnable(request_t *request)
Mark a request as resumable.
Definition interpret.c:1612
static xlat_arg_parser_t const unlang_interpret_xlat_args[]
Definition interpret.c:1781
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:1657
bool unlang_request_is_scheduled(request_t const *request)
Return whether a request is currently scheduled.
Definition interpret.c:1565
int unlang_interpret_init_global(TALLOC_CTX *ctx)
Definition interpret.c:2039
void stack_dump(request_t *request)
Definition interpret.c:248
p_result_location_t
Definition interpret.c:64
@ P_RESULT_LOCATION_FRAME
Definition interpret.c:66
@ P_RESULT_LOCATION_FUNCTION_RCTX
Definition interpret.c:70
@ P_RESULT_LOCATION_UNKNOWN
Definition interpret.c:65
@ P_RESULT_LOCATION_SCRATCH
Definition interpret.c:67
@ P_RESULT_LOCATION_MODULE_RCTX
Definition interpret.c:69
@ P_RESULT_LOCATION_STATE
Definition interpret.c:68
unlang_interpret_t * unlang_interpret_get_thread_default(void)
Get the default interpreter for this thread.
Definition interpret.c:2032
fr_dict_t const * old_dict
the previous dictionary for the request
Definition interpret.c:344
void * unlang_interpret_stack_alloc(TALLOC_CTX *ctx)
Allocate a new unlang stack.
Definition interpret.c:1210
void unlang_interpret_set_thread_default(unlang_interpret_t *intp)
Set the default interpreter for this thread.
Definition interpret.c:2021
static fr_table_num_ordered_t const p_result_location_table[]
Definition interpret.c:137
#define DUMP_STACK
Definition interpret.c:257
unlang_mod_action_t unlang_interpret_priority(request_t *request)
Get the last instruction priority OR the last frame that was popped.
Definition interpret.c:1547
static void instruction_retry_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
Definition interpret.c:1462
unlang_interpret_t * unlang_interpret_init(TALLOC_CTX *ctx, fr_event_list_t *el, unlang_request_func_t *funcs, void *uctx)
Initialize a unlang compiler / interpret.
Definition interpret.c:1949
static void instruction_timeout_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
Definition interpret.c:1478
bool unlang_request_is_cancelled(request_t const *request)
Return whether a request has been cancelled.
Definition interpret.c:1575
int unlang_interpret_push_instruction(unlang_result_t *p_result, request_t *request, void *instruction, unlang_frame_conf_t const *conf)
Push an instruction onto the request stack for later interpretation.
Definition interpret.c:1182
static void unlang_cancel_event(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *uctx)
Signal the request to stop executing.
Definition interpret.c:1687
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1389
static xlat_arg_parser_t const unlang_cancel_xlat_args[]
Definition interpret.c:1672
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:1159
static unlang_frame_action_t result_calculate(request_t *request, unlang_stack_frame_t *frame, unlang_result_t *result)
Update the current result after each instruction, and after popping each stack frame.
Definition interpret.c:448
static fr_table_num_ordered_t const unlang_action_table[]
Definition interpret.c:45
static int _local_variables_free(unlang_variable_ref_t *ref)
Definition interpret.c:348
static size_t p_result_location_table_len
Definition interpret.c:144
static void instruction_dump(request_t *request, unlang_t const *instruction)
Definition interpret.c:146
bool unlang_interpret_is_resumable(request_t *request)
Check if a request as resumable.
Definition interpret.c:1594
int unlang_interpret_push(unlang_result_t *p_result, 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:280
static void instruction_done_debug(request_t *request, unlang_stack_frame_t *frame, unlang_t const *instruction)
Definition interpret.c:687
request_t * request
the request
Definition interpret.c:345
static unlang_frame_action_t result_pop(request_t *request, unlang_stack_frame_t *frame, unlang_result_t *result)
Function called to merge inter-stack-frame results.
Definition interpret.c:657
void unlang_stack_signal(request_t *request, fr_signal_t action, int limit)
Delivers a frame to one or more frames in the stack.
Definition interpret.c:1329
static xlat_action_t unlang_cancel_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Allows a request to dynamically alter its own lifetime.
Definition interpret.c:1707
static size_t unlang_frame_action_table_len
Definition interpret.c:59
rlm_rcode_t unlang_interpret_rcode(request_t *request)
Get the last instruction result OR the last frame that was popped.
Definition interpret.c:1537
static void frame_dump(request_t *request, unlang_stack_frame_t *frame, bool with_actions)
Definition interpret.c:175
unlang_action_t unlang_interpret_push_children(unlang_result_t *p_result, request_t *request, rlm_rcode_t default_rcode, bool do_next_sibling)
Push the children of the current frame onto a new frame onto the stack.
Definition interpret.c:384
static void actions_dump(request_t *request, unlang_t const *instruction)
Definition interpret.c:161
static _Thread_local unlang_interpret_t * intp_thread_default
The default interpreter instance for this thread.
Definition interpret.c:43
fr_event_list_t * unlang_interpret_event_list(request_t *request)
Get the event list for the current interpreter.
Definition interpret.c:2009
unlang_result_t default_result
The default result for the frame.
Definition interpret.h:146
#define UNLANG_STACK_MAX
The maximum depth of the stack.
Definition interpret.h:39
unlang_request_prioritise_t prioritise
Function to re-priotise a request in the runnable queue.
Definition interpret.h:129
unlang_mod_action_t priority
The priority or action for that rcode.
Definition interpret.h:136
#define UNLANG_RESULT_NOT_SET
Definition interpret.h:139
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:152
unlang_request_done_t done_internal
Function called when an internal request completes.
Definition interpret.h:119
unlang_request_resume_t resume
Function called when a request is resumed.
Definition interpret.h:124
#define UNLANG_SUB_FRAME
Definition interpret.h:37
unlang_request_done_t done_external
Function called when a external request completes.
Definition interpret.h:118
unlang_request_init_t detach
Function called when a request is detached.
Definition interpret.h:122
unlang_request_runnable_t mark_runnable
Function called when a request needs to be added back to the runnable queue.
Definition interpret.h:125
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
unlang_request_yield_t yield
Function called when a request yields.
Definition interpret.h:123
unlang_request_done_t done_detached
Function called when a detached request completes.
Definition interpret.h:120
unlang_request_scheduled_t scheduled
Function to check if a request is already scheduled.
Definition interpret.h:127
#define UNLANG_RESULT_RCODE(_x)
Definition interpret.h:140
unlang_request_init_t init_internal
Function called to initialise an internal request.
Definition interpret.h:116
struct unlang_interpret_s unlang_interpret_t
Interpreter handle.
Definition interpret.h:48
Configuration structure to make it easier to pass configuration options to initialise the frame with.
Definition interpret.h:144
External functions provided by the owner of the interpret.
Definition interpret.h:110
Private declarations for the unlang interpreter.
fr_event_list_t * el
unlang_request_func_t funcs
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:443
#define DEBUG_ENABLED5
True if global debug level 1-5 messages are enabled.
Definition log.h:261
#define RDEBUG3(fmt,...)
Definition log.h:343
#define RERROR(fmt,...)
Definition log.h:298
#define DEBUG4(_fmt,...)
Definition log.h:267
#define RPERROR(fmt,...)
Definition log.h:302
#define RPEDEBUG(fmt,...)
Definition log.h:376
#define RDEBUG4(fmt,...)
Definition log.h:344
#define RINDENT()
Indent R* messages by one level.
Definition log.h:430
unlang_op_t unlang_ops[UNLANG_TYPE_MAX]
Different operations the interpreter can execute.
Definition base.c:31
talloc_free(reap)
Stores all information relating to an event list.
Definition event.c:377
static char * stack[MAX_STACK]
Definition radmin.c:159
@ FR_TYPE_TIME_DELTA
A period of time measured in nanoseconds.
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
@ FR_TYPE_VOID
User data.
unsigned int uint32_t
unsigned char uint8_t
static uint8_t depth(fr_minmax_heap_index_t i)
Definition minmax_heap.c:83
const char * mod_action_name[MOD_PRIORITY_MAX+1]
Definition mod_action.c:113
#define DEFAULT_MOD_ACTIONS
Definition mod_action.h:68
unlang_mod_action_t
Definition mod_action.h:36
@ MOD_ACTION_NOT_SET
default "not set by anything"
Definition mod_action.h:37
@ MOD_ACTION_RETURN
stop processing the section, and return the rcode with unset priority
Definition mod_action.h:40
@ MOD_ACTION_REJECT
change the rcode to REJECT, with unset priority
Definition mod_action.h:39
@ MOD_ACTION_RETRY
retry the instruction, MUST also set a retry config
Definition mod_action.h:38
#define MOD_ACTION_VALID(_x)
Definition mod_action.h:60
fr_retry_config_t retry
Definition mod_action.h:65
unlang_mod_action_t actions[RLM_MODULE_NUMCODES]
Definition mod_action.h:64
Declarations for the unlang module interface.
void * rctx
for resume / signal
Definition module_priv.h:63
A module stack entry.
Definition module_priv.h:45
int fr_pair_delete(fr_pair_list_t *list, fr_pair_t *vp)
Remove fr_pair_t from a list and free.
Definition pair.c:1823
#define fr_assert(_expr)
Definition rad_assert.h:38
#define REDEBUG(fmt,...)
Definition radclient.h:52
#define RDEBUG_ENABLED2()
Definition radclient.h:50
#define RDEBUG2(fmt,...)
Definition radclient.h:54
#define RDEBUG(fmt,...)
Definition radclient.h:53
#define RDEBUG_ENABLED()
Definition radclient.h:49
static rs_t * conf
Definition radsniff.c:53
fr_table_num_sorted_t const rcode_table[]
Definition rcode.c:35
rlm_rcode_t
Return codes indicating the result of the module call.
Definition rcode.h:40
@ RLM_MODULE_FAIL
Module failed, don't reply.
Definition rcode.h:44
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:43
@ RLM_MODULE_TIMEOUT
Module (or section) timed out.
Definition rcode.h:52
@ RLM_MODULE_NOT_SET
Error resolving rcode (should not be returned by modules).
Definition rcode.h:41
@ RLM_MODULE_NUMCODES
How many valid return codes there are.
Definition rcode.h:53
#define REQUEST_VERIFY(_x)
Definition request.h:309
@ REQUEST_TYPE_EXTERNAL
A request received on the wire.
Definition request.h:178
@ REQUEST_TYPE_INTERNAL
A request generated internally.
Definition request.h:179
@ REQUEST_TYPE_DETACHED
A request that was generated internally, but is now detached (not associated with a parent request....
Definition request.h:180
#define request_is_detachable(_x)
Definition request.h:187
@ REQUEST_DONE
Request has completed.
Definition request.h:89
@ REQUEST_STOP_PROCESSING
Request has been signalled to stop.
Definition request.h:88
void * request_data_get(request_t *request, void const *unique_ptr, int unique_int)
Get opaque data from a request.
#define request_data_add(_request, _unique_ptr, _unique_int, _opaque, _free_on_replace, _free_on_parent, _persist)
Add opaque data to a request_t.
fr_signal_t
Signals that can be generated/processed by request signal handlers.
Definition signal.h:38
@ FR_SIGNAL_CANCEL
Request has been cancelled.
Definition signal.h:40
@ FR_SIGNAL_DETACH
Request is being detached from its parent.
Definition signal.h:45
fr_aka_sim_id_type_t type
fr_pair_t * vp
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
An element in an arbitrarily ordered array of name to num mappings.
Definition table.h:57
#define talloc_zero_pooled_object(_ctx, _type, _num_subobjects, _total_subobjects_size)
Definition talloc.h:177
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
#define fr_time_delta_ispos(_a)
Definition time.h:290
#define fr_time_delta_eq(_a, _b)
Definition time.h:287
static fr_time_t fr_time_from_sec(time_t when)
Convert a time_t (wallclock time) to a fr_time_t (internal time)
Definition time.h:858
#define fr_time_sub(_a, _b)
Subtract one time from another.
Definition time.h:229
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
"server local" time.
Definition time.h:69
fr_time_t fr_timer_when(fr_timer_t *ev)
Internal timestamp representing when the timer should fire.
Definition timer.c:719
An event timer list.
Definition timer.c:50
A timer event.
Definition timer.c:84
#define fr_timer_in(...)
Definition timer.h:87
static fr_event_list_t * el
static unlang_result_t result
uint8_t required
Argument must be present, and non-empty.
Definition xlat.h:146
#define XLAT_ARGS(_list,...)
Populate local variables with value boxes from the input list.
Definition xlat.h:383
#define XLAT_ARG_PARSER_TERMINATOR
Definition xlat.h:170
xlat_action_t
Definition xlat.h:37
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
Definition for a single argument consumend by an xlat function.
Definition xlat.h:145
Private interpreter structures and functions.
fr_retry_state_t state
#define unlang_frame_perf_resume(_x)
unlang_result_t section_result
The aggregate result of executing all siblings in this section.
static void frame_pop(request_t *request, unlang_stack_t *stack)
Pop a stack frame, removing any associated dynamically allocated state.
static void frame_next(unlang_stack_t *stack, unlang_stack_frame_t *frame)
Advance to the next sibling instruction.
@ UNLANG_FRAME_FLAG_NONE
No flags.
static bool is_repeatable(unlang_stack_frame_t const *frame)
#define UNLANG_NEXT_SIBLING
unlang_result_t * p_result
Where to write the result of executing the current instruction.
static void repeatable_clear(unlang_stack_frame_t *frame)
static unlang_action_t unwind_to_depth(unlang_stack_t *stack, unsigned int to_depth)
Mark up frames as cancelled so they're immediately popped by the interpreter.
unlang_retry_t * retry
if the frame is being retried.
unlang_signal_t signal
function to call when signalling this stack frame
char const * debug_name
Printed in log messages when the node is executed.
void * state
Stack frame specialisations.
unlang_mod_actions_t actions
Priorities, etc. for the various return codes.
static void frame_state_init(unlang_stack_t *stack, unlang_stack_frame_t *frame)
Initialise memory and instruction for a frame when a new instruction is to be evaluated.
unlang_dump_t dump
Dump additional information about the frame state.
static unlang_t * unlang_group_to_generic(unlang_group_t const *p)
rindent_t indent
Indent level of the request when the frame was created.
fr_timer_t * ev
unlang_process_t interpret
Function to interpret the keyword.
unlang_result_t scratch_result
The result of executing the current instruction.
int depth
of this retry structure
request_t * request
CONF_ITEM * ci
used to generate this item
static bool is_top_frame(unlang_stack_frame_t const *frame)
static unlang_group_t * unlang_generic_to_group(unlang_t const *p)
static unlang_stack_frame_t * frame_current(request_t *request)
unlang_list_t children
static bool is_private_result(unlang_stack_frame_t const *frame)
char const * name
Unknown...
static bool is_break_point(unlang_stack_frame_t const *frame)
#define has_debug_braces(_thing)
@ UNLANG_TYPE_GROUP
Grouping section.
Definition unlang_priv.h:51
@ UNLANG_TYPE_MODULE
Module method.
Definition unlang_priv.h:49
unlang_t const * instruction
The unlang node we're evaluating.
static bool is_rcode_set(unlang_stack_frame_t const *frame)
static bool is_yielded(unlang_stack_frame_t const *frame)
static void top_frame_set(unlang_stack_frame_t *frame)
unlang_variable_t * variables
rarely used, so we don't usually need it
char const * name
Name of the keyword.
unlang_frame_action_t
Allows the frame evaluator to signal the interpreter.
Definition unlang_priv.h:90
@ UNLANG_FRAME_ACTION_POP
Pop the current frame, and check the next one further up in the stack for what to do next.
Definition unlang_priv.h:91
@ UNLANG_FRAME_ACTION_YIELD
Temporarily return control back to the caller on the C stack.
Definition unlang_priv.h:95
@ UNLANG_FRAME_ACTION_NEXT
Process the next instruction at this level.
Definition unlang_priv.h:94
@ UNLANG_FRAME_ACTION_RETRY
retry the current frame
Definition unlang_priv.h:93
static void yielded_set(unlang_stack_frame_t *frame)
static bool is_continue_point(unlang_stack_frame_t const *frame)
static void yielded_clear(unlang_stack_frame_t *frame)
#define unlang_frame_perf_yield(_x)
#define unlang_frame_perf_cleanup(_x)
unlang_t const * next
The next unlang node we will evaluate.
fr_dict_t * dict
our dictionary
static bool is_return_point(unlang_stack_frame_t const *frame)
unlang_process_t process
function to call for interpreting this stack frame
unlang_type_t type
The specialisation of this node.
unlang_frame_flag_t flag
Flags that mark up the frame for various things such as being the point where break,...
unlang_list_t * list
so we have fewer run-time dereferences
static bool is_unwinding(unlang_stack_frame_t const *frame)
Generic representation of a grouping.
An unlang operation.
A node in a graph of unlang_op_t (s) that we execute.
Our interpreter stack, as distinct from the C stack.
An unlang stack associated with a request.
fr_pair_t * fr_pair_list_tail(fr_pair_list_t const *list)
Get the tail of a valuepair list.
Definition pair_inline.c:55
fr_pair_t * fr_pair_list_prev(fr_pair_list_t const *list, fr_pair_t const *item))
Get the previous item in a valuepair list before a specific entry.
Definition pair_inline.c:82
#define RETRY_INIT
Definition retry.h:39
uint32_t mrc
Maximum retransmission count.
Definition retry.h:36
@ 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
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated string to a fr_value_box_t.
Definition value.c:4277
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Copy a string to to a fr_value_box_t.
Definition value.c:4498
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:642
int nonnull(2, 5))
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:653
static size_t char ** out
Definition value.h:1022
An xlat calling ctx.
Definition xlat_ctx.h:49
int xlat_func_args_set(xlat_t *x, xlat_arg_parser_t const args[])
Register the arguments of an xlat.
Definition xlat_func.c:363
xlat_t * xlat_func_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type)
Register an xlat function.
Definition xlat_func.c:216