The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
subrequest.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: 5cfa9ba0b8f13e52287a24e1057817d49bdad142 $
19 *
20 * @file unlang/subrequest.c
21 * @brief Unlang "subrequest" and "detach" keyword evaluation.
22 *
23 * @copyright 2006-2019 The FreeRADIUS server project
24 */
25
26RCSID("$Id: 5cfa9ba0b8f13e52287a24e1057817d49bdad142 $")
27
28#include <freeradius-devel/server/state.h>
29#include <freeradius-devel/server/tmpl_dcursor.h>
30#include <freeradius-devel/server/request.h>
31#include <freeradius-devel/server/rcode.h>
32#include <freeradius-devel/unlang/action.h>
33#include "unlang_priv.h"
34#include "interpret_priv.h"
35#include "subrequest_priv.h"
36#include "child_request_priv.h"
37
38/** Send a signal from parent request to subrequest
39 *
40 */
42#ifndef NDEBUG
43 UNUSED
44#endif
45 request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)
46{
47 unlang_child_request_t *cr = talloc_get_type_abort(frame->state, unlang_child_request_t);
48 request_t *child = talloc_get_type_abort(cr->request, request_t);
49
50 switch (cr->state) {
51 case CHILD_DETACHED:
52 RDEBUG3("subrequest detached during its execution - Not sending signal to child");
53 return;
54
55 case CHILD_CANCELLED:
56 RDEBUG3("subrequest is cancelled - Not sending signal to child");
57 return;
58
59 case CHILD_RUNNABLE:
60 fr_assert_msg(!unlang_request_is_scheduled(request), "Parent cannot be runnable if child has not completed");
61 break;
62
63 default:
64 break;
65 }
66
67 /*
68 * Parent should never receive a detach
69 * signal whilst the child is running.
70 *
71 * Only the child receives a detach
72 * signal when the detach keyword is used.
73 */
74 fr_assert(action != FR_SIGNAL_DETACH);
75
76 /*
77 * If the server is stopped, inside a breakpoint,
78 * whilst processing a child, on resumption both
79 * requests (parent and child) may need to be
80 * cancelled as they've both hit max request_time.
81 *
82 * Sometimes the child will run to completion before
83 * the cancellation is processed, but the parent
84 * will still be cancelled.
85 *
86 * When the parent is cancelled this function is
87 * executed, which will signal an already stopped
88 * child to cancel itself.
89 *
90 * This triggers asserts in the time tracking code.
91 *
92 * ...so we check to see if the child is done before
93 * sending a signal.
94 */
95 if (unlang_request_is_done(child)) return;
96
97 /*
98 * Forward other signals to the child
99 */
100 unlang_interpret_signal(child, action);
101}
102
103/** Parent being resumed after a child completes
104 *
105 */
108{
110 unlang_child_request_t *cr = talloc_get_type_abort(frame->state, unlang_child_request_t);
111 request_t *child = cr->request;
113
114 /*
115 * Child detached
116 */
117 if (cr->state == CHILD_DETACHED) {
118 RDEBUG3("subrequest detached during its execution - Not updating rcode or reply attributes");
119
120 /*
121 * If the child detached the subrequest section
122 * should become entirely transparent, and
123 * should not update the section rcode.
124 */
126 }
127
128 RDEBUG3("subrequest completeed with rcode %s",
130
131 /*
132 * If there's a no destination tmpl, we're done.
133 */
134 if (!child->reply) {
137 }
138
139 /*
140 * Otherwise... copy reply attributes into the
141 * specified destination.
142 */
144 if (gext->dst) {
145 fr_pair_t *vp = NULL;
147 fr_dcursor_t cursor;
148
149 /*
150 * Use callback to build missing destination container.
151 */
152 vp = tmpl_dcursor_build_init(NULL, request, &cc, &cursor, request, gext->dst, tmpl_dcursor_pair_build, NULL);
153 if (!vp) {
154 RPDEBUG("Discarding subrequest attributes - Failed allocating groups");
156 return UNLANG_ACTION_FAIL;
157 }
158
159 MEM(fr_pair_list_copy(vp, &vp->vp_group, &child->reply_pairs) >= 0);
160
162 }
163
166}
167
168/** Allocates a new subrequest and initialises it
169 *
170 */
172{
173 unlang_child_request_t *cr = talloc_get_type_abort(frame->state, unlang_child_request_t);
174 request_t *child;
175 fr_pair_t *vp;
176
179
180 /*
181 * This should only be set for manually pushed subrequests
182 */
183 fr_assert(!cr->config.free_child);
184
185 /*
186 * Initialize the state
187 */
190
192 child = unlang_io_subrequest_alloc(request, gext->dict, UNLANG_DETACHABLE);
193 if (!child) {
194 fail:
195 return UNLANG_ACTION_FAIL;
196 }
197 /*
198 * Set the packet type.
199 */
200 MEM(vp = fr_pair_afrom_da(child->request_ctx, gext->attr_packet_type));
201 if (gext->type_enum) {
202 child->packet->code = vp->vp_uint32 = gext->type_enum->value->vb_uint32;
203 } else {
204 fr_dict_enum_value_t const *type_enum;
205 fr_pair_t *attr;
206
207 if (tmpl_find_vp(&attr, request, gext->vpt) < 0) {
208 RDEBUG("Failed finding attribute %s", gext->vpt->name);
209 goto fail;
210 }
211
212 if (tmpl_attr_tail_da(gext->vpt)->type == FR_TYPE_STRING) {
213 type_enum = fr_dict_enum_by_name(gext->attr_packet_type, attr->vp_strvalue, attr->vp_length);
214 if (!type_enum) {
215 RDEBUG("Unknown Packet-Type %pV", &attr->data);
216 goto fail;
217 }
218
219 child->packet->code = vp->vp_uint32 = type_enum->value->vb_uint32;
220 } else {
221 fr_value_box_t box;
222
223 fr_value_box_init(&box, FR_TYPE_UINT32, NULL, false);
224 if (fr_value_box_cast(request, &box, FR_TYPE_UINT32, NULL, &attr->data) < 0) {
225 RDEBUG("Failed casting value from %pV to data type uint32", &attr->data);
226 goto fail;
227 }
228
229 /*
230 * Check that the value is known to the server.
231 *
232 * If it isn't known, then there's no
233 * "recv foo" section for it and we can't
234 * do anything with this packet.
235 */
236 type_enum = fr_dict_enum_by_value(gext->attr_packet_type, &box);
237 if (!type_enum) {
238 RDEBUG("Invalid value %pV for Packet-Type", &box);
239 goto fail;
240 }
241
242 child->packet->code = vp->vp_uint32 = box.vb_uint32;
243 }
244
245 }
246 fr_pair_append(&child->request_pairs, vp);
247
248 if ((gext->src) && (tmpl_copy_pair_children(child->request_ctx, &child->request_pairs, request, gext->src) < -1)) {
249 RPEDEBUG("Failed copying source attributes into subrequest");
250 goto fail;
251 }
252
253 /*
254 * Setup the child so it'll inform us when
255 * it resumes, or if it detaches.
256 *
257 * frame->instruction should be consistent
258 * as it's allocated by the unlang compiler.
259 */
260 if (unlang_child_request_init(cr, cr, child, p_result, NULL, frame->instruction, false) < 0) goto fail;
261
262 /*
263 * Push the first instruction the child's
264 * going to run.
265 */
266 if (unlang_interpret_push(NULL, child, g->children,
268 UNLANG_NEXT_SIBLING) < 0) goto fail;
269
270 /*
271 * Finally, setup the function that will be
272 * called when the child indicates the
273 * parent should be resumed.
274 */
276
277 /*
278 * This is a common function, either pushed
279 * onto the parent's stack, or called directly
280 * from the subrequest instruction..
281 */
282 return unlang_subrequest_child_run(p_result, request, frame); /* returns UNLANG_ACTION_YIELD */
283}
284
285/** Free a child request, detaching it from its parent and freeing allocated memory
286 *
287 * @param[in] child to free.
288 */
290{
291 request_detach(*child);
292 talloc_free(*child);
293 *child = NULL;
294}
295
296/** Allocate a subrequest to run through a virtual server at some point in the future
297 *
298 * @param[in] parent to hang sub request off of.
299 * @param[in] namespace the child will operate in.
300 * @return
301 * - A new child request.
302 * - NULL on failure.
303 */
308
309
310/** Function to run in the context of the parent on resumption
311 *
312 * @note Only executes if unlang_subrequest_child_push was called, not with the normal subrequest keyword.
313 */
316{
317 unlang_child_request_t *cr = talloc_get_type_abort(frame->state, unlang_child_request_t);
318
319 /*
320 * Default to NOOP
321 */
322 if (cr->result.rcode == RLM_MODULE_NOT_SET) {
324 if (cr->p_result) {
325 *cr->p_result = cr->result;
326 } else {
327 *p_result = cr->result;
328 }
329 }
330
331 /*
332 * We can free the child here as we're its parent
333 */
334 if (cr->config.free_child) {
337 } else {
338 TALLOC_FREE(cr->request);
339 }
340 }
341
343}
344
345/** Function called by the unlang interpreter, or manually to start the child running
346 *
347 * The reason why we do this on the unlang stack is so that _this_ frame
348 * is marked as resumable in the parent, not whatever frame was previously
349 * being processed by the interpreter when the parent was called.
350 *
351 * i.e. after calling unlang_subrequest_child_push, the code in the parent
352 * can call UNLANG_ACTION_PUSHED_CHILD, which will result in _this_ frame
353 * being executed, and _this_ frame can yield.
354 *
355 * @note Called from the parent to start a child running.
356 */
359{
360 unlang_child_request_t *cr = talloc_get_type_abort(frame->state, unlang_child_request_t);
361 request_t *child = cr->request;
362
363 /*
364 * No parent means this is a pre-detached child
365 * so the parent should continue executing.
366 */
367 if (!child || !child->parent) return UNLANG_ACTION_CALCULATE_RESULT;
368
369
370 /*
371 * Ensure we restore the session state information
372 * into the child.
373 */
374 if (cr->config.session_unique_ptr) fr_state_restore_to_child(child,
375 cr->config.session_unique_ptr,
376 cr->num);
377 /*
378 * Ensures the child is setup correctly and adds
379 * it into the runnable queue of whatever owns
380 * the interpreter.
381 */
383
384 /*
385 * This function is being called by something
386 * other than the subrequest keyword.
387 *
388 * Set a different resumption function that
389 * just writes the final rcode out.
390 */
391 if (frame->process == unlang_subrequest_child_run) {
393 }
394
395 cr->state = CHILD_RUNNABLE;
396
397 return UNLANG_ACTION_YIELD;
398}
399
400/** Push a pre-existing child back onto the stack as a subrequest
401 *
402 * The child *MUST* have been allocated with unlang_io_subrequest_alloc, or something
403 * that calls it.
404 *
405 * After the child is no longer required it *MUST* be freed with #unlang_subrequest_detach_and_free.
406 * It's not enough to free it with talloc_free.
407 *
408 * This function should be called _before_ pushing any additional frames onto the child's
409 * stack for it to execute.
410 *
411 * The parent should return UNLANG_ACTION_PUSHED_CHILD, when it's done setting up the
412 * child request. It should NOT return UNLANG_ACTION_YIELD.
413 *
414 * @param[in] p_result Where to write the result of the subrequest.
415 * @param[in] child to push.
416 * @param[in] unique_session_ptr Unique identifier for child's session data.
417 * @param[in] free_child automatically free the child when it's finished executing.
418 * This is useful if extracting the result from the child is
419 * done using the child's stack, and so the parent never needs
420 * to access it.
421 * @param[in] top_frame Set to UNLANG_TOP_FRAME if the interpreter should return.
422 * Set to UNLANG_SUB_FRAME if the interprer should continue.
423 * @return
424 * - 0 on success.
425 * - -1 on failure.
426 */
427
428int unlang_subrequest_child_push(unlang_result_t *p_result, request_t *child, void const *unique_session_ptr, bool free_child, bool top_frame)
429{
432
433 static unlang_t subrequest_instruction = {
435 .name = "subrequest",
436 .debug_name = "subrequest",
437 .actions = {
438 .actions = {
439 [RLM_MODULE_REJECT] = 0,
440 [RLM_MODULE_FAIL] = 0,
441 [RLM_MODULE_OK] = 0,
442 [RLM_MODULE_HANDLED] = 0,
443 [RLM_MODULE_INVALID] = 0,
446 [RLM_MODULE_NOOP] = 0,
448 },
449 .retry = RETRY_INIT,
450 }
451 };
452
453 fr_assert_msg(free_child || child->parent, "Child's request pointer must not be NULL when calling subrequest_child_push");
454
456 "Child stack depth must be 0 (not %d), when calling subrequest_child_push",
457 stack_depth_current(child))) return -1;
458
459 /*
460 * Push a new subrequest frame onto the stack
461 * of the parent.
462 *
463 * This allocates memory for the frame state
464 * which we fill in below.
465 *
466 * This frame executes once the subrequest has
467 * completed.
468 */
469 if (unlang_interpret_push(NULL, child->parent, &subrequest_instruction,
471 return -1;
472 }
473
474 frame = frame_current(child->parent);
476
477 /*
478 * Setup the state for the subrequest
479 */
480 cr = talloc_get_type_abort(frame_current(child->parent)->state, unlang_child_request_t);
481
482 /*
483 * Initialise our frame state, and push the first
484 * instruction onto the child's stack.
485 *
486 * This instruction will mark the parent as runnable
487 * when it executed.
488 */
489 if (unlang_child_request_init(cr, cr, child, p_result, NULL, unique_session_ptr, free_child) < 0) return -1;
490
491 return 0;
492}
493
494/** Add a child request to the runnable queue
495 *
496 * @param[in] request to add to the runnable queue.
497 * @return
498 * - 0 on success.
499 * - -1 on failure.
500 */
502{
503 /*
504 * Ensures the child is setup correctly and adds
505 * it into the runnable queue of whatever owns
506 * the interpreter.
507 */
508 interpret_child_init(request);
509
510 if (request_detach(request) < 0) {
511 RPEDEBUG("Failed detaching request");
512 return -1;
513 }
514
515 return 0;
516}
517
519{
521 char const *name2;
522
523 unlang_t *c;
524
527
528 unlang_compile_ctx_t unlang_ctx2;
529
530 tmpl_rules_t t_rules;
531 fr_dict_autoload_talloc_t *dict_ref = NULL;
532
533 fr_dict_t const *dict;
534 fr_dict_attr_t const *da = NULL;
535 fr_dict_enum_value_t const *type_enum = NULL;
536
537 ssize_t slen;
538 char *namespace = NULL;
539 char const *packet_name = NULL;
540
541 tmpl_t *vpt = NULL, *src_vpt = NULL, *dst_vpt = NULL;
542
543 /*
544 * subrequest { ... }
545 *
546 * Create a subrequest which is of the same dictionary
547 * and packet type as the current request.
548 *
549 * We assume that the Packet-Type attribute exists.
550 */
551 name2 = cf_section_name2(cs);
552 if (!name2) {
553 dict = unlang_ctx->rules->attr.dict_def;
554 packet_name = name2 = unlang_ctx->section_name2;
555 goto get_packet_type;
556 }
557
559 cf_log_err(cs, "The arguments to 'subrequest' must be a name or an attribute reference");
560 print_url:
561 cf_log_err(ci, DOC_KEYWORD_REF(subrequest));
562 return NULL;
563 }
564
565 dict = unlang_ctx->rules->attr.dict_def;
566
567 /*
568 * @foo is "dictionary foo", as with references in the dictionaries.
569 *
570 * @foo::bar is "dictionary foo, Packet-Type = ::bar"
571 *
572 * foo::bar is "dictionary foo, Packet-Type = ::bar"
573 *
574 * ::bar is "this dictionary, Packet-Type = ::bar", BUT
575 * we don't try to parse the new dictionary name, as it
576 * doesn't exist.
577 */
578 if ((name2[0] == '@') ||
579 ((name2[0] != ':') && (name2[0] != '&') && (strchr(name2 + 1, ':') != NULL))) {
580 char *q;
581
582 if (name2[0] == '@') name2++;
583
584 MEM(namespace = talloc_strdup(parent, name2));
585 q = namespace;
586
587 while (fr_dict_attr_allowed_chars[(unsigned int) *q]) {
588 q++;
589 }
590 *q = '\0';
591
592 dict = fr_dict_by_protocol_name(namespace);
593 if (!dict) {
594 dict_ref = fr_dict_autoload_talloc(NULL, &dict, namespace);
595 if (!dict_ref) {
596 cf_log_err(cs, "Unknown namespace in '%s'", name2);
597 talloc_free(namespace);
598 return NULL;
599 }
600 }
601
602 /*
603 * Skip the dictionary name, and go to the thing
604 * right after it.
605 */
606 name2 += (q - namespace);
607 TALLOC_FREE(namespace);
608 }
609
610 /*
611 * @dict::enum is "other dictionary, Packet-Type = ::enum"
612 * ::enum is this dictionary, "Packet-Type = ::enum"
613 */
614 if ((name2[0] == ':') && (name2[1] == ':')) {
615 packet_name = name2;
616 goto get_packet_type;
617 }
618
619 /*
620 * Can't do foo.bar.baz::foo, the enums are only used for Packet-Type.
621 */
622 if (strchr(name2, ':') != NULL) {
623 cf_log_err(cs, "Reference cannot contain enum value in '%s'", name2);
624 return NULL;
625 }
626
627 /*
628 * '&' means "attribute reference"
629 *
630 * Or, bare word an require_enum_prefix means "attribute reference".
631 */
632 slen = tmpl_afrom_attr_substr(parent, NULL, &vpt,
633 &FR_SBUFF_IN(name2, talloc_array_length(name2) - 1),
634 NULL, unlang_ctx->rules);
635 if (slen <= 0) {
636 cf_log_perr(cs, "Invalid argument to 'subrequest', failed parsing packet-type");
637 goto print_url;
638 }
639
641
642 /*
643 * Anything resembling an integer or string is
644 * OK. Nothing else makes sense.
645 */
646 switch (tmpl_attr_tail_da(vpt)->type) {
648 case FR_TYPE_STRING:
649 break;
650
651 default:
653 cf_log_err(cs, "Invalid data type for attribute %s. "
654 "Must be an integer type or string", name2 + 1);
655 goto print_url;
656 }
657
658 dict = unlang_ctx->rules->attr.dict_def;
659 packet_name = NULL;
660
661get_packet_type:
662 /*
663 * Local attributes cannot be used in a subrequest. They belong to the parent. Local attributes
664 * are NOT copied to the subrequest.
665 *
666 * @todo - maybe we want to copy local variables, too? But there may be multiple nested local
667 * variables, each with their own dictionary.
668 */
669 dict = fr_dict_proto_dict(dict);
670
671 /*
672 * Use dict name instead of "namespace", because "namespace" can be omitted.
673 */
674 da = fr_dict_attr_by_name(NULL, fr_dict_root(dict), "Packet-Type");
675 if (!da) {
676 cf_log_err(cs, "No such attribute 'Packet-Type' in namespace '%s'", fr_dict_root(dict)->name);
677 error:
678 talloc_free(namespace);
680 talloc_free(dict_ref);
681 goto print_url;
682 }
683
684 if (packet_name) {
685 /*
686 * Allow ::enum-name for packet types
687 */
688 if ((packet_name[0] == ':') && (packet_name[1] == ':')) packet_name += 2;
689
690 type_enum = fr_dict_enum_by_name(da, packet_name, -1);
691 if (!type_enum) {
692 cf_log_err(cs, "No such value '%s' for attribute 'Packet-Type' in namespace '%s'",
694 goto error;
695 }
696 }
697
698 /*
699 * No longer needed
700 */
701 talloc_free(namespace);
702
703 /*
704 * Source and destination arguments
705 */
706 {
707 char const *dst, *src;
708
709 src = cf_section_argv(cs, 0);
710 if (src) {
711 RULES_VERIFY(unlang_ctx->rules);
712
713 (void) tmpl_afrom_substr(parent, &src_vpt,
714 &FR_SBUFF_IN(src, talloc_array_length(src) - 1),
715 cf_section_argv_quote(cs, 0), NULL, unlang_ctx->rules);
716 if (!src_vpt) {
717 cf_log_perr(cs, "Invalid argument to 'subrequest', failed parsing src");
718 goto error;
719 }
720
721 if (!tmpl_contains_attr(src_vpt)) {
722 cf_log_err(cs, "Invalid argument to 'subrequest' src must be an attr or list, got %s",
723 tmpl_type_to_str(src_vpt->type));
724 talloc_free(src_vpt);
725 goto error;
726 }
727
728 dst = cf_section_argv(cs, 1);
729 if (dst) {
730 RULES_VERIFY(unlang_ctx->rules);
731
732 (void) tmpl_afrom_substr(parent, &dst_vpt,
733 &FR_SBUFF_IN(dst, talloc_array_length(dst) - 1),
734 cf_section_argv_quote(cs, 1), NULL, unlang_ctx->rules);
735 if (!dst_vpt) {
736 cf_log_perr(cs, "Invalid argument to 'subrequest', failed parsing dst");
737 goto error;
738 }
739
740 if (!tmpl_contains_attr(dst_vpt)) {
741 cf_log_err(cs, "Invalid argument to 'subrequest' dst must be an "
742 "attr or list, got %s",
743 tmpl_type_to_str(src_vpt->type));
744 talloc_free(src_vpt);
745 talloc_free(dst_vpt);
746 goto error;
747 }
748 }
749 }
750 }
751
752 if (!cf_item_next(cs, NULL)) {
754 talloc_free(src_vpt);
755 talloc_free(dst_vpt);
756 return UNLANG_IGNORE;
757 }
758
759 t_rules = *unlang_ctx->rules;
760 t_rules.parent = unlang_ctx->rules;
761 t_rules.attr.dict_def = dict;
762 t_rules.attr.allow_foreign = false;
763
764 /*
765 * Copy over the compilation context. This is mostly
766 * just to ensure that retry is handled correctly.
767 * i.e. reset.
768 */
769 unlang_compile_ctx_copy(&unlang_ctx2, unlang_ctx);
770
771 /*
772 * Then over-write the new compilation context.
773 */
774 unlang_ctx2.section_name1 = "subrequest";
775 unlang_ctx2.section_name2 = name2;
776 unlang_ctx2.rules = &t_rules;
777
778 /*
779 * Compile the subsection with a *different* default dictionary.
780 */
782 if (!c) return NULL;
783
784 /*
785 * Set the dictionary and packet information, which tells
786 * unlang_subrequest() how to process the request.
787 */
790
791 if (dict_ref) {
792 /*
793 * Parent the dictionary reference correctly now that we
794 * have the section with the dependency. This should
795 * be fast as dict_ref has no siblings.
796 */
797 talloc_steal(gext, dict_ref);
798 }
799 if (vpt) gext->vpt = talloc_steal(gext, vpt);
800
801 gext->dict = dict;
802 gext->attr_packet_type = da;
803 gext->type_enum = type_enum;
804 gext->src = src_vpt;
805 gext->dst = dst_vpt;
806
807 return c;
808}
809
810
811/** Initialise subrequest ops
812 *
813 */
815{
817 .name = "subrequest",
819
820 /*
821 * Frame can't be cancelled, because children need to
822 * write out status to the parent. If we don't do this,
823 * then all children must be detachable and must detach
824 * so they don't try and write out status to a "done"
825 * parent.
826 *
827 * It's easier to allow the child/parent relationship
828 * to end normally so that non-detachable requests are
829 * guaranteed the parent still exists.
830 */
832
833 .compile = unlang_compile_subrequest,
834 .interpret = unlang_subrequest_init,
835 .signal = unlang_subrequest_signal,
836
837 .unlang_size = sizeof(unlang_subrequest_t),
838 .unlang_name = "unlang_subrequest_t",
839 .pool_headers = (TMPL_POOL_DEF_HEADERS * 3),
840 .pool_len = (TMPL_POOL_DEF_LEN * 3),
841
842 .frame_state_size = sizeof(unlang_child_request_t),
843 .frame_state_type = "unlang_child_request_t",
844 });
845
846 if (unlang_child_request_op_init() < 0) return -1;
847
848 return 0;
849}
unlang_action_t
Returned by unlang_op_t calls, determine the next action of the interpreter.
Definition action.h:35
@ UNLANG_ACTION_EXECUTE_NEXT
Execute the next unlang_t.
Definition action.h:38
@ 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 RCSID(id)
Definition build.h:485
#define UNUSED
Definition build.h:317
#define RULES_VERIFY(_cs, _rules)
Definition cf_file.c:177
Common header for all CONF_* types.
Definition cf_priv.h:49
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
fr_token_t cf_section_argv_quote(CONF_SECTION const *cs, int argc)
Return the quoting for one of the variadic arguments.
Definition cf_util.c:1259
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1184
CONF_SECTION * cf_item_to_section(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_SECTION.
Definition cf_util.c:683
char const * cf_section_argv(CONF_SECTION const *cs, int argc)
Return variadic argument at the specified index.
Definition cf_util.c:1212
fr_token_t cf_section_name2_quote(CONF_SECTION const *cs)
Return the quoting of the name2 identifier.
Definition cf_util.c:1229
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:289
#define cf_item_next(_parent, _curr)
Definition cf_util.h:92
#define cf_log_perr(_cf, _fmt,...)
Definition cf_util.h:296
int unlang_child_request_op_init(void)
int unlang_child_request_init(TALLOC_CTX *ctx, unlang_child_request_t *out, request_t *child, unlang_result_t *p_result, unsigned int *sibling_count, void const *unique_session_ptr, bool free_child)
Initialize a child request.
struct unlang_child_request_t::@100 config
request_t * request
Child request. The actual request the child will run.
unlang_result_t result
The result of the child request.
unlang_child_request_state_t state
State of the child.
unlang_result_t * p_result
Pointer to the result of the child request.
@ CHILD_RUNNABLE
Running/runnable.
@ CHILD_DETACHED
Child has detached, we can't signal it or communicate with it anymore.
@ CHILD_CANCELLED
Child was cancelled.
int num
The child number.
Each child has a state, a number, a request, and a count of their siblings.
unlang_t * unlang_compile_section(unlang_t *parent, unlang_compile_ctx_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type)
Definition compile.c:1547
fr_table_num_sorted_t const mod_rcode_table[]
Definition compile.c:76
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:210
#define fr_cond_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:156
#define MEM(x)
Definition debug.h:36
#define fr_dict_autoload_talloc(_ctx, _dict_out, _proto)
Definition dict.h:873
fr_dict_t const * fr_dict_proto_dict(fr_dict_t const *dict)
Definition dict_util.c:5016
bool const fr_dict_attr_allowed_chars[UINT8_MAX+1]
Characters that are allowed in dictionary attribute names.
Definition dict_util.c:47
fr_dict_attr_t const * fr_dict_attr_by_name(fr_dict_attr_err_t *err, fr_dict_attr_t const *parent, char const *attr))
Locate a fr_dict_attr_t by its name.
Definition dict_util.c:3266
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2403
fr_value_box_t const * value
Enum value (what name maps to).
Definition dict.h:237
fr_dict_enum_value_t const * fr_dict_enum_by_value(fr_dict_attr_t const *da, fr_value_box_t const *value)
Lookup the structure representing an enum value in a fr_dict_attr_t.
Definition dict_util.c:3393
fr_dict_t const * fr_dict_by_protocol_name(char const *name)
Lookup a protocol by its name.
Definition dict_util.c:2580
fr_dict_enum_value_t const * fr_dict_enum_by_name(fr_dict_attr_t const *da, char const *name, ssize_t len)
Definition dict_util.c:3439
Value of an enumerated attribute.
Definition dict.h:233
Structure used to managed the lifetime of a dictionary.
Definition dict_util.c:4240
bool unlang_request_is_done(request_t const *request)
Return whether a request has been marked done.
Definition interpret.c:1590
bool unlang_request_is_scheduled(request_t const *request)
Return whether a request is currently scheduled.
Definition interpret.c:1573
void unlang_interpret_signal(request_t *request, fr_signal_t action)
Send a signal (usually stop) to a request.
Definition interpret.c:1396
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
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:153
#define UNLANG_SUB_FRAME
Definition interpret.h:37
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
Private declarations for the unlang interpreter.
static void interpret_child_init(request_t *request)
#define RDEBUG3(fmt,...)
Definition log.h:343
#define RPDEBUG(fmt,...)
Definition log.h:346
#define RPEDEBUG(fmt,...)
Definition log.h:376
static TALLOC_CTX * unlang_ctx
Definition base.c:71
void unlang_register(unlang_op_t *op)
Register an operation with the interpreter.
Definition base.c:56
request_t * unlang_io_subrequest_alloc(request_t *parent, fr_dict_t const *namespace, bool detachable)
Allocate a child request based on the parent.
Definition io.c:39
talloc_free(reap)
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
long int ssize_t
int fr_pair_list_copy(TALLOC_CTX *ctx, fr_pair_list_t *to, fr_pair_list_t const *from)
Duplicate a list of pairs.
Definition pair.c:2320
int fr_pair_append(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the end of the list.
Definition pair.c:1342
fr_pair_t * fr_pair_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Dynamically allocate a new attribute and assign a fr_dict_attr_t.
Definition pair.c:287
static const char * packet_name[]
#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 RETURN_UNLANG_NOOP
Definition rcode.h:63
int request_detach(request_t *child)
Unlink a subrequest from its parent.
Definition request.c:542
#define request_is_detachable(_x)
Definition request.h:187
static char const * name
#define FR_SBUFF_IN(_start, _len_or_end)
void fr_state_restore_to_child(request_t *child, void const *unique_ptr, int unique_int)
Restore subrequest data from a parent request.
Definition state.c:857
int tmpl_find_vp(fr_pair_t **out, request_t *request, tmpl_t const *vpt))
Returns the first VP matching a tmpl_t.
Definition tmpl_eval.c:768
static char const * tmpl_type_to_str(tmpl_type_t type)
Return a static string containing the type name.
Definition tmpl.h:634
#define tmpl_is_attr(vpt)
Definition tmpl.h:208
tmpl_rules_t const * parent
for parent / child relationships
Definition tmpl.h:333
#define tmpl_contains_attr(vpt)
Definition tmpl.h:225
ssize_t tmpl_afrom_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_token_t quote, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Convert an arbitrary string into a tmpl_t.
ssize_t tmpl_afrom_attr_substr(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t **out, fr_sbuff_t *name, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Parse a string into a TMPL_TYPE_ATTR_* type tmpl_t.
static fr_slen_t vpt
Definition tmpl.h:1269
#define TMPL_POOL_DEF_HEADERS
Define manipulation functions for the attribute reference list.
Definition tmpl.h:486
#define TMPL_POOL_DEF_LEN
How many additional bytes to allocate in a pool for a tmpl_t.
Definition tmpl.h:491
tmpl_attr_rules_t attr
Rules/data for parsing attribute references.
Definition tmpl.h:335
static fr_dict_attr_t const * tmpl_attr_tail_da(tmpl_t const *vpt)
Return the last attribute reference da.
Definition tmpl.h:801
int tmpl_copy_pair_children(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt))
Copy children of pairs matching a tmpl_t in the current request_t.
Definition tmpl_eval.c:720
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:332
fr_signal_t
Signals that can be generated/processed by request signal handlers.
Definition signal.h:38
@ 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
uint8_t allow_foreign
Allow arguments not found in dict_def.
Definition tmpl.h:312
fr_dict_t const * dict_def
Default dictionary to use with unqualified attribute references.
Definition tmpl.h:273
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
static unlang_action_t unlang_subrequest_parent_resume(UNUSED unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Parent being resumed after a child completes.
Definition subrequest.c:106
static unlang_action_t unlang_subrequest_init(unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
Allocates a new subrequest and initialises it.
Definition subrequest.c:171
int unlang_subrequest_op_init(void)
Initialise subrequest ops.
Definition subrequest.c:814
static void unlang_subrequest_signal(UNUSED request_t *request, unlang_stack_frame_t *frame, fr_signal_t action)
Send a signal from parent request to subrequest.
Definition subrequest.c:41
int unlang_subrequest_child_push_and_detach(request_t *request)
Add a child request to the runnable queue.
Definition subrequest.c:501
request_t * unlang_subrequest_alloc(request_t *parent, fr_dict_t const *namespace)
Allocate a subrequest to run through a virtual server at some point in the future.
Definition subrequest.c:304
void unlang_subrequest_detach_and_free(request_t **child)
Free a child request, detaching it from its parent and freeing allocated memory.
Definition subrequest.c:289
static unlang_action_t unlang_subrequest_child_done(unlang_result_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)
Function to run in the context of the parent on resumption.
Definition subrequest.c:314
static unlang_t * unlang_compile_subrequest(unlang_t *parent, unlang_compile_ctx_t *unlang_ctx, CONF_ITEM const *ci)
Definition subrequest.c:518
int unlang_subrequest_child_push(unlang_result_t *p_result, request_t *child, void const *unique_session_ptr, bool free_child, bool top_frame)
Push a pre-existing child back onto the stack as a subrequest.
Definition subrequest.c:428
unlang_action_t unlang_subrequest_child_run(UNUSED unlang_result_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)
Function called by the unlang interpreter, or manually to start the child running.
Definition subrequest.c:357
static unlang_subrequest_t * unlang_group_to_subrequest(unlang_group_t *g)
Cast a group structure to the subrequest keyword extension.
tmpl_t * vpt
Value to expand to find the value to place into the packet-type attribute.
fr_dict_attr_t const * attr_packet_type
Packet-type attribute in the subrequest protocol.
tmpl_t * src
Pairs to copy into the subrequest request list.
fr_dict_t const * dict
Dictionary of the subrequest protocol.
tmpl_t * dst
Where to copy pairs from the reply list in the subrequest to.
fr_dict_enum_value_t const * type_enum
Static enumeration value for attr_packet_type.
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
fr_pair_t * tmpl_dcursor_pair_build(fr_pair_t *parent, fr_dcursor_t *cursor, fr_dict_attr_t const *da, UNUSED void *uctx)
Simple pair building callback for use with tmpl_dcursors.
void tmpl_dcursor_clear(tmpl_dcursor_ctx_t *cc)
Clear any temporary state allocations.
#define tmpl_dcursor_build_init(_err, _ctx, _cc, _cursor, _request, _vpt, _build, _uctx)
Maintains state between cursor calls.
@ T_BARE_WORD
Definition token.h:120
Private interpreter structures and functions.
#define UNLANG_NORMAL_CHILD
#define UNLANG_DETACHABLE
#define UNLANG_NEXT_SIBLING
Definition unlang_priv.h:98
void * state
Stack frame specialisations.
tmpl_rules_t const * rules
#define UNLANG_NEXT_STOP
Definition unlang_priv.h:97
static void unlang_compile_ctx_copy(unlang_compile_ctx_t *dst, unlang_compile_ctx_t const *src)
#define UNLANG_IGNORE
static unlang_group_t * unlang_generic_to_group(unlang_t const *p)
char const * section_name1
static unlang_stack_frame_t * frame_current(request_t *request)
static int stack_depth_current(request_t *request)
@ UNLANG_TYPE_SUBREQUEST
create a child subrequest
Definition unlang_priv.h:66
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.
@ UNLANG_OP_FLAG_NO_FORCE_UNWIND
Must not be cancelled.
@ UNLANG_OP_FLAG_DEBUG_BRACES
Print debug braces.
@ UNLANG_OP_FLAG_RCODE_SET
Set request->rcode to the result of this operation.
unlang_process_t process
function to call for interpreting this stack frame
unlang_type_t type
The specialisation of this node.
unlang_t * children
Children beneath this group.
char const * section_name2
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.
static fr_slen_t parent
Definition pair.h:839
#define RETRY_INIT
Definition retry.h:39
#define FR_TYPE_INTEGER_EXCEPT_BOOL
Definition types.h:299
#define DOC_KEYWORD_REF(_x)
Definition version.h:89
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
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:606