The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
call_env.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: 57faf3db5dc01a27d3fa50f2ab0c297a8c4bb8ea $
19 *
20 * @file unlang/call_env.c
21 * @brief Call environment parsing functions
22 *
23 * @copyright 2023 Network RADIUS SAS (legal@networkradius.com)
24 */
25
26RCSID("$Id: 57faf3db5dc01a27d3fa50f2ab0c297a8c4bb8ea $")
27
28#include <freeradius-devel/server/log.h>
29#include <freeradius-devel/server/cf_util.h>
30#include <freeradius-devel/server/tmpl.h>
31#include <freeradius-devel/server/rcode.h>
32#include <freeradius-devel/server/section.h>
33#include <freeradius-devel/server/main_config.h>
34#include <freeradius-devel/unlang/action.h>
35#include <freeradius-devel/unlang/tmpl.h>
36#include <freeradius-devel/unlang/function.h>
37#include <freeradius-devel/unlang/interpret.h>
38#include <freeradius-devel/unlang/call_env.h>
39
40#include <talloc.h>
41#include "call_env.h"
42
44 call_env_parsed_entry_t entry; //!< Entry in list of parsed call_env_parsers.
45
46 union {
47 tmpl_t const *tmpl; //!< Tmpl produced from parsing conf pair.
48 fr_value_box_t const *vb; //!< Value box produced from parsing conf pair.
49 void const *ptr; //!< Data produced from parsing conf pair.
51
52 size_t count; //!< Number of CONF_PAIRs found, matching the #call_env_parser_t.
53 size_t multi_index; //!< Array index for this instance.
54 call_env_parser_t const *rule; //!< Used to produce this.
55};
56FR_DLIST_FUNCS(call_env_parsed, call_env_parsed_t, entry)
57
58#if defined(DEBUG_CALL_ENV)
59# define CALL_ENV_DEBUG(_ci, fmt, ...) cf_log_debug(_ci, fmt, ##__VA_ARGS__)
60#else
61# define CALL_ENV_DEBUG(_ci, ...)
62#endif
63
64/** Parse the result of call_env tmpl expansion
65 */
66static inline CC_HINT(always_inline)
67call_env_result_t call_env_result(TALLOC_CTX *ctx, request_t *request, void *out, call_env_parsed_t const *env,
68 fr_value_box_list_t *tmpl_expanded)
69{
71
72 vb = fr_value_box_list_head(tmpl_expanded);
73 if (!vb) {
74 if (!call_env_nullable(env->rule->flags)) {
75 RPEDEBUG("Failed to evaluate required module option %s = %s", env->rule->name, env->data.tmpl->name);
76 return CALL_ENV_MISSING;
77 }
78 return CALL_ENV_SUCCESS;
79 }
80
81 /*
82 * Concatenate multiple boxes if needed
83 */
84 if ((call_env_concat(env->rule->flags) || call_env_attribute(env->rule->flags)) &&
85 (env->rule->pair.cast_type != FR_TYPE_VOID) &&
86 fr_value_box_list_concat_in_place(vb, vb, tmpl_expanded, env->rule->pair.cast_type,
87 FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0 ) {
88 RPEDEBUG("Failed concatenating values for %s", env->rule->name);
89 return CALL_ENV_INVALID;
90 }
91
92 if (call_env_single(env->rule->flags) && (fr_value_box_list_num_elements(tmpl_expanded) > 1)) {
93 RPEDEBUG("%u values found for %s. Only one is allowed",
94 fr_value_box_list_num_elements(tmpl_expanded), env->rule->name);
95 return CALL_ENV_INVALID;
96 }
97
98 while ((vb = fr_value_box_list_pop_head(tmpl_expanded))) {
99 switch (env->rule->pair.type) {
102 break;
103
105 if (!fr_value_box_list_initialised((fr_value_box_list_t *)out)) fr_value_box_list_init((fr_value_box_list_t *)out);
106 fr_value_box_list_insert_tail((fr_value_box_list_t *)out, vb);
107 break;
108
109 default:
110 fr_assert(0);
111 break;
112 }
113 }
114
115 return CALL_ENV_SUCCESS;
116}
117
118/** Context to keep track of expansion of call environments
119 *
120 */
121typedef struct {
122 call_env_result_t *result; //!< Where to write the return code of callenv expansion.
123 unlang_result_t expansion_result; //!< The result of calling the call env expansions functions.
124 call_env_t const *call_env; //!< Call env being expanded.
125 call_env_parsed_t const *last_expanded; //!< The last expanded tmpl.
126 fr_value_box_list_t tmpl_expanded; //!< List to write value boxes to as tmpls are expanded.
127 void **data; //!< Final destination structure for value boxes.
129
130static unlang_action_t call_env_expand_repeat(UNUSED unlang_result_t *p_result, request_t *request, void *uctx);
131
132/** Start the expansion of a call environment tmpl.
133 *
134 */
136{
137 call_env_rctx_t *call_env_rctx = talloc_get_type_abort(uctx, call_env_rctx_t);
138 TALLOC_CTX *ctx;
139 call_env_parsed_t const *env = NULL;
140 void **out;
141
142again:
143 while ((call_env_rctx->last_expanded = call_env_parsed_next(&call_env_rctx->call_env->parsed, call_env_rctx->last_expanded))) {
144 env = call_env_rctx->last_expanded;
145 fr_assert(env != NULL);
146
147 /*
148 * Subsections are expanded during parsing to produce a list of
149 * call_env_parsed_t. They are not expanded at runtime.
150 */
151 fr_assert_msg(call_env_is_subsection(env->rule->flags) == false, "Subsections cannot be expanded at runtime");
152
153 /*
154 * If there's an offset to copy the output to, do that.
155 * We may also need to expand the tmpl_t and write out the result
156 * to the pair offset.
157 */
158 if (env->rule->pair.parsed.offset >= 0) {
159 /*
160 * If we only need the tmpl or data, just set the pointer and move the next.
161 */
162 out = (void **)((uint8_t *)*call_env_rctx->data + env->rule->pair.parsed.offset);
163
164 /*
165 * For multi pair options, the pointers need to go into a new array.
166 * When processing the first expansion, allocate the array, and for
167 * all expansions adjust the `out` pointer to write to.
168 */
169 if (call_env_multi(env->rule->flags)) {
170 void **array;
171 if (env->multi_index == 0) {
172 /*
173 * Coverity thinks talloc_zero_array being called with the type `void *`
174 * is a size mismatch. This works round the false positive.
175 */
176 MEM(array = _talloc_zero_array((*call_env_rctx->data), sizeof(uint8_t *),
177 env->count, "void *"));
178 *out = array;
179 }
180 array = (void **)(*out);
181 out = (void **)((uint8_t *)array + sizeof(void *) * env->multi_index);
182 }
183
184 switch (env->rule->pair.parsed.type) {
186 *out = UNCONST(tmpl_t *, env->data.tmpl);
187 break;
188
190 *out = UNCONST(fr_value_box_t *, env->data.vb);
191 continue; /* Can't evaluate these */
192
194 *out = UNCONST(void *, env->data.ptr);
195 continue; /* Can't evaluate these */
196 }
197 }
198
199 /*
200 * If this is not parse_only, we need to expand the tmpl.
201 */
202 if ((env->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_TMPL) && !call_env_parse_only(env->rule->flags)) break;
203 }
204
205 if (!call_env_rctx->last_expanded) { /* No more! */
206 if (call_env_rctx->result) *call_env_rctx->result = CALL_ENV_SUCCESS;
208 }
209
210 ctx = *call_env_rctx->data;
211
212 fr_assert(env != NULL);
213
214 /*
215 * Multi pair options should allocate boxes in the context of the array
216 */
217 if (call_env_multi(env->rule->flags)) {
218 out = (void **)((uint8_t *)(*call_env_rctx->data) + env->rule->pair.offset);
219
220 /*
221 * For multi pair options, allocate the array before expanding the first entry.
222 */
223 if (env->multi_index == 0) {
224 void *array;
225 MEM(array = _talloc_zero_array((*call_env_rctx->data), env->rule->pair.size,
226 env->count, env->rule->pair.type_name));
227 *out = array;
228 }
229 ctx = *out;
230 }
231
232 /*
233 * If the tmpl is already data, we can just copy the data to the right place.
234 */
235 if (tmpl_is_data(call_env_rctx->last_expanded->data.tmpl)) {
236 fr_value_box_t *vb;
237 call_env_result_t result;
238 void *box_out;
239
240 MEM(vb = fr_value_box_acopy(ctx, &call_env_rctx->last_expanded->data.tmpl->data.literal));
241 fr_value_box_list_insert_tail(&call_env_rctx->tmpl_expanded, vb);
242
243 box_out = ((uint8_t*)(*call_env_rctx->data)) + env->rule->pair.offset;
244
245 if (call_env_multi(env->rule->flags)) {
246 void *array = *(void **)box_out;
247 box_out = ((uint8_t *)array) + env->rule->pair.size * env->multi_index;
248 }
249
250 /* coverity[var_deref_model] */
251 result = call_env_result(*call_env_rctx->data, request, box_out, env, &call_env_rctx->tmpl_expanded);
252 if (result != CALL_ENV_SUCCESS) {
253 if (call_env_rctx->result) *call_env_rctx->result = result;
254 return UNLANG_ACTION_FAIL;
255 }
256 goto again;
257 }
258
259 if (unlang_tmpl_push(ctx, &call_env_rctx->expansion_result, &call_env_rctx->tmpl_expanded, request,
260 call_env_rctx->last_expanded->data.tmpl,
261 NULL, UNLANG_SUB_FRAME) < 0) return UNLANG_ACTION_FAIL;
262
264}
265
266/** Extract expanded call environment tmpl and store in env_data
267 *
268 * If there are more call environments to evaluate, push the next one.
269 */
271{
272 void *out = NULL;
273 call_env_rctx_t *call_env_rctx = talloc_get_type_abort(uctx, call_env_rctx_t);
274 call_env_parsed_t const *env;
275 call_env_result_t result;
276
277 /*
278 * Something went wrong expanding the call env
279 * return fail.
280 *
281 * The module should not be executed.
282 */
283 if (call_env_rctx->expansion_result.rcode == RLM_MODULE_FAIL) return UNLANG_ACTION_FAIL;
284
285 env = call_env_rctx->last_expanded;
286 if (!env) return UNLANG_ACTION_CALCULATE_RESULT;
287
288 /*
289 * Find the location of the output
290 */
291 out = ((uint8_t*)(*call_env_rctx->data)) + env->rule->pair.offset;
292
293 /*
294 * If this is a multi pair option, the output is an array.
295 * Find the correct offset in the array
296 */
297 if (call_env_multi(env->rule->flags)) {
298 void *array = *(void **)out;
299 out = ((uint8_t *)array) + env->rule->pair.size * env->multi_index;
300 }
301
302 /* coverity[var_deref_model] */
303 result = call_env_result(*call_env_rctx->data, request, out, env, &call_env_rctx->tmpl_expanded);
304 if (result != CALL_ENV_SUCCESS) {
305 if (call_env_rctx->result) *call_env_rctx->result = result;
306 return UNLANG_ACTION_FAIL;
307 }
308
309 if (!call_env_parsed_next(&call_env_rctx->call_env->parsed, env)) {
310 if (call_env_rctx->result) *call_env_rctx->result = CALL_ENV_SUCCESS;
312 }
313
315 request,
318 NULL,
320 call_env_rctx);
321}
322
323/** Initialise the expansion of a call environment
324 *
325 * @param[in] ctx in which to allocate destination structure for resulting value boxes.
326 * @param[in] request Current request.
327 * @param[out] env_result Where to write the result of the callenv expansion. May be NULL
328 * @param[in,out] env_data Where the destination structure should be created.
329 * @param[in] call_env Call environment being expanded.
330 */
331unlang_action_t call_env_expand(TALLOC_CTX *ctx, request_t *request, call_env_result_t *env_result, void **env_data,
332 call_env_t const *call_env)
333{
334 call_env_rctx_t *call_env_rctx;
335
336 MEM(call_env_rctx = talloc_zero(ctx, call_env_rctx_t));
337 MEM(*env_data = talloc_zero_array(ctx, uint8_t, call_env->method->inst_size));
338 talloc_set_name_const(*env_data, call_env->method->inst_type);
339 call_env_rctx->result = env_result;
340 if (env_result) *env_result = CALL_ENV_INVALID; /* Make sure we ran to completion*/
341 call_env_rctx->data = env_data;
342 call_env_rctx->call_env = call_env;
343 fr_value_box_list_init(&call_env_rctx->tmpl_expanded);
344
346 request,
349 NULL,
351 call_env_rctx);
352}
353
354/** Allocates a new call env parsed struct
355 *
356 */
357static inline CC_HINT(always_inline)
359{
360 call_env_parsed_t *call_env_parsed;
361
362 MEM(call_env_parsed = talloc_zero(ctx, call_env_parsed_t));
363 call_env_parsed->rule = rule;
364 call_env_parsed->count = 1;
365 call_env_parsed->multi_index = 0;
366
367 return call_env_parsed;
368}
369
370static inline CC_HINT(always_inline)
371int call_env_parsed_valid(call_env_parsed_t const *parsed, CONF_ITEM const *ci, call_env_parser_t const *rule)
372{
373 tmpl_t const *tmpl;
374
375 if (rule->pair.parsed.type != CALL_ENV_PARSE_TYPE_TMPL) return 0;
376
377 tmpl = parsed->data.tmpl;
378 switch (tmpl->type) {
379 /*
380 * These can't be created from a call_env flag which is marked as an attribute.
381 */
382 case TMPL_TYPE_DATA:
383 case TMPL_TYPE_EXEC:
384 case TMPL_TYPE_XLAT:
385 fr_assert(!call_env_attribute(rule->flags));
386 break;
387
388 /*
389 * This can be created from multiple types of flags, not just an attribute one.
390 */
391 case TMPL_TYPE_ATTR:
392 break;
393
394 default:
395 cf_log_err(ci, "'%s' expands to invalid tmpl type %s", tmpl->name,
396 tmpl_type_to_str(tmpl->type));
397 return -1;
398 }
399
400 return 0;
401}
402
403/** Standard function we use for parsing call env pairs
404 *
405 * @note This is called where no custom pair parsing function is provided, but may be called by custom functions to avoid
406 * duplicating the standard parsing code.
407 *
408 * @param[in] ctx to allocate any data in.
409 * @param[out] out Where to write the result of parsing.
410 * @param[in] t_rules we're parsing attributes with. Contains the default dictionary and nested 'caller' tmpl_rules_t.
411 * @param[in] ci The #CONF_SECTION or #CONF_PAIR to parse.
412 * @param[in] cec information about the call.
413 * @param[in] rule Parse rules - How the #CONF_PAIR or #CONF_SECTION should be converted.
414 * @return
415 * - 0 on success.
416 * - -1 on failure.
417 */
418int call_env_parse_pair(TALLOC_CTX *ctx, void *out, tmpl_rules_t const *t_rules, CONF_ITEM *ci,
419 UNUSED call_env_ctx_t const *cec, call_env_parser_t const *rule)
420{
421 CONF_PAIR const *to_parse = cf_item_to_pair(ci);
422 tmpl_t *parsed_tmpl;
423 fr_token_t quote = cf_pair_value_quote(to_parse);
424
425 /*
426 * If it's marked as containing an attribute reference,
427 * then always parse it as an attribute reference.
428 */
429 if (call_env_attribute(rule->flags) ||
430 ((quote == T_BARE_WORD) && call_env_bare_word_attribute(rule->flags))) {
431 if (tmpl_afrom_attr_str(ctx, NULL, &parsed_tmpl, cf_pair_value(to_parse), t_rules) <= 0) {
432 return -1;
433 }
434 } else {
435 if (tmpl_afrom_substr(ctx, &parsed_tmpl,
438 t_rules) < 0) {
439 return -1;
440 }
441 }
442 *(void **)out = parsed_tmpl;
443
444 /*
445 * All attributes and functions should be resolved at this point
446 */
447 return tmpl_resolve(parsed_tmpl, NULL);
448}
449
450/** Parse per call env
451 *
452 * Used for config options which must be parsed in the context in which
453 * the module is being called.
454 *
455 * @param[in] ctx To allocate parsed environment in.
456 * @param[out] parsed Where to write parsed environment.
457 * @param[in] name Module name for error messages.
458 * @param[in] t_rules controlling how the call env is parsed.
459 * @param[in] cs Module config.
460 * @param[in] cec information about the call.
461 * @param[in] rule to parse.
462 * @return
463 * - 0 on success;
464 * - <0 on failure;
465 */
466int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char const *name, tmpl_rules_t const *t_rules,
467 CONF_SECTION const *cs,
468 call_env_ctx_t const *cec, call_env_parser_t const *rule) {
469 CONF_PAIR const *cp, *next;
470 call_env_parsed_t *call_env_parsed = NULL;
471 ssize_t count, multi_index;
472 call_env_parser_t const *rule_p = rule;
473
474 while (rule_p->name) {
475 CALL_ENV_DEBUG(cs, "%s: Parsing call env data for %s", name, section_name_str(rule_p->name));
476
477 if (call_env_is_subsection(rule_p->flags)) {
478 CONF_SECTION const *subcs;
479 subcs = cf_section_find(cs, rule_p->name, rule_p->section.name2);
480 if (!subcs && !call_env_parse_missing(rule_p->flags)) {
481 if (!call_env_required(rule_p->flags)) goto next;
482 cf_log_err(cs, "Module %s missing required section \"%s\"", name, rule_p->name);
483 return -1;
484 }
485
486 /*
487 * Hand off to custom parsing function if there is one...
488 */
489 if (rule_p->section.func) {
490 /*
491 * Record our position so we can process any new entries
492 * after the callback returns.
493 */
494 call_env_parsed_t *last = call_env_parsed_tail(parsed);
495
496 CALL_ENV_DEBUG(cs, "%s: Calling subsection callback %p", name, rule_p->section.func);
497
498 if (rule_p->section.func(ctx, parsed, t_rules, cf_section_to_item(subcs), cec, rule_p) < 0) {
499 cf_log_perr(cs, "Failed parsing configuration section %s",
500 rule_p->name == CF_IDENT_ANY ? cf_section_name(cs) : rule_p->name);
501 talloc_free(call_env_parsed);
502 return -1;
503 }
504
505 CALL_ENV_DEBUG(subcs, "%s: Callback returned %u parsed call envs", name,
506 call_env_parsed_num_elements(parsed));
507
508 /*
509 * We _could_ fix up count and multi_index on behalf of
510 * the callback, but there's no guarantee that all call_env_parsed_t
511 * are related to each other, so we don't.
512 */
513 call_env_parsed = last;
514 while ((call_env_parsed = call_env_parsed_next(parsed, call_env_parsed))) {
515 CALL_ENV_DEBUG(subcs, "%s: Checking parsed env", name, rule_p->section.func);
516 if (call_env_parsed_valid(call_env_parsed, cf_section_to_item(subcs), rule_p) < 0) {
517 cf_log_err(cf_section_to_item(subcs), "Invalid data produced by %s",
518 rule_p->name == CF_IDENT_ANY ? cf_section_name(cs) : rule_p->name);
519 return -1;
520 }
521 }
522 goto next;
523 }
524
525 if (call_env_parse(ctx, parsed, name, t_rules, subcs, cec, rule_p->section.subcs) < 0) {
526 CALL_ENV_DEBUG(cs, "%s: Recursive call failed", name);
527 return -1;
528 }
529 goto next;
530 }
531
532 cp = cf_pair_find(cs, rule_p->name);
533
534 if (!cp && !rule_p->pair.dflt) {
535 if (!call_env_required(rule_p->flags)) goto next;
536
537 cf_log_err(cs, "Missing required config item '%s'", rule_p->name);
538 return -1;
539 }
540
541 /*
542 * Check for additional conf pairs and error
543 * if there is one and multi is not allowed.
544 */
545 if (!call_env_multi(rule_p->flags) && ((next = cf_pair_find_next(cs, cp, rule_p->name)))) {
546 cf_log_err(cf_pair_to_item(next), "Invalid duplicate configuration item '%s'", rule_p->name);
547 return -1;
548 }
549
550 count = cf_pair_count(cs, rule_p->name);
551 if (count == 0) count = 1;
552
553 for (multi_index = 0; multi_index < count; multi_index++) {
554 CONF_PAIR *tmp_cp = NULL;
555 CONF_PAIR const *to_parse;
556 tmpl_rules_t our_rules = {};
557 fr_type_t type = rule_p->pair.cast_type;
558 call_env_parse_pair_t func = rule_p->pair.func ? rule_p->pair.func : call_env_parse_pair;
559
560 if (t_rules) {
561 our_rules.parent = t_rules->parent;
562 our_rules.attr.dict_def = t_rules->attr.dict_def;
563 our_rules.escape = rule_p->pair.escape; /* Escape rules will now get embedded in the tmpl_t and used at evaluation */
564 }
565
567 our_rules.cast = ((type == FR_TYPE_VOID) ? FR_TYPE_NULL : type);
568 our_rules.literals_safe_for = rule_p->pair.literals_safe_for;
569
570 call_env_parsed = call_env_parsed_alloc(ctx, rule_p);
571 call_env_parsed->count = count;
572 call_env_parsed->multi_index = multi_index;
573
574 /*
575 * With the conf_parser code we can add default pairs
576 * if they don't exist, but as the same CONF_SECTIONs
577 * are evaluated multiple times for each module call
578 * we can't do that here.
579 */
580 if (cp) {
581 if (call_env_force_quote(rule_p->flags)) {
582 to_parse = tmp_cp = cf_pair_alloc(NULL,
585 call_env_force_quote(rule_p->flags) ? rule_p->pair.dflt_quote : cf_pair_value_quote(cp));
586 } else {
587 to_parse = cp;
588 }
589 } else {
590 to_parse = tmp_cp = cf_pair_alloc(NULL,
591 rule_p->name, rule_p->pair.dflt, T_OP_EQ,
592 T_BARE_WORD, rule_p->pair.dflt_quote);
593 }
594
595 /*
596 * The parsing function can either produce a tmpl_t as tmpl_afrom_substr
597 * would, or produce a custom structure, which will be copied into the
598 * result structure.
599 */
600 if (unlikely(func(ctx, &call_env_parsed->data, &our_rules, cf_pair_to_item(to_parse), cec, rule_p) < 0)) {
601 error:
602 cf_log_perr(to_parse, "Failed to parse configuration item '%s = %s'", rule_p->name, cf_pair_value(to_parse));
603 talloc_free(call_env_parsed);
604 talloc_free(tmp_cp);
605 return -1;
606 }
607 if (!call_env_parsed->data.ptr) {
608 talloc_free(call_env_parsed);
609 goto next_pair;
610 }
611
612 /*
613 * Ensure only valid data is produced.
614 */
615 if (call_env_parsed_valid(call_env_parsed, cf_pair_to_item(to_parse), rule_p) < 0) goto error;
616
617 call_env_parsed_insert_tail(parsed, call_env_parsed);
618 next_pair:
619 talloc_free(tmp_cp);
620 cp = cf_pair_find_next(cs, cp, rule_p->name);
621 }
622 next:
623 rule_p++;
624 }
625
626 CALL_ENV_DEBUG(cs, "Returning afer processing %u rules", (unsigned int)(rule_p - rule));
627
628 return 0;
629}
630
631/** Perform a quick assessment of how many parsed call env will be produced.
632 *
633 * @param[in,out] names_len Where to write the sum of bytes required to represent
634 * the strings which will be parsed as tmpls. This is required
635 * to pre-allocate space for the tmpl name buffers.
636 * @param[in] cs Conf section to search for pairs.
637 * @param[in] call_env to parse.
638 * @return Number of parsed_call_env expected to be required.
639 */
640static size_t call_env_count(size_t *names_len, CONF_SECTION const *cs, call_env_parser_t const *call_env)
641{
642 size_t pair_count, tmpl_count = 0;
643 CONF_PAIR const *cp;
644
645 *names_len = 0;
646
647 while (call_env->name) {
648 if (call_env_is_subsection(call_env->flags)) {
649 CONF_SECTION const *subcs;
650 subcs = cf_section_find(cs, call_env->name, call_env->section.name2);
651 if (!subcs) goto next;
652
653 /*
654 * May only be a callback...
655 */
656 if (call_env->section.subcs) tmpl_count += call_env_count(names_len, subcs, call_env->section.subcs);
657 goto next;
658 }
659 pair_count = 0;
660 cp = NULL;
661 while ((cp = cf_pair_find_next(cs, cp, call_env->name))) {
662 pair_count++;
663 *names_len += talloc_array_length(cf_pair_value(cp));
664 }
665 if (!pair_count && call_env->pair.dflt) {
666 pair_count = 1;
667 *names_len += strlen(call_env->pair.dflt);
668 }
669 tmpl_count += pair_count;
670 next:
671 call_env++;
672 }
673
674 return tmpl_count;
675}
676
677/** Allocate a new call_env_parsed_t structure and add it to the list of parsed call envs
678 *
679 * @note tmpl_t and void * should be allocated in the context of the call_env_parsed_t
680 *
681 * @param[in] ctx to allocate the new call_env_parsed_t in.
682 * @param[out] head to add the new call_env_parsed_t to.
683 * @param[in] rule to base call_env_parsed_t around. MUST NOT BE THE RULE PASSED TO THE CALLBACK.
684 * The rule passed to the callback describes how to parse a subsection, but the
685 * subsection callback is adding rules describing how to parse its children.
686 * @return The new call_env_parsed_t.
687 */
688call_env_parsed_t *call_env_parsed_add(TALLOC_CTX *ctx, call_env_parsed_head_t *head, call_env_parser_t const *rule)
689{
690 call_env_parsed_t *call_env_parsed;
691 call_env_parser_t *our_rules;
692
693 fr_assert_msg(call_env_is_subsection(rule->flags) == false, "Rules added by subsection callbacks cannot be subsections themselves");
694
695 MEM(call_env_parsed = call_env_parsed_alloc(ctx, rule));
696
697 /*
698 * Copy the rule the callback provided, there's no guarantee
699 * it's not stack allocated, or in some way ephemeral.
700 */
701 MEM(our_rules = talloc(call_env_parsed, call_env_parser_t));
702 memcpy(our_rules, rule, sizeof(*our_rules));
703 call_env_parsed->rule = our_rules;
704 call_env_parsed_insert_tail(head, call_env_parsed);
705
706 return call_env_parsed;
707}
708
709/** Assign a tmpl to a call_env_parsed_t
710 *
711 * @note Intended to be used by subsection callbacks to add a tmpl to be
712 * evaluated during the call.
713 *
714 * @param[in] parsed to assign the tmpl to.
715 * @param[in] tmpl to assign.
716 */
718{
719 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_TMPL, "Rule must indicate parsed output is a tmpl_t");
720 parsed->data.tmpl = tmpl;
721}
722
723/** Assign a value box to a call_env_parsed_t
724 *
725 * @note Intended to be used by subsection callbacks to set a static boxed
726 * value to be written out to the result structure.
727 *
728 * @param[in] parsed to assign the tmpl to.
729 * @param[in] vb to assign.
730 */
732{
733 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_VALUE_BOX, "Rule must indicate parsed output is a value box");
734 parsed->data.vb = vb;
735}
736
737/** Assign data to a call_env_parsed_t
738 *
739 * @note Intended to be used by subsection callbacks to set arbitrary data
740 * to be written out to the result structure.
741 *
742 * @param[in] parsed to assign the tmpl to.
743 * @param[in] data to assign.
744 */
746{
747 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_VOID, "Rule must indicate parsed output is a void *");
748 parsed->data.ptr = data;
749}
750
751/** Assign a count and index to a call_env_parsed_t
752 *
753 * @note Intended to be used by subsection callbacks to indicate related
754 * call_env_parsed_t.
755 *
756 * @param[in] parsed to modify metadata of.
757 * @param[in] count to assign.
758 * @param[in] index to assign.
759 */
760void call_env_parsed_set_multi_index(call_env_parsed_t *parsed, size_t count, size_t index)
761{
762 fr_assert_msg(call_env_multi(parsed->rule->flags), "Rule must indicate parsed output is a multi pair");
763 parsed->multi_index = index;
764 parsed->count = count;
765}
766
767/** Remove a call_env_parsed_t from the list of parsed call envs
768 *
769 * @note Intended to be used by subsection callbacks to remove a call_env_parsed_t
770 * from the list of parsed call envs (typically on error).
771 *
772 * @param[in] parsed to remove parsed data from.
773 * @param[in] ptr to remove.
774 */
775void call_env_parsed_free(call_env_parsed_head_t *parsed, call_env_parsed_t *ptr)
776{
777 call_env_parsed_remove(parsed, ptr);
778 talloc_free(ptr);
779}
780
781/** Given a call_env_method, parse all call_env_pair_t in the context of a specific call to an xlat or module method
782 *
783 * @param[in] ctx to allocate the call_env_t in.
784 * @param[in] name Module name for error messages.
785 * @param[in] call_env_method containing the call_env_pair_t to evaluate against the specified CONF_SECTION.
786 * @param[in] t_rules that control how call_env_pair_t are parsed.
787 * @param[in] cs to parse in the context of the call.
788 * @param[in] cec information about how the call is being made.
789 * @return
790 * - A new call_env_t on success.
791 * - NULL on failure.
792 */
793call_env_t *call_env_alloc(TALLOC_CTX *ctx, char const *name, call_env_method_t const *call_env_method,
794 tmpl_rules_t const *t_rules, CONF_SECTION *cs, call_env_ctx_t const *cec)
795{
796 unsigned int count;
797 size_t names_len;
798 call_env_t *call_env;
799
800 /*
801 * Only used if caller doesn't use a more specific assert
802 */
803 fr_assert_msg(call_env_method->inst_size, "inst_size 0 for %s, method_env (%p)", name, call_env_method);
804
805 /*
806 * Firstly assess how many parsed env there will be and create a talloc pool to hold them.
807 * The pool size is a rough estimate based on each tmpl also allocating at least two children,
808 * for which we allow twice the length of the value to be parsed.
809 */
810 count = call_env_count(&names_len, cs, call_env_method->env);
811
812 /*
813 * Pre-allocated headers:
814 * 1 header for the call_env_pair_parsed_t, 1 header for the tmpl_t, 1 header for the name,
815 * one header for the value.
816 *
817 * Pre-allocated memory:
818 * ((sizeof(call_env_pair_parsed_t) + sizeof(tmpl_t)) * count) + (names of tmpls * 2)... Not sure what
819 * the * 2 is for, maybe for slop?
820 */
821 MEM(call_env = talloc_pooled_object(ctx, call_env_t, count * 4, (sizeof(call_env_parser_t) + sizeof(tmpl_t)) * count + names_len * 2));
822 call_env->method = call_env_method;
823 call_env_parsed_init(&call_env->parsed);
824 if (call_env_parse(call_env, &call_env->parsed, name, t_rules, cs, cec, call_env_method->env) < 0) {
825 talloc_free(call_env);
826 return NULL;
827 }
828
829 return call_env;
830}
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_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
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSID(id)
Definition build.h:485
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
call_env_parser_t const * rule
Used to produce this.
Definition call_env.c:54
size_t count
Number of CONF_PAIRs found, matching the call_env_parser_t.
Definition call_env.c:52
int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char const *name, tmpl_rules_t const *t_rules, CONF_SECTION const *cs, call_env_ctx_t const *cec, call_env_parser_t const *rule)
Parse per call env.
Definition call_env.c:466
call_env_parsed_t const * last_expanded
The last expanded tmpl.
Definition call_env.c:125
void call_env_parsed_free(call_env_parsed_head_t *parsed, call_env_parsed_t *ptr)
Remove a call_env_parsed_t from the list of parsed call envs.
Definition call_env.c:775
static unlang_action_t call_env_expand_start(UNUSED unlang_result_t *p_result, request_t *request, void *uctx)
Start the expansion of a call environment tmpl.
Definition call_env.c:135
static unlang_action_t call_env_expand_repeat(UNUSED unlang_result_t *p_result, request_t *request, void *uctx)
Extract expanded call environment tmpl and store in env_data.
Definition call_env.c:270
#define CALL_ENV_DEBUG(_ci,...)
Definition call_env.c:61
static int call_env_parsed_valid(call_env_parsed_t const *parsed, CONF_ITEM const *ci, call_env_parser_t const *rule)
Definition call_env.c:371
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:331
static call_env_parsed_t * call_env_parsed_alloc(TALLOC_CTX *ctx, call_env_parser_t const *rule)
Allocates a new call env parsed struct.
Definition call_env.c:358
call_env_parsed_t * call_env_parsed_add(TALLOC_CTX *ctx, call_env_parsed_head_t *head, call_env_parser_t const *rule)
Allocate a new call_env_parsed_t structure and add it to the list of parsed call envs.
Definition call_env.c:688
call_env_t const * call_env
Call env being expanded.
Definition call_env.c:124
static size_t call_env_count(size_t *names_len, CONF_SECTION const *cs, call_env_parser_t const *call_env)
Perform a quick assessment of how many parsed call env will be produced.
Definition call_env.c:640
size_t multi_index
Array index for this instance.
Definition call_env.c:53
void call_env_parsed_set_multi_index(call_env_parsed_t *parsed, size_t count, size_t index)
Assign a count and index to a call_env_parsed_t.
Definition call_env.c:760
call_env_parsed_entry_t entry
Entry in list of parsed call_env_parsers.
Definition call_env.c:44
call_env_result_t * result
Where to write the return code of callenv expansion.
Definition call_env.c:122
void ** data
Final destination structure for value boxes.
Definition call_env.c:127
fr_value_box_list_t tmpl_expanded
List to write value boxes to as tmpls are expanded.
Definition call_env.c:126
void call_env_parsed_set_data(call_env_parsed_t *parsed, void const *data)
Assign data to a call_env_parsed_t.
Definition call_env.c:745
union call_env_parsed_s::@99 data
call_env_t * call_env_alloc(TALLOC_CTX *ctx, char const *name, call_env_method_t const *call_env_method, tmpl_rules_t const *t_rules, CONF_SECTION *cs, call_env_ctx_t const *cec)
Given a call_env_method, parse all call_env_pair_t in the context of a specific call to an xlat or mo...
Definition call_env.c:793
void call_env_parsed_set_value(call_env_parsed_t *parsed, fr_value_box_t const *vb)
Assign a value box to a call_env_parsed_t.
Definition call_env.c:731
void call_env_parsed_set_tmpl(call_env_parsed_t *parsed, tmpl_t const *tmpl)
Assign a tmpl to a call_env_parsed_t.
Definition call_env.c:717
int call_env_parse_pair(TALLOC_CTX *ctx, void *out, tmpl_rules_t const *t_rules, CONF_ITEM *ci, UNUSED call_env_ctx_t const *cec, call_env_parser_t const *rule)
Standard function we use for parsing call env pairs.
Definition call_env.c:418
unlang_result_t expansion_result
The result of calling the call env expansions functions.
Definition call_env.c:123
static call_env_result_t call_env_result(TALLOC_CTX *ctx, request_t *request, void *out, call_env_parsed_t const *env, fr_value_box_list_t *tmpl_expanded)
Parse the result of call_env tmpl expansion.
Definition call_env.c:67
Context to keep track of expansion of call environments.
Definition call_env.c:121
Structures and functions for handling call environments.
#define call_env_parse_missing(_flags)
Definition call_env.h:132
call_env_flags_t flags
Flags controlling parser behaviour.
Definition call_env.h:182
#define call_env_is_subsection(_flags)
Definition call_env.h:130
#define call_env_required(_flags)
Definition call_env.h:114
char const * name
Of conf pair to pass to tmpl_tokenizer.
Definition call_env.h:181
#define call_env_nullable(_flags)
Definition call_env.h:122
#define call_env_multi(_flags)
Definition call_env.h:120
#define call_env_single(_flags)
Definition call_env.h:118
#define call_env_concat(_flags)
Definition call_env.h:116
@ CALL_ENV_RESULT_TYPE_VALUE_BOX_LIST
Output of the evaluation phase is a list of value boxes.
Definition call_env.h:69
@ CALL_ENV_RESULT_TYPE_VALUE_BOX
Output of the evaluation phase is a single value box.
Definition call_env.h:68
size_t inst_size
Size of per call env.
Definition call_env.h:245
#define call_env_attribute(_flags)
Definition call_env.h:128
call_env_result_t
Definition call_env.h:51
@ CALL_ENV_INVALID
Definition call_env.h:54
@ CALL_ENV_MISSING
Definition call_env.h:53
@ CALL_ENV_SUCCESS
Definition call_env.h:52
call_env_parser_t const * env
Parsing rules for call method env.
Definition call_env.h:247
char const * inst_type
Type of per call env.
Definition call_env.h:246
#define call_env_parse_only(_flags)
Definition call_env.h:126
#define call_env_force_quote(_flags)
Definition call_env.h:124
call_env_parsed_head_t parsed
The per call parsed call environment.
Definition call_env.h:253
@ CALL_ENV_PARSE_TYPE_VALUE_BOX
Output of the parsing phase is a single value box (static data).
Definition call_env.h:61
@ CALL_ENV_PARSE_TYPE_TMPL
Output of the parsing phase is a tmpl_t.
Definition call_env.h:60
@ CALL_ENV_PARSE_TYPE_VOID
Output of the parsing phase is undefined (a custom structure).
Definition call_env.h:62
#define call_env_bare_word_attribute(_flags)
Definition call_env.h:136
call_env_method_t const * method
The method this call env is for.
Definition call_env.h:254
int(* call_env_parse_pair_t)(TALLOC_CTX *ctx, void *out, tmpl_rules_t const *t_rules, CONF_ITEM *ci, call_env_ctx_t const *cec, call_env_parser_t const *rule)
Callback for performing custom parsing of a CONF_PAIR.
Definition call_env.h:151
Per method call config.
Definition call_env.h:180
Structure containing both a talloc pool, a list of parsed call_env_pairs.
Definition call_env.h:252
Common header for all CONF_* types.
Definition cf_priv.h:49
Configuration AVP similar to a fr_pair_t.
Definition cf_priv.h:70
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
fr_token_t cf_pair_attr_quote(CONF_PAIR const *pair)
Return the value (lhs) quoting of a pair.
Definition cf_util.c:1622
CONF_PAIR * cf_pair_find_next(CONF_SECTION const *cs, CONF_PAIR const *prev, char const *attr)
Find a pair with a name matching attr, after specified pair.
Definition cf_util.c:1452
unsigned int cf_pair_count(CONF_SECTION const *cs, char const *attr)
Count the number of times an attribute occurs in a parent section.
Definition cf_util.c:1519
CONF_ITEM * cf_section_to_item(CONF_SECTION const *cs)
Cast a CONF_SECTION to a CONF_ITEM.
Definition cf_util.c:737
CONF_PAIR * cf_pair_alloc(CONF_SECTION *parent, char const *attr, char const *value, fr_token_t op, fr_token_t lhs_quote, fr_token_t rhs_quote)
Allocate a CONF_PAIR.
Definition cf_util.c:1278
CONF_SECTION * cf_section_find(CONF_SECTION const *cs, char const *name1, char const *name2)
Find a CONF_SECTION with name1 and optionally name2.
Definition cf_util.c:1027
CONF_PAIR * cf_pair_find(CONF_SECTION const *cs, char const *attr)
Search for a CONF_PAIR with a specific name.
Definition cf_util.c:1438
char const * cf_section_name(CONF_SECTION const *cs)
Return name2 if set, else name1.
Definition cf_util.c:1196
fr_token_t cf_pair_operator(CONF_PAIR const *pair)
Return the operator of a pair.
Definition cf_util.c:1607
fr_token_t cf_pair_value_quote(CONF_PAIR const *pair)
Return the value (rhs) quoting of a pair.
Definition cf_util.c:1637
CONF_PAIR * cf_item_to_pair(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_PAIR.
Definition cf_util.c:663
char const * cf_pair_value(CONF_PAIR const *pair)
Return the value of a CONF_PAIR.
Definition cf_util.c:1593
CONF_ITEM * cf_pair_to_item(CONF_PAIR const *cp)
Cast a CONF_PAIR to a CONF_ITEM.
Definition cf_util.c:721
char const * cf_pair_attr(CONF_PAIR const *pair)
Return the attr of a CONF_PAIR.
Definition cf_util.c:1577
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:289
#define cf_log_perr(_cf, _fmt,...)
Definition cf_util.h:296
#define CF_IDENT_ANY
Definition cf_util.h:78
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:202
#define MEM(x)
Definition debug.h:36
#define FR_DLIST_FUNCS(_name, _element_type, _element_entry)
Define type specific wrapper functions for dlists.
Definition dlist.h:1152
#define unlang_function_push_with_result(_result_p, _request, _func, _repeat, _signal, _sigmask, _top_frame, _uctx)
Push a generic function onto the unlang stack that produces a result.
Definition function.h:144
#define UNLANG_SUB_FRAME
Definition interpret.h:37
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:134
#define RPEDEBUG(fmt,...)
Definition log.h:376
talloc_free(reap)
fr_type_t
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
@ FR_TYPE_VOID
User data.
long int ssize_t
unsigned char uint8_t
#define fr_assert(_expr)
Definition rad_assert.h:38
@ RLM_MODULE_FAIL
Module failed, don't reply.
Definition rcode.h:44
fr_dict_attr_t const * request_attr_request
Definition request.c:43
static char const * name
#define FR_SBUFF_IN(_start, _len_or_end)
static char const * section_name_str(char const *name)
Return a printable string for the section name.
Definition section.h:98
static char const * tmpl_type_to_str(tmpl_type_t type)
Return a static string containing the type name.
Definition tmpl.h:634
tmpl_escape_t escape
How escaping should be handled during evaluation.
Definition tmpl.h:349
int tmpl_resolve(tmpl_t *vpt, tmpl_res_rules_t const *tr_rules))
Attempt to resolve functions and attributes in xlats and attribute references.
fr_value_box_safe_for_t literals_safe_for
safe_for value assigned to literal values in xlats, execs, and data.
Definition tmpl.h:347
tmpl_rules_t const * parent
for parent / child relationships
Definition tmpl.h:333
ssize_t tmpl_afrom_attr_str(TALLOC_CTX *ctx, tmpl_attr_error_t *err, tmpl_t **out, char const *name, tmpl_rules_t const *rules))
Parse a string into a TMPL_TYPE_ATTR_* type tmpl_t.
@ TMPL_TYPE_ATTR
Reference to one or more attributes.
Definition tmpl.h:142
@ TMPL_TYPE_XLAT
Pre-parsed xlat expansion.
Definition tmpl.h:146
@ TMPL_TYPE_EXEC
Callout to an external script or program.
Definition tmpl.h:150
@ TMPL_TYPE_DATA
Value in native boxed format.
Definition tmpl.h:138
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.
#define tmpl_is_data(vpt)
Definition tmpl.h:206
fr_type_t cast
Whether there was an explicit cast.
Definition tmpl.h:340
tmpl_attr_rules_t attr
Rules/data for parsing attribute references.
Definition tmpl.h:335
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:332
return count
Definition module.c:155
fr_aka_sim_id_type_t type
fr_dict_attr_t const * list_def
Default list to use with unqualified attribute reference.
Definition tmpl.h:295
fr_dict_t const * dict_def
Default dictionary to use with unqualified attribute references.
Definition tmpl.h:273
Functions which we wish were included in the standard talloc distribution.
#define talloc_pooled_object(_ctx, _type, _num_subobjects, _total_subobjects_size)
Definition talloc.h:180
static size_t talloc_strlen(char const *s)
Returns the length of a talloc array containing a string.
Definition talloc.h:294
int unlang_tmpl_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args, bool top_frame)
Push a tmpl onto the stack for evaluation.
Definition tmpl.c:276
enum fr_token fr_token_t
@ T_BARE_WORD
Definition token.h:120
@ T_OP_EQ
Definition token.h:83
static fr_slen_t head
Definition xlat.h:420
fr_sbuff_parse_rules_t const * value_parse_rules_quoted[T_TOKEN_LAST]
Parse rules for quoted strings.
Definition value.c:612
void fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t const *src)
Perform a shallow copy of a value_box.
Definition value.c:4281
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:6236
@ FR_VALUE_BOX_LIST_FREE
Definition value.h:239
static fr_slen_t data
Definition value.h:1291
static fr_value_box_t * fr_value_box_acopy(TALLOC_CTX *ctx, fr_value_box_t const *src)
Copy an existing box, allocating a new box to hold its contents.
Definition value.h:737
static size_t char ** out
Definition value.h:1023