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: b9fa2f847fabd784a50ad52670c2589e6a12ba52 $
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: b9fa2f847fabd784a50ad52670c2589e6a12ba52 $")
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,
68 void **tmpl_out, call_env_parsed_t const *env,
69 fr_value_box_list_t *tmpl_expanded)
70{
72
73 if (tmpl_out) *tmpl_out = UNCONST(tmpl_t *, env->data.tmpl);
74 if (call_env_parse_only(env->rule->flags)) return CALL_ENV_SUCCESS;
75
76 vb = fr_value_box_list_head(tmpl_expanded);
77 if (!vb) {
78 if (!call_env_nullable(env->rule->flags)) {
79 RPEDEBUG("Failed to evaluate required module option %s = %s", env->rule->name, env->data.tmpl->name);
80 return CALL_ENV_MISSING;
81 }
82 return CALL_ENV_SUCCESS;
83 }
84
85 /*
86 * Concatenate multiple boxes if needed
87 */
88 if ((call_env_concat(env->rule->flags) || call_env_attribute(env->rule->flags)) &&
89 (env->rule->pair.cast_type != FR_TYPE_VOID) &&
90 fr_value_box_list_concat_in_place(vb, vb, tmpl_expanded, env->rule->pair.cast_type,
91 FR_VALUE_BOX_LIST_FREE, true, SIZE_MAX) < 0 ) {
92 RPEDEBUG("Failed concatenating values for %s", env->rule->name);
93 return CALL_ENV_INVALID;
94 }
95
96 if (call_env_single(env->rule->flags) && (fr_value_box_list_num_elements(tmpl_expanded) > 1)) {
97 RPEDEBUG("%u values found for %s. Only one is allowed",
98 fr_value_box_list_num_elements(tmpl_expanded), env->rule->name);
99 return CALL_ENV_INVALID;
100 }
101
102 while ((vb = fr_value_box_list_pop_head(tmpl_expanded))) {
103 switch (env->rule->pair.type) {
106 break;
107
109 if (!fr_value_box_list_initialised((fr_value_box_list_t *)out)) fr_value_box_list_init((fr_value_box_list_t *)out);
110 fr_value_box_list_insert_tail((fr_value_box_list_t *)out, vb);
111 break;
112
113 default:
114 fr_assert(0);
115 break;
116 }
117 }
118
119 return CALL_ENV_SUCCESS;
120}
121
122/** Context to keep track of expansion of call environments
123 *
124 */
125typedef struct {
126 call_env_result_t *result; //!< Where to write the return code of callenv expansion.
127 unlang_result_t expansion_result; //!< The result of calling the call env expansions functions.
128 call_env_t const *call_env; //!< Call env being expanded.
129 call_env_parsed_t const *last_expanded; //!< The last expanded tmpl.
130 fr_value_box_list_t tmpl_expanded; //!< List to write value boxes to as tmpls are expanded.
131 void **data; //!< Final destination structure for value boxes.
133
134static unlang_action_t call_env_expand_repeat(UNUSED unlang_result_t *p_result, request_t *request, void *uctx);
135
136/** Start the expansion of a call environment tmpl.
137 *
138 */
140{
141 call_env_rctx_t *call_env_rctx = talloc_get_type_abort(uctx, call_env_rctx_t);
142 TALLOC_CTX *ctx;
143 call_env_parsed_t const *env = NULL;
144 void **out;
145
146 while ((call_env_rctx->last_expanded = call_env_parsed_next(&call_env_rctx->call_env->parsed, call_env_rctx->last_expanded))) {
147 env = call_env_rctx->last_expanded;
148 fr_assert(env != NULL);
149
150 /*
151 * Subsections are expanded during parsing to produce a list of
152 * call_env_parsed_t. They are not expanded at runtime.
153 */
154 fr_assert_msg(call_env_is_subsection(env->rule->flags) == false, "Subsections cannot be expanded at runtime");
155
156 /*
157 * If there's an offset to copy the output to, do that.
158 * We may also need to expand the tmpl_t and write out the result
159 * to the pair offset.
160 */
161 if (env->rule->pair.parsed.offset >= 0) {
162 /*
163 * If we only need the tmpl or data, just set the pointer and move the next.
164 */
165 out = (void **)((uint8_t *)*call_env_rctx->data + env->rule->pair.parsed.offset);
166
167 /*
168 * For multi pair options, the pointers need to go into a new array.
169 * When processing the first expansion, allocate the array, and for
170 * all expansions adjust the `out` pointer to write to.
171 */
172 if (call_env_multi(env->rule->flags)) {
173 void **array;
174 if (env->multi_index == 0) {
175 /*
176 * Coverity thinks talloc_zero_array being called with the type `void *`
177 * is a size mismatch. This works round the false positive.
178 */
179 MEM(array = _talloc_zero_array((*call_env_rctx->data), sizeof(uint8_t *),
180 env->count, "void *"));
181 *out = array;
182 }
183 array = (void **)(*out);
184 out = (void **)((uint8_t *)array + sizeof(void *) * env->multi_index);
185 }
186
187 switch (env->rule->pair.parsed.type) {
189 *out = UNCONST(tmpl_t *, env->data.tmpl);
190 break;
191
193 *out = UNCONST(fr_value_box_t *, env->data.vb);
194 continue; /* Can't evaluate these */
195
197 *out = UNCONST(void *, env->data.ptr);
198 continue; /* Can't evaluate these */
199 }
200 }
201
202 /*
203 * If this is not parse_only, we need to expand the tmpl.
204 */
205 if ((env->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_TMPL) && !call_env_parse_only(env->rule->flags)) break;
206 }
207
208 if (!call_env_rctx->last_expanded) { /* No more! */
209 if (call_env_rctx->result) *call_env_rctx->result = CALL_ENV_SUCCESS;
211 }
212
213 ctx = *call_env_rctx->data;
214
215 fr_assert(env != NULL);
216
217 /*
218 * Multi pair options should allocate boxes in the context of the array
219 */
220 if (call_env_multi(env->rule->flags)) {
221 out = (void **)((uint8_t *)(*call_env_rctx->data) + env->rule->pair.offset);
222
223 /*
224 * For multi pair options, allocate the array before expanding the first entry.
225 */
226 if (env->multi_index == 0) {
227 void *array;
228 MEM(array = _talloc_zero_array((*call_env_rctx->data), env->rule->pair.size,
229 env->count, env->rule->pair.type_name));
230 *out = array;
231 }
232 ctx = *out;
233 }
234
235 if (unlang_tmpl_push(ctx, &call_env_rctx->tmpl_expanded, request, call_env_rctx->last_expanded->data.tmpl,
236 NULL) < 0) return UNLANG_ACTION_FAIL;
237
239}
240
241/** Extract expanded call environment tmpl and store in env_data
242 *
243 * If there are more tmpls to expand, push the next expansion.
244 */
246{
247 void *out = NULL, *tmpl_out = NULL;
248 call_env_rctx_t *call_env_rctx = talloc_get_type_abort(uctx, call_env_rctx_t);
249 call_env_parsed_t const *env;
250 call_env_result_t result;
251
252 /*
253 * Something went wrong expanding the call env
254 * return fail.
255 *
256 * The module should not be executed.
257 */
258 if (call_env_rctx->expansion_result.rcode == RLM_MODULE_FAIL) return UNLANG_ACTION_FAIL;
259
260 env = call_env_rctx->last_expanded;
261 if (!env) return UNLANG_ACTION_CALCULATE_RESULT;
262
263 if (call_env_parse_only(env->rule->flags)) goto parse_only;
264 /*
265 * Find the location of the output
266 */
267 out = ((uint8_t*)(*call_env_rctx->data)) + env->rule->pair.offset;
268
269 /*
270 * If this is a multi pair option, the output is an array.
271 * Find the correct offset in the array
272 */
273 if (call_env_multi(env->rule->flags)) {
274 void *array = *(void **)out;
275 out = ((uint8_t *)array) + env->rule->pair.size * env->multi_index;
276 }
277
278parse_only:
279 if (env->rule->pair.parsed.offset >= 0) tmpl_out = ((uint8_t *)*call_env_rctx->data) + env->rule->pair.parsed.offset;
280
281 /* coverity[var_deref_model] */
282 result = call_env_result(*call_env_rctx->data, request, out, tmpl_out, env, &call_env_rctx->tmpl_expanded);
283 if (result != CALL_ENV_SUCCESS) {
284 if (call_env_rctx->result) *call_env_rctx->result = result;
285 return UNLANG_ACTION_FAIL;
286 }
287
288 if (!call_env_parsed_next(&call_env_rctx->call_env->parsed, env)) {
289 if (call_env_rctx->result) *call_env_rctx->result = CALL_ENV_SUCCESS;
291 }
292
294 request,
297 NULL,
299 call_env_rctx);
300}
301
302/** Initialise the expansion of a call environment
303 *
304 * @param[in] ctx in which to allocate destination structure for resulting value boxes.
305 * @param[in] request Current request.
306 * @param[out] env_result Where to write the result of the callenv expansion. May be NULL
307 * @param[in,out] env_data Where the destination structure should be created.
308 * @param[in] call_env Call environment being expanded.
309 */
310unlang_action_t call_env_expand(TALLOC_CTX *ctx, request_t *request, call_env_result_t *env_result, void **env_data,
311 call_env_t const *call_env)
312{
313 call_env_rctx_t *call_env_rctx;
314
315 MEM(call_env_rctx = talloc_zero(ctx, call_env_rctx_t));
316 MEM(*env_data = talloc_zero_array(ctx, uint8_t, call_env->method->inst_size));
317 talloc_set_name_const(*env_data, call_env->method->inst_type);
318 call_env_rctx->result = env_result;
319 if (env_result) *env_result = CALL_ENV_INVALID; /* Make sure we ran to completion*/
320 call_env_rctx->data = env_data;
321 call_env_rctx->call_env = call_env;
322 fr_value_box_list_init(&call_env_rctx->tmpl_expanded);
323
325 request,
328 NULL,
330 call_env_rctx);
331}
332
333/** Allocates a new call env parsed struct
334 *
335 */
336static inline CC_HINT(always_inline)
338{
339 call_env_parsed_t *call_env_parsed;
340
341 MEM(call_env_parsed = talloc_zero(ctx, call_env_parsed_t));
342 call_env_parsed->rule = rule;
343 call_env_parsed->count = 1;
344 call_env_parsed->multi_index = 0;
345
346 return call_env_parsed;
347}
348
349static inline CC_HINT(always_inline)
350int call_env_parsed_valid(call_env_parsed_t const *parsed, CONF_ITEM const *ci, call_env_parser_t const *rule)
351{
352 tmpl_t const *tmpl;
353
354 if (rule->pair.parsed.type != CALL_ENV_PARSE_TYPE_TMPL) return 0;
355
356 tmpl = parsed->data.tmpl;
357 switch (tmpl->type) {
358 /*
359 * These can't be created from a call_env flag which is marked as an attribute.
360 */
361 case TMPL_TYPE_DATA:
362 case TMPL_TYPE_EXEC:
363 case TMPL_TYPE_XLAT:
364 fr_assert(!call_env_attribute(rule->flags));
365 break;
366
367 /*
368 * This can be created from multiple types of flags, not just an attribute one.
369 */
370 case TMPL_TYPE_ATTR:
371 break;
372
373 default:
374 cf_log_err(ci, "'%s' expands to invalid tmpl type %s", tmpl->name,
375 tmpl_type_to_str(tmpl->type));
376 return -1;
377 }
378
379 return 0;
380}
381
382/** Standard function we use for parsing call env pairs
383 *
384 * @note This is called where no custom pair parsing function is provided, but may be called by custom functions to avoid
385 * duplicating the standard parsing code.
386 *
387 * @param[in] ctx to allocate any data in.
388 * @param[out] out Where to write the result of parsing.
389 * @param[in] t_rules we're parsing attributes with. Contains the default dictionary and nested 'caller' tmpl_rules_t.
390 * @param[in] ci The #CONF_SECTION or #CONF_PAIR to parse.
391 * @param[in] cec information about the call.
392 * @param[in] rule Parse rules - How the #CONF_PAIR or #CONF_SECTION should be converted.
393 * @return
394 * - 0 on success.
395 * - -1 on failure.
396 */
397int call_env_parse_pair(TALLOC_CTX *ctx, void *out, tmpl_rules_t const *t_rules, CONF_ITEM *ci,
398 UNUSED call_env_ctx_t const *cec, call_env_parser_t const *rule)
399{
400 CONF_PAIR const *to_parse = cf_item_to_pair(ci);
401 tmpl_t *parsed_tmpl;
402 fr_token_t quote = cf_pair_value_quote(to_parse);
403
404 /*
405 * If it's marked as containing an attribute reference,
406 * then always parse it as an attribute reference.
407 */
408 if (call_env_attribute(rule->flags) ||
409 ((quote == T_BARE_WORD) && call_env_bare_word_attribute(rule->flags))) {
410 if (tmpl_afrom_attr_str(ctx, NULL, &parsed_tmpl, cf_pair_value(to_parse), t_rules) <= 0) {
411 return -1;
412 }
413 } else {
414 if (tmpl_afrom_substr(ctx, &parsed_tmpl,
417 t_rules) < 0) {
418 return -1;
419 }
420 }
421 *(void **)out = parsed_tmpl;
422
423 /*
424 * All attributes and functions should be resolved at this point
425 */
426 return tmpl_resolve(parsed_tmpl, NULL);
427}
428
429/** Parse per call env
430 *
431 * Used for config options which must be parsed in the context in which
432 * the module is being called.
433 *
434 * @param[in] ctx To allocate parsed environment in.
435 * @param[out] parsed Where to write parsed environment.
436 * @param[in] name Module name for error messages.
437 * @param[in] t_rules controlling how the call env is parsed.
438 * @param[in] cs Module config.
439 * @param[in] cec information about the call.
440 * @param[in] rule to parse.
441 * @return
442 * - 0 on success;
443 * - <0 on failure;
444 */
445static int call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *parsed, char const *name, tmpl_rules_t const *t_rules,
446 CONF_SECTION const *cs,
447 call_env_ctx_t const *cec, call_env_parser_t const *rule) {
448 CONF_PAIR const *cp, *next;
449 call_env_parsed_t *call_env_parsed = NULL;
450 ssize_t count, multi_index;
451 call_env_parser_t const *rule_p = rule;
452
453 while (rule_p->name) {
454 CALL_ENV_DEBUG(cs, "%s: Parsing call env data for %s", name, section_name_str(rule_p->name));
455
456 if (call_env_is_subsection(rule_p->flags)) {
457 CONF_SECTION const *subcs;
458 subcs = cf_section_find(cs, rule_p->name, rule_p->section.name2);
459 if (!subcs && !call_env_parse_missing(rule_p->flags)) {
460 if (!call_env_required(rule_p->flags)) goto next;
461 cf_log_err(cs, "Module %s missing required section \"%s\"", name, rule_p->name);
462 return -1;
463 }
464
465 /*
466 * Hand off to custom parsing function if there is one...
467 */
468 if (rule_p->section.func) {
469 /*
470 * Record our position so we can process any new entries
471 * after the callback returns.
472 */
473 call_env_parsed_t *last = call_env_parsed_tail(parsed);
474
475 CALL_ENV_DEBUG(cs, "%s: Calling subsection callback %p", name, rule_p->section.func);
476
477 if (rule_p->section.func(ctx, parsed, t_rules, cf_section_to_item(subcs), cec, rule_p) < 0) {
478 cf_log_perr(cs, "Failed parsing configuration section %s",
479 rule_p->name == CF_IDENT_ANY ? cf_section_name(cs) : rule_p->name);
480 talloc_free(call_env_parsed);
481 return -1;
482 }
483
484 CALL_ENV_DEBUG(subcs, "%s: Callback returned %u parsed call envs", name,
485 call_env_parsed_num_elements(parsed));
486
487 /*
488 * We _could_ fix up count and multi_index on behalf of
489 * the callback, but there's no guarantee that all call_env_parsed_t
490 * are related to each other, so we don't.
491 */
492 call_env_parsed = last;
493 while ((call_env_parsed = call_env_parsed_next(parsed, call_env_parsed))) {
494 CALL_ENV_DEBUG(subcs, "%s: Checking parsed env", name, rule_p->section.func);
495 if (call_env_parsed_valid(call_env_parsed, cf_section_to_item(subcs), rule_p) < 0) {
496 cf_log_err(cf_section_to_item(subcs), "Invalid data produced by %s",
497 rule_p->name == CF_IDENT_ANY ? cf_section_name(cs) : rule_p->name);
498 return -1;
499 }
500 }
501 goto next;
502 }
503
504 if (call_env_parse(ctx, parsed, name, t_rules, subcs, cec, rule_p->section.subcs) < 0) {
505 CALL_ENV_DEBUG(cs, "%s: Recursive call failed", name);
506 return -1;
507 }
508 goto next;
509 }
510
511 cp = cf_pair_find(cs, rule_p->name);
512
513 if (!cp && !rule_p->pair.dflt) {
514 if (!call_env_required(rule_p->flags)) goto next;
515
516 cf_log_err(cs, "Missing required config item '%s'", rule_p->name);
517 return -1;
518 }
519
520 /*
521 * Check for additional conf pairs and error
522 * if there is one and multi is not allowed.
523 */
524 if (!call_env_multi(rule_p->flags) && ((next = cf_pair_find_next(cs, cp, rule_p->name)))) {
525 cf_log_err(cf_pair_to_item(next), "Invalid duplicate configuration item '%s'", rule_p->name);
526 return -1;
527 }
528
529 count = cf_pair_count(cs, rule_p->name);
530 if (count == 0) count = 1;
531
532 for (multi_index = 0; multi_index < count; multi_index++) {
533 CONF_PAIR *tmp_cp = NULL;
534 CONF_PAIR const *to_parse;
535 tmpl_rules_t our_rules = {};
536 fr_type_t type = rule_p->pair.cast_type;
537 call_env_parse_pair_t func = rule_p->pair.func ? rule_p->pair.func : call_env_parse_pair;
538
539 if (t_rules) {
540 our_rules.parent = t_rules->parent;
541 our_rules.attr.dict_def = t_rules->attr.dict_def;
542 our_rules.escape = rule_p->pair.escape; /* Escape rules will now get embedded in the tmpl_t and used at evaluation */
543 }
544
546 our_rules.cast = ((type == FR_TYPE_VOID) ? FR_TYPE_NULL : type);
547 our_rules.literals_safe_for = rule_p->pair.literals_safe_for;
548
549 call_env_parsed = call_env_parsed_alloc(ctx, rule_p);
550 call_env_parsed->count = count;
551 call_env_parsed->multi_index = multi_index;
552
553 /*
554 * With the conf_parser code we can add default pairs
555 * if they don't exist, but as the same CONF_SECTIONs
556 * are evaluated multiple times for each module call
557 * we can't do that here.
558 */
559 if (cp) {
560 if (call_env_force_quote(rule_p->flags)) {
561 to_parse = tmp_cp = cf_pair_alloc(NULL,
564 call_env_force_quote(rule_p->flags) ? rule_p->pair.dflt_quote : cf_pair_value_quote(cp));
565 } else {
566 to_parse = cp;
567 }
568 } else {
569 to_parse = tmp_cp = cf_pair_alloc(NULL,
570 rule_p->name, rule_p->pair.dflt, T_OP_EQ,
571 T_BARE_WORD, rule_p->pair.dflt_quote);
572 }
573
574 /*
575 * The parsing function can either produce a tmpl_t as tmpl_afrom_substr
576 * would, or produce a custom structure, which will be copied into the
577 * result structure.
578 */
579 if (unlikely(func(ctx, &call_env_parsed->data, &our_rules, cf_pair_to_item(to_parse), cec, rule_p) < 0)) {
580 error:
581 cf_log_perr(to_parse, "Failed to parse configuration item '%s = %s'", rule_p->name, cf_pair_value(to_parse));
582 talloc_free(call_env_parsed);
583 talloc_free(tmp_cp);
584 return -1;
585 }
586 if (!call_env_parsed->data.ptr) {
587 talloc_free(call_env_parsed);
588 goto next_pair;
589 }
590
591 /*
592 * Ensure only valid data is produced.
593 */
594 if (call_env_parsed_valid(call_env_parsed, cf_pair_to_item(to_parse), rule_p) < 0) goto error;
595
596 call_env_parsed_insert_tail(parsed, call_env_parsed);
597 next_pair:
598 talloc_free(tmp_cp);
599 cp = cf_pair_find_next(cs, cp, rule_p->name);
600 }
601 next:
602 rule_p++;
603 }
604
605 CALL_ENV_DEBUG(cs, "Returning afer processing %u rules", (unsigned int)(rule_p - rule));
606
607 return 0;
608}
609
610/** Perform a quick assessment of how many parsed call env will be produced.
611 *
612 * @param[in,out] names_len Where to write the sum of bytes required to represent
613 * the strings which will be parsed as tmpls. This is required
614 * to pre-allocate space for the tmpl name buffers.
615 * @param[in] cs Conf section to search for pairs.
616 * @param[in] call_env to parse.
617 * @return Number of parsed_call_env expected to be required.
618 */
619static size_t call_env_count(size_t *names_len, CONF_SECTION const *cs, call_env_parser_t const *call_env)
620{
621 size_t pair_count, tmpl_count = 0;
622 CONF_PAIR const *cp;
623
624 *names_len = 0;
625
626 while (call_env->name) {
627 if (call_env_is_subsection(call_env->flags)) {
628 CONF_SECTION const *subcs;
629 subcs = cf_section_find(cs, call_env->name, call_env->section.name2);
630 if (!subcs) goto next;
631
632 /*
633 * May only be a callback...
634 */
635 if (call_env->section.subcs) tmpl_count += call_env_count(names_len, subcs, call_env->section.subcs);
636 goto next;
637 }
638 pair_count = 0;
639 cp = NULL;
640 while ((cp = cf_pair_find_next(cs, cp, call_env->name))) {
641 pair_count++;
642 *names_len += talloc_array_length(cf_pair_value(cp));
643 }
644 if (!pair_count && call_env->pair.dflt) {
645 pair_count = 1;
646 *names_len += strlen(call_env->pair.dflt);
647 }
648 tmpl_count += pair_count;
649 next:
650 call_env++;
651 }
652
653 return tmpl_count;
654}
655
656/** Allocate a new call_env_parsed_t structure and add it to the list of parsed call envs
657 *
658 * @note tmpl_t and void * should be allocated in the context of the call_env_parsed_t
659 *
660 * @param[in] ctx to allocate the new call_env_parsed_t in.
661 * @param[out] head to add the new call_env_parsed_t to.
662 * @param[in] rule to base call_env_parsed_t around. MUST NOT BE THE RULE PASSED TO THE CALLBACK.
663 * The rule passed to the callback describes how to parse a subsection, but the
664 * subsection callback is adding rules describing how to parse its children.
665 * @return The new call_env_parsed_t.
666 */
667call_env_parsed_t *call_env_parsed_add(TALLOC_CTX *ctx, call_env_parsed_head_t *head, call_env_parser_t const *rule)
668{
669 call_env_parsed_t *call_env_parsed;
670 call_env_parser_t *our_rules;
671
672 fr_assert_msg(call_env_is_subsection(rule->flags) == false, "Rules added by subsection callbacks cannot be subsections themselves");
673
674 MEM(call_env_parsed = call_env_parsed_alloc(ctx, rule));
675
676 /*
677 * Copy the rule the callback provided, there's no guarantee
678 * it's not stack allocated, or in some way ephemeral.
679 */
680 MEM(our_rules = talloc(call_env_parsed, call_env_parser_t));
681 memcpy(our_rules, rule, sizeof(*our_rules));
682 call_env_parsed->rule = our_rules;
683 call_env_parsed_insert_tail(head, call_env_parsed);
684
685 return call_env_parsed;
686}
687
688/** Assign a tmpl to a call_env_parsed_t
689 *
690 * @note Intended to be used by subsection callbacks to add a tmpl to be
691 * evaluated during the call.
692 *
693 * @param[in] parsed to assign the tmpl to.
694 * @param[in] tmpl to assign.
695 */
697{
698 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_TMPL, "Rule must indicate parsed output is a tmpl_t");
699 parsed->data.tmpl = tmpl;
700}
701
702/** Assign a value box to a call_env_parsed_t
703 *
704 * @note Intended to be used by subsection callbacks to set a static boxed
705 * value to be written out to the result structure.
706 *
707 * @param[in] parsed to assign the tmpl to.
708 * @param[in] vb to assign.
709 */
711{
712 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_VALUE_BOX, "Rule must indicate parsed output is a value box");
713 parsed->data.vb = vb;
714}
715
716/** Assign data to a call_env_parsed_t
717 *
718 * @note Intended to be used by subsection callbacks to set arbitrary data
719 * to be written out to the result structure.
720 *
721 * @param[in] parsed to assign the tmpl to.
722 * @param[in] data to assign.
723 */
725{
726 fr_assert_msg(parsed->rule->pair.parsed.type == CALL_ENV_PARSE_TYPE_VOID, "Rule must indicate parsed output is a void *");
727 parsed->data.ptr = data;
728}
729
730/** Assign a count and index to a call_env_parsed_t
731 *
732 * @note Intended to be used by subsection callbacks to indicate related
733 * call_env_parsed_t.
734 *
735 * @param[in] parsed to modify metadata of.
736 * @param[in] count to assign.
737 * @param[in] index to assign.
738 */
739void call_env_parsed_set_multi_index(call_env_parsed_t *parsed, size_t count, size_t index)
740{
741 fr_assert_msg(call_env_multi(parsed->rule->flags), "Rule must indicate parsed output is a multi pair");
742 parsed->multi_index = index;
743 parsed->count = count;
744}
745
746/** Remove a call_env_parsed_t from the list of parsed call envs
747 *
748 * @note Intended to be used by subsection callbacks to remove a call_env_parsed_t
749 * from the list of parsed call envs (typically on error).
750 *
751 * @param[in] parsed to remove parsed data from.
752 * @param[in] ptr to remove.
753 */
754void call_env_parsed_free(call_env_parsed_head_t *parsed, call_env_parsed_t *ptr)
755{
756 call_env_parsed_remove(parsed, ptr);
757 talloc_free(ptr);
758}
759
760/** Given a call_env_method, parse all call_env_pair_t in the context of a specific call to an xlat or module method
761 *
762 * @param[in] ctx to allocate the call_env_t in.
763 * @param[in] name Module name for error messages.
764 * @param[in] call_env_method containing the call_env_pair_t to evaluate against the specified CONF_SECTION.
765 * @param[in] t_rules that control how call_env_pair_t are parsed.
766 * @param[in] cs to parse in the context of the call.
767 * @param[in] cec information about how the call is being made.
768 * @return
769 * - A new call_env_t on success.
770 * - NULL on failure.
771 */
772call_env_t *call_env_alloc(TALLOC_CTX *ctx, char const *name, call_env_method_t const *call_env_method,
773 tmpl_rules_t const *t_rules, CONF_SECTION *cs, call_env_ctx_t const *cec)
774{
775 unsigned int count;
776 size_t names_len;
777 call_env_t *call_env;
778
779 /*
780 * Only used if caller doesn't use a more specific assert
781 */
782 fr_assert_msg(call_env_method->inst_size, "inst_size 0 for %s, method_env (%p)", name, call_env_method);
783
784 /*
785 * Firstly assess how many parsed env there will be and create a talloc pool to hold them.
786 * The pool size is a rough estimate based on each tmpl also allocating at least two children,
787 * for which we allow twice the length of the value to be parsed.
788 */
789 count = call_env_count(&names_len, cs, call_env_method->env);
790
791 /*
792 * Pre-allocated headers:
793 * 1 header for the call_env_pair_parsed_t, 1 header for the tmpl_t, 1 header for the name,
794 * one header for the value.
795 *
796 * Pre-allocated memory:
797 * ((sizeof(call_env_pair_parsed_t) + sizeof(tmpl_t)) * count) + (names of tmpls * 2)... Not sure what
798 * the * 2 is for, maybe for slop?
799 */
800 MEM(call_env = talloc_pooled_object(ctx, call_env_t, count * 4, (sizeof(call_env_parser_t) + sizeof(tmpl_t)) * count + names_len * 2));
801 call_env->method = call_env_method;
802 call_env_parsed_init(&call_env->parsed);
803 if (call_env_parse(call_env, &call_env->parsed, name, t_rules, cs, cec, call_env_method->env) < 0) {
804 talloc_free(call_env);
805 return NULL;
806 }
807
808 return call_env;
809}
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
call_env_parsed_t const * last_expanded
The last expanded tmpl.
Definition call_env.c:129
static call_env_result_t call_env_result(TALLOC_CTX *ctx, request_t *request, void *out, void **tmpl_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
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:754
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:139
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:245
#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:350
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
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:337
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:667
call_env_t const * call_env
Call env being expanded.
Definition call_env.c:128
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:619
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:739
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:126
static 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:445
void ** data
Final destination structure for value boxes.
Definition call_env.c:131
fr_value_box_list_t tmpl_expanded
List to write value boxes to as tmpls are expanded.
Definition call_env.c:130
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:724
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:772
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:710
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:696
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:397
unlang_result_t expansion_result
The result of calling the call env expansions functions.
Definition call_env.c:127
Context to keep track of expansion of call environments.
Definition call_env.c:125
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:210
#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:42
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.
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, fr_value_box_list_t *out, request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args)
Push a tmpl onto the stack for evaluation.
Definition tmpl.c:254
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:605
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:4065
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
Definition value.h:237
static fr_slen_t data
Definition value.h:1288
static size_t char ** out
Definition value.h:1020