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: c2ebfb2f39ec725ca0cf6606f263023ffffba313 $
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: c2ebfb2f39ec725ca0cf6606f263023ffffba313 $")
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 * @param[in] frame The current stack frame.
444 * @param[in] result from the previous action.
445 * @return
446 * - UNLANG_FRAME_ACTION_NEXT evaluate more instructions.
447 * - UNLANG_FRAME_ACTION_POP the final result has been calculated for this frame.
448 */
449static inline CC_HINT(always_inline)
451{
452 unlang_t const *instruction = frame->instruction;
453 unlang_stack_t *stack = request->stack;
454 unlang_result_t *frame_result = frame->p_result;
455
456 if (is_unwinding(frame)) {
457 RDEBUG4("** [%i] %s - unwinding frame", stack->depth, __FUNCTION__);
459 }
460
461 /*
462 * Don't calculate a new return code for the frame, just skip
463 * to the next instruction.
464 */
465 if (result->rcode == RLM_MODULE_NOT_SET) {
466 RDEBUG4("** [%i] %s - skipping frame, no result set",
467 stack->depth, __FUNCTION__);
469 }
470
471 fr_assert(MOD_ACTION_VALID(frame_result->priority));
472 fr_assert(MOD_ACTION_VALID(result->priority));
473
474 RDEBUG4("** [%i] %s - have (%s %s) frame or module returned (%s %s)",
475 stack->depth, __FUNCTION__,
476 fr_table_str_by_value(mod_rcode_table, frame_result->rcode, "<invalid>"),
477 mod_action_name[frame_result->priority],
478 fr_table_str_by_value(mod_rcode_table, result->rcode, "<invalid>"),
479 mod_action_name[result->priority]);
480
481 /*
482 * Update request->rcode if the instruction says we should
483 * We don't care about priorities for this.
484 *
485 * This is the field that's evaluated in unlang conditions
486 * like `if (ok)`.
487 */
488 if (is_rcode_set(frame) && (request->rcode != result->rcode)) {
489 RDEBUG3("Setting request->rcode to '%s'",
490 fr_table_str_by_value(rcode_table, result->rcode, "<INVALID>"));
491 request->rcode = result->rcode;
492 }
493
494 /*
495 * The array holds a default priority for this return
496 * code. Grab it in preference to any unset priority.
497 */
498 if (result->priority == MOD_ACTION_NOT_SET) {
499 result->priority = instruction->actions.actions[result->rcode];
500
501 fr_assert(MOD_ACTION_VALID(result->priority));
502
503 RDEBUG4("** [%i] %s - using default instruction priority for %s, %s",
504 stack->depth, __FUNCTION__,
505 fr_table_str_by_value(mod_rcode_table, result->rcode, "<invalid>"),
506 mod_action_name[result->priority]);
507 }
508
509 /*
510 * Deal with special priorities which indicate we need
511 * to do something in addition to modifying the frame's
512 * rcode.
513 */
514 switch (result->priority) {
515 /*
516 * The child's prioriy value indicates we
517 * should return from this frame.
518 */
520 RDEBUG4("** [%i] %s - action says to return with (%s %s)",
521 stack->depth, __FUNCTION__,
522 fr_table_str_by_value(mod_rcode_table, result->rcode, "<invalid>"),
523 mod_action_name[result->priority]);
524
525 *frame_result = UNLANG_RESULT_RCODE(result->rcode);
527
528 /*
529 * Reject means we should return, but
530 * with a reject rcode. This allows the
531 * user to change normally positive rcodes
532 * into negative ones.
533 *
534 * They could also just check the rcode
535 * after the module returns...
536 */
538 RDEBUG4("** [%i] %s - action says to return with (%s %s)",
539 stack->depth, __FUNCTION__,
541 mod_action_name[result->priority]);
542
543 *frame_result = UNLANG_RESULT_RCODE(RLM_MODULE_REJECT);
545
546 case MOD_ACTION_RETRY:
547 {
548 unlang_retry_t *retry = frame->retry;
549
550 RDEBUG4("** [%i] %s - action says to retry with",
551 stack->depth, __FUNCTION__);
552
553 /*
554 * If this is the first time doing the retry,
555 * then allocate the structure and set the timer.
556 */
557 if (!retry) {
558 MEM(frame->retry = retry = talloc_zero(stack, unlang_retry_t));
559
560 retry->request = request;
561 retry->depth = stack->depth;
562 retry->state = FR_RETRY_CONTINUE;
563 retry->count = 1;
564
565 /*
566 * Set a timer which automatically fires
567 * if there's a timeout. And parent it
568 * from the retry structure, so that the
569 * timer is automatically freed when the
570 * frame is cleaned up.
571 */
572 if (fr_time_delta_ispos(instruction->actions.retry.mrd)) {
573 if (fr_timer_in(retry, unlang_interpret_event_list(request)->tl, &retry->ev, instruction->actions.retry.mrd,
574 false, instruction_retry_handler, request) < 0) {
575 RPEDEBUG("Failed inserting retry event");
576 *frame_result = UNLANG_RESULT_RCODE(RLM_MODULE_FAIL);
577 goto finalize;
578 }
579 }
580
581 } else {
582 /*
583 * We've been told to stop doing retries,
584 * probably from a timeout.
585 */
586 if (retry->state != FR_RETRY_CONTINUE) goto timeout;
587
588 /*
589 * Clamp it at the maximum count.
590 */
591 if (instruction->actions.retry.mrc > 0) {
592 retry->count++;
593
594 if (retry->count >= instruction->actions.retry.mrc) {
595 retry->state = FR_RETRY_MRC;
596
597 REDEBUG("Retries hit max_rtx_count (%u) - returning 'timeout'", instruction->actions.retry.mrc);
598
599 timeout:
601 goto finalize;
602 }
603 }
604 }
605
606 RINDENT();
607 if (instruction->actions.retry.mrc) {
608 RDEBUG("... retrying (%u/%u)", retry->count, instruction->actions.retry.mrc);
609 } else {
610 RDEBUG("... retrying");
611 }
612 REXDENT();
613
614 talloc_free(frame->state);
616 frame_state_init(stack, frame); /* Don't change p_result */
618 default:
619 break;
620 }
621 }
622
623finalize:
624 /*
625 * We're higher or equal to previous priority, remember this
626 * return code and priority.
627 */
628 if (result->priority >= frame_result->priority) {
629 fr_assert(MOD_ACTION_VALID(result->priority));
630 fr_assert(MOD_ACTION_VALID(frame_result->priority));
631
632 RDEBUG4("** [%i] %s - overwriting existing result (%s %s) with higher priority (%s %s)",
633 stack->depth, __FUNCTION__,
634 fr_table_str_by_value(mod_rcode_table, frame_result->rcode, "<invalid>"),
635 mod_action_name[frame_result->priority],
636 fr_table_str_by_value(mod_rcode_table, result->rcode, "<invalid>"),
637 mod_action_name[result->priority]);
638 *frame->p_result = *result;
639 }
640
641 /*
642 * Determine if we should continue processing siblings
643 * or pop the frame ending the section.
644 */
646}
647
648/** Function called to merge inter-stack-frame results
649 *
650 * This function is called whenever a frame is popped from the stack.
651 *
652 * 'result' is the result from the frame being popped, and 'frame' is the next highest frame in the stack.
653 *
654 * The logic here is very similar to result_eval(), with two important differences:
655 * - The priority of the lower frame is ignored, and the default priority of the higher frame is used.
656 * Unless the higher frame's priority is MOD_ACTION_NOT_SET, in which case the lower frame's priority is used.
657 */
658static inline CC_HINT(always_inline)
660{
661 unlang_stack_t *stack = request->stack;
662 unlang_result_t our_result = *result;
663
664 fr_assert(MOD_ACTION_VALID(result->priority));
665
666 /*
667 * When a stack frame is being popped, the priority of the
668 * source (lower) frame is ignored, and the default priority
669 * of the destination (higher) frame is used.
670 *
671 * We could (easily) add support for preserving the priority
672 * from the lower frame, if the priority of the higher frame
673 * was MOD_ACTION_NOT_SET, but there are no concrete use
674 * cases for this yet.
675 */
676 if (result->rcode != RLM_MODULE_NOT_SET) {
677 fr_assert(MOD_ACTION_VALID(frame->instruction->actions.actions[result->rcode]));
678 our_result.priority = frame->instruction->actions.actions[result->rcode];
679 }
680
681 RDEBUG4("** [%i] %s - using instruction priority for higher frame (%s, %s)",
682 stack->depth, __FUNCTION__,
683 fr_table_str_by_value(mod_rcode_table, our_result.rcode, "<invalid>"),
684 mod_action_name[our_result.priority]);
685
686 return result_calculate(request, frame, &our_result);
687}
688
689static inline CC_HINT(always_inline) void instruction_done_debug(request_t *request, unlang_stack_frame_t *frame, unlang_t const *instruction)
690{
691 if (has_debug_braces(instruction)) {
692 REXDENT();
693
694 /*
695 * If we're at debug level 1, don't emit the closing
696 * brace as the opening brace wasn't emitted.
697 *
698 * Not a typo, we don't want to print the scratch_result
699 * here, aka the ones the section actually returned,
700 * vs the section result, which may have just been left
701 * at defaults.
702 */
704 RDEBUG("# %s %s%s%s", frame->instruction->debug_name,
705 frame->p_result == &frame->section_result ? "(" : "))",
707 frame->p_result == &frame->section_result ? "(" : "))");
708 } else {
709 RDEBUG2("} # %s %s%s%s", frame->instruction->debug_name,
710 frame->p_result == &frame->section_result ? "(" : "((",
712 frame->p_result == &frame->section_result ? ")" : "))");
713 }
714 }
715}
716
717/** Evaluates all the unlang nodes in a section
718 *
719 * This function interprets a list of unlang instructions at a given level using the same
720 * stack frame, and pushes additional frames onto the stack as needed.
721 *
722 * This function can be seen as moving horizontally.
723 *
724 * @param[in] request The current request.
725 * @param[in] frame The current stack frame.
726 * @return
727 * - UNLANG_FRAME_ACTION_NEXT evaluate more instructions in the current stack frame
728 * which may not be the same frame as when this function
729 * was called.
730 * - UNLANG_FRAME_ACTION_POP the final result has been calculated for this frame.
731 */
732static inline CC_HINT(always_inline)
734{
735 unlang_stack_t *stack = request->stack;
736 unlang_result_t *scratch = &frame->scratch_result;
737
738 /*
739 * Loop over all the instructions in this list.
740 */
741 while (frame->instruction) {
742 unlang_t const *instruction = frame->instruction;
745
747
748 fr_assert(instruction->debug_name != NULL); /* if this happens, all bets are off. */
749 fr_assert(unlang_ops[instruction->type].interpret != NULL);
750 fr_assert(frame->process != NULL);
751
752 REQUEST_VERIFY(request);
753
754 /*
755 * We're running this frame, so it can't possibly be yielded.
756 */
757 if (is_yielded(frame)) {
758 RDEBUG("%s - Resuming execution", instruction->debug_name);
759 yielded_clear(frame);
760 }
761
762#ifndef NDEBUG
763 /*
764 * Failure testing!
765 */
766 if (request->ins_max) {
767 request->ins_count++;
768
769 if (request->ins_count >= request->ins_max) {
770 RERROR("Failing request due to maximum instruction count %" PRIu64, request->ins_max);
771
773 }
774 }
775#endif
776
777 /*
778 * We're not re-entering this frame, this is the first
779 * time we're evaluating this instruction, so we should
780 * print debug braces and indent.
781 */
782 if (!is_repeatable(frame)) {
783 if (has_debug_braces(frame)) {
784 RDEBUG2("%s {", instruction->debug_name);
785 RINDENT();
786 }
787 /*
788 * Clear the repeatable flag so this frame
789 * won't get executed again unless it specifically
790 * requests it.
791 *
792 * The flag may still be set again during the
793 * process function to indicate that the frame
794 * should be evaluated again.
795 */
796 } else {
797 repeatable_clear(frame);
798 }
799
800 /*
801 * Execute an operation
802 */
803 RDEBUG4("** [%i] %s >> %s", stack->depth, __FUNCTION__,
804 unlang_ops[instruction->type].name);
805
807
808 /*
809 * catch plays games with the frame so we skip
810 * to the next catch section at a given depth,
811 * it's not safe to access frame->instruction
812 * after this point, and the cached instruction
813 * should be used instead.
814 */
815 ua = frame->process(&frame->scratch_result, request, frame);
816
818
819 RDEBUG4("** [%i] %s << %s (%s %s)", stack->depth, __FUNCTION__,
821 fr_table_str_by_value(mod_rcode_table, scratch->rcode, "<INVALID>"),
822 mod_action_name[scratch->priority]);
823
824 /*
825 * If the frame is cancelled we ignore the
826 * return code of the process function and
827 * pop the frame. We'll keep popping
828 * frames until we hit a non-cancelled frame
829 * or the top frame.
830 */
831 if (is_unwinding(frame)) goto calculate_result;
832
833 switch (ua) {
835 /*
836 * This marks all the cancellable
837 * frames with the unwind flag,
838 * and starts popping them.
839 */
842
843 /*
844 * The operation resulted in additional frames
845 * being pushed onto the stack, execution should
846 * now continue at the deepest frame.
847 */
849 fr_assert_msg(&stack->frame[stack->depth] > frame,
850 "Instruction %s returned UNLANG_ACTION_PUSHED_CHILD, "
851 "but stack depth was not increased",
852 instruction->name);
855
856 /*
857 * Yield control back to the scheduler, or whatever
858 * called the interpreter.
859 */
861 fr_assert_msg(&stack->frame[stack->depth] == frame,
862 "Instruction %s returned UNLANG_ACTION_YIELD, but pushed additional "
863 "frames for evaluation. Instruction should return UNLANG_ACTION_PUSHED_CHILD "
864 "instead", instruction->name);
866 yielded_set(frame);
867 RDEBUG4("** [%i] %s - yielding with current (%s %s)", stack->depth, __FUNCTION__,
868 fr_table_str_by_value(mod_rcode_table, scratch->rcode, "<invalid>"),
869 mod_action_name[scratch->priority]);
871
872 /*
873 * This action is intended to be returned by library
874 * functions. It reduces boilerplate.
875 */
877 /*
878 * Let unlang_calculate figure out if this is the final result
879 */
880 frame->scratch_result = UNLANG_RESULT_RCODE(RLM_MODULE_FAIL);
882
883 /*
884 * Instruction finished execution,
885 * check to see what we need to do next, and update
886 * the section rcode and priority.
887 */
889 calculate_result:
890 /*
891 * Merge in the scratch result _before_ printing
892 * out the rcode for the frame, so get what we'll
893 * actually return.
894 */
895 fa = result_calculate(request, frame, &frame->scratch_result);
896
897 instruction_done_debug(request, frame, instruction);
898
899 switch (fa) {
901 goto pop;
902
904 if (has_debug_braces(instruction)) {
905 REXDENT();
906 RDEBUG2("} # retrying the same section");
907 }
908 continue; /* with the current instruction */
909
910 default:
911 break;
912 }
913 break;
914
915 /*
916 * Execute the next instruction in this frame
917 */
919 if (has_debug_braces(instruction)) {
920 REXDENT();
921 RDEBUG2("}");
922 }
923 break;
924 } /* switch over return code from the interpret function */
925
926 frame_next(stack, frame);
927 }
928
929pop:
930 fr_assert(MOD_ACTION_VALID(frame->p_result->priority));
931
932 RDEBUG4("** [%i] %s - done current subsection with (%s %s), %s",
933 stack->depth, __FUNCTION__,
934 fr_table_str_by_value(mod_rcode_table, frame->p_result->rcode, "<invalid>"),
935 mod_action_name[frame->p_result->priority],
936 frame->p_result == &(frame->section_result) ? "will set higher frame rcode" : "will NOT set higher frame rcode (p_result)");
937
939}
940
941/** Run the interpreter for a current request
942 *
943 * This function runs the interpreter for a request. It deals with popping
944 * stack frames, and calaculating the final result for the frame.
945 *
946 * @param[in] request to run. If this is an internal request
947 * the request may be freed by the interpreter.
948 * @param[in] running Is the interpreter already running.
949 * @return The final request rcode.
950 */
951CC_HINT(hot) rlm_rcode_t unlang_interpret(request_t *request, bool running)
952{
953 unlang_stack_t *stack = request->stack;
954 unlang_interpret_t *intp = stack->intp;
955 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
956
957 /*
958 * This is needed to ensure that if a frame is marked
959 * for unwinding whilst the request is yielded, we
960 * unwind the cancelled frame correctly, instead of
961 * continuing.
962 */
964
965#ifndef NDEBUG
966 if (DEBUG_ENABLED5) DEBUG("###### unlang_interpret is starting");
968#endif
969
970 fr_assert(!unlang_request_is_scheduled(request)); /* if we're running it, it can't be scheduled */
971 fr_assert_msg(intp, "request has no interpreter associated");
972
973 RDEBUG4("** [%i] %s - interpret entered", stack->depth, __FUNCTION__);
974 if (!running) intp->funcs.resume(request, intp->uctx);
975
976 for (;;) {
977 fr_assert(stack->depth > 0);
979
980 RDEBUG4("** [%i] %s - frame action %s", stack->depth, __FUNCTION__,
982 switch (fa) {
983 next:
984 RDEBUG4("** [%i] %s - frame action next", stack->depth, __FUNCTION__);
986
987 case UNLANG_FRAME_ACTION_NEXT: /* Evaluate the current frame */
988 frame = &stack->frame[stack->depth];
989 fa = frame_eval(request, frame);
990 if (fa != UNLANG_FRAME_ACTION_POP) continue;
991
992 RDEBUG4("** [%i] %s - frame action %s", stack->depth, __FUNCTION__,
995
996 case UNLANG_FRAME_ACTION_POP: /* Pop this frame and check the one beneath it */
997 {
998 bool top_frame = is_top_frame(frame);
999 bool private_result = is_private_result(frame);
1000
1001 unlang_result_t section_result = frame->section_result; /* record the result of the frame before we pop it*/
1002
1003 DUMP_STACK;
1004
1005 /*
1006 * Triggers can run modules which pop, and then the stack is empty.
1007 */
1008 if (unlikely(stack->depth == 0)) {
1009 break;
1010 }
1011
1012 /*
1013 * Head on back up the stack
1014 */
1015 frame_pop(request, stack);
1016 RDEBUG4("** [%i] %s - frame popped", stack->depth + 1, __FUNCTION__);
1017
1018 /*
1019 * Update the stack frame
1020 */
1021 frame = &stack->frame[stack->depth];
1022 DUMP_STACK;
1023
1024 /*
1025 * Transition back to the C stack
1026 *
1027 * We still need to merge in the previous frame's result,
1028 * but we don't care about the action, as we're returning.
1029 */
1030 if (top_frame) {
1031 if (!private_result) result_calculate(request, frame, &section_result);
1032 break; /* stop */
1033 }
1034
1035 /*
1036 * Don't process the section result for a frame if
1037 * the result is being consumed by a module.
1038 */
1039 if (private_result) {
1041 /*
1042 * Merge lower frame into higher frame.
1043 *
1044 * this _MUST_ be done, even on resume, because the
1045 * section result needs to be updated for the frame
1046 * being resumed, in case it cares about the rcode
1047 * like transaction sections.
1048 */
1049 } else {
1050 fa = result_pop(request, frame, &section_result);
1051 }
1052
1053 /*
1054 * Resume a "foreach" loop, or a "load-balance" section
1055 * or anything else that needs to be checked on the way
1056 * back on up the stack. Here we just resume evaluating
1057 * the frame, we don't advance the instruction.
1058 */
1059 if (!is_unwinding(frame) && is_repeatable(frame)) goto next;
1060
1061 /*
1062 * Close out the section we entered earlier
1063 */
1064 instruction_done_debug(request, frame, frame->instruction);
1065
1067
1068 /*
1069 * If we're continuing after popping a frame
1070 * then we advance the instruction else we
1071 * end up executing the same code over and over...
1072 */
1073 switch (fa) {
1075 DEBUG4("** [%i] %s - continuing after subsection with (%s %s)",
1076 stack->depth, __FUNCTION__,
1079 frame_next(stack, frame);
1080 goto next;
1081
1082 /*
1083 * Else if we're really done with this frame
1084 * print some helpful debug...
1085 */
1086 default:
1087 RDEBUG4("** [%i] %s - done current subsection with (%s %s)",
1088 stack->depth, __FUNCTION__,
1091 continue;
1092 }
1093
1094 }
1095
1097 /* Cannot yield from a nested call to unlang_interpret */
1098 fr_assert(!running);
1099
1100 RDEBUG4("** [%i] %s - interpret yielding", stack->depth, __FUNCTION__);
1101 intp->funcs.yield(request, intp->uctx);
1102 return RLM_MODULE_NOT_SET;
1103
1104 case UNLANG_FRAME_ACTION_RETRY: /* retry the current frame */
1105 goto next;
1106 }
1107 break;
1108 }
1109
1110 fr_assert(stack->depth >= 0);
1111
1112 /*
1113 * We're at the top frame, return the result from the
1114 * stack, and get rid of the top frame.
1115 */
1116 RDEBUG4("** [%i] %s - interpret exiting, returning (%s)", stack->depth, __FUNCTION__,
1118
1119 DUMP_STACK;
1120
1121 {
1122 rlm_rcode_t rcode;
1123 /*
1124 * Record this now as the done functions may free
1125 * the request.
1126 *
1127 * Note: We use p_result here, as that's where the
1128 * result of evaluating the frame was written.
1129 * We don't use the section_result, as that may have
1130 * been left as its default value which may be 0
1131 * (reject).
1132 */
1133 rcode = frame->p_result->rcode;
1134
1135 /*
1136 * This usually means the request is complete in its
1137 * entirety.
1138 */
1139 if ((stack->depth == 0) && !running) unlang_interpret_request_done(request);
1140
1141 return rcode;
1142 }
1143}
1144
1146 .self = {
1148 .debug_name = "empty-group",
1149 .actions = {
1150 .actions = {
1160 },
1161 .retry = RETRY_INIT,
1162 },
1163 },
1164};
1165
1166/** Push a configuration section onto the request stack for later interpretation.
1167 *
1168 */
1170{
1171 unlang_t *instruction = NULL;
1172
1173 /*
1174 * Interpretable unlang instructions are stored as CONF_DATA
1175 * associated with sections.
1176 */
1177 if (cs) {
1178 instruction = (unlang_t *)cf_data_value(cf_data_find(cs, unlang_group_t, NULL));
1179 if (!instruction) {
1180 REDEBUG("Failed to find pre-compiled unlang for section %s %s { ... }",
1182 return -1;
1183 }
1184 }
1185
1186 return unlang_interpret_push_instruction(p_result, request, instruction, conf);
1187}
1188
1189/** Push an instruction onto the request stack for later interpretation.
1190 *
1191 */
1193{
1194 unlang_stack_t *stack = request->stack;
1195
1196 if (!instruction) {
1197 instruction = unlang_group_to_generic(&empty_group);
1198 }
1199
1200 /*
1201 * Push the default action, and the instruction which has
1202 * no action.
1203 */
1204 if (unlang_interpret_push(p_result, request, instruction, conf, UNLANG_NEXT_SIBLING) < 0) {
1205 return -1;
1206 }
1207
1208 RDEBUG4("** [%i] %s - substack begins", stack->depth, __FUNCTION__);
1209
1210 return 0;
1211}
1212
1213/** Allocate a new unlang stack
1214 *
1215 * @param[in] ctx to allocate stack in.
1216 * @return
1217 * - A new stack on success.
1218 * - NULL on OOM.
1219 */
1220void *unlang_interpret_stack_alloc(TALLOC_CTX *ctx)
1221{
1222 /*
1223 * Should never be evaluated, is just here to reduce
1224 * branches, so we don't need to check for frame->instruction.
1225 */
1226 static unlang_t unlang_instruction = {
1227 .debug_name = "top",
1228 .actions = DEFAULT_MOD_ACTIONS,
1229 };
1230
1232
1233 /*
1234 * If we have talloc_pooled_object allocate the
1235 * stack as a combined chunk/pool, with memory
1236 * to hold at mutable data for at least a quarter
1237 * of the maximum number of stack frames.
1238 *
1239 * Having a dedicated pool for mutable stack data
1240 * means we don't have memory fragmentations issues
1241 * as we would if request were used as the pool.
1242 *
1243 * This number is pretty arbitrary, but it seems
1244 * like too low level to make into a tuneable.
1245 */
1246 MEM(stack = talloc_zero_pooled_object(ctx, unlang_stack_t, UNLANG_STACK_MAX, 128)); /* 128 bytes per state */
1247 stack->frame[0].p_result = &stack->frame[0].section_result;
1248 stack->frame[0].scratch_result = UNLANG_RESULT_NOT_SET;
1249 stack->frame[0].section_result = UNLANG_RESULT_NOT_SET;
1250 stack->frame[0].instruction = &unlang_instruction; /* The top frame has no instruction, so we use a dummy one */
1251
1252 return stack;
1253}
1254
1255/** Indicate to the caller of the interpreter that this request is complete
1256 *
1257 */
1259{
1260 unlang_stack_t *stack = request->stack;
1261 unlang_interpret_t *intp;
1262
1263 if (!fr_cond_assert(stack != NULL)) return;
1264
1265 intp = stack->intp;
1266
1267 request->master_state = REQUEST_DONE;
1268 switch (request->type) {
1270 intp->funcs.done_external(request, frame_current(request)->section_result.rcode, intp->uctx);
1271 break;
1272
1274 intp->funcs.done_internal(request, frame_current(request)->section_result.rcode, intp->uctx);
1275 break;
1276
1278 intp->funcs.done_detached(request, frame_current(request)->section_result.rcode, intp->uctx); /* Callback will usually free the request */
1279 break;
1280 }
1281}
1282
1283/** Tell the interpreter to detach the request
1284 *
1285 * This function should not be called directly use unlang_interpret_signal(request, FR_SIGNAL_DETACH) instead.
1286 * This will ensure all frames on the request's stack receive the detach signal.
1287 */
1288static inline CC_HINT(always_inline)
1290{
1291 unlang_stack_t *stack = request->stack;
1292 unlang_interpret_t *intp;
1293
1294 if (!fr_cond_assert(stack != NULL)) return;
1295
1296 if (!request_is_detachable(request)) return;
1297
1298 intp = stack->intp;
1299
1300 intp->funcs.detach(request, intp->uctx);
1301}
1302
1304{
1305 unlang_stack_t *stack = request->stack;
1306 unlang_interpret_t *intp;
1307
1308 if (!fr_cond_assert(stack != NULL)) return;
1309
1310 intp = stack->intp;
1311
1312 request->priority = priority;
1313
1314 if (intp->funcs.prioritise) intp->funcs.prioritise(request, intp->uctx);
1315}
1316
1317/** Delivers a frame to one or more frames in the stack
1318 *
1319 * This is typically called via an "async" action, i.e. an action outside
1320 * of the normal processing of the request.
1321 *
1322 * For FR_SIGNAL_CANCEL all frames are marked up for cancellation, but the
1323 * cancellation is handled by the interpret.
1324 *
1325 * Other signal types are delivered immediately, inrrespecitve of whether
1326 * the request is currently being processed or not.
1327 *
1328 * Signaling stops at the "limit" frame. This is so that keywords
1329 * such as "timeout" and "limit" can signal frames *lower* than theirs
1330 * to stop, but then continue with their own work.
1331 *
1332 * @note It's better (clearer) to use one of the unwind_* functions
1333 * unless the entire request is being cancelled.
1334 *
1335 * @param[in] request The current request.
1336 * @param[in] action to signal.
1337 * @param[in] limit the frame at which to stop signaling.
1338 */
1339void unlang_stack_signal(request_t *request, fr_signal_t action, int limit)
1340{
1341 unlang_stack_frame_t *frame;
1342 unlang_stack_t *stack = request->stack;
1343 int i, depth = stack->depth;
1344
1345 (void)talloc_get_type_abort(request, request_t); /* Check the request hasn't already been freed */
1346
1347 fr_assert(stack->depth >= 1);
1348
1349 /*
1350 * Does not complete the unwinding here, just marks
1351 * up the frames for unwinding. The request must
1352 * be marked as runnable to complete the cancellation.
1353 */
1354 if (action == FR_SIGNAL_CANCEL) unwind_to_depth(stack, limit);
1355
1356 /*
1357 * Walk back up the stack, calling signal handlers
1358 * to cancel any pending operations and free/release
1359 * any resources.
1360 *
1361 * There may be multiple resumption points in the
1362 * stack, as modules can push xlats and function
1363 * calls.
1364 *
1365 * Note: Slightly confusingly, a cancellation signal
1366 * can still be delivered to a frame that is not
1367 * cancellable, but the frame won't be automatically
1368 * unwound.
1369 */
1370 for (i = depth; i >= limit; i--) {
1371 frame = &stack->frame[i];
1372 if (frame->signal) {
1373 frame->signal(request, frame, action);
1374
1375 /*
1376 * Once the cancellation function has been
1377 * called, the frame is no longer in a state
1378 * where it can accept further signals.
1379 */
1380 if (action == FR_SIGNAL_CANCEL) frame->signal = NULL;
1381 }
1382 }
1383}
1384
1385/** Send a signal (usually stop) to a request
1386 *
1387 * This is typically called via an "async" action, i.e. an action
1388 * outside of the normal processing of the request.
1389 *
1390 * @note This does NOT immediately stop the request, it just deliveres
1391 * signals, and in the case of a cancel, marks up frames for unwinding
1392 * and adds it to the runnable queue if it's yielded.
1393 *
1394 * @note This function should be safe to call anywhere.
1395 *
1396 * @param[in] request The current request.
1397 * @param[in] action to signal.
1398 */
1400{
1401 unlang_stack_t *stack = request->stack;
1402
1403 switch (action) {
1404 case FR_SIGNAL_DETACH:
1405 /*
1406 * Ensure the request is able to be detached
1407 * else don't signal.
1408 */
1409 if (!fr_cond_assert(request_is_detachable(request))) return;
1410 break;
1411
1412 default:
1413 break;
1414 }
1415
1416 /*
1417 * Requests that haven't been run through the interpreter
1418 * yet should have a stack depth of zero, so we don't
1419 * need to do anything.
1420 */
1421 if (!stack || stack->depth == 0) return;
1422
1423 unlang_stack_signal(request, action, 1);
1424
1425 switch (action) {
1426 case FR_SIGNAL_CANCEL:
1427 {
1428 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1429 /*
1430 * Let anything that cares, know that the
1431 * request was forcefully stopped.
1432 */
1433 request->master_state = REQUEST_STOP_PROCESSING;
1434
1435 /*
1436 * Give cancelled requests the highest priority
1437 * to get them to release resources ASAP.
1438 */
1439 unlang_interpret_request_prioritise(request, UINT32_MAX);
1440
1441 /*
1442 * If the request is yielded, mark it as runnable
1443 *
1444 * If the request was _not_ cancelled, it means
1445 * it's not cancellable, and we need to let the
1446 * request progress normally.
1447 *
1448 * A concrete example of this, is the parent of
1449 * subrequests, which must not continue until
1450 * the subrequest is done.
1451 */
1452 if (stack && is_yielded(frame) && is_unwinding(frame) && !unlang_request_is_scheduled(request)) {
1454 }
1455 }
1456 break;
1457
1458 case FR_SIGNAL_DETACH:
1459 /*
1460 * Cleanup any cross-request pointers, and mark the
1461 * request as detached. When the request completes it
1462 * should by automatically freed.
1463 */
1465 break;
1466
1467 default:
1468 break;
1469 }
1470}
1471
1473{
1474 unlang_retry_t *retry = talloc_get_type_abort(ctx, unlang_retry_t);
1475 request_t *request = talloc_get_type_abort(retry->request, request_t);
1476
1477 RDEBUG("retry timeout reached, signalling interpreter to cancel.");
1478
1479 /*
1480 * Signal all lower frames to exit.
1481 */
1482 unlang_stack_signal(request, FR_SIGNAL_CANCEL, retry->depth);
1483
1484 retry->state = FR_RETRY_MRD;
1486}
1487
1489{
1490 request_t *request = talloc_get_type_abort(ctx, request_t);
1491
1492 RDEBUG("Maximum timeout reached, signalling interpreter to stop the request.");
1493
1494 /*
1495 * Stop the entire request.
1496 */
1498}
1499
1500
1501/** Set a timeout for a request.
1502 *
1503 * The timeout is associated with the current stack frame.
1504 *
1505 */
1507{
1508 unlang_stack_t *stack = request->stack;
1509 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1510 unlang_retry_t *retry;
1511 TALLOC_CTX *frame_ctx;
1512
1513 fr_assert(!frame->retry);
1515
1516 frame_ctx = frame->state;
1517 if (!frame_ctx) frame_ctx = stack;
1518
1519 frame->retry = retry = talloc_zero(frame_ctx, unlang_retry_t);
1520 if (!frame->retry) return -1;
1521
1522 retry->request = request;
1523 retry->depth = stack->depth;
1524 retry->state = FR_RETRY_CONTINUE;
1525 retry->count = 1;
1526
1527 return fr_timer_in(retry, unlang_interpret_event_list(request)->tl, &retry->ev, timeout,
1528 false, instruction_timeout_handler, request);
1529}
1530
1531
1532/** Return the depth of the request's stack
1533 *
1534 */
1536{
1537 unlang_stack_t *stack = request->stack;
1538
1539 return stack->depth;
1540}
1541
1542/** Get the last instruction result OR the last frame that was popped
1543 *
1544 * @param[in] request The current request.
1545 * @return the current rcode for the frame.
1546 */
1548{
1549 return frame_current(request)->p_result->rcode;
1550}
1551
1552/** Get the last instruction priority OR the last frame that was popped
1553 *
1554 * @param[in] request The current request.
1555 * @return the current rcode for the frame.
1556 */
1561
1562/** Get the last instruction result OR the last frame that was popped
1563 *
1564 * @param[in] request The current request.
1565 * @return the current result for the frame.
1566 */
1568{
1569 return frame_current(request)->p_result;
1570}
1571
1572/** Return whether a request is currently scheduled
1573 *
1574 */
1576{
1577 unlang_stack_t *stack = request->stack;
1578 unlang_interpret_t *intp = stack->intp;
1579
1580 return intp->funcs.scheduled(request, intp->uctx);
1581}
1582
1583/** Return whether a request has been cancelled
1584 */
1586{
1587 return (request->master_state == REQUEST_STOP_PROCESSING);
1588}
1589
1590/** Return whether a request has been marked done
1591 */
1593{
1594 return (request->master_state == REQUEST_DONE);
1595}
1596
1597/** Check if a request as resumable.
1598 *
1599 * @param[in] request The current request.
1600 * @return
1601 * - true if the request is resumable (i.e. has yielded)
1602 * - false if the request is not resumable (i.e. has not yielded)
1603 */
1605{
1606 unlang_stack_t *stack = request->stack;
1607 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1608
1609 return is_yielded(frame);
1610}
1611
1612/** Mark a request as resumable.
1613 *
1614 * It's not called "unlang_interpret", because it doesn't actually
1615 * resume the request, it just schedules it for resumption.
1616 *
1617 * @note that this schedules the request for resumption. It does not immediately
1618 * start running the request.
1619 *
1620 * @param[in] request The current request.
1621 */
1623{
1624 unlang_stack_t *stack = request->stack;
1625 unlang_interpret_t *intp = stack->intp;
1626 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1627
1628 bool scheduled = unlang_request_is_scheduled(request);
1629
1630 /*
1631 * The request hasn't yielded, OR it's already been
1632 * marked as runnable. Don't do anything.
1633 *
1634 * The IO code, or children have no idea where they're
1635 * being called from. They just ask to mark the parent
1636 * resumable when they're done. So we have to check here
1637 * if this request is resumable.
1638 *
1639 * If the parent called the child directly, then the
1640 * parent hasn't yielded, so it isn't resumable. When
1641 * the child is done, the parent will automatically
1642 * continue running. We therefore don't need to insert
1643 * the parent into the backlog.
1644 *
1645 * Multiple child request may also mark a parent request
1646 * runnable, before the parent request starts running.
1647 */
1648 if (!is_yielded(frame) || scheduled) {
1649 RDEBUG3("Not marking request %s as runnable due to%s%s",
1650 request->name,
1651 !is_yielded(frame) ?
1652 " it not being yielded " : "", scheduled ? " it already being scheduled" : "");
1653 return;
1654 }
1655
1656 RDEBUG3("Interpreter - Request marked as runnable");
1657
1658 intp->funcs.mark_runnable(request, intp->uctx);
1659}
1660
1661/** Get a talloc_ctx which is valid only for this frame
1662 *
1663 * @param[in] request The current request.
1664 * @return
1665 * - a TALLOC_CTX which is valid only for this stack frame
1666 */
1668{
1669 unlang_stack_t *stack = request->stack;
1670 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
1671
1672 if (frame->state) return (TALLOC_CTX *)frame->state;
1673
1674 /*
1675 * If the frame doesn't ordinarily have a
1676 * state, assume the caller knows what it's
1677 * doing and allocate one.
1678 */
1679 return (TALLOC_CTX *)(frame->state = talloc_new(request));
1680}
1681
1683 { .required = false, .single = true, .type = FR_TYPE_TIME_DELTA },
1685};
1686
1687static xlat_action_t unlang_cancel_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
1688 UNUSED xlat_ctx_t const *xctx,
1689 request_t *request, fr_value_box_list_t *args);
1690
1691/** Signal the request to stop executing
1692 *
1693 * The request can't be running at this point because we're in the event
1694 * loop. This means the request is always in a consistent state when
1695 * the timeout event fires, even if that's state is waiting on I/O.
1696 */
1698{
1699 request_t *request = talloc_get_type_abort(uctx, request_t);
1700
1701 RDEBUG2("Request canceled by dynamic timeout");
1702 /*
1703 * Cleans up the memory allocated to hold
1704 * the pointer, not the event itself.
1705 */
1706 talloc_free(request_data_get(request, (void *)unlang_cancel_xlat, 0));
1707
1709}
1710
1711/** Allows a request to dynamically alter its own lifetime
1712 *
1713 * %cancel(<timeout>)
1714 *
1715 * If timeout is 0, then the request is immediately cancelled.
1716 */
1718 UNUSED xlat_ctx_t const *xctx,
1719 request_t *request, fr_value_box_list_t *args)
1720{
1721 fr_value_box_t *timeout;
1723 fr_timer_t **ev_p, **ev_p_og;
1724 fr_value_box_t *vb;
1725 fr_time_t when = fr_time_from_sec(0); /* Invalid clang complaints if we don't set this */
1726
1727 XLAT_ARGS(args, &timeout);
1728
1729 /*
1730 * No timeout means cancel immediately, so yield allowing
1731 * the interpreter to run the event we added to cancel
1732 * the request.
1733 *
1734 * We call unlang_xlat_yield to keep the interpreter happy
1735 * as it expects to see a resume function set.
1736 */
1737 if (!timeout || fr_time_delta_eq(timeout->vb_time_delta, fr_time_delta_from_sec(0))) {
1739 return XLAT_ACTION_DONE;
1740 }
1741
1742 /*
1743 * First see if we already have a timeout event
1744 * that was previously added by this xlat.
1745 */
1746 ev_p = ev_p_og = request_data_get(request, (void *)unlang_cancel_xlat, 0);
1747 if (ev_p) {
1748 if (*ev_p) when = fr_timer_when(*ev_p); /* *ev_p should never be NULL, really... */
1749 } else {
1750 /*
1751 * Must not be parented from the request
1752 * as this is freed by request data.
1753 */
1754 MEM(ev_p = talloc_zero(NULL, fr_timer_t *));
1755 }
1756
1757 if (unlikely(fr_timer_in(ev_p, el->tl, ev_p,
1758 timeout ? timeout->vb_time_delta : fr_time_delta_from_sec(0),
1759 false, unlang_cancel_event, request) < 0)) {
1760 RPERROR("Failed inserting cancellation event");
1761 talloc_free(ev_p);
1762 return XLAT_ACTION_FAIL;
1763 }
1764 if (unlikely(request_data_add(request, (void *)unlang_cancel_xlat, 0,
1765 UNCONST(fr_timer_t **, ev_p), true, true, false) < 0)) {
1766 RPERROR("Failed associating cancellation event with request");
1767 talloc_free(ev_p);
1768 return XLAT_ACTION_FAIL;
1769 }
1770
1771 if (ev_p_og) {
1772 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
1773
1774 /*
1775 * Return how long before the previous
1776 * cancel event would have fired.
1777 *
1778 * This can be useful for doing stacked
1779 * cancellations in policy.
1780 */
1781 vb->vb_time_delta = fr_time_sub(when, unlang_interpret_event_list(request)->tl->time());
1783 }
1784
1785 /*
1786 * No value if this is the first cleanup event
1787 */
1788 return XLAT_ACTION_DONE;
1789}
1790
1792 { .required = true, .single = true, .type = FR_TYPE_STRING },
1794};
1795
1796/** Get information about the interpreter state
1797 *
1798 * @ingroup xlat_functions
1799 */
1801 UNUSED xlat_ctx_t const *xctx,
1802 request_t *request, fr_value_box_list_t *in)
1803{
1804 unlang_stack_t *stack = request->stack;
1805 int depth = stack->depth;
1806 unlang_stack_frame_t *frame;
1807 unlang_t const *instruction;
1808 fr_value_box_t *arg = fr_value_box_list_head(in);
1809 char const *fmt = arg->vb_strvalue;
1810 fr_value_box_t *vb;
1811
1812 MEM(vb = fr_value_box_alloc_null(ctx));
1813
1814 /*
1815 * Find the correct stack frame.
1816 */
1817 while (*fmt == '.') {
1818 if (depth <= 1) {
1819 if (fr_value_box_bstrndup(vb, vb, NULL, "<underflow>", 11, false) < 0) {
1820 error:
1821 talloc_free(vb);
1822 return XLAT_ACTION_FAIL;
1823 }
1824 goto finish;
1825 }
1826
1827 fmt++;
1828 depth--;
1829 }
1830
1831 /*
1832 * Get the current instruction.
1833 */
1834 frame = &stack->frame[depth];
1835 instruction = frame->instruction;
1836
1837 /*
1838 * Nothing there...
1839 */
1840 if (!instruction) {
1841 talloc_free(vb);
1842 return XLAT_ACTION_DONE;
1843 }
1844
1845 /*
1846 * How deep the current stack is.
1847 */
1848 if (strcmp(fmt, "depth") == 0) {
1849 fr_value_box_int32(vb, NULL, depth, false);
1850 goto finish;
1851 }
1852
1853 /*
1854 * The current module
1855 */
1856 if (strcmp(fmt, "module") == 0) {
1857 if (fr_value_box_strdup(vb, vb, NULL, request->module, false) < 0) goto error;
1858
1859 goto finish;
1860 }
1861
1862 /*
1863 * Name of the instruction.
1864 */
1865 if (strcmp(fmt, "name") == 0) {
1866 if (fr_value_box_bstrndup(vb, vb, NULL, instruction->name,
1867 strlen(instruction->name), false) < 0) goto error;
1868 goto finish;
1869 }
1870
1871 /*
1872 * The request processing stage.
1873 */
1874 if (strcmp(fmt, "processing_stage") == 0) {
1875 if (fr_value_box_strdup(vb, vb, NULL, request->component, false) < 0) goto error;
1876
1877 goto finish;
1878 }
1879
1880 /*
1881 * The current return code.
1882 */
1883 if (strcmp(fmt, "rcode") == 0) {
1884 if (fr_value_box_strdup(vb, vb, NULL, fr_table_str_by_value(rcode_table, request->rcode, "<INVALID>"), false) < 0) goto error;
1885
1886 goto finish;
1887 }
1888
1889 /*
1890 * The virtual server handling the request
1891 */
1892 if (strcmp(fmt, "server") == 0) {
1893 if (!unlang_call_current(request)) goto finish;
1894
1895 if (fr_value_box_strdup(vb, vb, NULL, cf_section_name2(unlang_call_current(request)), false) < 0) goto error;
1896
1897 goto finish;
1898 }
1899
1900 /*
1901 * Unlang instruction type.
1902 */
1903 if (strcmp(fmt, "type") == 0) {
1904 if (fr_value_box_bstrndup(vb, vb, NULL, unlang_ops[instruction->type].name,
1905 strlen(unlang_ops[instruction->type].name), false) < 0) goto error;
1906
1907 goto finish;
1908 }
1909
1910 /*
1911 * All of the remaining things need a CONF_ITEM.
1912 */
1913 if (!instruction->ci) {
1914 if (fr_value_box_bstrndup(vb, vb, NULL, "<INVALID>", 3, false) < 0) goto error;
1915
1916 goto finish;
1917 }
1918
1919 /*
1920 * Line number of the current section.
1921 */
1922 if (strcmp(fmt, "line") == 0) {
1923 fr_value_box_int32(vb, NULL, cf_lineno(instruction->ci), false);
1924
1925 goto finish;
1926 }
1927
1928 /*
1929 * Filename of the current section.
1930 */
1931 if (strcmp(fmt, "filename") == 0) {
1932 if (fr_value_box_strdup(vb, vb, NULL, cf_filename(instruction->ci), false) < 0) goto error;
1933
1934 goto finish;
1935 }
1936
1937finish:
1938 if (vb->type != FR_TYPE_NULL) {
1940 } else {
1941 talloc_free(vb);
1942 }
1943
1944 return XLAT_ACTION_DONE;
1945}
1946
1947/** Initialize a unlang compiler / interpret.
1948 *
1949 * @param[in] ctx to bind lifetime of the interpret to.
1950 * Shouldn't be any free order issues here as
1951 * the interpret itself has no state.
1952 * But event loop should be stopped before
1953 * freeing the interpret.
1954 * @param[in] el for any timer or I/O events.
1955 * @param[in] funcs Callbacks to used to communicate request
1956 * state to our owner.
1957 * @param[in] uctx Data to pass to callbacks.
1958 */
1960 fr_event_list_t *el, unlang_request_func_t *funcs, void *uctx)
1961{
1962 unlang_interpret_t *intp;
1963
1964 fr_assert(funcs->init_internal);
1965
1966 fr_assert(funcs->done_internal);
1967 fr_assert(funcs->done_detached);
1968 fr_assert(funcs->done_external);
1969
1970 fr_assert(funcs->detach);
1971 fr_assert(funcs->yield);
1972 fr_assert(funcs->resume);
1973 fr_assert(funcs->mark_runnable);
1974 fr_assert(funcs->scheduled);
1975
1976 MEM(intp = talloc(ctx, unlang_interpret_t));
1977 *intp = (unlang_interpret_t){
1978 .el = el,
1979 .funcs = *funcs,
1980 .uctx = uctx
1981 };
1982
1983 return intp;
1984}
1985
1986/** Discard the bottom most frame on the request's stack
1987 *
1988 * This is used for cleaning up after errors. i.e. the caller
1989 * uses a push function, and experiences an error and needs to
1990 * remove the frame that was just pushed.
1991 */
1993{
1994 frame_pop(request, request->stack);
1995}
1996
1997/** Set a specific interpreter for a request
1998 *
1999 */
2001{
2002 unlang_stack_t *stack = request->stack;
2003 stack->intp = intp;
2004}
2005
2006/** Get the interpreter set for a request
2007 *
2008 */
2010{
2011 unlang_stack_t *stack = request->stack;
2012
2013 return stack->intp;
2014}
2015
2016/** Get the event list for the current interpreter
2017 *
2018 */
2020{
2021 unlang_stack_t *stack = request->stack;
2022
2023 if (!stack->intp) return NULL;
2024
2025 return stack->intp->el;
2026}
2027
2028/** Set the default interpreter for this thread
2029 *
2030 */
2032{
2033 if (intp) (void)talloc_get_type_abort(intp, unlang_interpret_t);
2034
2035 intp_thread_default = intp;
2036}
2037
2038/** Get the default interpreter for this thread
2039 *
2040 * This allows detached requests to be executed asynchronously
2041 */
2043{
2044 if (!intp_thread_default) return NULL;
2045
2046 return talloc_get_type_abort(intp_thread_default, unlang_interpret_t);
2047}
2048
2050{
2051 xlat_t *xlat;
2052 /*
2053 * Should be void, but someone decided not to register multiple xlats
2054 * breaking the convention we use everywhere else in the server...
2055 */
2056 if (unlikely((xlat = xlat_func_register(ctx, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID)) == NULL)) return -1;
2058
2059 if (unlikely((xlat = xlat_func_register(ctx, "cancel", unlang_cancel_xlat, FR_TYPE_VOID)) == NULL)) return -1;
2061
2062 return 0;
2063}
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:1750
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:241
#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:861
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:1800
void unlang_interpret_request_prioritise(request_t *request, uint32_t priority)
Definition interpret.c:1303
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:1289
rlm_rcode_t unlang_interpret(request_t *request, bool running)
Run the interpreter for a current request.
Definition interpret.c:951
bool unlang_request_is_done(request_t const *request)
Return whether a request has been marked done.
Definition interpret.c:1592
static void stack_dump_body(request_t *request, bool with_actions)
Definition interpret.c:233
static unlang_group_t empty_group
Definition interpret.c:1145
unlang_result_t * unlang_interpret_result(request_t *request)
Get the last instruction result OR the last frame that was popped.
Definition interpret.c:1567
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:1992
int unlang_interpret_set_timeout(request_t *request, fr_time_delta_t timeout)
Set a timeout for a request.
Definition interpret.c:1506
void unlang_interpret_request_done(request_t *request)
Indicate to the caller of the interpreter that this request is complete.
Definition interpret.c:1258
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:733
void unlang_interpret_set(request_t *request, unlang_interpret_t *intp)
Set a specific interpreter for a request.
Definition interpret.c:2000
unlang_interpret_t * unlang_interpret_get(request_t *request)
Get the interpreter set for a request.
Definition interpret.c:2009
int unlang_interpret_stack_depth(request_t *request)
Return the depth of the request's stack.
Definition interpret.c:1535
void unlang_interpret_mark_runnable(request_t *request)
Mark a request as resumable.
Definition interpret.c:1622
static xlat_arg_parser_t const unlang_interpret_xlat_args[]
Definition interpret.c:1791
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:1667
bool unlang_request_is_scheduled(request_t const *request)
Return whether a request is currently scheduled.
Definition interpret.c:1575
int unlang_interpret_init_global(TALLOC_CTX *ctx)
Definition interpret.c:2049
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:2042
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:1220
void unlang_interpret_set_thread_default(unlang_interpret_t *intp)
Set the default interpreter for this thread.
Definition interpret.c:2031
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:1557
static void instruction_retry_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
Definition interpret.c:1472
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:1959
static void instruction_timeout_handler(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
Definition interpret.c:1488
bool unlang_request_is_cancelled(request_t const *request)
Return whether a request has been cancelled.
Definition interpret.c:1585
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:1192
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:1697
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1399
static xlat_arg_parser_t const unlang_cancel_xlat_args[]
Definition interpret.c:1682
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:1169
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:450
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:1604
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:689
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:659
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:1339
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:1717
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:1547
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:2019
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:1824
#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:720
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
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
Definition unlang_priv.h:99
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:89
@ 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:90
@ UNLANG_FRAME_ACTION_YIELD
Temporarily return control back to the caller on the C stack.
Definition unlang_priv.h:94
@ UNLANG_FRAME_ACTION_NEXT
Process the next instruction at this level.
Definition unlang_priv.h:93
@ UNLANG_FRAME_ACTION_RETRY
retry the current frame
Definition unlang_priv.h:92
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:4368
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:4589
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:643
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:654
static size_t char ** out
Definition value.h:1023
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