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