The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
xlat.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: a90773df51b5a15d578ad6dadb3c2c227bdb70a3 $
19 *
20 * @file unlang/xlat.c
21 * @brief Integration between the unlang interpreter and xlats
22 *
23 * @copyright 2018 The FreeRADIUS server project
24 * @copyright 2018 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
25 */
26RCSID("$Id: a90773df51b5a15d578ad6dadb3c2c227bdb70a3 $")
27
28#include <freeradius-devel/server/base.h>
29
30#include <ctype.h>
31#include <freeradius-devel/unlang/mod_action.h>
32#include <freeradius-devel/unlang/xlat_priv.h>
33#include <freeradius-devel/util/debug.h>
34#include "unlang_priv.h" /* Fixme - Should create a proper semi-public interface for the interpret */
35
36/** State of an xlat expansion
37 *
38 * State of one level of nesting within an xlat expansion.
39 */
40typedef struct {
41 TALLOC_CTX *ctx; //!< to allocate boxes and values in.
42 TALLOC_CTX *event_ctx; //!< for temporary events
43 xlat_exp_head_t const *head; //!< of the xlat list
44 xlat_exp_t const *exp; //!< current one we're evaluating
45 fr_dcursor_t values; //!< Values aggregated so far.
46
47 rindent_t indent; //!< indentation
48
49 void *env_data; //!< Expanded per call environment tmpls.
50 /*
51 * For func and alternate
52 */
53 fr_value_box_list_t out; //!< Head of the result of a nested
54 ///< expansion.
55 xlat_func_t resume; //!< called on resume
56 xlat_func_signal_t signal; //!< called on signal
57 fr_signal_t sigmask; //!< Signals to block
58 void *rctx; //!< for resume / signal
59
60 unlang_result_t *p_result; //!< If set, where to record the result
61 ///< of the execution.
63
64/** Wrap an #fr_timer_t providing data needed for unlang events
65 *
66 */
67typedef struct {
68 request_t *request; //!< Request this event pertains to.
69 int fd; //!< File descriptor to wait on.
70 fr_unlang_xlat_timeout_t timeout; //!< Function to call on timeout.
71 fr_unlang_xlat_fd_event_t fd_read; //!< Function to call when FD is readable.
72 fr_unlang_xlat_fd_event_t fd_write; //!< Function to call when FD is writable.
73 fr_unlang_xlat_fd_event_t fd_error; //!< Function to call when FD has errored.
74 xlat_inst_t *inst; //!< xlat instance data.
75 xlat_thread_inst_t *thread; //!< Thread specific xlat instance.
76 void const *rctx; //!< rctx data to pass to callbacks.
77 fr_timer_t *ev; //!< Event in this worker's event heap.
79
80typedef struct {
82 xlat_inst_t *inst; //!< xlat instance data.
83 xlat_thread_inst_t *thread; //!< Thread specific xlat instance.
84
85 fr_unlang_xlat_retry_t retry_cb; //!< callback to run on timeout
86 void *rctx; //!< rctx data to pass to timeout callback
87
88 fr_timer_t *ev; //!< retry timer just for this xlat
89 fr_retry_t retry; //!< retry timers, etc.
91
92/** Frees an unlang event, removing it from the request's event loop
93 *
94 * @param[in] ev The event to free.
95 *
96 * @return 0
97 */
99{
100 FR_TIMER_DELETE(&(ev->ev));
101
102 if (ev->fd >= 0) {
104 }
105
106 return 0;
107}
108
109/** Call the callback registered for a timeout event
110 *
111 * @param[in] tl the event timer was inserted into.
112 * @param[in] now The current time, as held by the event_list.
113 * @param[in] uctx unlang_module_event_t structure holding callbacks.
114 *
115 */
117{
118 unlang_xlat_event_t *ev = talloc_get_type_abort(uctx, unlang_xlat_event_t);
119
120 /*
121 * If the timeout's fired then the xlat must necessarily
122 * be yielded, so it's fine to pass in its rctx.
123 *
124 * It should be able to free the rctx if it wants to.
125 * We never free it explicitly, and instead rely on
126 * talloc parenting.
127 */
128 ev->timeout(XLAT_CTX(ev->inst->data,
129 ev->thread->data,
130 NULL,
131 ev->thread->mctx, NULL,
132 UNCONST(void *, ev->rctx)),
133 ev->request, now);
134
135 /* Remove old references from the request */
136 talloc_free(ev);
137}
138
139/** Add a timeout for an xlat handler
140 *
141 * @note The timeout is automatically removed when the xlat is cancelled or resumed.
142 *
143 * @param[in] request the request
144 * @param[in] callback to run when the timeout hits
145 * @param[in] rctx passed to the callback
146 * @param[in] when when the timeout fires
147 * @return
148 * - <0 on error
149 * - 0 on success
150 */
152 fr_unlang_xlat_timeout_t callback, void const *rctx, fr_time_t when)
153{
154 unlang_stack_t *stack = request->stack;
155 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
157 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
158
159 fr_assert(stack->depth > 0);
161
162 if (!state->event_ctx) MEM(state->event_ctx = talloc_zero(state, bool));
163
164 MEM(ev = talloc_zero(state->event_ctx, unlang_xlat_event_t));
165 ev->request = request;
166 ev->fd = -1;
167 ev->timeout = callback;
168 fr_assert(state->exp->type == XLAT_FUNC);
169 ev->inst = state->exp->call.inst;
171 ev->rctx = rctx;
172
173 if (fr_timer_at(request, unlang_interpret_event_list(request)->tl,
174 &ev->ev, when,
175 false, unlang_xlat_event_timeout_handler, ev) < 0) {
176 RPEDEBUG("Failed inserting event");
177 talloc_free(ev);
178 return -1;
179 }
180
181 talloc_set_destructor(ev, _unlang_xlat_event_free);
182
183 return 0;
184}
185
186/** Push a pre-compiled xlat onto the stack for evaluation
187 *
188 * @param[in] ctx To allocate value boxes and values in.
189 * @param[out] p_result If set, rcodes and priorities will be written here and
190 * not evaluated by the unlang interpreter.
191 * @param[out] out Where to write the result of the expansion.
192 * @param[in] request to push xlat onto.
193 * @param[in] xlat head of list
194 * @param[in] node to evaluate.
195 * @param[in] top_frame Set to UNLANG_TOP_FRAME if the interpreter should return.
196 * Set to UNLANG_SUB_FRAME if the interprer should continue.
197 * @return
198 * - 0 on success.
199 * - -1 on failure.
200 */
201static int unlang_xlat_push_internal(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out,
202 request_t *request, xlat_exp_head_t const *xlat, xlat_exp_t *node, bool top_frame)
203{
204 /** Static instruction for performing xlat evaluations
205 *
206 */
207 static unlang_t xlat_instruction = {
209 .name = "xlat",
210 .debug_name = "xlat",
211 .actions = {
212 .actions = {
213 [RLM_MODULE_REJECT] = 0,
214 [RLM_MODULE_FAIL] = MOD_ACTION_RETURN, /* Exit out of nested levels */
215 [RLM_MODULE_OK] = 0,
216 [RLM_MODULE_HANDLED] = 0,
217 [RLM_MODULE_INVALID] = 0,
220 [RLM_MODULE_NOOP] = 0,
222 },
223 .retry = RETRY_INIT,
224 },
225 };
226
228 unlang_stack_t *stack = request->stack;
230
231 /*
232 * Push a new xlat eval frame onto the stack
233 */
234 if (unlang_interpret_push(p_result, request, &xlat_instruction,
235 FRAME_CONF(RLM_MODULE_NOT_SET, top_frame), UNLANG_NEXT_STOP) < 0) return -1;
236 frame = &stack->frame[stack->depth];
237
238 /*
239 * Allocate its state, and setup a cursor for the xlat nodes
240 */
241 MEM(frame->state = state = talloc_zero(stack, unlang_frame_state_xlat_t));
242 state->head = xlat;
243 state->exp = node;
244 state->p_result = p_result;
245 state->ctx = ctx;
246
247 if (node) switch (node->type) {
248 case XLAT_GROUP:
249 case XLAT_BOX:
250 break;
251
252 case XLAT_TMPL:
253 if (tmpl_is_data(node->vpt)) break;
255
256 default:
257 RDEBUG("| %s", node->fmt);
258 break;
259 }
260
261 /*
262 * Initialise the input and output lists
263 */
264 fr_dcursor_init(&state->values, fr_value_box_list_dlist_head(out));
265 fr_value_box_list_init(&state->out);
266
267 return 0;
268}
269
270/** Push a pre-compiled xlat onto the stack for evaluation
271 *
272 * @param[in] ctx To allocate value boxes and values in.
273 * @param[out] out Where to write the result of the expansion.
274 * @param[in] request to push xlat onto.
275 * @param[in] xlat to evaluate.
276 * @param[in] top_frame Set to UNLANG_TOP_FRAME if the interpreter should return.
277 * Set to UNLANG_SUB_FRAME if the interprer should continue.
278 * @return
279 * - 0 on success.
280 * - -1 on failure.
281 */
282int unlang_xlat_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out,
283 request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
284{
286
287 return unlang_xlat_push_internal(ctx, p_result, out, request, xlat, xlat_exp_head(xlat), top_frame);
288}
289
290/** Push a pre-compiled xlat onto the stack for evaluation
291 *
292 * @param[in] ctx To allocate value boxes and values in.
293 * @param[out] p_result If set, and execution succeeds, true will be written
294 * here. If execution fails, false will be written.
295 * @param[out] out Where to write the result of the expansion.
296 * @param[in] request to push xlat onto.
297 * @param[in] node to evaluate. Only this node will be evaluated.
298 * @return
299 * - 0 on success.
300 * - -1 on failure.
301 */
302int unlang_xlat_push_node(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out,
303 request_t *request, xlat_exp_t *node)
304{
305 return unlang_xlat_push_internal(ctx, p_result, out, request, NULL, node, UNLANG_TOP_FRAME);
306}
307
309{
310 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
311 xlat_action_t xa;
312 xlat_exp_head_t const *child = NULL;
313
314 /*
315 * If the xlat is a function with a method_env, expand it before calling the function.
316 */
317 if ((state->exp->type == XLAT_FUNC) && state->exp->call.inst->call_env && !state->env_data) {
318 unlang_action_t ua = call_env_expand(state, request, NULL, &state->env_data,
319 state->exp->call.inst->call_env);
320 switch (ua) {
322 goto fail;
323
327
328 default:
329 break;
330 }
331 }
332
333 xa = xlat_frame_eval_repeat(state->ctx, &state->values, &child,
334 request, state->head, &state->exp, state->env_data, &state->out);
335 switch (xa) {
337 fr_assert(child);
338
339 repeatable_set(frame); /* Was cleared by the interpreter */
340
341 /*
342 * Clear out the results of any previous expansions
343 * at this level. A frame may be used to evaluate
344 * multiple sibling nodes.
345 */
346 fr_value_box_list_talloc_free(&state->out);
347 if (unlang_xlat_push(state->ctx, p_result, &state->out, request, child, false) < 0) {
348 REXDENT();
350 }
352
354 repeatable_set(frame); /* Call the xlat code on the way back down */
356
358 if (!state->resume) {
359 RWDEBUG("Missing call to unlang_xlat_yield()");
360 goto fail;
361 }
362 repeatable_set(frame);
363 return UNLANG_ACTION_YIELD;
364
365 case XLAT_ACTION_DONE:
366 p_result->rcode = RLM_MODULE_OK;
367 REXDENT();
369
370 case XLAT_ACTION_FAIL:
371 fail:
372 p_result->rcode = RLM_MODULE_FAIL;
373 REXDENT();
375
376 default:
377 fr_assert(0);
378 goto fail;
379 }
380}
381
382/** Stub function for calling the xlat interpreter
383 *
384 * Calls the xlat interpreter and translates its wants and needs into
385 * unlang_action_t codes.
386 */
388{
389 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
390 xlat_action_t xa;
391 xlat_exp_head_t const *child = NULL;
392
393 RINDENT_SAVE(state, request);
394 RINDENT();
395
396 xa = xlat_frame_eval(state->ctx, &state->values, &child, request, state->head, &state->exp);
397 switch (xa) {
399 fr_assert(child);
400
402
403 /*
404 * Clear out the results of any previous expansions
405 * at this level. A frame may be used to evaluate
406 * multiple sibling nodes.
407 */
408 fr_value_box_list_talloc_free(&state->out);
409 if (unlang_xlat_push(state->ctx, NULL, &state->out, request, child, false) < 0) {
410 RINDENT_RESTORE(request, state);
412 }
414
416 repeatable_set(frame); /* Call the xlat code on the way back down */
418
420 if (!state->resume) {
421 RWDEBUG("Missing call to unlang_xlat_yield()");
422 goto fail;
423 }
424 repeatable_set(frame);
425 return UNLANG_ACTION_YIELD;
426
427 case XLAT_ACTION_DONE:
428 p_result->rcode = RLM_MODULE_OK;
429 RINDENT_RESTORE(request, state);
431
432 case XLAT_ACTION_FAIL:
433 fail:
434 p_result->rcode = RLM_MODULE_FAIL;
435 RINDENT_RESTORE(request, state);
437
438 default:
439 fr_assert(0);
440 goto fail;
441 }
442}
443
444/** Send a signal (usually stop) to a request that's running an xlat expansions
445 *
446 * This is typically called via an "async" action, i.e. an action
447 * outside of the normal processing of the request.
448 *
449 * If there is no #xlat_func_signal_t callback defined, the action is ignored.
450 *
451 * @param[in] request The current request.
452 * @param[in] frame The current stack frame.
453 * @param[in] action What the request should do (the type of signal).
454 */
456{
457 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
458
459 /*
460 * Delete timers, etc. when the xlat is cancelled.
461 */
462 if (action == FR_SIGNAL_CANCEL) {
463 TALLOC_FREE(state->event_ctx);
464 }
465
466 if (!state->signal || (state->sigmask & action)) return;
467
468 xlat_signal(state->signal, state->exp, request, state->rctx, action);
469}
470
471/** Called when we're ready to resume processing the request
472 *
473 * @param[in] p_result the result of the xlat function.
474 * - RLM_MODULE_OK on success.
475 * - RLM_MODULE_FAIL on failure.
476 * @param[in] request to resume processing.
477 * @param[in] frame the current stack frame.
478 * @return
479 * - UNLANG_ACTION_YIELD if additional asynchronous
480 * operations need to be performed.
481 * - UNLANG_ACTION_CALCULATE_RESULT if done.
482 */
484{
485 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
486 xlat_action_t xa;
487 xlat_exp_head_t const *child = NULL;
488
489 fr_assert(state->resume != NULL);
490
491 /*
492 * Delete timers, etc. when the xlat is resumed.
493 */
494 TALLOC_FREE(state->event_ctx);
495
496 xa = xlat_frame_eval_resume(state->ctx, &state->values, &child, request, state->head, &state->exp,
497 &state->out, state->resume, state->rctx);
498 switch (xa) {
500 repeatable_set(frame);
501 return UNLANG_ACTION_YIELD;
502
503 case XLAT_ACTION_DONE:
504 p_result->rcode = RLM_MODULE_OK;
505 RINDENT_RESTORE(request, state);
507
509 repeatable_set(frame);
511
513 fr_assert(child);
514
515 repeatable_set(frame); /* Was cleared by the interpreter */
516
517 /*
518 * Clear out the results of any previous expansions
519 * at this level. A frame may be used to evaluate
520 * multiple sibling nodes.
521 */
522 fr_value_box_list_talloc_free(&state->out);
523 if (unlang_xlat_push(state->ctx, state->p_result, &state->out, request, child, false) < 0) {
524 RINDENT_RESTORE(request, state);
526 }
528
529 case XLAT_ACTION_FAIL:
530 p_result->rcode = RLM_MODULE_FAIL;
531 RINDENT_RESTORE(request, state);
533 /* DON'T SET DEFAULT */
534 }
535
536 fr_assert(0); /* Garbage xlat action */
537
538 p_result->rcode = RLM_MODULE_FAIL;
539 RINDENT_RESTORE(request, state);
541}
542
543/** Yield a request back to the interpreter from within a module
544 *
545 * This passes control of the request back to the unlang interpreter, setting
546 * callbacks to execute when the request is 'signalled' asynchronously, or whatever
547 * timer or I/O event the module was waiting for occurs.
548 *
549 * @note The module function which calls #unlang_module_yield should return control
550 * of the C stack to the unlang interpreter immediately after calling #unlang_xlat_yield.
551 * A common pattern is to use ``return unlang_xlat_yield(...)``.
552 *
553 * @param[in] request The current request.
554 * @param[in] resume Called on unlang_interpret_mark_runnable().
555 * @param[in] signal Called on unlang_action().
556 * @param[in] sigmask Signals to block.
557 * @param[in] rctx to pass to the callbacks.
558 * @return always returns XLAT_ACTION_YIELD
559 */
561 xlat_func_t resume, xlat_func_signal_t signal, fr_signal_t sigmask,
562 void *rctx)
563{
564 unlang_stack_t *stack = request->stack;
565 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
566 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
567
569
570 /*
571 * Over-ride whatever functions were there before.
572 */
573 state->resume = resume;
574 state->signal = signal;
575 state->sigmask = sigmask;
576 state->rctx = rctx;
577
578 return XLAT_ACTION_YIELD;
579}
580
581/** Frees an unlang event, removing it from the request's event loop
582 *
583 * @param[in] ev The event to free.
584 *
585 * @return 0
586 */
588{
589 FR_TIMER_DELETE(&(ev->ev));
590
591 return 0;
592}
593
594/** Call the callback registered for a timeout event
595 *
596 * @param[in] tl the event timer was inserted into.
597 * @param[in] now The current time, as held by the event_list.
598 * @param[in] uctx unlang_module_event_t structure holding callbacks.
599 *
600 */
602{
603 unlang_xlat_retry_t *ev = talloc_get_type_abort(uctx, unlang_xlat_retry_t);
604 request_t *request = ev->request;
605
606 switch (fr_retry_next(&ev->retry, now)) {
608 /*
609 * Call the module retry handler, with the state of the retry. On MRD / MRC, the
610 * module is made runnable again, and the "resume" function is called.
611 */
612 ev->retry_cb(XLAT_CTX(ev->inst->data,
613 ev->thread->data,
614 NULL,
615 ev->thread->mctx, NULL,
616 UNCONST(void *, ev->rctx)),
617 ev->request, &ev->retry);
618
619 /*
620 * Reset the timer.
621 */
622 if (fr_timer_at(ev, unlang_interpret_event_list(request)->tl, &ev->ev, ev->retry.next,
623 false, unlang_xlat_event_retry_handler, request) < 0) {
624 RPEDEBUG("Failed inserting event");
625 talloc_free(ev);
627 }
628 return;
629
630 case FR_RETRY_MRD:
631 RDEBUG("Reached max_rtx_duration (%pVs > %pVs) - sending timeout",
633 break;
634
635 case FR_RETRY_MRC:
636 RDEBUG("Reached max_rtx_count %u- sending timeout",
637 ev->retry.config->mrc);
638 break;
639 }
640
641 /*
642 * Run the retry handler on MRD / MRC, too.
643 */
644 ev->retry_cb(XLAT_CTX(ev->inst->data,
645 ev->thread->data,
646 NULL,
647 ev->thread->mctx, NULL,
648 UNCONST(void *, ev->rctx)),
649 ev->request, &ev->retry);
650
651 /*
652 * On final timeout, always mark the request as runnable.
653 */
654 talloc_free(ev);
656}
657
658
659/** Yield a request back to the interpreter, with retries
660 *
661 * This passes control of the request back to the unlang interpreter, setting
662 * callbacks to execute when the request is 'signalled' asynchronously, or when
663 * the retry timer hits.
664 *
665 * @note The module function which calls #unlang_module_yield_to_retry should return control
666 * of the C stack to the unlang interpreter immediately after calling #unlang_module_yield_to_retry.
667 * A common pattern is to use ``return unlang_module_yield_to_retry(...)``.
668 *
669 * @param[in] request The current request.
670 * @param[in] resume Called on unlang_interpret_mark_runnable().
671 * @param[in] retry Called on when a retry timer hits
672 * @param[in] signal Called on unlang_action().
673 * @param[in] sigmask Set of signals to block.
674 * @param[in] rctx to pass to the callbacks.
675 * @param[in] retry_cfg to set up the retries
676 * @return
677 * - XLAT_ACTION_YIELD on success
678 * - XLAT_ACTION_FAIL on failure
679 */
681 xlat_func_signal_t signal, fr_signal_t sigmask, void *rctx,
682 fr_retry_config_t const *retry_cfg)
683{
684 unlang_stack_t *stack = request->stack;
685 unlang_stack_frame_t *frame = &stack->frame[stack->depth];
687 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
688
689 fr_assert(stack->depth > 0);
691
692 if (!state->event_ctx) MEM(state->event_ctx = talloc_zero(state, bool));
693
694 MEM(ev = talloc_zero(state->event_ctx, unlang_xlat_retry_t));
695
696 ev->request = request;
697 fr_assert(state->exp->type == XLAT_FUNC);
698 ev->inst = state->exp->call.inst;
700 ev->retry_cb = retry;
701 ev->rctx = rctx;
702
703 fr_retry_init(&ev->retry, fr_time(), retry_cfg);
704
705 if (fr_timer_at(request, unlang_interpret_event_list(request)->tl,
706 &ev->ev, ev->retry.next,
707 false, unlang_xlat_event_retry_handler, ev) < 0) {
708 RPEDEBUG("Failed inserting event");
709 talloc_free(ev);
710 return XLAT_ACTION_FAIL;
711 }
712
713 talloc_set_destructor(ev, _unlang_xlat_retry_free);
714
715 return unlang_xlat_yield(request, resume, signal, sigmask, rctx);
716}
717
718/** Evaluate a "pure" (or not impure) xlat
719 *
720 * @param[in] ctx To allocate value boxes and values in.
721 * @param[out] out Where to write the result of the expansion.
722 * @param[in] request to push xlat onto.
723 * @param[in] xlat to evaluate.
724 * @return
725 * - 0 on success.
726 * - -1 on failure.
727 */
728int unlang_xlat_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat)
729{
730 unlang_result_t result = { .rcode = RLM_MODULE_NOT_SET, .priority = MOD_ACTION_NOT_SET };
731
732 if (xlat->flags.impure_func) {
733 fr_strerror_const("Expansion requires async operations");
734 return -1;
735 }
736
737 if (unlang_xlat_push(ctx, &result, out, request, xlat, UNLANG_TOP_FRAME) < 0) return -1;
738
740
741 if (!XLAT_RESULT_SUCCESS(&result)) return -1;
742
743 return 0;
744}
745
746/** Evaluate a "pure" (or not impure) xlat
747 *
748 * @param[in] ctx To allocate value boxes and values in.
749 * @param[out] vb output value-box
750 * @param[in] type expected type
751 * @param[in] enumv enum for type
752 * @param[in] request to push xlat onto.
753 * @param[in] xlat to evaluate.
754 * @return
755 * - 0 on success.
756 * - -1 on failure.
757 */
758int unlang_xlat_eval_type(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t type, fr_dict_attr_t const *enumv, request_t *request, xlat_exp_head_t const *xlat)
759{
760 fr_value_box_t *src;
761 fr_value_box_list_t list;
762
764 fr_strerror_const("Invalid type for output of evaluation");
765 return -1;
766 }
767
768 fr_value_box_list_init(&list);
769
770 if (unlang_xlat_eval(ctx, &list, request, xlat) < 0) return -1;
771
772 fr_value_box_init(vb, type, NULL, false);
773
774 switch (type) {
775 default:
776 /*
777 * Take only the first entry from the list.
778 */
779 src = fr_value_box_list_head(&list);
780 if (!src) {
781 fr_strerror_const("Expression returned no results");
782 fail:
783 fr_value_box_list_talloc_free(&list);
784 return -1;
785 }
786
787 if (fr_value_box_cast(ctx, vb, type, enumv, src) < 0) goto fail;
788 fr_value_box_list_talloc_free(&list);
789 break;
790
791 case FR_TYPE_STRING:
792 case FR_TYPE_OCTETS:
793 /*
794 * No output: create an empty string.
795 *
796 * The "concat in place" function returns an error for empty input, which is arguably not
797 * what we want to do here.
798 */
799 if (fr_value_box_list_empty(&list)) {
800 break;
801 }
802
803 if (fr_value_box_list_concat_in_place(ctx, vb, &list, type, FR_VALUE_BOX_LIST_FREE_BOX, false, SIZE_MAX) < 0) {
804 goto fail;
805 }
806 break;
807 }
808
809 return 0;
810}
811
813{
814 unlang_frame_state_xlat_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_xlat_t);
815 xlat_exp_t const *exp = state->exp;
816
817 if (exp) RDEBUG("expression %s", exp->fmt);
818}
819/** Register xlat operation with the interpreter
820 *
821 */
823{
825 &(unlang_op_t){
826 .name = "xlat_eval",
827 .interpret = unlang_xlat,
828 .signal = unlang_xlat_signal,
829 .dump = unlang_xlat_dump,
830 .frame_state_size = sizeof(unlang_frame_state_xlat_t),
831 .frame_state_type = "unlang_frame_state_xlat_t",
832 });
833}
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_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
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSID(id)
Definition build.h:485
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
Definition build.h:324
#define UNUSED
Definition build.h:317
unlang_action_t call_env_expand(TALLOC_CTX *ctx, request_t *request, call_env_result_t *env_result, void **env_data, call_env_t const *call_env)
Initialise the expansion of a call environment.
Definition call_env.c:310
#define fr_dcursor_init(_cursor, _head)
Initialise a cursor.
Definition dcursor.h:710
#define MEM(x)
Definition debug.h:36
@ FR_EVENT_FILTER_IO
Combined filter for read/write functions/.
Definition event.h:84
rlm_rcode_t unlang_interpret(request_t *request, bool running)
Run the interpreter for a current request.
Definition interpret.c:941
void unlang_interpret_mark_runnable(request_t *request)
Mark a request as resumable.
Definition interpret.c:1616
int unlang_interpret_push(unlang_result_t *result_p, request_t *request, unlang_t const *instruction, unlang_frame_conf_t const *conf, bool do_next_sibling)
Push a new frame onto the stack.
Definition interpret.c:283
fr_event_list_t * unlang_interpret_event_list(request_t *request)
Get the event list for the current interpreter.
Definition interpret.c:2013
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:153
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
#define UNLANG_TOP_FRAME
Definition interpret.h:36
#define UNLANG_REQUEST_RUNNING
Definition interpret.h:42
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:443
#define RWDEBUG(fmt,...)
Definition log.h:361
#define RINDENT_SAVE(_x, _request)
Save indentation for later restoral.
Definition log.h:388
#define RINDENT_RESTORE(_request, _x)
Definition log.h:392
#define RPEDEBUG(fmt,...)
Definition log.h:376
#define RINDENT()
Indent R* messages by one level.
Definition log.h:430
void unlang_register(int type, unlang_op_t *op)
Register an operation with the interpreter.
Definition base.c:63
talloc_free(reap)
int fr_event_fd_delete(fr_event_list_t *el, int fd, fr_event_filter_t filter)
Remove a file descriptor from the event loop.
Definition event.c:1203
static char * stack[MAX_STACK]
Definition radmin.c:159
fr_type_t
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_OCTETS
Raw octets.
@ MOD_ACTION_NOT_SET
Definition mod_action.h:40
@ MOD_ACTION_RETURN
Definition mod_action.h:43
#define fr_assert(_expr)
Definition rad_assert.h:38
#define RDEBUG(fmt,...)
Definition radclient.h:53
@ RLM_MODULE_INVALID
The module considers the request invalid.
Definition rcode.h:45
@ RLM_MODULE_OK
The module is OK, continue.
Definition rcode.h:43
@ RLM_MODULE_FAIL
Module failed, don't reply.
Definition rcode.h:42
@ RLM_MODULE_DISALLOW
Reject the request (user is locked out).
Definition rcode.h:46
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:41
@ RLM_MODULE_NOTFOUND
User not found.
Definition rcode.h:47
@ RLM_MODULE_UPDATED
OK (pairs modified).
Definition rcode.h:49
@ RLM_MODULE_NOT_SET
Error resolving rcode (should not be returned by modules).
Definition rcode.h:52
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:48
@ RLM_MODULE_HANDLED
The module handled the request, so stop.
Definition rcode.h:44
#define tmpl_is_data(vpt)
Definition tmpl.h:206
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_aka_sim_id_type_t type
#define fr_time()
Allow us to arbitrarily manipulate time.
Definition state_test.c:8
#define talloc_get_type_abort_const
Definition talloc.h:287
#define fr_time_sub(_a, _b)
Subtract one time from another.
Definition time.h:229
"server local" time.
Definition time.h:69
An event timer list.
Definition timer.c:50
A timer event.
Definition timer.c:84
#define FR_TIMER_DELETE(_ev_p)
Definition timer.h:103
#define fr_timer_at(...)
Definition timer.h:81
fr_timer_t * ev
retry timer just for this xlat
Definition xlat.c:88
int unlang_xlat_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat)
Evaluate a "pure" (or not impure) xlat.
Definition xlat.c:728
xlat_exp_head_t const * head
of the xlat list
Definition xlat.c:43
TALLOC_CTX * ctx
to allocate boxes and values in.
Definition xlat.c:41
fr_unlang_xlat_fd_event_t fd_read
Function to call when FD is readable.
Definition xlat.c:71
int unlang_xlat_eval_type(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t type, fr_dict_attr_t const *enumv, request_t *request, xlat_exp_head_t const *xlat)
Evaluate a "pure" (or not impure) xlat.
Definition xlat.c:758
static void unlang_xlat_dump(request_t *request, unlang_stack_frame_t *frame)
Definition xlat.c:812
TALLOC_CTX * event_ctx
for temporary events
Definition xlat.c:42
xlat_func_signal_t signal
called on signal
Definition xlat.c:56
static void unlang_xlat_event_retry_handler(UNUSED fr_timer_list_t *tl, fr_time_t now, void *uctx)
Call the callback registered for a timeout event.
Definition xlat.c:601
unlang_result_t * p_result
If set, where to record the result of the execution.
Definition xlat.c:60
xlat_thread_inst_t * thread
Thread specific xlat instance.
Definition xlat.c:83
static int _unlang_xlat_event_free(unlang_xlat_event_t *ev)
Frees an unlang event, removing it from the request's event loop.
Definition xlat.c:98
void * rctx
for resume / signal
Definition xlat.c:58
int unlang_xlat_push_node(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_t *node)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:302
xlat_action_t unlang_xlat_yield_to_retry(request_t *request, xlat_func_t resume, fr_unlang_xlat_retry_t retry, xlat_func_signal_t signal, fr_signal_t sigmask, void *rctx, fr_retry_config_t const *retry_cfg)
Yield a request back to the interpreter, with retries.
Definition xlat.c:680
fr_dcursor_t values
Values aggregated so far.
Definition xlat.c:45
fr_value_box_list_t out
Head of the result of a nested expansion.
Definition xlat.c:53
fr_timer_t * ev
Event in this worker's event heap.
Definition xlat.c:77
xlat_action_t unlang_xlat_yield(request_t *request, xlat_func_t resume, xlat_func_signal_t signal, fr_signal_t sigmask, void *rctx)
Yield a request back to the interpreter from within a module.
Definition xlat.c:560
xlat_func_t resume
called on resume
Definition xlat.c:55
fr_unlang_xlat_retry_t retry_cb
callback to run on timeout
Definition xlat.c:85
fr_retry_t retry
retry timers, etc.
Definition xlat.c:89
request_t * request
Request this event pertains to.
Definition xlat.c:68
int fd
File descriptor to wait on.
Definition xlat.c:69
static unlang_action_t unlang_xlat(UNUSED unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Stub function for calling the xlat interpreter.
Definition xlat.c:387
fr_unlang_xlat_timeout_t timeout
Function to call on timeout.
Definition xlat.c:70
request_t * request
Definition xlat.c:81
static void unlang_xlat_event_timeout_handler(UNUSED fr_timer_list_t *tl, fr_time_t now, void *uctx)
Call the callback registered for a timeout event.
Definition xlat.c:116
static int unlang_xlat_push_internal(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat, xlat_exp_t *node, bool top_frame)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:201
xlat_inst_t * inst
xlat instance data.
Definition xlat.c:74
int unlang_xlat_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:282
xlat_inst_t * inst
xlat instance data.
Definition xlat.c:82
void * rctx
rctx data to pass to timeout callback
Definition xlat.c:86
fr_unlang_xlat_fd_event_t fd_write
Function to call when FD is writable.
Definition xlat.c:72
static unlang_action_t unlang_xlat_repeat(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Definition xlat.c:308
fr_signal_t sigmask
Signals to block.
Definition xlat.c:57
static int _unlang_xlat_retry_free(unlang_xlat_retry_t *ev)
Frees an unlang event, removing it from the request's event loop.
Definition xlat.c:587
int unlang_xlat_timeout_add(request_t *request, fr_unlang_xlat_timeout_t callback, void const *rctx, fr_time_t when)
Add a timeout for an xlat handler.
Definition xlat.c:151
rindent_t indent
indentation
Definition xlat.c:47
void * env_data
Expanded per call environment tmpls.
Definition xlat.c:49
static unlang_action_t unlang_xlat_resume(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Called when we're ready to resume processing the request.
Definition xlat.c:483
void const * rctx
rctx data to pass to callbacks.
Definition xlat.c:76
static void unlang_xlat_signal(request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)
Send a signal (usually stop) to a request that's running an xlat expansions.
Definition xlat.c:455
void unlang_xlat_init(void)
Register xlat operation with the interpreter.
Definition xlat.c:822
xlat_exp_t const * exp
current one we're evaluating
Definition xlat.c:44
fr_unlang_xlat_fd_event_t fd_error
Function to call when FD has errored.
Definition xlat.c:73
xlat_thread_inst_t * thread
Thread specific xlat instance.
Definition xlat.c:75
State of an xlat expansion.
Definition xlat.c:40
Wrap an fr_timer_t providing data needed for unlang events.
Definition xlat.c:67
void * data
Thread specific instance data.
Definition xlat.h:94
xlat_thread_inst_t * xlat_thread_instance_find(xlat_exp_t const *node)
Retrieve xlat/thread specific instance data.
Definition xlat_inst.c:405
void(* fr_unlang_xlat_fd_event_t)(xlat_ctx_t const *xctx, request_t *request, int fd)
A callback when the FD is ready for reading.
Definition xlat.h:212
#define XLAT_RESULT_SUCCESS(_p_result)
Definition xlat.h:503
void(* xlat_func_signal_t)(xlat_ctx_t const *xctx, request_t *request, fr_signal_t action)
A callback when the request gets a fr_signal_t.
Definition xlat.h:243
void(* fr_unlang_xlat_retry_t)(xlat_ctx_t const *xctx, request_t *request, fr_retry_t const *retry)
A callback when the the timeout occurs.
Definition xlat.h:199
xlat_action_t(* xlat_func_t)(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
xlat callback function
Definition xlat.h:232
void * data
xlat node specific instance data.
Definition xlat.h:78
void(* fr_unlang_xlat_timeout_t)(xlat_ctx_t const *xctx, request_t *request, fr_time_t fired)
A callback when the the timeout occurs.
Definition xlat.h:185
uint8_t impure_func
xlat contains an impure function
Definition xlat.h:111
xlat_action_t
Definition xlat.h:37
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
@ XLAT_ACTION_YIELD
An xlat function pushed a resume frame onto the stack.
Definition xlat.h:42
@ XLAT_ACTION_PUSH_UNLANG
An xlat function pushed an unlang frame onto the unlang stack.
Definition xlat.h:39
@ XLAT_ACTION_PUSH_CHILD
A deeper level of nesting needs to be evaluated.
Definition xlat.h:38
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
module_ctx_t const * mctx
A synthesised module calling ctx containing module global and thread instance data.
Definition xlat.h:96
Instance data for an xlat expansion node.
Definition xlat.h:71
Thread specific instance data for xlat expansion node.
Definition xlat.h:85
Private interpreter structures and functions.
void * state
Stack frame specialisations.
#define UNLANG_NEXT_STOP
Definition unlang_priv.h:97
@ UNLANG_TYPE_XLAT
Represents one level of an xlat expansion.
Definition unlang_priv.h:79
static void frame_repeat(unlang_stack_frame_t *frame, unlang_process_t process)
Mark the current stack frame up for repeat, and set a new process function.
unlang_t const * instruction
The unlang node we're evaluating.
static void repeatable_set(unlang_stack_frame_t *frame)
unlang_process_t process
function to call for interpreting this stack frame
unlang_type_t type
The specialisation of this node.
An unlang operation.
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_retry_state_t fr_retry_next(fr_retry_t *r, fr_time_t now)
Initialize a retransmission counter.
Definition retry.c:108
void fr_retry_init(fr_retry_t *r, fr_time_t now, fr_retry_config_t const *config)
Initialize a retransmission counter.
Definition retry.c:36
fr_time_t start
when we started the retransmission
Definition retry.h:53
#define RETRY_INIT
Definition retry.h:39
uint32_t mrc
Maximum retransmission count.
Definition retry.h:36
fr_retry_config_t const * config
master configuration
Definition retry.h:52
@ FR_RETRY_MRC
reached maximum retransmission count
Definition retry.h:47
@ FR_RETRY_CONTINUE
Definition retry.h:46
@ FR_RETRY_MRD
reached maximum retransmission duration
Definition retry.h:48
fr_time_delta_t mrd
Maximum retransmission duration.
Definition retry.h:35
fr_time_t next
when the next timer should be set
Definition retry.h:55
#define fr_strerror_const(_msg)
Definition strerror.h:223
#define fr_type_is_structural(_x)
Definition types.h:388
int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert one type of fr_value_box_t to another.
Definition value.c:3574
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx, fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type, fr_value_box_list_action_t proc_action, bool flatten, size_t max_size)
Concatenate a list of value boxes.
Definition value.c:5949
@ FR_VALUE_BOX_LIST_FREE_BOX
Free each processed box.
Definition value.h:234
#define fr_box_time_delta(_val)
Definition value.h:362
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:606
static size_t char ** out
Definition value.h:1020
#define XLAT_CTX(_inst, _thread, _ex, _mctx, _env_data, _rctx)
Wrapper to create a xlat_ctx_t as a compound literal.
Definition xlat_ctx.h:95
xlat_action_t xlat_frame_eval_repeat(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in, void *env_data, fr_value_box_list_t *result)
Process the result of a previous nested expansion.
Definition xlat_eval.c:1119
void xlat_signal(xlat_func_signal_t signal, xlat_exp_t const *exp, request_t *request, void *rctx, fr_signal_t action)
Signal an xlat function.
Definition xlat_eval.c:1011
xlat_action_t xlat_frame_eval_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in, fr_value_box_list_t *result, xlat_func_t resume, void *rctx)
Call an xlat's resumption method.
Definition xlat_eval.c:1045
xlat_action_t xlat_frame_eval(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child, request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in)
Converts xlat nodes to value boxes.
Definition xlat_eval.c:1324
xlat_flags_t flags
Flags that control resolution and evaluation.
Definition xlat_priv.h:190
@ XLAT_BOX
fr_value_box_t
Definition xlat_priv.h:108
@ XLAT_TMPL
xlat attribute
Definition xlat_priv.h:112
@ XLAT_FUNC
xlat module
Definition xlat_priv.h:110
@ XLAT_GROUP
encapsulated string of xlats
Definition xlat_priv.h:116
char const *_CONST fmt
The original format string (a talloced buffer).
Definition xlat_priv.h:151
xlat_type_t _CONST type
type of this expansion.
Definition xlat_priv.h:155
static xlat_exp_t * xlat_exp_head(xlat_exp_head_t const *head)
Definition xlat_priv.h:209
An xlat expansion node.
Definition xlat_priv.h:148