The FreeRADIUS server $Id: a4e7f8c94e8038b7627bcf52356b7ed15955c1d7 $
Loading...
Searching...
No Matches
xlat_builtin.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: d88bd9f3bb79f9485eb13c1e98466812dc655217 $
19 *
20 * @file xlat_builtin.c
21 * @brief String expansion ("translation"). Baked in expansions.
22 *
23 * @copyright 2000,2006 The FreeRADIUS server project
24 * @copyright 2000 Alan DeKok (aland@freeradius.org)
25 */
26RCSID("$Id: d88bd9f3bb79f9485eb13c1e98466812dc655217 $")
27
28/**
29 * @defgroup xlat_functions xlat expansion functions
30 */
31#include <freeradius-devel/server/base.h>
32#include <freeradius-devel/server/tmpl_dcursor.h>
33#include <freeradius-devel/server/main_config.h>
34#include <freeradius-devel/unlang/xlat_priv.h>
35
36#include <freeradius-devel/io/test_point.h>
37
38#include <freeradius-devel/util/base16.h>
39
40#ifdef HAVE_OPENSSL_EVP_H
41# include <freeradius-devel/tls/openssl_user_macros.h>
42# include <openssl/evp.h>
43#endif
44
45#include <sys/stat.h>
46#include <fcntl.h>
47
48static char const hextab[] = "0123456789abcdef";
49static TALLOC_CTX *xlat_ctx;
50
51typedef struct {
52 fr_test_point_pair_decode_t *tp_decode;
53 fr_dict_t const *dict; //!< Restrict xlat to this namespace
54} xlat_pair_decode_uctx_t;
55
59
63
64/** Copy an argument from the input list to the output cursor.
65 *
66 * For now we just move it. This utility function will let us have
67 * value-box cursors as input arguments.
68 *
69 * @param[in] ctx talloc ctx
70 * @param[out] out where the value-box will be stored
71 * @param[in] in input value-box list
72 * @param[in] vb the argument to copy
73 */
74void xlat_arg_copy_out(TALLOC_CTX *ctx, fr_dcursor_t *out, fr_value_box_list_t *in, fr_value_box_t *vb)
75{
76 fr_value_box_list_remove(in, vb);
77 if (talloc_parent(vb) != ctx) {
78 (void) talloc_steal(ctx, vb);
79 }
80 fr_dcursor_append(out, vb);
81}
82
83/*
84 * Regular xlat functions
85 */
86static xlat_arg_parser_t const xlat_func_debug_args[] = {
87 { .single = true, .type = FR_TYPE_INT8 },
88 XLAT_ARG_PARSER_TERMINATOR
89};
90
91/** Dynamically change the debugging level for the current request
92 *
93 * Example:
94@verbatim
95%debug(3)
96@endverbatim
97 *
98 * @ingroup xlat_functions
99 */
100static xlat_action_t xlat_func_debug(TALLOC_CTX *ctx, fr_dcursor_t *out,
101 UNUSED xlat_ctx_t const *xctx,
102 request_t *request, fr_value_box_list_t *args)
103{
104 int level = 0;
105 fr_value_box_t *vb, *lvl_vb;
106
107 XLAT_ARGS(args, &lvl_vb);
108
109 /*
110 * Expand to previous (or current) level
111 */
112 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_INT8, NULL));
113 vb->vb_int8 = request->log.lvl;
114 fr_dcursor_append(out, vb);
115
116 /*
117 * Assume we just want to get the current value and NOT set it to 0
118 */
119 if (!lvl_vb) goto done;
120
121 level = lvl_vb->vb_int8;
122 if (level == 0) {
123 request->log.lvl = RAD_REQUEST_LVL_NONE;
124 } else {
125 if (level > L_DBG_LVL_MAX) level = L_DBG_LVL_MAX;
126 request->log.lvl = level;
127 }
128
129done:
130 return XLAT_ACTION_DONE;
131}
132
133
134static void xlat_debug_attr_vp(request_t *request, fr_pair_t const *vp,
135 fr_dict_attr_t const *da);
136
137static void xlat_debug_attr_list(request_t *request, fr_pair_list_t const *list,
138 fr_dict_attr_t const *parent)
139{
140 fr_pair_t *vp;
141
142 for (vp = fr_pair_list_next(list, NULL);
143 vp != NULL;
144 vp = fr_pair_list_next(list, vp)) {
145 xlat_debug_attr_vp(request, vp, parent);
146 }
147}
148
149
154
155static void xlat_debug_attr_vp(request_t *request, fr_pair_t const *vp,
156 fr_dict_attr_t const *parent)
157{
158 fr_dict_vendor_t const *vendor;
159 fr_table_num_ordered_t const *type;
160 size_t i;
161 ssize_t slen;
162 fr_sbuff_t sbuff;
163 char buffer[1024];
164
165 sbuff = FR_SBUFF_OUT(buffer, sizeof(buffer));
166
167 /*
168 * Squash the names down if necessary.
169 */
170 if (!RDEBUG_ENABLED3) {
171 slen = fr_pair_print_name(&sbuff, parent, &vp);
172 } else {
173 slen = fr_sbuff_in_sprintf(&sbuff, "%s %s ", vp->da->name, fr_tokens[vp->op]);
174 }
175 if (slen <= 0) return;
176
177 switch (vp->vp_type) {
178 case FR_TYPE_STRUCTURAL:
179 RIDEBUG2("%s{", buffer);
180 RINDENT();
181 xlat_debug_attr_list(request, &vp->vp_group, vp->da);
182 REXDENT();
183 RIDEBUG2("}");
184 break;
185
186 default:
187 RIDEBUG2("%s%pV", buffer, &vp->data);
188 }
189
190 if (!RDEBUG_ENABLED3) return;
191
192 RINDENT();
193 RIDEBUG3("da : %p", vp->da);
194 RIDEBUG3("is_raw : %pV", fr_box_bool(vp->vp_raw));
195 RIDEBUG3("is_unknown : %pV", fr_box_bool(vp->da->flags.is_unknown));
196
197 if (RDEBUG_ENABLED3) {
198 RIDEBUG3("parent : %s (%p)", vp->da->parent->name, vp->da->parent);
199 } else {
200 RIDEBUG2("parent : %s", vp->da->parent->name);
201 }
202 RIDEBUG3("attr : %u", vp->da->attr);
203 vendor = fr_dict_vendor_by_da(vp->da);
204 if (vendor) RIDEBUG2("vendor : %u (%s)", vendor->pen, vendor->name);
205 RIDEBUG3("type : %s", fr_type_to_str(vp->vp_type));
206
207 switch (vp->vp_type) {
208 case FR_TYPE_LEAF:
209 if (fr_box_is_variable_size(&vp->data)) {
210 RIDEBUG3("length : %zu", vp->vp_length);
211 }
212 RIDEBUG3("tainted : %pV", fr_box_bool(vp->data.tainted));
213 break;
214 default:
215 break;
216 }
217
218 if (!RDEBUG_ENABLED4) {
219 REXDENT();
220 return;
221 }
222
223 for (i = 0; i < fr_type_table_len; i++) {
224 int pad;
225
226 fr_value_box_t *dst = NULL;
227
228 type = &fr_type_table[i];
229
230 if ((fr_type_t) type->value == vp->vp_type) goto next_type;
231
232 /*
233 * Don't cast TO structural, or FROM structural types.
234 */
235 if (!fr_type_is_leaf(type->value) || !fr_type_is_leaf(vp->vp_type)) goto next_type;
236
237 MEM(dst = fr_value_box_acopy(NULL, &vp->data));
238
239 /* We expect some to fail */
240 if (fr_value_box_cast_in_place(dst, dst, type->value, NULL) < 0) {
241 goto next_type;
242 }
243
244 pad = (type->name.len < 11) ? (int)(11 - type->name.len) : 0;
245
246 RINDENT();
247 RDEBUG4("as %s%*s: %pV", type->name.str, pad, " ", dst);
248 REXDENT();
249
250 next_type:
251 talloc_free(dst);
252 }
253
254 REXDENT();
255}
256
257/** Common function to move boxes from input list to output list
258 *
259 * This can be used to implement safe_for functions, as the xlat framework
260 * can be used for concatenation, casting, and marking up output boxes as
261 * safe_for.
262 */
263xlat_action_t xlat_transparent(TALLOC_CTX *ctx, fr_dcursor_t *out,
264 UNUSED xlat_ctx_t const *xctx,
265 UNUSED request_t *request, fr_value_box_list_t *args)
266{
267 fr_value_box_list_foreach(args, vb) {
268 xlat_arg_copy_out(ctx, out, args, vb);
269 }
270
271 return XLAT_ACTION_DONE;
272}
273
274/** Print out attribute info
275 *
276 * Prints out all instances of a current attribute, or all attributes in a list.
277 *
278 * At higher debugging levels, also prints out alternative decodings of the same
279 * value. This is helpful to determine types for unknown attributes of long
280 * passed vendors, or just crazy/broken NAS.
281 *
282 * This expands to a zero length string.
283 *
284 * Example:
285@verbatim
286%pairs.debug(&request)
287@endverbatim
288 *
289 * @ingroup xlat_functions
290 */
291static xlat_action_t xlat_func_pairs_debug(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
292 UNUSED xlat_ctx_t const *xctx,
293 request_t *request, fr_value_box_list_t *args)
294{
295 fr_pair_t *vp;
296 fr_dcursor_t *cursor;
297 fr_value_box_t *in_head;
298
299 XLAT_ARGS(args, &in_head);
300
301 if (!RDEBUG_ENABLED2) return XLAT_ACTION_DONE; /* NOOP if debugging isn't enabled */
302
303 cursor = fr_value_box_get_cursor(in_head);
304
305 RDEBUG("Attributes matching \"%s\"", in_head->vb_cursor_name);
306
307 RINDENT();
308 for (vp = fr_dcursor_current(cursor);
309 vp;
310 vp = fr_dcursor_next(cursor)) {
311 xlat_debug_attr_vp(request, vp, NULL);
312 }
313 REXDENT();
314
315 return XLAT_ACTION_DONE;
316}
317
318DIAG_OFF_OPTIONAL(gnu-designator)
319
320#define FR_FILENAME_SAFE_FOR ((uintptr_t) filename_xlat_escape)
321
322static int CC_HINT(nonnull(1)) filename_xlat_escape(fr_value_box_t *vb, UNUSED void *uctx)
323{
324 fr_sbuff_t *out = NULL;
325 fr_value_box_entry_t entry;
326
327 FR_SBUFF_TALLOC_THREAD_LOCAL(&out, 256, 4096);
328
329 /*
330 * Integers are just numbers, so they don't need to be escaped.
331 *
332 * Except that FR_TYPE_INTEGER includes 'date' and 'time_delta', which is annoying.
333 *
334 * 'octets' get printed as hex, so they don't need to be escaped.
335 */
336 switch (vb->type) {
337 case FR_TYPE_BOOL:
338 case FR_TYPE_UINT8:
339 case FR_TYPE_UINT16:
340 case FR_TYPE_UINT32:
341 case FR_TYPE_UINT64:
342 case FR_TYPE_INT8:
343 case FR_TYPE_INT16:
344 case FR_TYPE_INT32:
345 case FR_TYPE_INT64:
346 case FR_TYPE_SIZE:
347 case FR_TYPE_OCTETS:
348 return 0;
349
350 case FR_TYPE_NON_LEAF:
351 fr_assert(0);
352 return -1;
353
354 case FR_TYPE_DATE:
355 case FR_TYPE_TIME_DELTA:
356 case FR_TYPE_IFID:
357 case FR_TYPE_ETHERNET:
358 case FR_TYPE_FLOAT32:
359 case FR_TYPE_FLOAT64:
360 case FR_TYPE_COMBO_IP_ADDR:
361 case FR_TYPE_COMBO_IP_PREFIX:
362 case FR_TYPE_IPV4_ADDR:
363 case FR_TYPE_IPV4_PREFIX:
364 case FR_TYPE_IPV6_ADDR:
365 case FR_TYPE_IPV6_PREFIX:
366 case FR_TYPE_ATTR:
367 /*
368 * Printing prefixes etc. does NOT result in the escape function being called! So
369 * instead, we cast the results to a string, and then escape the string.
370 */
371 if (fr_value_box_cast_in_place(vb, vb, FR_TYPE_STRING, NULL) < 0) return -1;
372
373 fr_value_box_print(out, vb, &fr_filename_escape);
374 break;
375
376 case FR_TYPE_STRING:
377 {
378 ssize_t slen;
379 /*
380 * Note that we set ".always_escape" in the function arguments, so that we get called for
381 * IP addresses. Otherwise, the xlat evaluator and/or the list_concat_as_string
382 * functions won't call us. And the expansion will return IP addresses with '/' in them.
383 * Which is not what we want.
384 */
385 if (fr_value_box_is_safe_for(vb, FR_FILENAME_SAFE_FOR)) return 1;
386
387 /*
388 * If the tainted string has a leading '.', then escape _all_ periods in it. This is so that we
389 * don't accidentally allow a "safe" value to end with '/', and then an "unsafe" value contains
390 * "..", and we now have a directory traversal attack.
391 *
392 * The escape rules will escape '/' in unsafe strings, so there's no possibility for an unsafe
393 * string to either end with a '/', or to contain "/.." itself.
394 *
395 * Allowing '.' in the middle of the string means we can have filenames based on realms, such as
396 * "log/aland@freeradius.org".
397 */
398 if (vb->vb_strvalue[0] == '.') {
399 slen = fr_value_box_print(out, vb, &fr_filename_escape_dots);
400 } else {
401 slen = fr_value_box_print(out, vb, &fr_filename_escape);
402 }
403 if (slen < 0) return -1;
404 }
405 break;
406 }
407
408 entry = vb->entry;
409 fr_value_box_clear(vb);
410 (void) fr_value_box_bstrndup(vb, vb, NULL, fr_sbuff_start(out), fr_sbuff_used(out), false);
411 vb->entry = entry;
412
413 return 0;
414}
415
416xlat_arg_parser_t const xlat_func_file_name_args[] = {
417 { .required = true, .concat = true, .type = FR_TYPE_STRING,
418 .func = filename_xlat_escape, .safe_for = FR_FILENAME_SAFE_FOR, .always_escape = true },
419 XLAT_ARG_PARSER_TERMINATOR
420};
421
422static xlat_arg_parser_t const xlat_func_file_name_count_args[] = {
423 { .required = true, .concat = true, .type = FR_TYPE_STRING,
424 .func = filename_xlat_escape, .safe_for = FR_FILENAME_SAFE_FOR, .always_escape = true },
425 { .required = false, .type = FR_TYPE_UINT32 },
426 XLAT_ARG_PARSER_TERMINATOR
427};
428
429
430/*
431 * Limit the %file...() functions to a particular subset of directories.
432 */
433bool xlat_file_allowed(request_t *request, fr_value_box_t const *vb, int oflags)
434{
435 /*
436 * Note that we do *not* bypass these checks even if a file is SAFE_FOR_ANY here. We want to
437 * have "defense in depth".
438 */
439
440 /*
441 * The filename contains a directory traversal attack, opens a directory, etc.
442 */
443 if (!fr_filename_ok(vb->vb_strvalue, vb->vb_strvalue + vb->vb_length, (oflags & O_DIRECTORY) != 0)) {
444 RPEDEBUG("Invalid filename %pV", vb);
445 return false;
446 }
447
448 /*
449 * No "limit files" section. We allow everything.
450 */
451 if (!main_config->limit.files_is_set) return true;
452
453 /*
454 * If there are no read/write limits, then check if the section exists. A missing section is
455 * "allow all". An empty section is "forbid all".
456 */
457 if (!main_config->limit.allowed_files && !main_config->limit.readonly_files) {
458 REDEBUG("Failed accessing file %pV - all %%file() access is forbidden by the 'limit files { ... }' section", vb);
459 return false;
460 }
461
462 /*
463 * If it's in the "allowed" list, then we allow it for both read and write.
464 *
465 * If it's not in the "allowed" list, then we complain if there's no "read-only" list, or if
466 * the caller is trying to write.
467 */
468 if (main_config->limit.allowed_files) {
469 if (fr_filename_allowed_by_list(vb->vb_strvalue, vb->vb_strvalue + vb->vb_length,
470 main_config->limit.allowed_files)) return true;
471
472 if (!main_config->limit.readonly_files || ((oflags & O_ACCMODE) != O_RDONLY)) {
473 REDEBUG("Failed accessing file %pV - it is outside of allowed access for 'limit files { ... }'", vb);
474 return false;
475 }
476 } /* else there MUST be a read-only list, otherwise the check above for both being empty would have fired. */
477
478 /*
479 * We have a "read-only" list. Fail if the caller is trying to write, or if the filename doesn't
480 * match the "read-only" list.
481 */
482 if (main_config->limit.readonly_files) {
483 if (((oflags & O_ACCMODE) != O_RDONLY) ||
484 !fr_filename_allowed_by_list(vb->vb_strvalue, vb->vb_strvalue + vb->vb_length,
485 main_config->limit.readonly_files)) {
486 REDEBUG("Failed accessing file %pV - it is outside of read-only access for 'limit files { ... }'", vb);
487 return false;
488 }
489 }
490
491 return true;
492}
493
494#define XLAT_FILE_ALLOWED(_vb, _p) xlat_file_allowed(request, _vb, _p)
495
496static xlat_action_t xlat_func_file_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
497 UNUSED xlat_ctx_t const *xctx,
498 request_t *request, fr_value_box_list_t *args)
499{
500 fr_value_box_t *dst, *vb;
501 char const *filename;
502 struct stat buf;
503
504 XLAT_ARGS(args, &vb);
505 fr_assert(vb->type == FR_TYPE_STRING);
506 filename = vb->vb_strvalue;
507
508 if (!XLAT_FILE_ALLOWED(vb, O_RDONLY)) return XLAT_ACTION_FAIL;
509
510 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
511 fr_dcursor_append(out, dst);
512
513 dst->vb_bool = (stat(filename, &buf) == 0);
514
515 return XLAT_ACTION_DONE;
516}
517
518
519static xlat_action_t xlat_func_file_head(TALLOC_CTX *ctx, fr_dcursor_t *out,
520 UNUSED xlat_ctx_t const *xctx,
521 request_t *request, fr_value_box_list_t *args)
522{
523 fr_value_box_t *dst, *vb;
524 char const *filename;
525 ssize_t len;
526 int fd;
527 char *p, buffer[256];
528
529 XLAT_ARGS(args, &vb);
530 fr_assert(vb->type == FR_TYPE_STRING);
531 filename = vb->vb_strvalue;
532
533 if (!XLAT_FILE_ALLOWED(vb, O_RDONLY)) return XLAT_ACTION_FAIL;
534
535 fd = open(filename, O_RDONLY);
536 if (fd < 0) {
537 REDEBUG3("Failed opening file %s - %s", filename, fr_syserror(errno));
538 return XLAT_ACTION_FAIL;
539 }
540
541 len = read(fd, buffer, sizeof(buffer));
542 if (len < 0) {
543 REDEBUG3("Failed reading file %s - %s", filename, fr_syserror(errno));
544 close(fd);
545 return XLAT_ACTION_FAIL;
546 }
547
548 /*
549 * Find the first CR/LF, but bail if we get any weird characters.
550 */
551 for (p = buffer; p < (buffer + len); p++) {
552 if ((*p == '\r') || (*p == '\n')) {
553 break;
554 }
555
556 if ((*p < ' ') && (*p != '\t')) {
557 invalid:
558 REDEBUG("Invalid text in file %s", filename);
559 close(fd);
560 return XLAT_ACTION_FAIL;
561 }
562 }
563
564 if ((p - buffer) > len) goto invalid;
565 close(fd);
566
567 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
568 if (fr_value_box_bstrndup(dst, dst, NULL, buffer, p - buffer, false) < 0) {
569 talloc_free(dst);
570 return XLAT_ACTION_FAIL;
571 }
572
573 fr_dcursor_append(out, dst);
574
575 return XLAT_ACTION_DONE;
576}
577
578
579static xlat_action_t xlat_func_file_size(TALLOC_CTX *ctx, fr_dcursor_t *out,
580 UNUSED xlat_ctx_t const *xctx,
581 request_t *request, fr_value_box_list_t *args)
582{
583 fr_value_box_t *dst, *vb;
584 char const *filename;
585 struct stat buf;
586
587 XLAT_ARGS(args, &vb);
588 fr_assert(vb->type == FR_TYPE_STRING);
589 filename = vb->vb_strvalue;
590
591 if (!XLAT_FILE_ALLOWED(vb, O_RDONLY)) return XLAT_ACTION_FAIL;
592
593 if (stat(filename, &buf) < 0) {
594 REDEBUG3("Failed checking file %s - %s", filename, fr_syserror(errno));
595 return XLAT_ACTION_FAIL;
596 }
597
598 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_UINT64, NULL)); /* off_t is signed, but file sizes shouldn't be negative */
599 fr_dcursor_append(out, dst);
600
601 dst->vb_uint64 = buf.st_size;
602
603 return XLAT_ACTION_DONE;
604}
605
606
607static xlat_action_t xlat_func_file_tail(TALLOC_CTX *ctx, fr_dcursor_t *out,
608 UNUSED xlat_ctx_t const *xctx,
609 request_t *request, fr_value_box_list_t *args)
610{
611 fr_value_box_t *dst, *vb, *num = NULL;
612 char const *filename;
613 ssize_t len;
614 off_t offset;
615 int fd;
616 int crlf, stop = 1;
617 char *p, *end, *found, buffer[256];
618
619 XLAT_ARGS(args, &vb, &num);
620 fr_assert(vb->type == FR_TYPE_STRING);
621 filename = vb->vb_strvalue;
622
623 if (!XLAT_FILE_ALLOWED(vb, O_RDONLY)) return XLAT_ACTION_FAIL;
624
625 fd = open(filename, O_RDONLY);
626 if (fd < 0) {
627 REDEBUG3("Failed opening file %s - %s", filename, fr_syserror(errno));
628 return XLAT_ACTION_FAIL;
629 }
630
631 offset = lseek(fd, 0, SEEK_END);
632 if (offset < 0) {
633 REDEBUG3("Failed seeking to end of file %s - %s", filename, fr_syserror(errno));
634 goto fail;
635 }
636
637 if (offset > (off_t) sizeof(buffer)) {
638 offset -= sizeof(buffer);
639 } else {
640 offset = 0;
641 }
642
643 if (lseek(fd, offset, SEEK_SET) < 0) {
644 REDEBUG3("Failed seeking backwards from end of file %s - %s", filename, fr_syserror(errno));
645 goto fail;
646 }
647
648 len = read(fd, buffer, sizeof(buffer));
649 if (len < 0) {
650 fail:
651 REDEBUG3("Failed reading file %s - %s", filename, fr_syserror(errno));
652 close(fd);
653 return XLAT_ACTION_FAIL;
654 }
655 close(fd);
656
657 found = buffer;
658 end = buffer + len;
659
660 /*
661 * No data, OR just one CR / LF, we print it all out.
662 */
663 if (len <= 1) goto done;
664
665 /*
666 * Clamp number of lines to a reasonable value. They
667 * still all have to fit into 256 characters, though.
668 *
669 * @todo - have a large thread-local temporary buffer for this stuff.
670 */
671 if (num) {
672 fr_assert(num->type == FR_TYPE_GROUP);
673 fr_assert(fr_value_box_list_num_elements(&num->vb_group) == 1);
674
675 num = fr_value_box_list_head(&num->vb_group);
676 fr_assert(num->type == FR_TYPE_UINT32);
677
678 if (!num->vb_uint32) {
679 stop = 1;
680
681 } else if (num->vb_uint32 <= 16) {
682 stop = num->vb_uint32;
683
684 } else {
685 stop = 16;
686 }
687 } else {
688 stop = 1;
689 }
690
691 p = end - 1;
692 crlf = 0;
693
694 /*
695 * Skip any trailing CRLF first.
696 */
697 while (p > buffer) {
698 /*
699 * Could be CRLF, or just LF.
700 */
701 if (*p == '\n') {
702 end = p;
703 p--;
704 if (p == buffer) {
705 goto done;
706 }
707 if (*p >= ' ') {
708 break;
709 }
710 }
711
712 if (*p == '\r') {
713 end = p;
714 p--;
715 break;
716 }
717
718 /*
719 * We've found CR, LF, or CRLF. The previous
720 * thing is either raw text, or is another CR/LF.
721 */
722 break;
723 }
724
725 found = p;
726
727 while (p > buffer) {
728 crlf++;
729
730 /*
731 * If the current line is empty, we can stop.
732 */
733 if ((crlf == stop) && (*found < ' ')) {
734 found++;
735 goto done;
736 }
737
738 while (p > buffer) {
739 if (*p < ' ') {
740 break;
741 }
742
743 found = p;
744 p--;
745 }
746 if (p == buffer) {
747 found = buffer;
748 goto done;
749 }
750
751 if (crlf == stop) {
752 break;
753 }
754
755 /*
756 * Check again for CRLF.
757 */
758 if (*p == '\n') {
759 p--;
760 if (p == buffer) {
761 break;
762 }
763 if (*p >= ' ') {
764 continue;
765 }
766 }
767
768 if (*p == '\r') {
769 p--;
770 if (p == buffer) {
771 break;
772 }
773 continue;
774 }
775 }
776
777done:
778
779 /*
780 * @todo - return a _list_ of value-boxes, one for each line in the file.
781 * Which means chopping off each CRLF in the file
782 */
783
784 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
785 if (fr_value_box_bstrndup(dst, dst, NULL, found, (size_t) (end - found), false) < 0) {
786 talloc_free(dst);
787 return XLAT_ACTION_FAIL;
788 }
789
790 fr_dcursor_append(out, dst);
791
792 return XLAT_ACTION_DONE;
793}
794
795static xlat_arg_parser_t const xlat_func_file_cat_args[] = {
796 { .required = true, .concat = true, .type = FR_TYPE_STRING,
797 .func = filename_xlat_escape, .safe_for = FR_FILENAME_SAFE_FOR, .always_escape = true },
798 { .required = true, .type = FR_TYPE_SIZE, .single = true },
799 XLAT_ARG_PARSER_TERMINATOR
800};
801
802static xlat_action_t xlat_func_file_cat(TALLOC_CTX *ctx, fr_dcursor_t *out,
803 UNUSED xlat_ctx_t const *xctx,
804 request_t *request, fr_value_box_list_t *args)
805{
806 fr_value_box_t *dst, *vb, *max_size;
807 char const *filename;
808 ssize_t len;
809 int fd;
810 struct stat buf;
811 uint8_t *buffer;
812
813 XLAT_ARGS(args, &vb, &max_size);
814 fr_assert(vb->type == FR_TYPE_STRING);
815 filename = vb->vb_strvalue;
816
817 if (!XLAT_FILE_ALLOWED(vb, O_RDONLY)) return XLAT_ACTION_FAIL;
818
819 fd = open(filename, O_RDONLY);
820 if (fd < 0) {
821 RPERROR("Failed opening file %s - %s", filename, fr_syserror(errno));
822 return XLAT_ACTION_FAIL;
823 }
824
825 if (fstat(fd, &buf) < 0) {
826 RPERROR("Failed checking file %s - %s", filename, fr_syserror(errno));
827 fail:
828 close(fd);
829 return XLAT_ACTION_FAIL;
830 }
831
832 if ((size_t)buf.st_size > max_size->vb_size) {
833 RPERROR("File larger than specified maximum (%zu vs %zu)", (size_t)buf.st_size, max_size->vb_size);
834 goto fail;
835 }
836
837 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_OCTETS, NULL));
838 fr_value_box_mem_alloc(dst, &buffer, dst, NULL, buf.st_size, true);
839
840 len = read(fd, buffer, buf.st_size);
841 if (len < 0) {
842 RPERROR("Failed reading file %s - %s", filename, fr_syserror(errno));
843 talloc_free(dst);
844 goto fail;
845 }
846 close(fd);
847
848 if (len < buf.st_size) {
849 RPERROR("Failed reading all of file %s", filename);
850 talloc_free(dst);
851 return XLAT_ACTION_FAIL;
852 }
853
854 fr_dcursor_append(out, dst);
855
856 return XLAT_ACTION_DONE;
857}
858
859static xlat_action_t xlat_func_file_rm(TALLOC_CTX *ctx, fr_dcursor_t *out,
860 UNUSED xlat_ctx_t const *xctx,
861 request_t *request, fr_value_box_list_t *args)
862{
863 fr_value_box_t *dst, *vb;
864 char const *filename;
865
866 XLAT_ARGS(args, &vb);
867 fr_assert(vb->type == FR_TYPE_STRING);
868 filename = vb->vb_strvalue;
869
870 if (!XLAT_FILE_ALLOWED(vb, O_RDWR)) return XLAT_ACTION_FAIL;
871
872 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
873 fr_dcursor_append(out, dst);
874
875 dst->vb_bool = (unlink(filename) == 0);
876 if (!dst->vb_bool) {
877 REDEBUG3("Failed unlinking file %s - %s", filename, fr_syserror(errno));
878 }
879
880 return XLAT_ACTION_DONE;
881}
882
883static xlat_action_t xlat_func_file_touch(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
884 request_t *request, fr_value_box_list_t *args)
885{
886 fr_value_box_t *dst, *vb;
887 char const *filename;
888 int fd;
889
890 XLAT_ARGS(args, &vb);
891 fr_assert(vb->type == FR_TYPE_STRING);
892 filename = vb->vb_strvalue;
893
894 if (!XLAT_FILE_ALLOWED(vb, O_RDWR)) return XLAT_ACTION_FAIL;
895
896 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
897 fr_dcursor_append(out, dst);
898
899 fd = open(filename, O_CREAT | O_WRONLY, 0600);
900 if (fd < 0) {
901 dst->vb_bool = false;
902 REDEBUG3("Failed touching file %s - %s", filename, fr_syserror(errno));
903 return XLAT_ACTION_DONE;
904 }
905 dst->vb_bool = true;
906
907 close(fd);
908
909 return XLAT_ACTION_DONE;
910}
911
912static xlat_action_t xlat_func_file_mkdir(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
913 request_t *request, fr_value_box_list_t *args)
914{
915 fr_value_box_t *dst, *vb;
916 char const *dirname;
917
918 XLAT_ARGS(args, &vb);
919 fr_assert(vb->type == FR_TYPE_STRING);
920 dirname = vb->vb_strvalue;
921
922 if (!XLAT_FILE_ALLOWED(vb, O_RDWR | O_DIRECTORY)) return XLAT_ACTION_FAIL;
923
924 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
925 fr_dcursor_append(out, dst);
926
927 dst->vb_bool = (fr_mkdir(NULL, dirname, -1, 0700, NULL, NULL) > 0);
928 if (!dst->vb_bool) {
929 REDEBUG3("Failed creating directory %s - %s", dirname, fr_syserror(errno));
930 }
931
932 return XLAT_ACTION_DONE;
933}
934
935static xlat_action_t xlat_func_file_rmdir(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
936 request_t *request, fr_value_box_list_t *args)
937{
938 fr_value_box_t *dst, *vb;
939 char const *dirname;
940
941 XLAT_ARGS(args, &vb);
942 fr_assert(vb->type == FR_TYPE_STRING);
943 dirname = vb->vb_strvalue;
944
945 if (!XLAT_FILE_ALLOWED(vb, O_RDWR | O_DIRECTORY)) return XLAT_ACTION_FAIL;
946
947 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
948 fr_dcursor_append(out, dst);
949
950 dst->vb_bool = (rmdir(dirname) == 0);
951 if (!dst->vb_bool) {
952 REDEBUG3("Failed removing directory %s - %s", dirname, fr_syserror(errno));
953 }
954
955 return XLAT_ACTION_DONE;
956}
957
958static xlat_arg_parser_t const xlat_func_unsafe_args[] = {
959 { .required = true, .type = FR_TYPE_VOID },
960 { .variadic = XLAT_ARG_VARIADIC_EMPTY_KEEP, .type = FR_TYPE_VOID },
961 XLAT_ARG_PARSER_TERMINATOR
962};
963
964/** Mark every argument as safe for nothing
965 *
966 * Literals in policy are safe for any consumer, so no escape function runs on
967 * a literal. Wrapping a literal in this function forces every consumer to
968 * escape the literal. The escaping tests use the function to exercise the
969 * escape functions with known input.
970 *
971@verbatim
972%unsafe(<value>, ...)
973@endverbatim
974 *
975 * @ingroup xlat_functions
976 */
977static xlat_action_t xlat_func_unsafe(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
978 UNUSED xlat_ctx_t const *xctx,
979 UNUSED request_t *request, fr_value_box_list_t *in)
980{
981 fr_value_box_t *vb;
982
983 while ((vb = fr_value_box_list_pop_head(in)) != NULL) {
984 fr_value_box_t *child;
985
986 fr_assert(vb->type == FR_TYPE_GROUP);
987
988 while ((child = fr_value_box_list_pop_head(&vb->vb_group)) != NULL) {
989 child->tainted = true;
990 fr_value_box_mark_unsafe(child);
991
992 fr_dcursor_append(out, child);
993 }
994 }
995
996 return XLAT_ACTION_DONE;
997}
998
999static xlat_arg_parser_t const xlat_func_explode_args[] = {
1000 { .required = true, .type = FR_TYPE_STRING },
1001 { .required = true, .concat = true, .type = FR_TYPE_STRING },
1002 XLAT_ARG_PARSER_TERMINATOR
1003};
1004
1005/** Split a string into multiple new strings based on a delimiter
1006 *
1007@verbatim
1008%explode(<string>, <delim>)
1009@endverbatim
1010 *
1011 * Example:
1012@verbatim
1013update request {
1014 &Tmp-String-1 := "a,b,c"
1015}
1016"%concat(%explode(%{Tmp-String-1}, ','), '|')" == "a|b|c"g
1017@endverbatim
1018 *
1019 * @ingroup xlat_functions
1020 */
1021static xlat_action_t xlat_func_explode(TALLOC_CTX *ctx, fr_dcursor_t *out,
1022 UNUSED xlat_ctx_t const *xctx,
1023 request_t *request, fr_value_box_list_t *args)
1024{
1025 fr_value_box_t *strings;
1026 fr_value_box_list_t *list;
1027 fr_value_box_t *delim_vb;
1028 ssize_t delim_len;
1029 char const *delim;
1030 fr_value_box_t *string, *vb;
1031
1032 XLAT_ARGS(args, &strings, &delim_vb);
1033
1034 list = &strings->vb_group;
1035
1036 if (delim_vb->vb_length == 0) {
1037 REDEBUG("Delimiter must be greater than zero characters");
1038 return XLAT_ACTION_FAIL;
1039 }
1040
1041 delim = delim_vb->vb_strvalue;
1042 delim_len = delim_vb->vb_length;
1043
1044 while ((string = fr_value_box_list_pop_head(list))) {
1045 fr_sbuff_t sbuff = FR_SBUFF_IN(string->vb_strvalue, string->vb_length);
1046 fr_sbuff_marker_t m_start;
1047
1048 /*
1049 * If the delimiter is not in the string, just move to the output
1050 */
1051 if (!fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, delim, delim_len)) {
1052 fr_dcursor_append(out, string);
1053 continue;
1054 }
1055
1056 fr_sbuff_set_to_start(&sbuff);
1057 fr_sbuff_marker(&m_start, &sbuff);
1058
1059 while (fr_sbuff_remaining(&sbuff)) {
1060 if (fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, delim, delim_len)) {
1061 /*
1062 * If there's nothing before the delimiter skip
1063 */
1064 if (fr_sbuff_behind(&m_start) == 0) goto advance;
1065
1066 MEM(vb = fr_value_box_alloc_null(ctx));
1067 fr_value_box_bstrndup(vb, vb, NULL, fr_sbuff_current(&m_start),
1068 fr_sbuff_behind(&m_start), false);
1069 fr_value_box_safety_copy(vb, string);
1070 fr_dcursor_append(out, vb);
1071
1072 advance:
1073 fr_sbuff_advance(&sbuff, delim_len);
1074 fr_sbuff_set(&m_start, &sbuff);
1075 continue;
1076 }
1077
1078 fr_sbuff_set_to_end(&sbuff);
1079 MEM(vb = fr_value_box_alloc_null(ctx));
1080 fr_value_box_bstrndup(vb, vb, NULL, fr_sbuff_current(&m_start),
1081 fr_sbuff_behind(&m_start), false);
1082
1083 fr_value_box_safety_copy(vb, string);
1084 fr_dcursor_append(out, vb);
1085 break;
1086 }
1087 talloc_free(string);
1088 }
1089
1090 return XLAT_ACTION_DONE;
1091}
1092
1093/** Mark one or more attributes as immutable
1094 *
1095 * Example:
1096@verbatim
1097%pairs.immutable(request.State[*])
1098@endverbatim
1099 *
1100 * @ingroup xlat_functions
1101 */
1102static xlat_action_t xlat_func_immutable_attr(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1103 UNUSED xlat_ctx_t const *xctx,
1104 request_t *request, fr_value_box_list_t *args)
1105{
1106 fr_pair_t *vp;
1107 fr_dcursor_t *cursor;
1108 fr_value_box_t *in_head;
1109
1110 XLAT_ARGS(args, &in_head);
1111
1112 cursor = fr_value_box_get_cursor(in_head);
1113
1114 RDEBUG("Attributes matching \"%s\"", in_head->vb_cursor_name);
1115
1116 RINDENT();
1117 for (vp = fr_dcursor_current(cursor);
1118 vp;
1119 vp = fr_dcursor_next(cursor)) {
1120 fr_pair_set_immutable(vp);
1121 }
1122 REXDENT();
1123
1124 return XLAT_ACTION_DONE;
1125}
1126
1127static xlat_arg_parser_t const xlat_func_integer_args[] = {
1128 { .required = true, .single = true, .type = FR_TYPE_VOID },
1129 XLAT_ARG_PARSER_TERMINATOR
1130};
1131
1132/** Print data as integer, not as VALUE.
1133 *
1134 * Example:
1135@verbatim
1136update request {
1137 &Tmp-IP-Address-0 := "127.0.0.5"
1138}
1139%integer(%{Tmp-IP-Address-0}) == 2130706437
1140@endverbatim
1141 * @ingroup xlat_functions
1142 */
1143static xlat_action_t xlat_func_integer(TALLOC_CTX *ctx, fr_dcursor_t *out,
1144 UNUSED xlat_ctx_t const *xctx,
1145 request_t *request, fr_value_box_list_t *args)
1146{
1147 fr_value_box_t *in_vb;
1148 char const *p;
1149
1150 XLAT_ARGS(args, &in_vb);
1151
1152 fr_strerror_clear(); /* Make sure we don't print old errors */
1153
1154 fr_value_box_list_remove(args, in_vb);
1155
1156 switch (in_vb->type) {
1157 default:
1158 error:
1159 RPEDEBUG("Failed converting %pR (%s) to an integer", in_vb,
1160 fr_type_to_str(in_vb->type));
1161 talloc_free(in_vb);
1162 return XLAT_ACTION_FAIL;
1163
1164 case FR_TYPE_NUMERIC:
1165 /*
1166 * Ensure enumeration is NULL so that the integer
1167 * version of a box is returned
1168 */
1169 in_vb->enumv = NULL;
1170
1171 /*
1172 * FR_TYPE_DATE and FR_TYPE_TIME_DELTA need to be cast
1173 * to int64_t so that they're printed in a
1174 * numeric format.
1175 */
1176 if ((in_vb->type == FR_TYPE_DATE) || (in_vb->type == FR_TYPE_TIME_DELTA)) {
1177 if (fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_INT64, NULL) < 0) goto error;
1178 }
1179 break;
1180
1181 case FR_TYPE_STRING:
1182 /*
1183 * Strings are always zero terminated. They may
1184 * also have zeros in the middle, but if that
1185 * happens, the caller will only get the part up
1186 * to the first zero.
1187 *
1188 * We check for negative numbers, just to be
1189 * nice.
1190 */
1191 for (p = in_vb->vb_strvalue; *p != '\0'; p++) {
1192 if (*p == '-') break;
1193 }
1194
1195 if (*p == '-') {
1196 if (fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_INT64, NULL) < 0) goto error;
1197 } else {
1198 if (fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT64, NULL) < 0) goto error;
1199 }
1200 break;
1201
1202 case FR_TYPE_OCTETS:
1203 if (in_vb->vb_length > sizeof(uint64_t)) {
1204 fr_strerror_printf("Expected octets length <= %zu, got %zu", sizeof(uint64_t), in_vb->vb_length);
1205 goto error;
1206 }
1207
1208 if (in_vb->vb_length > sizeof(uint32_t)) {
1209 if (unlikely(fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT64, NULL) < 0)) goto error;
1210 } else if (in_vb->vb_length > sizeof(uint16_t)) {
1211 if (unlikely(fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT32, NULL) < 0)) goto error;
1212 } else if (in_vb->vb_length > sizeof(uint8_t)) {
1213 if (unlikely(fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT16, NULL) < 0)) goto error;
1214 } else {
1215 if (unlikely(fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT8, NULL) < 0)) goto error;
1216 }
1217
1218 break;
1219
1220 case FR_TYPE_IPV4_ADDR:
1221 case FR_TYPE_IPV4_PREFIX:
1222 if (fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT32, NULL) < 0) goto error;
1223 break;
1224
1225 case FR_TYPE_ETHERNET:
1226 if (fr_value_box_cast_in_place(ctx, in_vb, FR_TYPE_UINT64, NULL) < 0) goto error;
1227 break;
1228
1229 case FR_TYPE_IPV6_ADDR:
1230 case FR_TYPE_IPV6_PREFIX:
1231 {
1232 uint128_t ipv6int;
1233 char buff[40];
1234 fr_value_box_t *vb;
1235
1236 /*
1237 * Needed for correct alignment (as flagged by ubsan)
1238 */
1239 memcpy(&ipv6int, &in_vb->vb_ipv6addr, sizeof(ipv6int));
1240
1241 fr_snprint_uint128(buff, sizeof(buff), ntohlll(ipv6int));
1242
1243 MEM(vb = fr_value_box_alloc_null(ctx));
1244 fr_value_box_bstrndup(vb, vb, NULL, buff, strlen(buff), false);
1245 fr_dcursor_append(out, vb);
1246 talloc_free(in_vb);
1247 return XLAT_ACTION_DONE;
1248 }
1249 }
1250
1251 fr_dcursor_append(out, in_vb);
1252
1253 return XLAT_ACTION_DONE;
1254}
1255
1256static xlat_arg_parser_t const xlat_func_log_arg[] = {
1257 { .concat = true, .type = FR_TYPE_STRING },
1258 XLAT_ARG_PARSER_TERMINATOR
1259};
1260
1261/** Log something at INFO level.
1262 *
1263 * Example:
1264@verbatim
1265%log("This is an informational message")
1266@endverbatim
1267 *
1268 * @ingroup xlat_functions
1269 */
1270static xlat_action_t xlat_func_log_info(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1271 UNUSED xlat_ctx_t const *xctx,
1272 request_t *request, fr_value_box_list_t *args)
1273{
1274 fr_value_box_t *vb;
1275
1276 XLAT_ARGS(args, &vb);
1277
1278 if (!vb) return XLAT_ACTION_DONE;
1279
1280 RINFO("%s", vb->vb_strvalue);
1281
1282 return XLAT_ACTION_DONE;
1283}
1284
1285
1286/** Log something at DEBUG level.
1287 *
1288 * Example:
1289@verbatim
1290%log.debug("This is a message")
1291@endverbatim
1292 *
1293 * @ingroup xlat_functions
1294 */
1295static xlat_action_t xlat_func_log_debug(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1296 UNUSED xlat_ctx_t const *xctx,
1297 request_t *request, fr_value_box_list_t *args)
1298{
1299 fr_value_box_t *vb;
1300
1301 XLAT_ARGS(args, &vb);
1302
1303 if (!vb) return XLAT_ACTION_DONE;
1304
1305 RDEBUG("%s", vb->vb_strvalue);
1306
1307 return XLAT_ACTION_DONE;
1308}
1309
1310
1311/** Log something at ERROR level.
1312 *
1313 * Example:
1314@verbatim
1315%log.err("Big error here")
1316@endverbatim
1317 *
1318 * @ingroup xlat_functions
1319 */
1320static xlat_action_t xlat_func_log_err(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1321 UNUSED xlat_ctx_t const *xctx,
1322 request_t *request, fr_value_box_list_t *args)
1323{
1324 fr_value_box_t *vb;
1325
1326 XLAT_ARGS(args, &vb);
1327
1328 if (!vb) return XLAT_ACTION_DONE;
1329
1330 REDEBUG("%s", vb->vb_strvalue);
1331
1332 return XLAT_ACTION_DONE;
1333}
1334
1335
1336/** Log something at WARN level.
1337 *
1338 * Example:
1339@verbatim
1340%log.warn("Maybe something bad happened")
1341@endverbatim
1342 *
1343 * @ingroup xlat_functions
1344 */
1345static xlat_action_t xlat_func_log_warn(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1346 UNUSED xlat_ctx_t const *xctx,
1347 request_t *request, fr_value_box_list_t *args)
1348{
1349 fr_value_box_t *vb;
1350
1351 XLAT_ARGS(args, &vb);
1352
1353 if (!vb) return XLAT_ACTION_DONE;
1354
1355 RWDEBUG("%s", vb->vb_strvalue);
1356
1357 return XLAT_ACTION_DONE;
1358}
1359
1360static int _log_dst_free(fr_log_t *log)
1361{
1362 close(log->fd);
1363 return 0;
1364}
1365
1366static xlat_arg_parser_t const xlat_func_log_dst_args[] = {
1367 { .required = false, .type = FR_TYPE_STRING, .concat = true },
1368 { .required = false, .type = FR_TYPE_UINT32, .single = true },
1369 { .required = false, .type = FR_TYPE_STRING, .concat = true },
1370 XLAT_ARG_PARSER_TERMINATOR
1371};
1372
1373/** Change the log destination to the named one
1374 *
1375 * Example:
1376@verbatim
1377%log.destination('foo')
1378@endverbatim
1379 *
1380 * @ingroup xlat_functions
1381 */
1382static xlat_action_t xlat_func_log_dst(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1383 UNUSED xlat_ctx_t const *xctx,
1384 request_t *request, fr_value_box_list_t *args)
1385{
1386 fr_value_box_t *dst, *lvl, *file;
1387 fr_log_t *log, *dbg;
1388 uint32_t level = 2;
1389
1390 XLAT_ARGS(args, &dst, &lvl, &file);
1391
1392 /*
1393 * An explicit `null` is treated the same as a missing arg.
1394 * vb_strvalue on an FR_TYPE_NULL box is unset, so reading
1395 * it below would be UB.
1396 */
1397 if (dst && fr_type_is_null(dst->type)) dst = NULL;
1398 if (lvl && fr_type_is_null(lvl->type)) lvl = NULL;
1399 if (file && fr_type_is_null(file->type)) file = NULL;
1400
1401 if (!dst || !*dst->vb_strvalue) {
1402 request_log_prepend(request, NULL, L_DBG_LVL_DISABLE);
1403 return XLAT_ACTION_DONE;
1404 }
1405
1406 log = log_dst_by_name(dst->vb_strvalue);
1407 if (!log) return XLAT_ACTION_FAIL;
1408
1409 if (lvl) {
1410 if (lvl->vb_uint32 > L_DBG_LVL_MAX) {
1411 REDEBUG("Invalid debug level %u, expected 0 to %u", lvl->vb_uint32, L_DBG_LVL_MAX);
1412 return XLAT_ACTION_FAIL;
1413 }
1414 level = lvl->vb_uint32;
1415 }
1416
1417 if (!file || ((log->dst != L_DST_NULL) && (log->dst != L_DST_FILES))) {
1418 request_log_prepend(request, log, level);
1419 return XLAT_ACTION_DONE;
1420 }
1421
1422 /*
1423 * Clone it.
1424 */
1425 MEM(dbg = talloc_memdup(request, log, sizeof(*log)));
1426 dbg->parent = log;
1427
1428 /*
1429 * If we have a filename passed to us, then it over-rides
1430 * the one in the "log foo { ... }" destination.
1431 */
1432 if (file) MEM(dbg->file = talloc_strdup(dbg, file->vb_strvalue));
1433
1434 /*
1435 * Open the new filename.
1436 */
1437 dbg->dst = L_DST_FILES;
1438 dbg->fd = open(dbg->file, O_WRONLY | O_CREAT | O_CLOEXEC, 0600);
1439 if (dbg->fd < 0) {
1440 REDEBUG("Failed opening %s - %s", dbg->file, fr_syserror(errno));
1441 talloc_free(dbg);
1442 return XLAT_ACTION_DONE;
1443 }
1444
1445 /*
1446 * Ensure that we close the file handle when done.
1447 */
1448 talloc_set_destructor(dbg, _log_dst_free);
1449
1450 request_log_prepend(request, dbg, level);
1451 return XLAT_ACTION_DONE;
1452}
1453
1454
1455static xlat_arg_parser_t const xlat_func_map_arg[] = {
1456 { .required = true, .type = FR_TYPE_STRING },
1457 XLAT_ARG_PARSER_TERMINATOR
1458};
1459
1460/** Processes fmt as a map string and applies it to the current request
1461 *
1462 * e.g.
1463@verbatim
1464%map("User-Name := 'foo'")
1465@endverbatim
1466 *
1467 * Allows sets of modifications to be cached and then applied.
1468 * Useful for processing generic attributes from LDAP.
1469 *
1470 * @ingroup xlat_functions
1471 */
1472static xlat_action_t xlat_func_map(TALLOC_CTX *ctx, fr_dcursor_t *out,
1473 UNUSED xlat_ctx_t const *xctx,
1474 request_t *request, fr_value_box_list_t *args)
1475{
1476 map_t *map = NULL;
1477 int ret;
1478 fr_value_box_t *fmt_vb;
1479 fr_value_box_t *vb;
1480
1481 tmpl_rules_t attr_rules = {
1482 .attr = {
1483 .dict_def = request->local_dict,
1484 .list_def = request_attr_request,
1485 },
1486 .xlat = {
1487 .runtime_el = unlang_interpret_event_list(request)
1488 }
1489 };
1490
1491 XLAT_ARGS(args, &fmt_vb);
1492
1493 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
1494 vb->vb_bool = false; /* Default fail value - changed to true on success */
1495 fr_dcursor_append(out, vb);
1496
1497 fr_value_box_list_foreach(&fmt_vb->vb_group, fmt) {
1498 if (map_afrom_attr_str(request, &map, fmt->vb_strvalue, &attr_rules, &attr_rules) < 0) {
1499 RPEDEBUG("Failed parsing \"%s\" as map", fmt_vb->vb_strvalue);
1500 return XLAT_ACTION_FAIL;
1501 }
1502
1503 switch (map->lhs->type) {
1504 case TMPL_TYPE_ATTR:
1505 case TMPL_TYPE_XLAT:
1506 break;
1507
1508 default:
1509 REDEBUG("Unexpected type %s in left hand side of expression",
1510 tmpl_type_to_str(map->lhs->type));
1511 return XLAT_ACTION_FAIL;
1512 }
1513
1514 switch (map->rhs->type) {
1515 case TMPL_TYPE_ATTR:
1516 case TMPL_TYPE_EXEC:
1517 case TMPL_TYPE_DATA:
1518 case TMPL_TYPE_REGEX_XLAT_UNRESOLVED:
1519 case TMPL_TYPE_DATA_UNRESOLVED:
1520 case TMPL_TYPE_XLAT:
1521 break;
1522
1523 default:
1524 REDEBUG("Unexpected type %s in right hand side of expression",
1525 tmpl_type_to_str(map->rhs->type));
1526 return XLAT_ACTION_FAIL;
1527 }
1528
1529 RINDENT();
1530 ret = map_to_request(request, map, map_to_vp, NULL);
1531 REXDENT();
1532 talloc_free(map);
1533 if (ret < 0) return XLAT_ACTION_FAIL;
1534 }
1535
1536 vb->vb_bool = true;
1537 return XLAT_ACTION_DONE;
1538}
1539
1540
1545
1546
1547static xlat_arg_parser_t const xlat_func_module_call_arg[] = {
1548 { .required = true, .concat = true, .type = FR_TYPE_STRING },
1549 XLAT_ARG_PARSER_TERMINATOR
1550};
1551
1552/** Just serves to push the result up the stack
1553 *
1554 */
1555static xlat_action_t xlat_module_call_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1556 xlat_ctx_t const *xctx,
1557 UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
1558{
1559 xlat_module_call_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_module_call_rctx_t);
1560 xlat_action_t xa = XLAT_RESULT_SUCCESS(&rctx->last_result) ? XLAT_ACTION_DONE : XLAT_ACTION_FAIL;
1561
1562 talloc_free(rctx);
1563
1564 return xa;
1565}
1566
1567
1568/** Calls a named virtual module
1569 *
1570 * e.g.
1571@verbatim
1572%module.call("foo")
1573@endverbatim
1574 *
1575 * @ingroup xlat_functions
1576 */
1577static xlat_action_t xlat_func_module_call(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1578 UNUSED xlat_ctx_t const *xctx,
1579 request_t *request, fr_value_box_list_t *args)
1580{
1581 fr_value_box_t *box;
1582 CONF_SECTION *cs;
1583 xlat_module_call_rctx_t *rctx;
1584 fr_dict_t const *dict;
1585
1586 XLAT_ARGS(args, &box);
1587
1588 cs = module_rlm_virtual_by_name(box->vb_strvalue);
1589 if (!cs) {
1590 REDEBUG("Unknown module %pV", box);
1591 return XLAT_ACTION_FAIL;
1592 }
1593
1594 dict = virtual_server_dict_by_cs(cs);
1595 if (!dict) {
1596 REDEBUG("Virtual module %pV does not have a known dictionary - ignoring", box);
1597 return XLAT_ACTION_FAIL;
1598 }
1599
1600 if (!fr_dict_compatible(request->proto_dict, dict)) {
1601 REDEBUG("Virtual module %pV has incompatible namespace %s", box, fr_dict_root(dict)->name);
1602 return XLAT_ACTION_FAIL;
1603 }
1604
1605 MEM(rctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), xlat_module_call_rctx_t));
1606
1607 /*
1608 * Push the resumption point BEFORE pushing the module onto
1609 * the stack.
1610 */
1611 (void) unlang_xlat_yield(request, xlat_module_call_resume, NULL, FR_SIGNAL_NONE, rctx);
1612
1613 if (unlang_interpret_push_section(&rctx->last_result, request, cs,
1614 FRAME_CONF(RLM_MODULE_NOOP, UNLANG_SUB_FRAME)) < 0) {
1615 return XLAT_ACTION_FAIL;
1616 }
1617
1618 return XLAT_ACTION_PUSH_UNLANG;
1619}
1620
1621
1622static xlat_arg_parser_t const xlat_func_next_time_args[] = {
1623 { .required = true, .concat = true, .type = FR_TYPE_STRING },
1624 XLAT_ARG_PARSER_TERMINATOR
1625};
1626
1627/** Calculate number of seconds until the next n hour(s), day(s), week(s), year(s).
1628 *
1629 * For example, if it were 16:18 %time.next(1h) would expand to 2520.
1630 *
1631 * The envisaged usage for this function is to limit sessions so that they don't
1632 * cross billing periods. The output of the xlat should be combined with %rand() to create
1633 * some jitter, unless the desired effect is every subscriber on the network
1634 * re-authenticating at the same time.
1635 *
1636 * @ingroup xlat_functions
1637 */
1638static xlat_action_t xlat_func_next_time(TALLOC_CTX *ctx, fr_dcursor_t *out,
1639 UNUSED xlat_ctx_t const *xctx,
1640 request_t *request, fr_value_box_list_t *args)
1641{
1642 unsigned long num;
1643
1644 char const *p;
1645 char *q;
1646 time_t now;
1647 struct tm *local, local_buff;
1648 fr_value_box_t *in_head;
1649 fr_value_box_t *vb;
1650
1651 XLAT_ARGS(args, &in_head);
1652
1653 /*
1654 * We want to limit based on _now_, not on when they logged in.
1655 */
1656 now = time(NULL);
1657 local = localtime_r(&now, &local_buff);
1658
1659 p = in_head->vb_strvalue;
1660
1661 num = strtoul(p, &q, 10);
1662 if ((num == ULONG_MAX) || !q || *q == '\0') {
1663 REDEBUG("<int> must be followed by time period (h|d|w|m|y)");
1664 return XLAT_ACTION_FAIL;
1665 }
1666 if (num == 0) {
1667 REDEBUG("<int> must be greater than zero");
1668 return XLAT_ACTION_FAIL;
1669 }
1670
1671 if (p == q) {
1672 num = 1;
1673 } else {
1674 p += q - p;
1675 }
1676
1677 local->tm_sec = 0;
1678 local->tm_min = 0;
1679
1680 switch (*p) {
1681 case 'h':
1682 local->tm_hour += num;
1683 break;
1684
1685 case 'd':
1686 local->tm_hour = 0;
1687 local->tm_mday += num;
1688 break;
1689
1690 case 'w':
1691 local->tm_hour = 0;
1692 local->tm_mday += (7 - local->tm_wday) + (7 * (num-1));
1693 break;
1694
1695 case 'm':
1696 local->tm_hour = 0;
1697 local->tm_mday = 1;
1698 local->tm_mon += num;
1699 break;
1700
1701 case 'y':
1702 local->tm_hour = 0;
1703 local->tm_mday = 1;
1704 local->tm_mon = 0;
1705 local->tm_year += num;
1706 break;
1707
1708 default:
1709 REDEBUG("Invalid time period '%c', must be h|d|w|m|y", *p);
1710 return XLAT_ACTION_FAIL;
1711 }
1712
1713 MEM(vb = fr_value_box_alloc_null(ctx));
1714 fr_value_box_uint64(vb, NULL, (uint64_t)(mktime(local) - now), false);
1715 fr_dcursor_append(out, vb);
1716 return XLAT_ACTION_DONE;
1717}
1718
1723
1724/** Just serves to push the result up the stack
1725 *
1726 */
1727static xlat_action_t xlat_eval_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
1728 xlat_ctx_t const *xctx,
1729 UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
1730{
1731 xlat_eval_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_eval_rctx_t);
1732 xlat_action_t xa = XLAT_RESULT_SUCCESS(&rctx->last_result) ? XLAT_ACTION_DONE : XLAT_ACTION_FAIL;
1733
1734 talloc_free(rctx);
1735
1736 return xa;
1737}
1738
1739static xlat_arg_parser_t const xlat_func_eval_arg[] = {
1740 { .required = true, .concat = true, .type = FR_TYPE_STRING },
1741 XLAT_ARG_PARSER_TERMINATOR
1742};
1743
1744/** Dynamically evaluate an expansion string
1745 *
1746 * @ingroup xlat_functions
1747 */
1748static xlat_action_t xlat_func_eval(TALLOC_CTX *ctx, fr_dcursor_t *out,
1749 UNUSED xlat_ctx_t const *xctx,
1750 request_t *request, fr_value_box_list_t *args)
1751{
1752 /*
1753 * These are escaping rules applied to the
1754 * input string. They're mostly here to
1755 * allow \% and \\ to work.
1756 *
1757 * Everything else should be passed in as
1758 * unescaped data.
1759 */
1760 static fr_sbuff_unescape_rules_t const escape_rules = {
1761 .name = "xlat",
1762 .chr = '\\',
1763 .subs = {
1764 ['%'] = '%',
1765 ['\\'] = '\\',
1766 },
1767 .do_hex = false,
1768 .do_oct = false
1769 };
1770
1771 xlat_eval_rctx_t *rctx;
1772 fr_value_box_t *arg = fr_value_box_list_head(args);
1773
1774 XLAT_ARGS(args, &arg);
1775
1776 MEM(rctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), xlat_eval_rctx_t));
1777
1778 /*
1779 * Parse the input as a literal expansion
1780 */
1781 if (xlat_tokenize_expression(rctx,
1782 &rctx->ex,
1783 &FR_SBUFF_IN(arg->vb_strvalue, arg->vb_length),
1784 &(fr_sbuff_parse_rules_t){
1785 .escapes = &escape_rules
1786 },
1787 &(tmpl_rules_t){
1788 .attr = {
1789 .dict_def = request->local_dict,
1790 .list_def = request_attr_request,
1791 .allow_unknown = false,
1792 .allow_unresolved = false,
1793 .allow_foreign = false,
1794 },
1795 .xlat = {
1796 .runtime_el = unlang_interpret_event_list(request),
1797 },
1798 .at_runtime = true
1799 }) < 0) {
1800 RPEDEBUG("Failed parsing expansion");
1801 error:
1802 talloc_free(rctx);
1803 return XLAT_ACTION_FAIL;
1804 }
1805
1806 /*
1807 * Call the resolution function so we produce
1808 * good errors about what function was
1809 * unresolved.
1810 */
1811 if (rctx->ex->flags.needs_resolving &&
1812 (xlat_resolve(rctx->ex, &(xlat_res_rules_t){ .allow_unresolved = false }) < 0)) {
1813 RPEDEBUG("Unresolved expansion functions in expansion");
1814 goto error;
1815
1816 }
1817
1818 if (unlang_xlat_yield(request, xlat_eval_resume, NULL, FR_SIGNAL_NONE, rctx) != XLAT_ACTION_YIELD) goto error;
1819
1820 if (unlang_xlat_push(ctx, &rctx->last_result, (fr_value_box_list_t *)fr_dcursor_list(out),
1821 request, rctx->ex, UNLANG_SUB_FRAME) < 0) goto error;
1822
1823 return XLAT_ACTION_PUSH_UNLANG;
1824}
1825
1826static xlat_arg_parser_t const xlat_func_pad_args[] = {
1827 { .required = true, .type = FR_TYPE_STRING },
1828 { .required = true, .single = true, .type = FR_TYPE_UINT64 },
1829 { .concat = true, .type = FR_TYPE_STRING },
1830 XLAT_ARG_PARSER_TERMINATOR
1831};
1832
1833/** lpad a string
1834 *
1835@verbatim
1836%lpad(%{Attribute-Name}, <length> [, <fill>])
1837@endverbatim
1838 *
1839 * Example: (User-Name = "foo")
1840@verbatim
1841%lpad(%{User-Name}, 5 'x') == "xxfoo"
1842@endverbatim
1843 *
1844 * @ingroup xlat_functions
1845 */
1846static xlat_action_t xlat_func_lpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
1847 UNUSED xlat_ctx_t const *xctx,
1848 request_t *request, fr_value_box_list_t *args)
1849{
1850 fr_value_box_t *values;
1851 fr_value_box_t *pad;
1852 fr_value_box_t *fill;
1853
1854 fr_value_box_list_t *list;
1855
1856 size_t pad_len;
1857
1858 char const *fill_str = NULL;
1859 size_t fill_len = 0;
1860
1861 fr_value_box_t *in = NULL;
1862
1863 XLAT_ARGS(args, &values, &pad, &fill);
1864
1865 list = &values->vb_group;
1866 pad_len = (size_t)pad->vb_uint64;
1867
1868 /*
1869 * Fill is optional
1870 */
1871 if (fill) {
1872 fill_str = fill->vb_strvalue;
1873 fill_len = talloc_strlen(fill_str);
1874 }
1875
1876 if (fill_len == 0) {
1877 fill_str = " ";
1878 fill_len = 1;
1879 }
1880
1881 while ((in = fr_value_box_list_pop_head(list))) {
1882 size_t len = talloc_strlen(in->vb_strvalue);
1883 size_t remaining;
1884 char *buff;
1885 fr_sbuff_t sbuff;
1886 fr_sbuff_marker_t m_data;
1887
1888 fr_dcursor_append(out, in);
1889
1890 if (len >= pad_len) continue;
1891
1892 if (fr_value_box_bstr_realloc(in, &buff, in, pad_len) < 0) {
1893 RPEDEBUG("Failed reallocing input data");
1894 return XLAT_ACTION_FAIL;
1895 }
1896
1897 fr_sbuff_init_in(&sbuff, buff, pad_len);
1898 fr_sbuff_marker(&m_data, &sbuff);
1899
1900 /*
1901 * ...nothing to move if the input
1902 * string is empty.
1903 */
1904 if (len > 0) {
1905 fr_sbuff_advance(&m_data, pad_len - len); /* Mark where we want the data to go */
1906 fr_sbuff_move(&FR_SBUFF(&m_data), &FR_SBUFF(&sbuff), len); /* Shift the data */
1907 }
1908
1909 if (fill_len == 1) {
1910 memset(fr_sbuff_current(&sbuff), *fill_str, fr_sbuff_ahead(&m_data));
1911 continue;
1912 }
1913
1914 /*
1915 * Copy fill as a repeating pattern
1916 */
1917 while ((remaining = fr_sbuff_ahead(&m_data))) {
1918 size_t to_copy = remaining >= fill_len ? fill_len : remaining;
1919 memcpy(fr_sbuff_current(&sbuff), fill_str, to_copy); /* avoid \0 termination */
1920 fr_sbuff_advance(&sbuff, to_copy);
1921 }
1922 fr_sbuff_set_to_end(&sbuff);
1923 fr_sbuff_terminate(&sbuff); /* Move doesn't re-terminate */
1924 }
1925
1926 return XLAT_ACTION_DONE;
1927}
1928
1929/** Right pad a string
1930 *
1931@verbatim
1932%rpad(%{Attribute-Name}, <length> [, <fill>])
1933@endverbatim
1934 *
1935 * Example: (User-Name = "foo")
1936@verbatim
1937%rpad(%{User-Name}, 5 'x') == "fooxx"
1938@endverbatim
1939 *
1940 * @ingroup xlat_functions
1941 */
1942static xlat_action_t xlat_func_rpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
1943 UNUSED xlat_ctx_t const *xctx,
1944 request_t *request, fr_value_box_list_t *args)
1945{
1946 fr_value_box_t *values;
1947 fr_value_box_list_t *list;
1948 fr_value_box_t *pad;
1949 size_t pad_len;
1950 fr_value_box_t *fill;
1951 char const *fill_str = NULL;
1952 size_t fill_len = 0;
1953
1954 fr_value_box_t *in = NULL;
1955
1956 XLAT_ARGS(args, &values, &pad, &fill);
1957
1958 list = &values->vb_group;
1959 pad_len = (size_t)pad->vb_uint64;
1960
1961 /*
1962 * Fill is optional
1963 */
1964 if (fill) {
1965 fill_str = fill->vb_strvalue;
1966 fill_len = talloc_strlen(fill_str);
1967 }
1968
1969 if (fill_len == 0) {
1970 fill_str = " ";
1971 fill_len = 1;
1972 }
1973
1974 while ((in = fr_value_box_list_pop_head(list))) {
1975 size_t len = talloc_strlen(in->vb_strvalue);
1976 size_t remaining;
1977 char *buff;
1978 fr_sbuff_t sbuff;
1979
1980 fr_dcursor_append(out, in);
1981
1982 if (len >= pad_len) continue;
1983
1984 if (fr_value_box_bstr_realloc(in, &buff, in, pad_len) < 0) {
1985 fail:
1986 RPEDEBUG("Failed reallocing input data");
1987 return XLAT_ACTION_FAIL;
1988 }
1989
1990 fr_sbuff_init_in(&sbuff, buff, pad_len);
1991 fr_sbuff_advance(&sbuff, len);
1992
1993 if (fill_len == 1) {
1994 memset(fr_sbuff_current(&sbuff), *fill_str, fr_sbuff_remaining(&sbuff));
1995 continue;
1996 }
1997
1998 /*
1999 * Copy fill as a repeating pattern
2000 */
2001 while ((remaining = fr_sbuff_remaining(&sbuff))) {
2002 if (fr_sbuff_in_bstrncpy(&sbuff, fill_str, remaining >= fill_len ? fill_len : remaining) < 0) {
2003 goto fail;
2004 }
2005 }
2006 }
2007
2008 return XLAT_ACTION_DONE;
2009}
2010
2011static xlat_arg_parser_t const xlat_func_base64_encode_arg[] = {
2012 { .required = true, .concat = true, .type = FR_TYPE_OCTETS },
2013 XLAT_ARG_PARSER_TERMINATOR
2014};
2015
2016/** Encode string or attribute as base64
2017 *
2018 * Example:
2019@verbatim
2020%base64.encode("foo") == "Zm9v"
2021@endverbatim
2022 *
2023 * @ingroup xlat_functions
2024 */
2025static xlat_action_t xlat_func_base64_encode(TALLOC_CTX *ctx, fr_dcursor_t *out,
2026 UNUSED xlat_ctx_t const *xctx,
2027 request_t *request, fr_value_box_list_t *args)
2028{
2029 size_t alen;
2030 ssize_t elen;
2031 char *buff;
2032 fr_value_box_t *vb;
2033 fr_value_box_t *in;
2034
2035 XLAT_ARGS(args, &in);
2036
2037 alen = FR_BASE64_ENC_LENGTH(in->vb_length);
2038
2039 MEM(vb = fr_value_box_alloc_null(ctx));
2040 if (fr_value_box_bstr_alloc(vb, &buff, vb, NULL, alen, false) < 0) {
2041 talloc_free(vb);
2042 return XLAT_ACTION_FAIL;
2043 }
2044
2045 elen = fr_base64_encode(&FR_SBUFF_OUT(buff, talloc_array_length(buff)),
2046 &FR_DBUFF_TMP(in->vb_octets, in->vb_length), true);
2047 if (elen < 0) {
2048 RPEDEBUG("Base64 encoding failed");
2049 talloc_free(vb);
2050 return XLAT_ACTION_FAIL;
2051 }
2052 fr_assert((size_t)elen <= alen);
2053 fr_value_box_safety_copy_changed(vb, in);
2054 fr_dcursor_append(out, vb);
2055
2056 return XLAT_ACTION_DONE;
2057}
2058
2059static xlat_arg_parser_t const xlat_func_base64_decode_arg[] = {
2060 { .required = true, .concat = true, .type = FR_TYPE_OCTETS },
2061 XLAT_ARG_PARSER_TERMINATOR
2062};
2063
2064/** Decode base64 string
2065 *
2066 * Example:
2067@verbatim
2068%base64.decode("Zm9v") == "foo"
2069@endverbatim
2070 *
2071 * @ingroup xlat_functions
2072 */
2073static xlat_action_t xlat_func_base64_decode(TALLOC_CTX *ctx, fr_dcursor_t *out,
2074 UNUSED xlat_ctx_t const *xctx,
2075 request_t *request, fr_value_box_list_t *args)
2076{
2077 size_t alen;
2078 ssize_t declen = 0;
2079 uint8_t *decbuf;
2080 fr_value_box_t *vb;
2081 fr_value_box_t *in;
2082
2083 XLAT_ARGS(args, &in);
2084
2085 /*
2086 * Pass empty arguments through
2087 *
2088 * FR_BASE64_DEC_LENGTH produces 2 for empty strings...
2089 */
2090 if (in->vb_length == 0) {
2091 xlat_arg_copy_out(ctx, out, args, in);
2092 return XLAT_ACTION_DONE;
2093 }
2094
2095 alen = FR_BASE64_DEC_LENGTH(in->vb_length);
2096 MEM(vb = fr_value_box_alloc_null(ctx));
2097 if (alen > 0) {
2098 MEM(fr_value_box_mem_alloc(vb, &decbuf, vb, NULL, alen, false) == 0);
2099 declen = fr_base64_decode(&FR_DBUFF_TMP(decbuf, alen),
2100 &FR_SBUFF_IN(in->vb_strvalue, in->vb_length), true, true);
2101 if (declen < 0) {
2102 RPEDEBUG("Base64 string invalid");
2103 talloc_free(vb);
2104 return XLAT_ACTION_FAIL;
2105 }
2106
2107 MEM(fr_value_box_mem_realloc(vb, NULL, vb, declen) == 0);
2108 }
2109
2110 fr_value_box_safety_copy_changed(vb, in);
2111 fr_dcursor_append(out, vb);
2112
2113 return XLAT_ACTION_DONE;
2114}
2115
2116static xlat_arg_parser_t const xlat_func_bin_arg[] = {
2117 { .required = true, .type = FR_TYPE_STRING },
2118 XLAT_ARG_PARSER_TERMINATOR
2119};
2120
2121/** Convert hex string to binary
2122 *
2123 * Example:
2124@verbatim
2125%bin("666f6f626172") == "foobar"
2126@endverbatim
2127 *
2128 * @see #xlat_func_hex
2129 *
2130 * @ingroup xlat_functions
2131 */
2132static xlat_action_t xlat_func_bin(TALLOC_CTX *ctx, fr_dcursor_t *out,
2133 UNUSED xlat_ctx_t const *xctx,
2134 request_t *request, fr_value_box_list_t *args)
2135{
2136 fr_value_box_t *result;
2137 char const *p, *end;
2138 uint8_t *bin;
2139 size_t len, outlen;
2140 fr_sbuff_err_t err;
2141 fr_value_box_t *list, *hex;
2142
2143 XLAT_ARGS(args, &list);
2144
2145 while ((hex = fr_value_box_list_pop_head(&list->vb_group))) {
2146 len = hex->vb_length;
2147 if ((len > 1) && (len & 0x01)) {
2148 REDEBUG("Input data length must be >1 and even, got %zu", len);
2149 return XLAT_ACTION_FAIL;
2150 }
2151
2152 p = hex->vb_strvalue;
2153 end = p + len;
2154
2155 /*
2156 * Look for 0x at the start of the string, and ignore if we see it.
2157 */
2158 if ((p[0] == '0') && (p[1] == 'x')) {
2159 p += 2;
2160 len -=2;
2161 }
2162
2163 /*
2164 * Zero length octets string
2165 */
2166 if (p == end) continue;
2167
2168 outlen = len / 2;
2169
2170 MEM(result = fr_value_box_alloc_null(ctx));
2171 MEM(fr_value_box_mem_alloc(result, &bin, result, NULL, outlen, false) == 0);
2172 fr_base16_decode(&err, &FR_DBUFF_TMP(bin, outlen), &FR_SBUFF_IN(p, end - p), true);
2173 if (err) {
2174 REDEBUG2("Invalid hex string");
2175 talloc_free(result);
2176 return XLAT_ACTION_FAIL;
2177 }
2178
2179 fr_value_box_safety_copy_changed(result, hex);
2180 fr_dcursor_append(out, result);
2181 }
2182
2183 return XLAT_ACTION_DONE;
2184}
2185
2186static xlat_arg_parser_t const xlat_func_block_args[] = {
2187 { .required = true, .single = true, .type = FR_TYPE_TIME_DELTA },
2188 XLAT_ARG_PARSER_TERMINATOR
2189};
2190
2191/** Block for the specified duration
2192 *
2193 * This is for developer use only to simulate blocking, synchronous I/O.
2194 * For normal use, use the %delay() xlat instead.
2195 *
2196 * Example:
2197@verbatim
2198%block(1s)
2199@endverbatim
2200 *
2201 * @ingroup xlat_functions
2202 */
2203static xlat_action_t xlat_func_block(TALLOC_CTX *ctx, fr_dcursor_t *out,
2204 UNUSED xlat_ctx_t const *xctx,
2205 UNUSED request_t *request, fr_value_box_list_t *args)
2206{
2207 fr_value_box_t *delay;
2208 fr_value_box_t *vb;
2209 struct timespec ts_in, ts_remain = {};
2210
2211 XLAT_ARGS(args, &delay);
2212
2213 ts_in = fr_time_delta_to_timespec(delay->vb_time_delta);
2214
2215 (void)nanosleep(&ts_in, &ts_remain);
2216
2217 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
2218 vb->vb_time_delta = fr_time_delta_sub(delay->vb_time_delta,
2219 fr_time_delta_from_timespec(&ts_remain));
2220 fr_dcursor_append(out, vb);
2221
2222 return XLAT_ACTION_DONE;
2223}
2224
2225static xlat_arg_parser_t const xlat_func_cast_args[] = {
2226 { .required = true, .single = true, .type = FR_TYPE_VOID },
2227 { .type = FR_TYPE_VOID },
2228 { .variadic = XLAT_ARG_VARIADIC_EMPTY_KEEP, .type = FR_TYPE_VOID },
2229 XLAT_ARG_PARSER_TERMINATOR
2230};
2231
2232/** Cast one or more output value-boxes to the given type
2233 *
2234 * First argument of is type to cast to.
2235 *
2236 * Example:
2237@verbatim
2238%cast('string', %{request[*]}) results in all of the input boxes being cast to string/
2239@endverbatim
2240 *
2241 * @ingroup xlat_functions
2242 */
2243xlat_action_t xlat_func_cast(TALLOC_CTX *ctx, fr_dcursor_t *out,
2244 UNUSED xlat_ctx_t const *xctx,
2245 request_t *request, fr_value_box_list_t *args)
2246{
2247 fr_value_box_t *name;
2248 fr_value_box_t *arg;
2249 fr_type_t type;
2250 fr_dict_attr_t const *time_res = NULL;
2251
2252 XLAT_ARGS(args, &name);
2253
2254 /*
2255 * Get the type, which can be in one of a few formats.
2256 */
2257 if (fr_type_is_numeric(name->type)) {
2258 if (fr_value_box_cast_in_place(name, name, FR_TYPE_UINT8, NULL) < 0) {
2259 RPEDEBUG("Failed parsing '%pV' as a numerical data type", name);
2260 return XLAT_ACTION_FAIL;
2261 }
2262 type = (fr_type_t)name->vb_uint8;
2263
2264 } else {
2265 if (name->type != FR_TYPE_STRING) {
2266 if (fr_value_box_cast_in_place(name, name, FR_TYPE_STRING, NULL) < 0) {
2267 RPEDEBUG("Failed parsing '%pV' as a string data type", name);
2268 return XLAT_ACTION_FAIL;
2269 }
2270 }
2271
2272 type = fr_table_value_by_str(fr_type_table, name->vb_strvalue, FR_TYPE_NULL);
2273 if (type == FR_TYPE_NULL) {
2274 if ((time_res = xlat_time_res_attr(name->vb_strvalue)) == NULL) {
2275 RDEBUG("Unknown data type '%s'", name->vb_strvalue);
2276 return XLAT_ACTION_FAIL;
2277 }
2278
2279 type = FR_TYPE_TIME_DELTA;
2280 }
2281 }
2282
2283 (void) fr_value_box_list_pop_head(args);
2284
2285 /*
2286 * When we cast nothing to a string / octets, the result is an empty string/octets.
2287 */
2288 if (unlikely(!fr_value_box_list_head(args))) {
2289 if ((type == FR_TYPE_STRING) || (type == FR_TYPE_OCTETS)) {
2290 fr_value_box_t *dst;
2291
2292 MEM(dst = fr_value_box_alloc(ctx, type, NULL));
2293 fr_dcursor_append(out, dst);
2294 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)fr_dcursor_list(out));
2295
2296 return XLAT_ACTION_DONE;
2297 }
2298
2299 RDEBUG("No data for cast to '%s'", fr_type_to_str(type));
2300 return XLAT_ACTION_FAIL;
2301 }
2302
2303 /*
2304 * Cast to string means *print* to string.
2305 */
2306 if (type == FR_TYPE_STRING) {
2307 fr_sbuff_t *agg;
2308 fr_value_box_t *dst;
2309 fr_value_box_safety_t safety = { .safe_for = FR_VALUE_BOX_SAFE_FOR_ANY };
2310
2311 talloc_free(name);
2312
2313 FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, SIZE_MAX);
2314
2315 MEM(dst = fr_value_box_alloc_null(ctx));
2316
2317 if (fr_value_box_list_concat_as_string(&safety, agg, args, NULL, 0, NULL,
2318 FR_VALUE_BOX_LIST_FREE_BOX, FR_VALUE_BOX_SAFE_FOR_ANY, true) < 0) {
2319 RPEDEBUG("Failed concatenating string");
2320 return XLAT_ACTION_FAIL;
2321 }
2322
2323 fr_value_box_bstrndup(dst, dst, NULL, fr_sbuff_start(agg), fr_sbuff_used(agg), false);
2324 fr_value_box_safety_set(dst, &safety);
2325 fr_dcursor_append(out, dst);
2326 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)fr_dcursor_list(out));
2327
2328 return XLAT_ACTION_DONE;
2329 }
2330
2331 /*
2332 * Copy inputs to outputs, casting them along the way.
2333 */
2334 arg = NULL;
2335 while ((arg = fr_value_box_list_next(args, arg)) != NULL) {
2336 fr_value_box_t *vb, *p;
2337
2338 fr_assert(arg->type == FR_TYPE_GROUP);
2339
2340 vb = fr_value_box_list_head(&arg->vb_group);
2341 while (vb) {
2342 p = fr_value_box_list_remove(&arg->vb_group, vb);
2343
2344 if (fr_value_box_cast_in_place(vb, vb, type, time_res) < 0) {
2345 RPEDEBUG("Failed casting %pV to data type '%s'", vb, fr_type_to_str(type));
2346 return XLAT_ACTION_FAIL;
2347 }
2348 fr_dcursor_append(out, vb);
2349 vb = fr_value_box_list_next(&arg->vb_group, p);
2350 }
2351 }
2352 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)fr_dcursor_list(out));
2353
2354 return XLAT_ACTION_DONE;
2355}
2356
2357static xlat_arg_parser_t const xlat_func_concat_args[] = {
2358 { .required = true, .type = FR_TYPE_VOID },
2359 { .concat = true, .type = FR_TYPE_STRING },
2360 XLAT_ARG_PARSER_TERMINATOR
2361};
2362
2363/** Concatenate string representation of values of given attributes using separator
2364 *
2365 * First argument of is the list of attributes to concatenate, followed
2366 * by an optional separator
2367 *
2368 * Example:
2369@verbatim
2370%concat(%{request.[*]}, ',') == "<attr1value>,<attr2value>,<attr3value>,..."
2371%concat(%{Tmp-String-0[*]}, '. ') == "<str1value>. <str2value>. <str3value>. ..."
2372%concat(%join(%{User-Name}, %{Calling-Station-Id}), ', ') == "bob, aa:bb:cc:dd:ee:ff"
2373@endverbatim
2374 *
2375 * @ingroup xlat_functions
2376 */
2377static xlat_action_t xlat_func_concat(TALLOC_CTX *ctx, fr_dcursor_t *out,
2378 UNUSED xlat_ctx_t const *xctx,
2379 request_t *request, fr_value_box_list_t *args)
2380{
2381 fr_value_box_t *result;
2382 fr_value_box_t *list;
2383 fr_value_box_t *separator;
2384 fr_value_box_list_t *to_concat;
2385 char *buff;
2386 char const *sep;
2387
2388 XLAT_ARGS(args, &list, &separator);
2389
2390 sep = (separator) ? separator->vb_strvalue : "";
2391 to_concat = &list->vb_group;
2392
2393 result = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL);
2394 if (!result) {
2395 error:
2396 RPEDEBUG("Failed concatenating input");
2397 return XLAT_ACTION_FAIL;
2398 }
2399
2400 buff = fr_value_box_list_aprint(result, to_concat, sep, NULL);
2401 if (!buff) goto error;
2402
2403 fr_value_box_bstrdup_buffer_shallow(NULL, result, NULL, buff, fr_value_box_list_tainted(args));
2404
2405 fr_dcursor_append(out, result);
2406
2407 return XLAT_ACTION_DONE;
2408}
2409
2410static xlat_arg_parser_t const xlat_func_hex_arg[] = {
2411 { .required = true, .type = FR_TYPE_OCTETS },
2412 XLAT_ARG_PARSER_TERMINATOR
2413};
2414
2415/** Print data as hex, not as VALUE.
2416 *
2417 * Example:
2418@verbatim
2419%hex("foobar") == "666f6f626172"
2420@endverbatim
2421 *
2422 * @see #xlat_func_bin
2423 *
2424 * @ingroup xlat_functions
2425 */
2426static xlat_action_t xlat_func_hex(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
2427 UNUSED xlat_ctx_t const *xctx,
2428 UNUSED request_t *request, fr_value_box_list_t *args)
2429{
2430 char *new_buff;
2431 fr_value_box_t *list, *bin;
2432 fr_value_box_t safety;
2433
2434 XLAT_ARGS(args, &list);
2435
2436 while ((bin = fr_value_box_list_pop_head(&list->vb_group))) {
2437 fr_value_box_safety_copy(&safety, bin);
2438
2439 /*
2440 * Use existing box, but with new buffer
2441 */
2442 MEM(new_buff = talloc_zero_array(bin, char, (bin->vb_length * 2) + 1));
2443 if (bin->vb_length) {
2444 fr_base16_encode(&FR_SBUFF_OUT(new_buff, (bin->vb_length * 2) + 1),
2445 &FR_DBUFF_TMP(bin->vb_octets, bin->vb_length));
2446 fr_value_box_clear_value(bin);
2447 fr_value_box_strdup_shallow(bin, NULL, new_buff, false);
2448 /*
2449 * Zero length binary > zero length hex string
2450 */
2451 } else {
2452 fr_value_box_clear_value(bin);
2453 fr_value_box_strdup(bin, bin, NULL, "", false);
2454 }
2455
2456 fr_value_box_safety_copy(bin, &safety);
2457 fr_dcursor_append(out, bin);
2458 }
2459
2460 return XLAT_ACTION_DONE;
2461}
2462
2467
2468static xlat_action_t xlat_hmac(TALLOC_CTX *ctx, fr_dcursor_t *out,
2469 fr_value_box_list_t *args, uint8_t *digest, int digest_len, hmac_type type)
2470{
2471 fr_value_box_t *vb, *data, *key;
2472
2473 XLAT_ARGS(args, &data, &key);
2474
2475 if (type == HMAC_MD5) {
2476 fr_hmac_md5(digest, data->vb_octets, data->vb_length, key->vb_octets, key->vb_length);
2477 } else if (type == HMAC_SHA1) {
2478 fr_hmac_sha1(digest, data->vb_octets, data->vb_length, key->vb_octets, key->vb_length);
2479 }
2480
2481 MEM(vb = fr_value_box_alloc_null(ctx));
2482 fr_value_box_memdup(vb, vb, NULL, digest, digest_len, false);
2483
2484 fr_dcursor_append(out, vb);
2485
2486 return XLAT_ACTION_DONE;
2487}
2488
2489static xlat_arg_parser_t const xlat_hmac_args[] = {
2490 { .required = true, .concat = true, .type = FR_TYPE_STRING },
2491 { .required = true, .concat = true, .type = FR_TYPE_STRING },
2492 XLAT_ARG_PARSER_TERMINATOR
2493};
2494
2495/** Generate the HMAC-MD5 of a string or attribute
2496 *
2497 * Example:
2498@verbatim
2499%hmacmd5('foo', 'bar') == "0x31b6db9e5eb4addb42f1a6ca07367adc"
2500@endverbatim
2501 *
2502 * @ingroup xlat_functions
2503 */
2504static xlat_action_t xlat_func_hmac_md5(TALLOC_CTX *ctx, fr_dcursor_t *out,
2505 UNUSED xlat_ctx_t const *xctx,
2506 UNUSED request_t *request, fr_value_box_list_t *in)
2507{
2508 uint8_t digest[MD5_DIGEST_LENGTH];
2509 return xlat_hmac(ctx, out, in, digest, MD5_DIGEST_LENGTH, HMAC_MD5);
2510}
2511
2512
2513/** Generate the HMAC-SHA1 of a string or attribute
2514 *
2515 * Example:
2516@verbatim
2517%hmacsha1('foo', 'bar') == "0x85d155c55ed286a300bd1cf124de08d87e914f3a"
2518@endverbatim
2519 *
2520 * @ingroup xlat_functions
2521 */
2522static xlat_action_t xlat_func_hmac_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out,
2523 UNUSED xlat_ctx_t const *xctx,
2524 UNUSED request_t *request, fr_value_box_list_t *in)
2525{
2526 uint8_t digest[SHA1_DIGEST_LENGTH];
2527 return xlat_hmac(ctx, out, in, digest, SHA1_DIGEST_LENGTH, HMAC_SHA1);
2528}
2529
2530static xlat_arg_parser_t const xlat_func_join_args[] = {
2531 { .required = true, .type = FR_TYPE_VOID },
2532 { .variadic = XLAT_ARG_VARIADIC_EMPTY_SQUASH, .type = FR_TYPE_VOID },
2533 XLAT_ARG_PARSER_TERMINATOR
2534};
2535
2536/** Join a series of arguments to form a single list
2537 *
2538 * null boxes are not preserved.
2539 */
2540static xlat_action_t xlat_func_join(TALLOC_CTX *ctx, fr_dcursor_t *out,
2541 UNUSED xlat_ctx_t const *xctx,
2542 UNUSED request_t *request, fr_value_box_list_t *in)
2543{
2544 fr_value_box_list_foreach(in, arg) {
2545 fr_assert(arg->type == FR_TYPE_GROUP);
2546
2547 fr_value_box_list_foreach(&arg->vb_group, vb) {
2548 xlat_arg_copy_out(ctx, out, &arg->vb_group, vb);
2549 }
2550 }
2551 return XLAT_ACTION_DONE;
2552}
2553
2554static void ungroup(fr_dcursor_t *out, fr_value_box_list_t *in)
2555{
2556 fr_value_box_t *vb;
2557
2558 while ((vb = fr_value_box_list_pop_head(in)) != NULL) {
2559 if (vb->type != FR_TYPE_GROUP) {
2560 fr_dcursor_append(out, vb);
2561 continue;
2562 }
2563 talloc_free(vb);
2564 }
2565}
2566
2567/** Ungroups all of its arguments into one flat list.
2568 *
2569 */
2570static xlat_action_t xlat_func_ungroup(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
2571 UNUSED xlat_ctx_t const *xctx,
2572 UNUSED request_t *request, fr_value_box_list_t *in)
2573{
2574 fr_value_box_t *arg = NULL;
2575
2576 while ((arg = fr_value_box_list_next(in, arg)) != NULL) {
2577 fr_assert(arg->type == FR_TYPE_GROUP);
2578
2579 ungroup(out, &arg->vb_group);
2580 }
2581 return XLAT_ACTION_DONE;
2582}
2583
2584static xlat_arg_parser_t const xlat_func_length_args[] = {
2585 { .single = true, .variadic = XLAT_ARG_VARIADIC_EMPTY_KEEP, .type = FR_TYPE_VOID },
2586 XLAT_ARG_PARSER_TERMINATOR
2587};
2588
2589/** Return the on-the-wire size of the boxes in bytes
2590 *
2591 * skips null values
2592 *
2593 * Example:
2594@verbatim
2595%length(foobar) == 6
2596%length(%bin("0102030005060708")) == 8
2597@endverbatim
2598 *
2599 * @see #xlat_func_strlen
2600 *
2601 * @ingroup xlat_functions
2602 */
2603static xlat_action_t xlat_func_length(TALLOC_CTX *ctx, fr_dcursor_t *out,
2604 UNUSED xlat_ctx_t const *xctx,
2605 UNUSED request_t *request, fr_value_box_list_t *in)
2606
2607{
2608 fr_value_box_list_foreach(in, vb) {
2609 fr_value_box_t *my;
2610
2611 MEM(my = fr_value_box_alloc(ctx, FR_TYPE_SIZE, NULL));
2612 if (!fr_type_is_null(vb->type)) my->vb_size = fr_value_box_network_length(vb);
2613 fr_dcursor_append(out, my);
2614 }
2615
2616 return XLAT_ACTION_DONE;
2617}
2618
2619
2620static xlat_arg_parser_t const xlat_func_md4_arg[] = {
2621 { .concat = true, .type = FR_TYPE_OCTETS },
2622 XLAT_ARG_PARSER_TERMINATOR
2623};
2624
2625/** Calculate the MD4 hash of a string or attribute.
2626 *
2627 * Example:
2628@verbatim
2629%md4("foo") == "0ac6700c491d70fb8650940b1ca1e4b2"
2630@endverbatim
2631 *
2632 * @ingroup xlat_functions
2633 */
2634static xlat_action_t xlat_func_md4(TALLOC_CTX *ctx, fr_dcursor_t *out,
2635 UNUSED xlat_ctx_t const *xctx,
2636 UNUSED request_t *request, fr_value_box_list_t *args)
2637{
2638 uint8_t digest[MD4_DIGEST_LENGTH];
2639 fr_value_box_t *vb;
2640 fr_value_box_t *in_head;
2641
2642 XLAT_ARGS(args, &in_head);
2643
2644 if (in_head) {
2645 fr_md4_calc(digest, in_head->vb_octets, in_head->vb_length);
2646 } else {
2647 /* Digest of empty string */
2648 fr_md4_calc(digest, NULL, 0);
2649 }
2650
2651 MEM(vb = fr_value_box_alloc_null(ctx));
2652 fr_value_box_memdup(vb, vb, NULL, digest, sizeof(digest), false);
2653
2654 fr_dcursor_append(out, vb);
2655 VALUE_BOX_LIST_VERIFY((fr_value_box_list_t *)fr_dcursor_list(out));
2656
2657 return XLAT_ACTION_DONE;
2658}
2659
2660static xlat_arg_parser_t const xlat_func_md5_arg[] = {
2661 { .concat = true, .type = FR_TYPE_OCTETS },
2662 XLAT_ARG_PARSER_TERMINATOR
2663};
2664
2665/** Calculate the MD5 hash of a string or attribute.
2666 *
2667 * Example:
2668@verbatim
2669%md5("foo") == "acbd18db4cc2f85cedef654fccc4a4d8"
2670@endverbatim
2671 *
2672 * @ingroup xlat_functions
2673 */
2674static xlat_action_t xlat_func_md5(TALLOC_CTX *ctx, fr_dcursor_t *out,
2675 UNUSED xlat_ctx_t const *xctx,
2676 UNUSED request_t *request, fr_value_box_list_t *args)
2677{
2678 uint8_t digest[MD5_DIGEST_LENGTH];
2679 fr_value_box_t *vb;
2680 fr_value_box_t *in_head;
2681
2682 XLAT_ARGS(args, &in_head);
2683
2684 if (in_head) {
2685 fr_md5_calc(digest, in_head->vb_octets, in_head->vb_length);
2686 } else {
2687 /* Digest of empty string */
2688 fr_md5_calc(digest, NULL, 0);
2689 }
2690
2691 MEM(vb = fr_value_box_alloc_null(ctx));
2692 fr_value_box_memdup(vb, vb, NULL, digest, sizeof(digest), false);
2693
2694 fr_dcursor_append(out, vb);
2695
2696 return XLAT_ACTION_DONE;
2697}
2698
2699
2700/** Encode attributes as a series of string attribute/value pairs
2701 *
2702 * This is intended to serialize one or more attributes as a comma
2703 * delimited string.
2704 *
2705 * Example:
2706@verbatim
2707%pairs.print(request.[*]) == 'User-Name = "foo"User-Password = "bar"'
2708%concat(%pairs.print.print(request.[*]), ', ') == 'User-Name = "foo", User-Password = "bar"'
2709@endverbatim
2710 *
2711 * @see #xlat_func_concat
2712 *
2713 * @ingroup xlat_functions
2714 */
2715static xlat_action_t xlat_func_pairs_print(TALLOC_CTX *ctx, fr_dcursor_t *out,
2716 UNUSED xlat_ctx_t const *xctx,
2717 request_t *request, fr_value_box_list_t *args)
2718{
2719 fr_pair_t *vp;
2720 fr_dcursor_t *cursor;
2721 fr_value_box_t *vb;
2722 fr_value_box_t *in_head;
2723
2724 XLAT_ARGS(args, &in_head);
2725
2726 cursor = fr_value_box_get_cursor(in_head);
2727
2728 for (vp = fr_dcursor_current(cursor);
2729 vp;
2730 vp = fr_dcursor_next(cursor)) {
2731 char *buff;
2732
2733 MEM(vb = fr_value_box_alloc_null(ctx));
2734 if (unlikely(fr_pair_aprint(vb, &buff, NULL, vp) < 0)) {
2735 RPEDEBUG("Failed printing pair");
2736 talloc_free(vb);
2737 return XLAT_ACTION_FAIL;
2738 }
2739
2740 fr_value_box_bstrdup_buffer_shallow(NULL, vb, NULL, buff, false);
2741 fr_dcursor_append(out, vb);
2742
2743 VALUE_BOX_VERIFY(vb);
2744 }
2745
2746 return XLAT_ACTION_DONE;
2747}
2748
2749static xlat_arg_parser_t const xlat_func_rand_arg[] = {
2750 { .required = true, .single = true, .type = FR_TYPE_UINT32 },
2751 XLAT_ARG_PARSER_TERMINATOR
2752};
2753
2754/** Generate a random integer value
2755 *
2756 * For "N = %rand(MAX)", 0 <= N < MAX
2757 *
2758 * Example:
2759@verbatim
2760%rand(100) == 42
2761@endverbatim
2762 *
2763 * @ingroup xlat_functions
2764 */
2765static xlat_action_t xlat_func_rand(TALLOC_CTX *ctx, fr_dcursor_t *out,
2766 UNUSED xlat_ctx_t const *xctx,
2767 UNUSED request_t *request, fr_value_box_list_t *in)
2768{
2769 int64_t result;
2770 fr_value_box_t *vb;
2771 fr_value_box_t *in_head = fr_value_box_list_head(in);
2772
2773 result = in_head->vb_uint32;
2774
2775 /* Make sure it isn't too big */
2776 if (result > (1 << 30)) result = (1 << 30);
2777
2778 result *= fr_rand(); /* 0..2^32-1 */
2779 result >>= 32;
2780
2781 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_UINT64, NULL));
2782 vb->vb_uint64 = result;
2783
2784 fr_dcursor_append(out, vb);
2785
2786 return XLAT_ACTION_DONE;
2787}
2788
2789static xlat_arg_parser_t const xlat_func_randstr_arg[] = {
2790 { .required = true, .concat = true, .type = FR_TYPE_STRING },
2791 XLAT_ARG_PARSER_TERMINATOR
2792};
2793
2794/** Generate a string of random chars
2795 *
2796 * Build strings of random chars, useful for generating tokens and passcodes
2797 * Format similar to String::Random.
2798 *
2799 * Format characters may include the following, and may be
2800 * preceded by a repetition count:
2801 * - "c" lowercase letters
2802 * - "C" uppercase letters
2803 * - "n" numbers
2804 * - "a" alphanumeric
2805 * - "!" punctuation
2806 * - "." alphanumeric + punctuation
2807 * - "s" alphanumeric + "./"
2808 * - "o" characters suitable for OTP (easily confused removed)
2809 * - "b" binary data
2810 *
2811 * Example:
2812@verbatim
2813%randstr("CCCC!!cccnnn") == "IPFL>{saf874"
2814%randstr("42o") == "yHdupUwVbdHprKCJRYfGbaWzVwJwUXG9zPabdGAhM9"
2815%hex(%randstr("bbbb")) == "a9ce04f3"
2816%hex(%randstr("8b")) == "fe165529f9f66839"
2817@endverbatim
2818 * @ingroup xlat_functions
2819 */
2820static xlat_action_t xlat_func_randstr(TALLOC_CTX *ctx, fr_dcursor_t *out,
2821 UNUSED xlat_ctx_t const *xctx,
2822 request_t *request, fr_value_box_list_t *args)
2823{
2824 /*
2825 * Lookup tables for randstr char classes
2826 */
2827 static char randstr_punc[] = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
2828 static char randstr_salt[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmopqrstuvwxyz/.";
2829
2830 /*
2831 * Characters humans rarely confuse. Reduces char set considerably
2832 * should only be used for things such as one time passwords.
2833 */
2834 static char randstr_otp[] = "469ACGHJKLMNPQRUVWXYabdfhijkprstuvwxyz";
2835
2836 char const *p, *start, *end;
2837 char *endptr;
2838 char *buff_p;
2839 uint32_t result;
2840 unsigned int reps;
2841 size_t outlen = 0;
2842 fr_value_box_t* vb;
2843 fr_value_box_t *in_head;
2844
2845 XLAT_ARGS(args, &in_head);
2846
2847 /** Max repetitions of a single character class
2848 *
2849 */
2850#define REPETITION_MAX 1024
2851
2852 start = p = in_head->vb_strvalue;
2853 end = p + in_head->vb_length;
2854
2855 /*
2856 * Calculate size of output
2857 */
2858 while (p < end) {
2859 /*
2860 * Repetition modifiers.
2861 *
2862 * We limit it to REPETITION_MAX, because we don't want
2863 * utter stupidity.
2864 */
2865 if (isdigit((uint8_t) *p)) {
2866 reps = strtol(p, &endptr, 10);
2867 if (reps > REPETITION_MAX) reps = REPETITION_MAX;
2868 outlen += reps;
2869 p = endptr;
2870 } else {
2871 outlen++;
2872 }
2873 p++;
2874 }
2875
2876 MEM(vb = fr_value_box_alloc_null(ctx));
2877 MEM(fr_value_box_bstr_alloc(vb, &buff_p, vb, NULL, outlen, false) == 0);
2878
2879 /* Reset p to start position */
2880 p = start;
2881
2882 while (p < end) {
2883 size_t i;
2884
2885 if (isdigit((uint8_t) *p)) {
2886 reps = strtol(p, &endptr, 10);
2887 if (reps > REPETITION_MAX) {
2888 reps = REPETITION_MAX;
2889 RMARKER(L_WARN, L_DBG_LVL_2, start, p - start,
2890 "Forcing repetition to %u", (unsigned int)REPETITION_MAX);
2891 }
2892 p = endptr;
2893 } else {
2894 reps = 1;
2895 }
2896
2897 for (i = 0; i < reps; i++) {
2898 result = fr_rand();
2899 switch (*p) {
2900 /*
2901 * Lowercase letters
2902 */
2903 case 'c':
2904 *buff_p++ = 'a' + (result % 26);
2905 break;
2906
2907 /*
2908 * Uppercase letters
2909 */
2910 case 'C':
2911 *buff_p++ = 'A' + (result % 26);
2912 break;
2913
2914 /*
2915 * Numbers
2916 */
2917 case 'n':
2918 *buff_p++ = '0' + (result % 10);
2919 break;
2920
2921 /*
2922 * Alpha numeric
2923 */
2924 case 'a':
2925 *buff_p++ = randstr_salt[result % (sizeof(randstr_salt) - 3)];
2926 break;
2927
2928 /*
2929 * Punctuation
2930 */
2931 case '!':
2932 *buff_p++ = randstr_punc[result % (sizeof(randstr_punc) - 1)];
2933 break;
2934
2935 /*
2936 * Alpha numeric + punctuation
2937 */
2938 case '.':
2939 *buff_p++ = '!' + (result % 95);
2940 break;
2941
2942 /*
2943 * Alpha numeric + salt chars './'
2944 */
2945 case 's':
2946 *buff_p++ = randstr_salt[result % (sizeof(randstr_salt) - 1)];
2947 break;
2948
2949 /*
2950 * Chars suitable for One Time Password tokens.
2951 * Alpha numeric with easily confused char pairs removed.
2952 */
2953 case 'o':
2954 *buff_p++ = randstr_otp[result % (sizeof(randstr_otp) - 1)];
2955 break;
2956
2957 /*
2958 * Binary data - Copy between 1-4 bytes at a time
2959 */
2960 case 'b':
2961 {
2962 size_t copy = (reps - i) > sizeof(result) ? sizeof(result) : reps - i;
2963
2964 memcpy(buff_p, (uint8_t *)&result, copy);
2965 buff_p += copy;
2966 i += (copy - 1); /* Loop +1 */
2967 }
2968 break;
2969
2970 default:
2971 REDEBUG("Invalid character class '%c'", *p);
2972 talloc_free(vb);
2973
2974 return XLAT_ACTION_FAIL;
2975 }
2976 }
2977
2978 p++;
2979 }
2980
2981 *buff_p++ = '\0';
2982
2983 fr_dcursor_append(out, vb);
2984
2985 return XLAT_ACTION_DONE;
2986}
2987
2988/** Convert a UUID in an array of uint32_t to the conventional string representation.
2989 */
2990static int uuid_print_vb(fr_value_box_t *vb, uint32_t vals[4])
2991{
2992 char buffer[36];
2993 int i, j = 0;
2994
2995#define UUID_CHARS(_v, _num) \
2996 do { \
2997 for (i = 0; i < _num; i++) { \
2998 buffer[j++] = fr_base16_alphabet_encode_lc[(uint8_t)((vals[_v] & 0xf0000000) >> 28)]; \
2999 vals[_v] = vals[_v] << 4; \
3000 } \
3001 } while (0)
3002
3003 UUID_CHARS(0, 8);
3004 buffer[j++] = '-';
3005 UUID_CHARS(1, 4);
3006 buffer[j++] = '-';
3007 UUID_CHARS(1, 4);
3008 buffer[j++] = '-';
3009 UUID_CHARS(2, 4);
3010 buffer[j++] = '-';
3011 UUID_CHARS(2, 4);
3012 UUID_CHARS(3, 8);
3013
3014 return fr_value_box_bstrndup(vb, vb, NULL, buffer, sizeof(buffer), false);
3015}
3016
3017static inline void uuid_set_version(uint32_t vals[4], uint8_t version)
3018{
3019 /*
3020 * The version is indicated by the upper 4 bits of byte 7 - the 3rd byte of vals[1]
3021 */
3022 vals[1] = (vals[1] & 0xffff0fff) | (((uint32_t)version & 0x0f) << 12);
3023}
3024
3025static inline void uuid_set_variant(uint32_t vals[4], uint8_t variant)
3026{
3027 /*
3028 * The variant is indicated by the first 1, 2 or 3 bits of byte 9
3029 * The number of bits is determined by the variant.
3030 */
3031 switch (variant) {
3032 case 0:
3033 vals[2] = vals[2] & 0x7fffffff;
3034 break;
3035
3036 case 1:
3037 vals[2] = (vals[2] & 0x3fffffff) | 0x80000000;
3038 break;
3039
3040 case 2:
3041 vals[2] = (vals[2] & 0x3fffffff) | 0xc0000000;
3042 break;
3043
3044 case 3:
3045 vals[2] = vals[2] | 0xe0000000;
3046 break;
3047 }
3048}
3049
3050/** Generate a version 4 UUID
3051 *
3052 * Version 4 UUIDs are all random except the version and variant fields
3053 *
3054 * Example:
3055@verbatim
3056%uuid.v4 == "cba48bda-641c-42ae-8173-d97aa04f888a"
3057@endverbatim
3058 * @ingroup xlat_functions
3059 */
3060static xlat_action_t xlat_func_uuid_v4(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
3061 UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
3062{
3063 fr_value_box_t *vb;
3064 uint32_t vals[4];
3065 int i;
3066
3067 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
3068
3069 /*
3070 * A type 4 UUID is all random except a few bits.
3071 * Start with 128 bits of random.
3072 */
3073 for (i = 0; i < 4; i++) vals[i] = fr_rand();
3074
3075 /*
3076 * Set the version and variant fields
3077 */
3078 uuid_set_version(vals, 4);
3079 uuid_set_variant(vals, 1);
3080
3081 if (uuid_print_vb(vb, vals) < 0) {
3082 talloc_free(vb);
3083 return XLAT_ACTION_FAIL;
3084 }
3085
3086 fr_dcursor_append(out, vb);
3087 return XLAT_ACTION_DONE;
3088}
3089
3090/** Generate a version 7 UUID
3091 *
3092 * Version 7 UUIDs use 48 bits of unix millisecond epoch and 74 bits of random
3093 *
3094 * Example:
3095@verbatim
3096%uuid.v7 == "019a58d8-8524-7342-aa07-c0fa2bba6a4e"
3097@endverbatim
3098 * @ingroup xlat_functions
3099 */
3100static xlat_action_t xlat_func_uuid_v7(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
3101 UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
3102{
3103 fr_value_box_t *vb;
3104 uint32_t vals[4];
3105 int i;
3106 uint64_t now;
3107
3108 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL));
3109
3110 /*
3111 * A type 7 UUID has random data from bit 48
3112 * Start with random from bit 32 - since fr_rand is uint32
3113 */
3114 for (i = 1; i < 4; i++) vals[i] = fr_rand();
3115
3116 /*
3117 * The millisecond epoch fills the first 48 bits
3118 */
3119 now = fr_time_to_msec(fr_time());
3120 now = now << 16;
3121 vals[0] = now >> 32;
3122 vals[1] = (vals[1] & 0x0000ffff) | (now & 0xffff0000);
3123
3124 /*
3125 * Set the version and variant fields
3126 */
3127 uuid_set_version(vals, 7);
3128 uuid_set_variant(vals, 1);
3129
3130 if (uuid_print_vb(vb, vals) < 0) return XLAT_ACTION_FAIL;
3131
3132 fr_dcursor_append(out, vb);
3133 return XLAT_ACTION_DONE;
3134}
3135
3136static xlat_arg_parser_t const xlat_func_range_arg[] = {
3137 { .required = true, .type = FR_TYPE_UINT64 },
3138 { .required = false, .type = FR_TYPE_UINT64 },
3139 { .required = false, .type = FR_TYPE_UINT64 },
3140 XLAT_ARG_PARSER_TERMINATOR
3141};
3142
3143/** Generate a range of uint64 numbers
3144 *
3145 * Example:
3146@verbatim
3147%range(end) - 0..end
3148%rang(start, end)
3149%range(start,end, step)
3150@endverbatim
3151 * @ingroup xlat_functions
3152 */
3153static xlat_action_t xlat_func_range(TALLOC_CTX *ctx, fr_dcursor_t *out,
3154 UNUSED xlat_ctx_t const *xctx,
3155 request_t *request, fr_value_box_list_t *args)
3156{
3157 fr_value_box_t *start_vb, *end_vb, *step_vb;
3158 fr_value_box_t *dst;
3159 uint64_t i, start, end, step;
3160
3161 XLAT_ARGS(args, &start_vb, &end_vb, &step_vb);
3162
3163 /*
3164 * Explicit `null` for an optional arg is equivalent to the
3165 * arg being absent. The vb_group field on an FR_TYPE_NULL
3166 * box is zeroed, so list_head() would return NULL and the
3167 * downstream `->vb_uint64` would dereference NULL.
3168 */
3169 if (end_vb && fr_type_is_null(end_vb->type)) end_vb = NULL;
3170 if (step_vb && fr_type_is_null(step_vb->type)) step_vb = NULL;
3171
3172 if (step_vb) {
3173 if (!end_vb) {
3174 REDEBUG("Invalid range - 'end' cannot be null when 'step' is provided");
3175 return XLAT_ACTION_FAIL;
3176 }
3177
3178 start = fr_value_box_list_head(&start_vb->vb_group)->vb_uint64;
3179 end = fr_value_box_list_head(&end_vb->vb_group)->vb_uint64;
3180 step = fr_value_box_list_head(&step_vb->vb_group)->vb_uint64;
3181
3182 } else if (end_vb) {
3183 start = fr_value_box_list_head(&start_vb->vb_group)->vb_uint64;
3184 end = fr_value_box_list_head(&end_vb->vb_group)->vb_uint64;
3185 step = 1;
3186
3187 } else {
3188 start = 0;
3189 end = fr_value_box_list_head(&start_vb->vb_group)->vb_uint64;
3190 step = 1;
3191 }
3192
3193 if (end <= start) {
3194 REDEBUG("Invalid range - 'start' must be less than 'end'");
3195 return XLAT_ACTION_FAIL;
3196 }
3197
3198 if (!step) {
3199 REDEBUG("Invalid range - 'step' must be greater than zero");
3200 return XLAT_ACTION_FAIL;
3201 }
3202
3203 if (step > (end - start)) {
3204 REDEBUG("Invalid range - 'step' must allow for at least one result");
3205 return XLAT_ACTION_FAIL;
3206 }
3207
3208 if (((end - start) / step) > 1000) {
3209 REDEBUG("Invalid range - Too many results");
3210 return XLAT_ACTION_FAIL;
3211 }
3212
3213 for (i = start; i < end; i += step) {
3214 MEM(dst = fr_value_box_alloc(ctx, FR_TYPE_UINT64, NULL));
3215 dst->vb_uint64 = i;
3216 fr_dcursor_append(out, dst);
3217 }
3218
3219 return XLAT_ACTION_DONE;
3220}
3221
3222/** Escape a value box so that it is safe to use as a regular expression
3223 */
3224int xlat_regex_escape(fr_value_box_t *vb, UNUSED void *uctx)
3225{
3226 ssize_t slen;
3227 fr_sbuff_t *out = NULL;
3228 fr_value_box_entry_t entry;
3229
3230 FR_SBUFF_TALLOC_THREAD_LOCAL(&out, 256, 4096);
3231
3232 slen = fr_value_box_print(out, vb, &regex_escape_rules);
3233 if (slen < 0) return -1;
3234
3235 entry = vb->entry;
3236 fr_value_box_clear(vb);
3237 (void) fr_value_box_bstrndup(vb, vb, NULL, fr_sbuff_start(out), fr_sbuff_used(out), false);
3238 vb->entry = entry;
3239
3240 return 0;
3241}
3242
3247
3248
3249/** Get named subcapture value from previous regex
3250 *
3251 * Example:
3252@verbatim
3253if ("foo" =~ /^(?<name>.*)/) {
3254 noop
3255}
3256%regex.match(name) == "foo"
3257@endverbatim
3258 *
3259 * @ingroup xlat_functions
3260 */
3261static xlat_action_t xlat_func_regex(TALLOC_CTX *ctx, fr_dcursor_t *out,
3262 UNUSED xlat_ctx_t const *xctx,
3263 request_t *request, fr_value_box_list_t *in)
3264{
3265 fr_value_box_t *in_head = fr_value_box_list_head(in);
3266
3267 /*
3268 * Find the first child of the first argument group
3269 */
3270 fr_value_box_t *arg = fr_value_box_list_head(&in_head->vb_group);
3271
3272 /*
3273 * Return the complete capture if no other capture is specified
3274 */
3275 if (!arg) {
3276 fr_value_box_t *vb;
3277
3278 MEM(vb = fr_value_box_alloc_null(ctx));
3279 if (regex_request_to_sub(vb, vb, request, 0) < 0) {
3280 REDEBUG2("No previous regex capture");
3281 talloc_free(vb);
3282 return XLAT_ACTION_FAIL;
3283 }
3284
3285 fr_dcursor_append(out, vb);
3286
3287 return XLAT_ACTION_DONE;
3288 }
3289
3290 switch (arg->type) {
3291 /*
3292 * If the input is an integer value then get an
3293 * arbitrary subcapture index.
3294 */
3295 case FR_TYPE_NUMERIC:
3296 {
3297 fr_value_box_t idx;
3298 fr_value_box_t *vb;
3299
3300 if (fr_value_box_list_next(in, in_head)) {
3301 REDEBUG("Only one subcapture argument allowed");
3302 return XLAT_ACTION_FAIL;
3303 }
3304
3305 if (fr_value_box_cast(NULL, &idx, FR_TYPE_UINT32, NULL, arg) < 0) {
3306 RPEDEBUG("Bad subcapture index");
3307 return XLAT_ACTION_FAIL;
3308 }
3309
3310 MEM(vb = fr_value_box_alloc_null(ctx));
3311 if (regex_request_to_sub(vb, vb, request, idx.vb_uint32) < 0) {
3312 REDEBUG2("No previous numbered regex capture group '%u'", idx.vb_uint32);
3313 talloc_free(vb);
3314 return XLAT_ACTION_DONE;
3315 }
3316 fr_dcursor_append(out, vb);
3317
3318 return XLAT_ACTION_DONE;
3319 }
3320
3321 default:
3322#if defined(HAVE_REGEX_PCRE) || defined(HAVE_REGEX_PCRE2)
3323 {
3324 fr_value_box_t *vb;
3325
3326 /*
3327 * Concatenate all input
3328 */
3329 if (fr_value_box_list_concat_in_place(ctx,
3330 arg, &in_head->vb_group, FR_TYPE_STRING,
3331 FR_VALUE_BOX_LIST_FREE, true,
3332 SIZE_MAX) < 0) {
3333 RPEDEBUG("Failed concatenating input");
3334 return XLAT_ACTION_FAIL;
3335 }
3336
3337 MEM(vb = fr_value_box_alloc_null(ctx));
3338 if (regex_request_to_sub_named(vb, vb, request, arg->vb_strvalue) < 0) {
3339 REDEBUG2("No previous named regex capture group '%s'", arg->vb_strvalue);
3340 talloc_free(vb);
3341 return XLAT_ACTION_DONE; /* NOT an error, just an empty result */
3342 }
3343 fr_dcursor_append(out, vb);
3344
3345 return XLAT_ACTION_DONE;
3346 }
3347#else
3348 RDEBUG("Named regex captures are not supported (they require libpcre2)");
3349 return XLAT_ACTION_FAIL;
3350#endif
3351 }
3352}
3353
3354static xlat_arg_parser_t const xlat_func_sha_arg[] = {
3355 { .concat = true, .type = FR_TYPE_OCTETS },
3356 XLAT_ARG_PARSER_TERMINATOR
3357};
3358
3359/** Calculate the SHA1 hash of a string or attribute.
3360 *
3361 * Example:
3362@verbatim
3363%sha1(foo) == "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
3364@endverbatim
3365 *
3366 * @ingroup xlat_functions
3367 */
3368static xlat_action_t xlat_func_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out,
3369 UNUSED xlat_ctx_t const *xctx,
3370 UNUSED request_t *request, fr_value_box_list_t *args)
3371{
3372 uint8_t digest[SHA1_DIGEST_LENGTH];
3373 fr_sha1_ctx sha1_ctx;
3374 fr_value_box_t *vb;
3375 fr_value_box_t *in_head;
3376
3377 XLAT_ARGS(args, &in_head);
3378
3379 fr_sha1_init(&sha1_ctx);
3380 if (in_head) {
3381 fr_sha1_update(&sha1_ctx, in_head->vb_octets, in_head->vb_length);
3382 } else {
3383 /* sha1 of empty string */
3384 fr_sha1_update(&sha1_ctx, NULL, 0);
3385 }
3386 fr_sha1_final(digest, &sha1_ctx);
3387
3388 MEM(vb = fr_value_box_alloc_null(ctx));
3389 fr_value_box_memdup(vb, vb, NULL, digest, sizeof(digest), false);
3390
3391 fr_dcursor_append(out, vb);
3392
3393 return XLAT_ACTION_DONE;
3394}
3395
3396/** Calculate any digest supported by OpenSSL EVP_MD
3397 *
3398 * Example:
3399@verbatim
3400%sha2_256(foo) == "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
3401@endverbatim
3402 *
3403 * @ingroup xlat_functions
3404 */
3405#ifdef HAVE_OPENSSL_EVP_H
3406static xlat_action_t xlat_evp_md(TALLOC_CTX *ctx, fr_dcursor_t *out,
3407 UNUSED xlat_ctx_t const *xctx,
3408 UNUSED request_t *request, fr_value_box_list_t *args, EVP_MD const *md)
3409{
3410 uint8_t digest[EVP_MAX_MD_SIZE];
3411 unsigned int digestlen;
3412 EVP_MD_CTX *md_ctx;
3413 fr_value_box_t *vb;
3414 fr_value_box_t *in_head;
3415
3416 XLAT_ARGS(args, &in_head);
3417
3418 md_ctx = EVP_MD_CTX_create();
3419 EVP_DigestInit_ex(md_ctx, md, NULL);
3420 if (in_head) {
3421 EVP_DigestUpdate(md_ctx, in_head->vb_octets, in_head->vb_length);
3422 } else {
3423 EVP_DigestUpdate(md_ctx, NULL, 0);
3424 }
3425 EVP_DigestFinal_ex(md_ctx, digest, &digestlen);
3426 EVP_MD_CTX_destroy(md_ctx);
3427
3428 MEM(vb = fr_value_box_alloc_null(ctx));
3429 fr_value_box_memdup(vb, vb, NULL, digest, digestlen, false);
3430
3431 fr_dcursor_append(out, vb);
3432
3433 return XLAT_ACTION_DONE;
3434}
3435
3436# define EVP_MD_XLAT(_md, _md_func) \
3437static xlat_action_t xlat_func_##_md(TALLOC_CTX *ctx, fr_dcursor_t *out,\
3438 xlat_ctx_t const *xctx, \
3439 request_t *request,\
3440 fr_value_box_list_t *in)\
3441{\
3442 return xlat_evp_md(ctx, out, xctx, request, in, EVP_##_md_func());\
3443}
3444
3445EVP_MD_XLAT(sha2_224, sha224)
3446EVP_MD_XLAT(sha2_256, sha256)
3447EVP_MD_XLAT(sha2_384, sha384)
3448EVP_MD_XLAT(sha2_512, sha512)
3449
3450/*
3451 * OpenWRT's OpenSSL library doesn't contain these by default
3452 */
3453#ifdef HAVE_EVP_BLAKE2S256
3454EVP_MD_XLAT(blake2s_256, blake2s256)
3455#endif
3456
3457#ifdef HAVE_EVP_BLAKE2B512
3458EVP_MD_XLAT(blake2b_512, blake2b512)
3459#endif
3460
3461EVP_MD_XLAT(sha3_224, sha3_224)
3462EVP_MD_XLAT(sha3_256, sha3_256)
3463EVP_MD_XLAT(sha3_384, sha3_384)
3464EVP_MD_XLAT(sha3_512, sha3_512)
3465#endif
3466
3467
3468static xlat_arg_parser_t const xlat_func_string_arg[] = {
3469 { .required = true, .concat = true, .type = FR_TYPE_STRING },
3470 XLAT_ARG_PARSER_TERMINATOR
3471};
3472
3473static xlat_arg_parser_t const xlat_func_strlen_arg[] = {
3474 { .concat = true, .type = FR_TYPE_STRING },
3475 XLAT_ARG_PARSER_TERMINATOR
3476};
3477
3478/** Print length of given string
3479 *
3480 * Example:
3481@verbatim
3482%strlen(foo) == 3
3483@endverbatim
3484 *
3485 * @see #xlat_func_length
3486 *
3487 * @ingroup xlat_functions
3488 */
3489static xlat_action_t xlat_func_strlen(TALLOC_CTX *ctx, fr_dcursor_t *out,
3490 UNUSED xlat_ctx_t const *xctx,
3491 UNUSED request_t *request, fr_value_box_list_t *args)
3492{
3493 fr_value_box_t *vb;
3494 fr_value_box_t *in_head;
3495
3496 XLAT_ARGS(args, &in_head);
3497
3498 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_SIZE, NULL));
3499
3500 if (!in_head) {
3501 vb->vb_size = 0;
3502 } else {
3503 vb->vb_size = strlen(in_head->vb_strvalue);
3504 }
3505
3506 fr_dcursor_append(out, vb);
3507
3508 return XLAT_ACTION_DONE;
3509}
3510
3511static xlat_arg_parser_t const xlat_func_str_printable_arg[] = {
3512 { .concat = true, .type = FR_TYPE_STRING, .required = true, },
3513 { .single = true, .type = FR_TYPE_BOOL },
3514 XLAT_ARG_PARSER_TERMINATOR
3515};
3516
3517/** Return whether a string has only printable chars
3518 *
3519 * This function returns true if the input string contains UTF8 sequences and printable chars.
3520 *
3521 * @note "\t" and " " are considered unprintable chars, unless the second argument(relaxed) is true.
3522 *
3523 * Example:
3524@verbatim
3525%str.printable("🍉abcdef🍓") == true
3526%str.printable("\000\n\r\t") == false
3527%str.printable("\t abcd", yes) == true
3528@endverbatim
3529 *
3530 * @ingroup xlat_functions
3531 */
3532static xlat_action_t xlat_func_str_printable(TALLOC_CTX *ctx, fr_dcursor_t *out,
3533 UNUSED xlat_ctx_t const *xctx,
3534 UNUSED request_t *request, fr_value_box_list_t *args)
3535{
3536 fr_value_box_t *vb;
3537 fr_value_box_t *str;
3538 fr_value_box_t *relaxed_vb;
3539 uint8_t const *p, *end;
3540 bool relaxed = false;
3541
3542 XLAT_ARGS(args, &str, &relaxed_vb);
3543
3544 if (relaxed_vb) relaxed = relaxed_vb->vb_bool;
3545
3546 p = (uint8_t const *)str->vb_strvalue;
3547 end = p + str->vb_length;
3548
3549 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
3550 fr_dcursor_append(out, vb);
3551 vb->vb_bool = false;
3552
3553 do {
3554 size_t clen;
3555
3556 if ((*p < '!') &&
3557 (!relaxed || ((*p != '\t') && (*p != ' ')))) return XLAT_ACTION_DONE;
3558
3559 if (*p == 0x7f) return XLAT_ACTION_DONE;
3560
3561 clen = fr_utf8_char(p, end - p);
3562 if (clen == 0) return XLAT_ACTION_DONE;
3563 p += clen;
3564 } while (p < end);
3565
3566 vb->vb_bool = true;
3567
3568 return XLAT_ACTION_DONE;
3569}
3570
3571static xlat_arg_parser_t const xlat_func_str_utf8_arg[] = {
3572 { .concat = true, .type = FR_TYPE_STRING },
3573 XLAT_ARG_PARSER_TERMINATOR
3574};
3575
3576/** Return whether a string is valid UTF-8
3577 *
3578 * This function returns true if the input string is valid UTF-8, false otherwise.
3579 *
3580 * Example:
3581@verbatim
3582%str.utf8(🍉🥝🍓) == true
3583%str.utf8(🍉\xff🍓) == false
3584@endverbatim
3585 *
3586 * @ingroup xlat_functions
3587 */
3588static xlat_action_t xlat_func_str_utf8(TALLOC_CTX *ctx, fr_dcursor_t *out,
3589 UNUSED xlat_ctx_t const *xctx,
3590 UNUSED request_t *request, fr_value_box_list_t *args)
3591{
3592 fr_value_box_t *vb;
3593 fr_value_box_t *in_head;
3594
3595 XLAT_ARGS(args, &in_head);
3596
3597 if (!in_head) return XLAT_ACTION_FAIL;
3598
3599 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
3600 vb->vb_bool = (fr_utf8_str((uint8_t const *)in_head->vb_strvalue,
3601 in_head->vb_length) >= 0);
3602
3603 fr_dcursor_append(out, vb);
3604
3605 return XLAT_ACTION_DONE;
3606}
3607
3608static xlat_arg_parser_t const xlat_func_substr_args[] = {
3609 { .single = true, .required = true, .type = FR_TYPE_VOID },
3610 { .single = true, .required = true, .type = FR_TYPE_INT32 },
3611 { .single = true, .type = FR_TYPE_INT32 },
3612 XLAT_ARG_PARSER_TERMINATOR
3613};
3614
3615/** Extract a substring from string / octets data
3616 *
3617 * Non string / octets data is cast to a string.
3618 *
3619 * Second parameter is start position, optional third parameter is length
3620 * Negative start / length count from RHS of data.
3621 *
3622 * Example: (User-Name = "hello")
3623@verbatim
3624%substr(&User-Name, 1, 3) == 'ell'
3625@endverbatim
3626 *
3627 * @ingroup xlat_functions
3628 */
3629static xlat_action_t xlat_func_substr(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
3630 request_t *request, fr_value_box_list_t *args)
3631{
3632 fr_value_box_t *in = NULL, *start_vb, *len_vb, *vb;
3633 int32_t start, end, len;
3634
3635 XLAT_ARGS(args, &in, &start_vb, &len_vb);
3636
3637 switch (in->type) {
3638 case FR_TYPE_OCTETS:
3639 case FR_TYPE_STRING:
3640 break;
3641
3642 default:
3643 if (fr_value_box_cast_in_place(in, in, FR_TYPE_STRING, NULL) < 0) {
3644 RPEDEBUG("Failed casting value to string");
3645 return XLAT_ACTION_FAIL;
3646 }
3647 break;
3648 }
3649
3650 if (start_vb->vb_int32 > (int32_t)in->vb_length) return XLAT_ACTION_DONE;
3651
3652 if (start_vb->vb_int32 < 0) {
3653 start = in->vb_length + start_vb->vb_int32;
3654 if (start < 0) start = 0;
3655 } else {
3656 start = start_vb->vb_int32;
3657 }
3658
3659 if (len_vb) {
3660 if (len_vb->vb_int32 < 0) {
3661 end = in->vb_length + len_vb->vb_int32;
3662 if (end < 0) return XLAT_ACTION_DONE;
3663 } else {
3664 end = start + len_vb->vb_int32;
3665 if (end > (int32_t)in->vb_length) end = in->vb_length;
3666 }
3667 } else {
3668 end = in->vb_length;
3669 }
3670
3671 if (start >= end) return XLAT_ACTION_DONE;
3672
3673 MEM(vb = fr_value_box_alloc(ctx, in->type, NULL));
3674
3675 len = end - start;
3676 switch (in->type) {
3677 case FR_TYPE_STRING:
3678 fr_value_box_bstrndup(vb, vb, NULL, &in->vb_strvalue[start], len, false);
3679 break;
3680 case FR_TYPE_OCTETS:
3681 {
3682 uint8_t *buf;
3683 fr_value_box_mem_alloc(vb, &buf, vb, NULL, len, false);
3684 memcpy(buf, &in->vb_octets[start], len);
3685 }
3686 break;
3687
3688 default: /* 'in' was cast to #FR_TYPE_STRING */
3689 fr_assert(0);
3690 }
3691
3692 fr_value_box_safety_copy(vb, in);
3693 fr_dcursor_append(out, vb);
3694
3695 return XLAT_ACTION_DONE;
3696}
3697
3698#ifdef HAVE_REGEX_PCRE2
3699/** Cache statically compiled expressions
3700 */
3701typedef struct {
3702 regex_t *pattern;
3703 fr_regex_flags_t flags;
3704} xlat_subst_regex_inst_t;
3705
3706/** Pre-compile regexes where possible
3707 */
3708static int xlat_instantiate_subst_regex(xlat_inst_ctx_t const *xctx)
3709{
3710 xlat_subst_regex_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_subst_regex_inst_t);
3711 xlat_exp_t *patt_exp;
3712 fr_sbuff_t sbuff;
3713 fr_sbuff_marker_t start_m, end_m;
3714
3715 /* args #2 (pattern) */
3716 patt_exp = fr_dlist_next(&xctx->ex->call.args->dlist, fr_dlist_head(&xctx->ex->call.args->dlist));
3717 fr_assert(patt_exp && patt_exp->type == XLAT_GROUP); /* args must be groups */
3718
3719 /* If there are dynamic expansions, we can't pre-compile */
3720 if (!xlat_is_literal(patt_exp->group)) return 0;
3721 fr_assert(fr_dlist_num_elements(&patt_exp->group->dlist) == 1);
3722
3723 patt_exp = fr_dlist_head(&patt_exp->group->dlist);
3724
3725 /* We can only pre-compile strings */
3726 if (!fr_type_is_string(patt_exp->data.type)) return 0;
3727
3728 sbuff = FR_SBUFF_IN(patt_exp->data.vb_strvalue, patt_exp->data.vb_length);
3729
3730 /* skip any whitesapce */
3731 fr_sbuff_adv_past_whitespace(&sbuff, SIZE_MAX, 0);
3732
3733 /* Is the next char a forward slash? */
3734 if (fr_sbuff_next_if_char(&sbuff, '/')) {
3735 fr_slen_t slen;
3736
3737 fr_sbuff_marker(&start_m, &sbuff);
3738
3739 if (!fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, '/')) return 0; /* Not a regex */
3740
3741 fr_sbuff_marker(&end_m, &sbuff);
3742 fr_sbuff_next(&sbuff); /* skip trailing slash */
3743
3744 if (fr_sbuff_remaining(&sbuff)) {
3745 slen = regex_flags_parse(NULL, &inst->flags,
3746 &sbuff,
3747 NULL, true);
3748 if (slen < 0) {
3749 PERROR("Failed parsing regex flags in \"%s\"", patt_exp->data.vb_strvalue);
3750 return -1;
3751 }
3752 }
3753
3754 if (regex_compile(inst, &inst->pattern,
3755 fr_sbuff_current(&start_m), fr_sbuff_current(&end_m) - fr_sbuff_current(&start_m),
3756 &inst->flags, true, false) <= 0) {
3757 PERROR("Failed compiling regex \"%s\"", patt_exp->data.vb_strvalue);
3758 return -1;
3759 }
3760 }
3761 /* No... then it's not a regex */
3762
3763 return 0;
3764}
3765
3766/** Perform regex substitution TODO CHECK
3767 *
3768 * Called when %subst() pattern begins with "/"
3769 *
3770@verbatim
3771%subst(<subject>, /<regex>/[flags], <replace>)
3772@endverbatim
3773 *
3774 * Example: (User-Name = "foo")
3775@verbatim
3776%subst(%{User-Name}, /oo.*$/, 'un') == "fun"
3777@endverbatim
3778 *
3779 * @note References can be specified in the replacement string with $<ref>
3780 *
3781 * @see #xlat_func_subst
3782 *
3783 * @ingroup xlat_functions
3784 */
3785static int xlat_func_subst_regex(TALLOC_CTX *ctx, fr_dcursor_t *out,
3786 xlat_ctx_t const *xctx, request_t *request,
3787 fr_value_box_list_t *args)
3788{
3789 xlat_subst_regex_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_subst_regex_inst_t);
3790 fr_sbuff_t sbuff;
3791 fr_sbuff_marker_t start_m, end_m;
3792 char *buff;
3793 fr_slen_t slen;
3794 regex_t *pattern, *our_pattern = NULL;
3795 fr_regex_flags_t const *flags;
3796 fr_regex_flags_t our_flags = {};
3797 fr_value_box_t *vb;
3798 fr_value_box_t *subject_vb;
3799 fr_value_box_t *regex_vb;
3800 fr_value_box_t *rep_vb;
3801
3802 XLAT_ARGS(args, &subject_vb, &regex_vb, &rep_vb);
3803
3804 /*
3805 * Was not pre-compiled, so we need to compile it now
3806 */
3807 if (!inst->pattern) {
3808 sbuff = FR_SBUFF_IN(regex_vb->vb_strvalue, regex_vb->vb_length);
3809 if (fr_sbuff_len(&sbuff) == 0) {
3810 REDEBUG("Regex must not be empty");
3811 return XLAT_ACTION_FAIL;
3812 }
3813
3814 fr_sbuff_next(&sbuff); /* skip leading slash */
3815 fr_sbuff_marker(&start_m, &sbuff);
3816
3817 if (!fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, '/')) return 1; /* Not a regex */
3818
3819 fr_sbuff_marker(&end_m, &sbuff);
3820 fr_sbuff_next(&sbuff); /* skip trailing slash */
3821
3822 slen = regex_flags_parse(NULL, &our_flags, &sbuff, NULL, true);
3823 if (slen < 0) {
3824 RPEDEBUG("Failed parsing regex flags");
3825 return -1;
3826 }
3827
3828 /*
3829 * Process the substitution
3830 */
3831 if (regex_compile(NULL, &our_pattern,
3832 fr_sbuff_current(&start_m), fr_sbuff_current(&end_m) - fr_sbuff_current(&start_m),
3833 &our_flags, true, true) <= 0) {
3834 RPEDEBUG("Failed compiling regex");
3835 return -1;
3836 }
3837 pattern = our_pattern;
3838 flags = &our_flags;
3839 } else {
3840 pattern = inst->pattern;
3841 flags = &inst->flags;
3842 }
3843
3844 MEM(vb = fr_value_box_alloc_null(ctx));
3845 if (regex_substitute(vb, &buff, 0, pattern, flags,
3846 subject_vb->vb_strvalue, subject_vb->vb_length,
3847 rep_vb->vb_strvalue, rep_vb->vb_length, NULL) < 0) {
3848 RPEDEBUG("Failed performing substitution");
3849 talloc_free(vb);
3850 talloc_free(pattern);
3851 return -1;
3852 }
3853 fr_value_box_bstrdup_buffer_shallow(NULL, vb, NULL, buff, false);
3854
3855 fr_value_box_safety_copy(vb, subject_vb);
3856 fr_value_box_safety_merge(vb, rep_vb);
3857
3858 fr_dcursor_append(out, vb);
3859
3860 talloc_free(our_pattern);
3861
3862 return 0;
3863}
3864#endif
3865
3866static xlat_arg_parser_t const xlat_func_subst_args[] = {
3867 { .required = true, .concat = true, .type = FR_TYPE_STRING },
3868 { .required = true, .concat = true, .type = FR_TYPE_STRING },
3869 { .required = true, .concat = true, .type = FR_TYPE_STRING },
3870 XLAT_ARG_PARSER_TERMINATOR
3871};
3872
3873/** Perform regex substitution
3874 *
3875@verbatim
3876%subst(<subject>, <pattern>, <replace>)
3877@endverbatim
3878 *
3879 * Example: (User-Name = "foobar")
3880@verbatim
3881%subst(%{User-Name}, 'oo', 'un') == "funbar"
3882@endverbatim
3883 *
3884 * @see xlat_func_subst_regex
3885 *
3886 * @ingroup xlat_functions
3887 */
3888static xlat_action_t xlat_func_subst(TALLOC_CTX *ctx, fr_dcursor_t *out,
3889#ifdef HAVE_REGEX_PCRE2
3890 xlat_ctx_t const *xctx,
3891#else
3892 UNUSED xlat_ctx_t const *xctx,
3893#endif
3894 request_t *request, fr_value_box_list_t *args)
3895{
3896 char const *p, *q, *end;
3897 char *vb_str;
3898
3899 char const *pattern, *rep;
3900 size_t pattern_len, rep_len;
3901
3902 fr_value_box_t *rep_vb, *vb;
3903 fr_value_box_t *subject_vb;
3904 fr_value_box_t *pattern_vb;
3905
3906 XLAT_ARGS(args, &subject_vb, &pattern_vb, &rep_vb);
3907
3908 pattern = pattern_vb->vb_strvalue;
3909 if (*pattern == '/') {
3910#ifdef HAVE_REGEX_PCRE2
3911 switch (xlat_func_subst_regex(ctx, out, xctx, request, args)) {
3912 case 0:
3913 return XLAT_ACTION_DONE;
3914
3915 case 1:
3916 /* Not a regex, fall through */
3917 break;
3918
3919 case -1:
3920 return XLAT_ACTION_FAIL;
3921 }
3922#else
3923 if (memchr(pattern, '/', pattern_vb->vb_length - 1)) {
3924 REDEBUG("regex based substitutions require libpcre2. "
3925 "Check ${features.regex-pcre2} to determine support");
3926 }
3927 return XLAT_ACTION_FAIL;
3928#endif
3929 }
3930
3931 /*
3932 * Check for empty pattern
3933 */
3934 pattern_len = pattern_vb->vb_length;
3935 if (pattern_len == 0) {
3936 REDEBUG("Empty pattern");
3937 return XLAT_ACTION_FAIL;
3938 }
3939
3940 rep = rep_vb->vb_strvalue;
3941 rep_len = rep_vb->vb_length;
3942
3943 p = subject_vb->vb_strvalue;
3944 end = p + subject_vb->vb_length;
3945
3946 MEM(vb = fr_value_box_alloc_null(ctx));
3947 vb_str = talloc_bstrndup(vb, "", 0);
3948
3949 while (p < end) {
3950 q = memmem(p, end - p, pattern, pattern_len);
3951 if (!q) {
3952 MEM(vb_str = talloc_bstr_append(vb, vb_str, p, end - p));
3953 break;
3954 }
3955
3956 if (q > p) MEM(vb_str = talloc_bstr_append(vb, vb_str, p, q - p));
3957 if (rep_len) MEM(vb_str = talloc_bstr_append(vb, vb_str, rep, rep_len));
3958 p = q + pattern_len;
3959 }
3960
3961 if (fr_value_box_bstrdup_buffer_shallow(NULL, vb, NULL, vb_str, false) < 0) {
3962 RPEDEBUG("Failed creating output box");
3963 talloc_free(vb);
3964 return XLAT_ACTION_FAIL;
3965 }
3966
3967 fr_value_box_safety_copy(vb, subject_vb);
3968 fr_value_box_safety_merge(vb, rep_vb);
3969
3970 fr_dcursor_append(out, vb);
3971
3972 return XLAT_ACTION_DONE;
3973}
3974
3975/*
3976 * Debug builds only, we don't want to allow unsanitised inputs to crash the server
3977 */
3978#ifndef NDEBUG
3979static xlat_arg_parser_t const xlat_func_signal_raise_args[] = {
3980 { .single = true, .required = true, .type = FR_TYPE_STRING },
3981 XLAT_ARG_PARSER_TERMINATOR
3982};
3983
3984static xlat_action_t xlat_func_signal_raise(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
3985 UNUSED xlat_ctx_t const *xctx, request_t *request,
3986 fr_value_box_list_t *args)
3987{
3988 static fr_table_num_sorted_t const signal_table[] = {
3989 { L("break"), SIGTRAP }, /* Save flailing at the keyboard */
3990 { L("BREAK"), SIGTRAP },
3991 { L("SIGABRT"), SIGABRT },
3992 { L("SIGALRM"), SIGALRM },
3993#ifdef SIGBUS
3994 { L("SIGBUS"), SIGBUS },
3995#endif
3996 { L("SIGCHLD"), SIGCHLD },
3997 { L("SIGCONT"), SIGCONT },
3998 { L("SIGFPE"), SIGFPE },
3999 { L("SIGHUP"), SIGHUP },
4000 { L("SIGILL"), SIGILL },
4001 { L("SIGINT"), SIGINT },
4002 { L("SIGKILL"), SIGKILL },
4003 { L("SIGPIPE"), SIGPIPE },
4004#ifdef SIGPOLL
4005 { L("SIGPOLL"), SIGPOLL },
4006#endif
4007 { L("SIGPROF"), SIGPROF },
4008 { L("SIGQUIT"), SIGQUIT },
4009 { L("SIGSEGV"), SIGSEGV },
4010 { L("SIGSTOP"), SIGSTOP },
4011#ifdef SIGSYS
4012 { L("SIGSYS"), SIGSYS },
4013#endif
4014 { L("SIGTERM"), SIGTERM },
4015#ifdef SIGTRAP
4016 { L("SIGTRAP"), SIGTRAP },
4017#endif
4018 { L("SIGTSTP"), SIGTSTP },
4019 { L("SIGTTIN"), SIGTTIN },
4020 { L("SIGTTOU"), SIGTTOU },
4021 { L("SIGURG"), SIGURG },
4022 { L("SIGUSR1"), SIGUSR1 },
4023 { L("SIGUSR2"), SIGUSR2 },
4024 { L("SIGVTALRM"), SIGVTALRM },
4025 { L("SIGXCPU"), SIGXCPU },
4026 { L("SIGXFSZ"), SIGXFSZ }
4027 };
4028 static size_t signal_table_len = NUM_ELEMENTS(signal_table);
4029
4030 fr_value_box_t *signal_vb;
4031 int signal;
4032
4033 XLAT_ARGS(args, &signal_vb);
4034
4035 signal = fr_table_value_by_substr(signal_table, signal_vb->vb_strvalue, signal_vb->vb_length, -1);
4036 if (signal < 0) {
4037 RERROR("Invalid signal \"%pV\"", signal_vb);
4038 return XLAT_ACTION_FAIL;
4039 }
4040 if (raise(signal) < 0) {
4041 RERROR("Failed raising signal %d: %s", signal, strerror(errno));
4042 return XLAT_ACTION_FAIL;
4043 }
4044 return XLAT_ACTION_DONE;
4045}
4046#endif
4047
4048static xlat_arg_parser_t const xlat_func_time_args[] = {
4049 { .required = false, .single = true, .type = FR_TYPE_STRING },
4050 XLAT_ARG_PARSER_TERMINATOR
4051};
4052
4053/** Return the time as a #FR_TYPE_DATE
4054 *
4055 * Note that all operations are UTC.
4056 *
4057@verbatim
4058%time()
4059@endverbatim
4060 *
4061 * Example:
4062@verbatim
4063update reply {
4064 &Reply-Message := "%{%time(now) - %time(request)}"
4065}
4066@endverbatim
4067 *
4068 * @ingroup xlat_functions
4069 */
4070static xlat_action_t xlat_func_time(TALLOC_CTX *ctx, fr_dcursor_t *out,
4071 UNUSED xlat_ctx_t const *xctx,
4072 request_t *request, fr_value_box_list_t *args)
4073{
4074 fr_value_box_t *arg;
4075 fr_value_box_t *vb;
4076 fr_unix_time_t value;
4077
4078 XLAT_ARGS(args, &arg);
4079
4080 /*
4081 * An explicit `null` is treated the same as a missing arg -
4082 * vb_strvalue is unset on an FR_TYPE_NULL box, so reading it
4083 * would be UB.
4084 */
4085 if (arg && fr_type_is_null(arg->type)) arg = NULL;
4086
4087 if (!arg || (strcmp(arg->vb_strvalue, "now") == 0)) {
4088 value = fr_time_to_unix_time(fr_time());
4089
4090 } else if (strcmp(arg->vb_strvalue, "request") == 0) {
4091 value = fr_time_to_unix_time(request->packet->timestamp);
4092
4093 } else if (strcmp(arg->vb_strvalue, "offset") == 0) {
4094 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
4095 vb->vb_time_delta = fr_time_gmtoff();
4096 goto append;
4097
4098 } else if (strcmp(arg->vb_strvalue, "dst") == 0) {
4099 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
4100 vb->vb_bool = fr_time_is_dst();
4101 goto append;
4102
4103 } else if (strcmp(arg->vb_strvalue, "mday_offset") == 0) {
4104 struct tm tm;
4105 fr_unix_time_t unix_time = fr_time_to_unix_time(request->packet->timestamp);
4106 time_t when = fr_unix_time_to_sec(unix_time);
4107 int64_t nsec;
4108
4109 gmtime_r(&when, &tm);
4110
4111 nsec = (int64_t) 86400 * (tm.tm_mday - 1);
4112 nsec += when % 86400;
4113 nsec *= NSEC;
4114 nsec += fr_unix_time_unwrap(unix_time) % NSEC;
4115
4116 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
4117 vb->vb_time_delta = fr_time_delta_wrap(nsec);
4118 goto append;
4119
4120 } else if (strcmp(arg->vb_strvalue, "wday_offset") == 0) {
4121 struct tm tm;
4122 fr_unix_time_t unix_time = fr_time_to_unix_time(request->packet->timestamp);
4123 time_t when = fr_unix_time_to_sec(unix_time);
4124 int64_t nsec;
4125
4126 gmtime_r(&when, &tm);
4127
4128 nsec = (int64_t) 86400 * tm.tm_wday;
4129 nsec += when % 86400;
4130 nsec *= NSEC;
4131 nsec += fr_unix_time_unwrap(unix_time) % NSEC;
4132
4133 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
4134 vb->vb_time_delta = fr_time_delta_wrap(nsec);
4135 goto append;
4136
4137 } else if (fr_unix_time_from_str(&value, arg->vb_strvalue, FR_TIME_RES_SEC) < 0) {
4138 REDEBUG("Invalid time specification '%s'", arg->vb_strvalue);
4139 return XLAT_ACTION_FAIL;
4140 }
4141
4142 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_DATE, NULL));
4143 vb->vb_date = value;
4144
4145append:
4146 fr_dcursor_append(out, vb);
4147
4148 return XLAT_ACTION_DONE;
4149}
4150
4151/** Return the current time as a #FR_TYPE_DATE
4152 *
4153 * Note that all operations are UTC.
4154 *
4155@verbatim
4156%time.now()
4157@endverbatim
4158 *
4159 * Example:
4160@verbatim
4161update reply {
4162 &Reply-Message := "%{%time.now() - %time.request()}"
4163}
4164@endverbatim
4165 *
4166 * @ingroup xlat_functions
4167 */
4168static xlat_action_t xlat_func_time_now(TALLOC_CTX *ctx, fr_dcursor_t *out,
4169 UNUSED xlat_ctx_t const *xctx,
4170 UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
4171{
4172 fr_value_box_t *vb;
4173
4174 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_DATE, NULL));
4175 vb->vb_date = fr_time_to_unix_time(fr_time());
4176
4177 fr_dcursor_append(out, vb);
4178
4179 return XLAT_ACTION_DONE;
4180}
4181
4182/** Return the request receive time as a #FR_TYPE_DATE
4183 *
4184 * Note that all operations are UTC.
4185 *
4186@verbatim
4187%time.request()
4188@endverbatim
4189 *
4190 * Example:
4191@verbatim
4192update reply {
4193 &Reply-Message := "%{%time.now() - %time.request()}"
4194}
4195@endverbatim
4196 *
4197 * @ingroup xlat_functions
4198 */
4199static xlat_action_t xlat_func_time_request(TALLOC_CTX *ctx, fr_dcursor_t *out,
4200 UNUSED xlat_ctx_t const *xctx,
4201 request_t *request, UNUSED fr_value_box_list_t *args)
4202{
4203 fr_value_box_t *vb;
4204
4205 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_DATE, NULL));
4206 vb->vb_date = fr_time_to_unix_time(request->packet->timestamp);
4207
4208 fr_dcursor_append(out, vb);
4209
4210 return XLAT_ACTION_DONE;
4211}
4212
4213
4214/** Return the current time offset from gmt
4215 *
4216 * @ingroup xlat_functions
4217 */
4218static xlat_action_t xlat_func_time_offset(TALLOC_CTX *ctx, fr_dcursor_t *out,
4219 UNUSED xlat_ctx_t const *xctx,
4220 UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
4221{
4222 fr_value_box_t *vb;
4223
4224 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL));
4225 vb->vb_time_delta = fr_time_gmtoff();
4226
4227 fr_dcursor_append(out, vb);
4228
4229 return XLAT_ACTION_DONE;
4230}
4231
4232
4233/** Return whether we are in daylight savings or not
4234 *
4235 * @ingroup xlat_functions
4236 */
4237static xlat_action_t xlat_func_time_is_dst(TALLOC_CTX *ctx, fr_dcursor_t *out,
4238 UNUSED xlat_ctx_t const *xctx,
4239 UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
4240{
4241 fr_value_box_t *vb;
4242
4243 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL));
4244 vb->vb_bool = fr_time_is_dst();
4245
4246 fr_dcursor_append(out, vb);
4247
4248 return XLAT_ACTION_DONE;
4249}
4250
4251
4252/** Change case of a string
4253 *
4254 * If upper is true, change to uppercase, otherwise, change to lowercase
4255 */
4256static xlat_action_t xlat_change_case(TALLOC_CTX *ctx, fr_dcursor_t *out,
4257 UNUSED request_t *request, fr_value_box_list_t *args, bool upper)
4258{
4259 char *p;
4260 char const *end;
4261 fr_value_box_t *vb;
4262
4263 XLAT_ARGS(args, &vb);
4264
4265 p = UNCONST(char *, vb->vb_strvalue);
4266 end = p + vb->vb_length;
4267
4268 while (p < end) {
4269 *(p) = upper ? toupper ((uint8_t) *(p)) : tolower((uint8_t) *(p));
4270 p++;
4271 }
4272
4273 xlat_arg_copy_out(ctx, out, args, vb);
4274
4275 return XLAT_ACTION_DONE;
4276}
4277
4278static xlat_arg_parser_t const xlat_change_case_arg[] = {
4279 { .required = true, .concat = true, .type = FR_TYPE_STRING },
4280 XLAT_ARG_PARSER_TERMINATOR
4281};
4282
4283
4284/** Convert a string to lowercase
4285 *
4286 * Example:
4287@verbatim
4288%tolower("Bar") == "bar"
4289@endverbatim
4290 *
4291 * Probably only works for ASCII
4292 *
4293 * @ingroup xlat_functions
4294 */
4295static xlat_action_t xlat_func_tolower(TALLOC_CTX *ctx, fr_dcursor_t *out,
4296 UNUSED xlat_ctx_t const *xctx,
4297 request_t *request, fr_value_box_list_t *in)
4298{
4299 return xlat_change_case(ctx, out, request, in, false);
4300}
4301
4302
4303/** Convert a string to uppercase
4304 *
4305 * Example:
4306@verbatim
4307%toupper("Foo") == "FOO"
4308@endverbatim
4309 *
4310 * Probably only works for ASCII
4311 *
4312 * @ingroup xlat_functions
4313 */
4314static xlat_action_t xlat_func_toupper(TALLOC_CTX *ctx, fr_dcursor_t *out,
4315 UNUSED xlat_ctx_t const *xctx,
4316 request_t *request, fr_value_box_list_t *in)
4317{
4318 return xlat_change_case(ctx, out, request, in, true);
4319}
4320
4321
4322static xlat_arg_parser_t const xlat_func_urlquote_arg[] = {
4323 { .required = true, .concat = true, .type = FR_TYPE_STRING },
4324 XLAT_ARG_PARSER_TERMINATOR
4325};
4326
4327/** URLencode special characters
4328 *
4329 * Example:
4330@verbatim
4331%urlquote("http://example.org/") == "http%3A%47%47example.org%47"
4332@endverbatim
4333 *
4334 * @ingroup xlat_functions
4335 */
4336static xlat_action_t xlat_func_urlquote(TALLOC_CTX *ctx, fr_dcursor_t *out,
4337 UNUSED xlat_ctx_t const *xctx,
4338 UNUSED request_t *request, fr_value_box_list_t *args)
4339{
4340 char const *p, *end;
4341 char *buff_p;
4342 size_t outlen = 0;
4343 fr_value_box_t *vb;
4344 fr_value_box_t *in_head;
4345
4346 XLAT_ARGS(args, &in_head);
4347
4348 p = in_head->vb_strvalue;
4349 end = p + in_head->vb_length;
4350
4351 /*
4352 * Calculate size of output
4353 */
4354 while (p < end) {
4355 if (isalnum(*p) ||
4356 *p == '-' ||
4357 *p == '_' ||
4358 *p == '.' ||
4359 *p == '~') {
4360 outlen++;
4361 } else {
4362 outlen += 3;
4363 }
4364 p++;
4365 }
4366
4367 MEM(vb = fr_value_box_alloc_null(ctx));
4368 MEM(fr_value_box_bstr_alloc(vb, &buff_p, vb, NULL, outlen, false) == 0);
4369 fr_value_box_safety_copy(vb, in_head);
4370
4371 /* Reset p to start position */
4372 p = in_head->vb_strvalue;
4373
4374 while (p < end) {
4375 if (isalnum(*p)) {
4376 *buff_p++ = *p++;
4377 continue;
4378 }
4379
4380 switch (*p) {
4381 case '-':
4382 case '_':
4383 case '.':
4384 case '~':
4385 *buff_p++ = *p++;
4386 break;
4387
4388 default:
4389 /* MUST be upper case hex to be compliant */
4390 snprintf(buff_p, 4, "%%%02X", (uint8_t) *p++); /* %XX */
4391
4392 buff_p += 3;
4393 }
4394 }
4395
4396 *buff_p = '\0';
4397
4398 // @todo - mark as safe for URL?
4399 fr_dcursor_append(out, vb);
4400
4401 return XLAT_ACTION_DONE;
4402}
4403
4404
4405static xlat_arg_parser_t const xlat_func_urlunquote_arg[] = {
4406 { .required = true, .concat = true, .type = FR_TYPE_STRING },
4407 XLAT_ARG_PARSER_TERMINATOR
4408};
4409
4410/** URLdecode special characters
4411 *
4412 * @note Remember to escape % with %% in strings, else xlat will try to parse it.
4413 *
4414 * Example:
4415@verbatim
4416%urlunquote("http%%3A%%47%%47example.org%%47") == "http://example.org/"
4417@endverbatim
4418 *
4419 * @ingroup xlat_functions
4420 */
4421static xlat_action_t xlat_func_urlunquote(TALLOC_CTX *ctx, fr_dcursor_t *out,
4422 UNUSED xlat_ctx_t const *xctx,
4423 request_t *request, fr_value_box_list_t *args)
4424{
4425 char const *p, *end;
4426 char *buff_p;
4427 char const *c1, *c2;
4428 size_t outlen = 0;
4429 fr_value_box_t *vb;
4430 fr_value_box_t *in_head;
4431
4432 XLAT_ARGS(args, &in_head);
4433
4434 p = in_head->vb_strvalue;
4435 end = p + in_head->vb_length;
4436
4437 /*
4438 * Calculate size of output
4439 */
4440 while (p < end) {
4441 if (*p == '%') {
4442 if (!p[1] || !p[2]) {
4443 REMARKER(in_head->vb_strvalue, p - in_head->vb_strvalue, "Invalid %% sequence");
4444 return XLAT_ACTION_FAIL;
4445 }
4446 p += 3;
4447 } else {
4448 p++;
4449 }
4450 outlen++;
4451 }
4452
4453 MEM(vb = fr_value_box_alloc_null(ctx));
4454 MEM(fr_value_box_bstr_alloc(vb, &buff_p, vb, NULL, outlen, false) == 0);
4455 fr_value_box_safety_copy(vb, in_head);
4456
4457 /* Reset p to start position */
4458 p = in_head->vb_strvalue;
4459
4460 while (p < end) {
4461 if (*p != '%') {
4462 *buff_p++ = *p++;
4463 continue;
4464 }
4465 /* Is a % char */
4466
4467 /* Don't need \0 check, as it won't be in the hextab */
4468 if (!(c1 = memchr(hextab, tolower((uint8_t) *++p), 16)) ||
4469 !(c2 = memchr(hextab, tolower((uint8_t) *++p), 16))) {
4470 REMARKER(in_head->vb_strvalue, p - in_head->vb_strvalue, "Non-hex char in %% sequence");
4471 talloc_free(vb);
4472
4473 return XLAT_ACTION_FAIL;
4474 }
4475 p++;
4476 *buff_p++ = ((c1 - hextab) << 4) + (c2 - hextab);
4477 }
4478
4479 *buff_p = '\0';
4480 fr_dcursor_append(out, vb);
4481
4482 return XLAT_ACTION_DONE;
4483}
4484
4485static xlat_arg_parser_t const xlat_pair_decode_args[] = {
4486 { .required = true, .type = FR_TYPE_VOID },
4487 { .single = true, .type = FR_TYPE_ATTR },
4488 XLAT_ARG_PARSER_TERMINATOR
4489};
4490
4491/** Decode any protocol attribute / options
4492 *
4493 * Creates protocol-specific attributes based on the given binary option data
4494 *
4495 * Example:
4496@verbatim
4497%dhcpv4.decode(%{Tmp-Octets-0})
4498@endverbatim
4499 *
4500 * @ingroup xlat_functions
4501 */
4502static xlat_action_t xlat_pair_decode(TALLOC_CTX *ctx, fr_dcursor_t *out,
4503 xlat_ctx_t const *xctx,
4504 request_t *request, fr_value_box_list_t *in)
4505{
4506 ssize_t decoded;
4507 fr_value_box_t *vb, *in_head, *root_da;
4508 void *decode_ctx = NULL;
4509 xlat_pair_decode_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_pair_decode_inst_t);
4510 xlat_pair_decode_uctx_t const *decode_uctx = inst->decode_uctx;
4511 fr_test_point_pair_decode_t const *tp_decode = decode_uctx->tp_decode;
4512 fr_pair_t *vp = NULL;
4513 bool created = false;
4514
4515 XLAT_ARGS(in, &in_head, &root_da);
4516
4517 fr_assert(in_head->type == FR_TYPE_GROUP);
4518
4519 if (decode_uctx->dict && decode_uctx->dict != request->proto_dict) {
4520 REDEBUG2("Can't call %%%s() when in %s namespace", xctx->ex->call.func->name,
4521 fr_dict_root(request->proto_dict)->name);
4522 return XLAT_ACTION_FAIL;
4523 }
4524
4525 if (root_da) {
4526 int ret;
4527 if (!fr_type_is_structural(root_da->vb_attr->type)) {
4528 REDEBUG2("Decoding context must be a structural attribute reference");
4529 return XLAT_ACTION_FAIL;
4530 }
4531 ret = fr_pair_update_by_da_parent(fr_pair_list_parent(&request->request_pairs), &vp, root_da->vb_attr);
4532 if (ret < 0) {
4533 REDEBUG2("Failed creating decoding root pair");
4534 return XLAT_ACTION_FAIL;
4535 }
4536 if (ret == 0) created = true;
4537 }
4538
4539 if (tp_decode->test_ctx) {
4540 if (tp_decode->test_ctx(&decode_ctx, ctx, request->proto_dict, root_da ? root_da->vb_attr : NULL) < 0) {
4541 goto fail;
4542 }
4543 }
4544
4545 decoded = xlat_decode_value_box_list(root_da ? vp : request->request_ctx,
4546 root_da ? &vp->vp_group : &request->request_pairs,
4547 request, decode_ctx, tp_decode->func, &in_head->vb_group);
4548 if (decoded <= 0) {
4549 talloc_free(decode_ctx);
4550 RPERROR("Protocol decoding failed");
4551 fail:
4552 if (created) fr_pair_delete(&request->request_pairs, vp);
4553 return XLAT_ACTION_FAIL;
4554 }
4555
4556 /*
4557 * Create a value box to hold the decoded count, and add
4558 * it to the output list.
4559 */
4560 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_UINT32, NULL));
4561 vb->vb_uint32 = (uint32_t)decoded;
4562 fr_dcursor_append(out, vb);
4563
4564 talloc_free(decode_ctx);
4565 return XLAT_ACTION_DONE;
4566}
4567
4568static xlat_arg_parser_t const xlat_func_subnet_args[] = {
4569 { .required = true, .single = true, .type = FR_TYPE_IPV4_PREFIX },
4570 XLAT_ARG_PARSER_TERMINATOR
4571};
4572
4573/** Calculate the subnet mask from a IPv4 prefix
4574 *
4575 * Example:
4576@verbatim
4577%ip.v4.netmask(%{Network-Prefix})
4578@endverbatim
4579 *
4580 * @ingroup xlat_functions
4581 */
4582static xlat_action_t xlat_func_subnet_netmask(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
4583 UNUSED request_t *request, fr_value_box_list_t *args)
4584{
4585 fr_value_box_t *subnet, *vb;
4586 XLAT_ARGS(args, &subnet);
4587
4588 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_IPV4_ADDR, NULL));
4589
4590 switch (subnet->vb_ip.prefix) {
4591 case 0:
4592 vb->vb_ipv4addr = 0;
4593 break;
4594
4595 case 32:
4596 vb->vb_ipv4addr = 0xffffffff;
4597 break;
4598
4599 default:
4600 vb->vb_ipv4addr = htonl((uint32_t)0xffffffff << (32 - subnet->vb_ip.prefix));
4601 break;
4602 }
4603
4604 fr_dcursor_append(out, vb);
4605
4606 return XLAT_ACTION_DONE;
4607}
4608
4609/** Calculate the broadcast address from a IPv4 prefix
4610 *
4611 * Example:
4612@verbatim
4613%ip.v4.broadcast(%{Network-Prefix})
4614@endverbatim
4615 *
4616 * @ingroup xlat_functions
4617 */
4618static xlat_action_t xlat_func_subnet_broadcast(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx,
4619 UNUSED request_t *request, fr_value_box_list_t *args)
4620{
4621 fr_value_box_t *subnet, *vb;
4622 XLAT_ARGS(args, &subnet);
4623
4624 MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_IPV4_ADDR, NULL));
4625 vb->vb_ipv4addr = htonl( ntohl(subnet->vb_ipv4addr) | ((uint32_t)0xffffffff >> subnet->vb_ip.prefix));
4626 fr_dcursor_append(out, vb);
4627
4628 return XLAT_ACTION_DONE;
4629}
4630
4631static int xlat_pair_decode_instantiate(xlat_inst_ctx_t const *xctx)
4632{
4633 xlat_pair_decode_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_pair_decode_inst_t);
4634
4635 inst->decode_uctx = talloc_get_type_abort_const(xctx->uctx, xlat_pair_decode_uctx_t);
4636 return 0;
4637}
4638
4639static int xlat_pair_encode_instantiate(xlat_inst_ctx_t const *xctx)
4640{
4641 xlat_pair_encode_inst_t *inst = talloc_get_type_abort(xctx->inst, xlat_pair_encode_inst_t);
4642
4643 inst->tp_encode = xctx->uctx;
4644 return 0;
4645}
4646
4652
4653/** Encode protocol attributes / options
4654 *
4655 * Returns octet string created from the provided pairs
4656 *
4657 * Example:
4658@verbatim
4659%dhcpv4.encode(&request[*])
4660@endverbatim
4661 *
4662 * @ingroup xlat_functions
4663 */
4664static xlat_action_t xlat_pair_encode(TALLOC_CTX *ctx, fr_dcursor_t *out,
4665 xlat_ctx_t const *xctx,
4666 request_t *request, fr_value_box_list_t *args)
4667{
4668 fr_pair_t *vp;
4669 fr_dcursor_t *cursor;
4670 bool tainted = false, encode_children = false;
4671 fr_value_box_t *encoded;
4672
4673 fr_dbuff_t *dbuff;
4674 ssize_t len = 0;
4675 fr_value_box_t *in_head, *root_da;
4676 void *encode_ctx = NULL;
4677 xlat_pair_encode_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_pair_encode_inst_t);
4678 fr_test_point_pair_encode_t const *tp_encode = inst->tp_encode;
4679
4680 FR_DBUFF_TALLOC_THREAD_LOCAL(&dbuff, 2048, SIZE_MAX);
4681
4682 XLAT_ARGS(args, &in_head, &root_da);
4683
4684 cursor = fr_value_box_get_cursor(in_head);
4685
4686 /*
4687 * Create the encoding context.
4688 */
4689 if (tp_encode->test_ctx) {
4690 if (tp_encode->test_ctx(&encode_ctx, cursor, request->proto_dict, root_da ? root_da->vb_attr : NULL) < 0) {
4691 return XLAT_ACTION_FAIL;
4692 }
4693 }
4694
4695 if (root_da) {
4696 if (!fr_type_is_structural(root_da->vb_attr->type)) {
4697 REDEBUG2("Encoding context must be a structural attribute reference");
4698 return XLAT_ACTION_FAIL;
4699 }
4700 vp = fr_dcursor_current(cursor);
4701 if (vp) {
4702 if (!fr_dict_attr_common_parent(root_da->vb_attr, vp->da, true) && (root_da->vb_attr != vp->da)) {
4703 REDEBUG2("%s is not a child of %s", vp->da->name, root_da->vb_attr->name);
4704 return XLAT_ACTION_FAIL;
4705 }
4706 if (root_da->vb_attr == vp->da) encode_children = true;
4707 }
4708 }
4709
4710 /*
4711 * Loop over the attributes, encoding them.
4712 */
4713 RDEBUG2("Encoding attributes");
4714
4715 if (RDEBUG_ENABLED2) {
4716 RINDENT();
4717 for (vp = fr_dcursor_current(cursor);
4718 vp != NULL;
4719 vp = fr_dcursor_next(cursor)) {
4720 RDEBUG2("%pP", vp);
4721 }
4722 REXDENT();
4723 }
4724
4725 /*
4726 * Encoders advance the cursor, so we just need to feed
4727 * in the next pair. This was originally so we could
4728 * extend the output buffer, but with dbuffs that's
4729 * no longer necessary... we might want to refactor this
4730 * in future.
4731 */
4732 for (vp = fr_dcursor_head(cursor);
4733 vp != NULL;
4734 vp = fr_dcursor_current(cursor)) {
4735 /*
4736 *
4737 * Don't check for internal attributes, the
4738 * encoders can skip them if they need to, and the
4739 * internal encoder can encode anything, as can
4740 * things like CBOR.
4741 *
4742 * Don't check the dictionaries. By definition,
4743 * vp->da->dict==request->proto_dict, OR else we're
4744 * using the internal encoder and encoding a real
4745 * protocol.
4746 *
4747 * However, we likely still want a
4748 * dictionary-specific "is encodable" function,
4749 * as AKA/SIM and DHCPv6 encode "bool"s only if
4750 * their value is true.
4751 */
4752 if (encode_children) {
4753 fr_dcursor_t child_cursor;
4754
4755 fr_assert(fr_type_is_structural(vp->vp_type));
4756
4757 /*
4758 * If we're given an encoding context which is the
4759 * same as the DA returned by the cursor, that means
4760 * encode the children.
4761 */
4762 fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
4763 while (fr_dcursor_current(&child_cursor)) {
4764 len = tp_encode->func(dbuff, &child_cursor, encode_ctx);
4765 if (len < 0) break;
4766 }
4767 fr_dcursor_next(cursor);
4768 } else {
4769 len = tp_encode->func(dbuff, cursor, encode_ctx);
4770 }
4771 if (len < 0) {
4772 RPEDEBUG("Protocol encoding failed");
4773 return XLAT_ACTION_FAIL;
4774 }
4775
4776 tainted |= vp->vp_tainted;
4777 }
4778
4779 /*
4780 * Pass the options string back to the caller.
4781 */
4782 MEM(encoded = fr_value_box_alloc_null(ctx));
4783 fr_value_box_memdup(encoded, encoded, NULL, fr_dbuff_start(dbuff), fr_dbuff_used(dbuff), tainted);
4784 fr_dcursor_append(out, encoded);
4785
4786 return XLAT_ACTION_DONE;
4787}
4788
4789static int xlat_protocol_register_by_name(dl_t *dl, char const *name, fr_dict_t const *dict)
4790{
4791 fr_test_point_pair_decode_t *tp_decode;
4792 fr_test_point_pair_encode_t *tp_encode;
4793 xlat_pair_decode_uctx_t *decode_uctx;
4794 xlat_t *xlat;
4795 char buffer[256+32];
4796
4797 /*
4798 * See if there's a decode function for it.
4799 */
4800 snprintf(buffer, sizeof(buffer), "%s_tp_decode_pair", name);
4801 tp_decode = dlsym(dl->handle, buffer);
4802 if (tp_decode) {
4803 snprintf(buffer, sizeof(buffer), "%s.decode", name);
4804
4805 /* May be called multiple times, so just skip protocols we've already registered */
4806 if (xlat_func_find(buffer, -1)) return 1;
4807
4808 if (unlikely((xlat = xlat_func_register(NULL, buffer, xlat_pair_decode, FR_TYPE_UINT32)) == NULL)) return -1;
4809 xlat_func_args_set(xlat, xlat_pair_decode_args);
4810 decode_uctx = talloc(xlat, xlat_pair_decode_uctx_t);
4811 decode_uctx->tp_decode = tp_decode;
4812 decode_uctx->dict = dict;
4813 xlat_func_instantiate_set(xlat, xlat_pair_decode_instantiate, xlat_pair_decode_inst_t, NULL, decode_uctx);
4814 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
4815 }
4816
4817 /*
4818 * See if there's an encode function for it.
4819 */
4820 snprintf(buffer, sizeof(buffer), "%s_tp_encode_pair", name);
4821 tp_encode = dlsym(dl->handle, buffer);
4822 if (tp_encode) {
4823 snprintf(buffer, sizeof(buffer), "%s.encode", name);
4824
4825 if (xlat_func_find(buffer, -1)) return 1;
4826
4827 if (unlikely((xlat = xlat_func_register(NULL, buffer, xlat_pair_encode, FR_TYPE_OCTETS)) == NULL)) return -1;
4828 xlat_func_args_set(xlat, xlat_pair_encode_args);
4829 xlat_func_instantiate_set(xlat, xlat_pair_encode_instantiate, xlat_pair_encode_inst_t, NULL, tp_encode);
4830 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
4831 }
4832
4833 return 0;
4834}
4835
4836static int xlat_protocol_register(fr_dict_t const *dict)
4837{
4838 dl_t *dl = fr_dict_dl(dict);
4839 char *p, name[256];
4840
4841 /*
4842 * No library for this protocol, skip it.
4843 *
4844 * Protocol TEST has no libfreeradius-test, so that's OK.
4845 */
4846 if (!dl) return 0;
4847
4848 strlcpy(name, fr_dict_root(dict)->name, sizeof(name));
4849 for (p = name; *p != '\0'; p++) {
4850 *p = tolower((uint8_t) *p);
4851 }
4852
4853 return xlat_protocol_register_by_name(dl, name, dict != fr_dict_internal() ? dict : NULL);
4854}
4855
4856static dl_loader_t *cbor_loader = NULL;
4857
4858static int xlat_protocol_register_cbor(void)
4859{
4860 dl_t *dl;
4861
4862 cbor_loader = dl_loader_init(NULL, NULL, false, false);
4863 if (!cbor_loader) return 0;
4864
4865 dl = dl_by_name(cbor_loader, "libfreeradius-cbor", NULL, false);
4866 if (!dl) return 0;
4867
4868 if (xlat_protocol_register_by_name(dl, "cbor", NULL) < 0) return -1;
4869
4870 return 0;
4871}
4872
4873
4874/** Register xlats for any loaded dictionaries
4875 */
4876int xlat_protocols_register(void)
4877{
4878 fr_dict_t *dict;
4879 fr_dict_global_ctx_iter_t iter;
4880
4881 for (dict = fr_dict_global_ctx_iter_init(&iter);
4882 dict != NULL;
4883 dict = fr_dict_global_ctx_iter_next(&iter)) {
4884 if (xlat_protocol_register(dict) < 0) return -1;
4885 }
4886
4887 /*
4888 * And the internal protocol, too.
4889 */
4890 if (xlat_protocol_register(fr_dict_internal()) < 0) return -1;
4891
4892 /*
4893 * And cbor stuff
4894 */
4895 if (xlat_protocol_register_cbor() < 0) return -1;
4896
4897 return 0;
4898}
4899
4900/** De-register all xlat functions we created
4901 *
4902 */
4903static int _xlat_global_free(UNUSED void *uctx)
4904{
4905 TALLOC_FREE(xlat_ctx);
4906 xlat_func_free();
4907 xlat_eval_free();
4908 talloc_free(cbor_loader);
4909
4910 return 0;
4911}
4912
4913/** Global initialisation for xlat
4914 *
4915 * @note Free memory with #xlat_free
4916 *
4917 * @return
4918 * - 0 on success.
4919 * - -1 on failure.
4920 *
4921 * @hidecallgraph
4922 */
4923static int _xlat_global_init(UNUSED void *uctx)
4924{
4925 xlat_t *xlat;
4926
4927 xlat_ctx = talloc_init("xlat");
4928 if (!xlat_ctx) return -1;
4929
4930 if (xlat_func_init() < 0) return -1;
4931
4932 /*
4933 * Lookup attributes used by virtual xlat expansions.
4934 */
4935 if (xlat_eval_init() < 0) return -1;
4936
4937 /*
4938 * Registers async xlat operations in the `unlang` interpreter.
4939 */
4940 unlang_xlat_init();
4941
4942 /*
4943 * These are all "pure" functions.
4944 */
4945#define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
4946do { \
4947 if (unlikely((xlat = xlat_func_register(xlat_ctx, _xlat, _func, _return_type)) == NULL)) return -1; \
4948 xlat_func_args_set(xlat, _args); \
4949 xlat_func_flags_set(xlat, (xlat_func_flags_t)(XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL)); \
4950} while (0)
4951
4952#define XLAT_NEW(_x) xlat->replaced_with = _x
4953
4954 XLAT_REGISTER_ARGS("cast", xlat_func_cast, FR_TYPE_VOID, xlat_func_cast_args);
4955
4956 XLAT_REGISTER_ARGS("str.concat", xlat_func_concat, FR_TYPE_STRING, xlat_func_concat_args);
4957 XLAT_REGISTER_ARGS("concat", xlat_func_concat, FR_TYPE_STRING, xlat_func_concat_args);
4958 XLAT_NEW("str.concat");
4959
4960 XLAT_REGISTER_ARGS("str.split", xlat_func_explode, FR_TYPE_STRING, xlat_func_explode_args);
4961 XLAT_REGISTER_ARGS("explode", xlat_func_explode, FR_TYPE_STRING, xlat_func_explode_args);
4962 XLAT_NEW("str.split");
4963
4964 XLAT_REGISTER_ARGS("file.escape", xlat_transparent, FR_TYPE_STRING, xlat_func_file_name_args);
4965
4966 XLAT_REGISTER_ARGS("hmac.md5", xlat_func_hmac_md5, FR_TYPE_OCTETS, xlat_hmac_args);
4967 XLAT_REGISTER_ARGS("hmacmd5", xlat_func_hmac_md5, FR_TYPE_OCTETS, xlat_hmac_args);
4968 XLAT_NEW("hmac.md5");
4969
4970 XLAT_REGISTER_ARGS("hmac.sha1", xlat_func_hmac_sha1, FR_TYPE_OCTETS, xlat_hmac_args);
4971 XLAT_REGISTER_ARGS("hmacsha1", xlat_func_hmac_sha1, FR_TYPE_OCTETS, xlat_hmac_args);
4972 XLAT_NEW("hmac.sha1");
4973
4974 XLAT_REGISTER_ARGS("integer", xlat_func_integer, FR_TYPE_VOID, xlat_func_integer_args);
4975 xlat->deprecated = true;
4976
4977 XLAT_REGISTER_ARGS("join", xlat_func_join, FR_TYPE_VOID, xlat_func_join_args);
4978 XLAT_REGISTER_ARGS("ungroup", xlat_func_ungroup, FR_TYPE_VOID, xlat_func_join_args);
4979 xlat->deprecated = true;
4980
4981 XLAT_REGISTER_ARGS("length", xlat_func_length, FR_TYPE_SIZE, xlat_func_length_args);
4982
4983 XLAT_REGISTER_ARGS("str.lpad", xlat_func_lpad, FR_TYPE_STRING, xlat_func_pad_args);
4984 XLAT_REGISTER_ARGS("lpad", xlat_func_lpad, FR_TYPE_STRING, xlat_func_pad_args);
4985 XLAT_NEW("str.lpad");
4986
4987 XLAT_REGISTER_ARGS("str.rpad", xlat_func_rpad, FR_TYPE_STRING, xlat_func_pad_args);
4988 XLAT_REGISTER_ARGS("rpad", xlat_func_rpad, FR_TYPE_STRING, xlat_func_pad_args);
4989 XLAT_NEW("str.rpad");
4990
4991 XLAT_REGISTER_ARGS("str.substr", xlat_func_substr, FR_TYPE_VOID, xlat_func_substr_args);
4992 XLAT_REGISTER_ARGS("substr", xlat_func_substr, FR_TYPE_VOID, xlat_func_substr_args);
4993 XLAT_NEW("str.substr");
4994
4995 XLAT_REGISTER_ARGS("ip.v4.netmask", xlat_func_subnet_netmask, FR_TYPE_IPV4_ADDR, xlat_func_subnet_args);
4996 XLAT_REGISTER_ARGS("ip.v4.broadcast", xlat_func_subnet_broadcast, FR_TYPE_IPV4_ADDR, xlat_func_subnet_args);
4997
4998 /*
4999 * The inputs to these functions are variable.
5000 */
5001#undef XLAT_REGISTER_ARGS
5002#define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
5003do { \
5004 if (unlikely((xlat = xlat_func_register(xlat_ctx, _xlat, _func, _return_type)) == NULL)) return -1; \
5005 xlat_func_args_set(xlat, _args); \
5006 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
5007} while (0)
5008
5009#undef XLAT_REGISTER_VOID
5010#define XLAT_REGISTER_VOID(_xlat, _func, _return_type) \
5011do { \
5012 if (unlikely((xlat = xlat_func_register(xlat_ctx, _xlat, _func, _return_type)) == NULL)) return -1; \
5013 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
5014} while (0)
5015
5016 XLAT_REGISTER_ARGS("block", xlat_func_block, FR_TYPE_TIME_DELTA, xlat_func_block_args);
5017 XLAT_REGISTER_ARGS("debug", xlat_func_debug, FR_TYPE_INT8, xlat_func_debug_args);
5018 XLAT_REGISTER_ARGS("debug_attr", xlat_func_pairs_debug, FR_TYPE_NULL, xlat_pair_cursor_args);
5019 XLAT_NEW("pairs.debug");
5020
5021 XLAT_REGISTER_ARGS("file.cat", xlat_func_file_cat, FR_TYPE_OCTETS, xlat_func_file_cat_args);
5022 XLAT_REGISTER_ARGS("file.exists", xlat_func_file_exists, FR_TYPE_BOOL, xlat_func_file_name_args);
5023 XLAT_REGISTER_ARGS("file.head", xlat_func_file_head, FR_TYPE_STRING, xlat_func_file_name_args);
5024 XLAT_REGISTER_ARGS("file.mkdir", xlat_func_file_mkdir, FR_TYPE_BOOL, xlat_func_file_name_args);
5025 XLAT_REGISTER_ARGS("file.rm", xlat_func_file_rm, FR_TYPE_BOOL, xlat_func_file_name_args);
5026 XLAT_REGISTER_ARGS("file.rmdir", xlat_func_file_rmdir, FR_TYPE_BOOL, xlat_func_file_name_args);
5027 XLAT_REGISTER_ARGS("file.size", xlat_func_file_size, FR_TYPE_UINT64, xlat_func_file_name_args);
5028 XLAT_REGISTER_ARGS("file.tail", xlat_func_file_tail, FR_TYPE_STRING, xlat_func_file_name_count_args);
5029 XLAT_REGISTER_ARGS("file.touch", xlat_func_file_touch, FR_TYPE_BOOL, xlat_func_file_name_args);
5030
5031 XLAT_REGISTER_ARGS("immutable", xlat_func_immutable_attr, FR_TYPE_NULL, xlat_pair_cursor_args);
5032 XLAT_NEW("pairs.immutable");
5033 XLAT_REGISTER_ARGS("pairs.immutable", xlat_func_immutable_attr, FR_TYPE_NULL, xlat_pair_cursor_args);
5034
5035 XLAT_REGISTER_ARGS("log.debug", xlat_func_log_debug, FR_TYPE_NULL, xlat_func_log_arg);
5036 XLAT_REGISTER_ARGS("log.err", xlat_func_log_err, FR_TYPE_NULL, xlat_func_log_arg);
5037 XLAT_REGISTER_ARGS("log.info", xlat_func_log_info, FR_TYPE_NULL, xlat_func_log_arg);
5038 XLAT_REGISTER_ARGS("log.warn", xlat_func_log_warn, FR_TYPE_NULL, xlat_func_log_arg);
5039 XLAT_REGISTER_ARGS("log.destination", xlat_func_log_dst, FR_TYPE_STRING, xlat_func_log_dst_args);
5040
5041 XLAT_REGISTER_ARGS("nexttime", xlat_func_next_time, FR_TYPE_UINT64, xlat_func_next_time_args);
5042 XLAT_NEW("time.next");
5043 XLAT_REGISTER_ARGS("time.next", xlat_func_next_time, FR_TYPE_UINT64, xlat_func_next_time_args);
5044
5045 XLAT_REGISTER_ARGS("pairs", xlat_func_pairs_print, FR_TYPE_STRING, xlat_pair_cursor_args);
5046 XLAT_NEW("pairs.print");
5047 XLAT_REGISTER_ARGS("pairs.print", xlat_func_pairs_print, FR_TYPE_STRING, xlat_pair_cursor_args);
5048
5049 XLAT_REGISTER_ARGS("pairs.debug", xlat_func_pairs_debug, FR_TYPE_NULL, xlat_pair_cursor_args);
5050
5051 XLAT_REGISTER_ARGS("str.subst", xlat_func_subst, FR_TYPE_STRING, xlat_func_subst_args);
5052#ifdef HAVE_REGEX_PCRE2
5053 xlat_func_instantiate_set(xlat, xlat_instantiate_subst_regex, xlat_subst_regex_inst_t, NULL, NULL);
5054#endif
5055 XLAT_REGISTER_ARGS("subst", xlat_func_subst, FR_TYPE_STRING, xlat_func_subst_args);
5056 XLAT_NEW("str.subst");
5057#ifdef HAVE_REGEX_PCRE2
5058 xlat_func_instantiate_set(xlat, xlat_instantiate_subst_regex, xlat_subst_regex_inst_t, NULL, NULL);
5059#endif
5060
5061#ifndef NDEBUG
5062 XLAT_REGISTER_ARGS("signal.raise", xlat_func_signal_raise, FR_TYPE_STRING, xlat_func_signal_raise_args);
5063#endif
5064
5065 XLAT_REGISTER_ARGS("time", xlat_func_time, FR_TYPE_VOID, xlat_func_time_args);
5066 XLAT_REGISTER_VOID("time.now", xlat_func_time_now, FR_TYPE_DATE);
5067 XLAT_REGISTER_VOID("time.request", xlat_func_time_request, FR_TYPE_DATE);
5068 XLAT_REGISTER_VOID("time.offset", xlat_func_time_offset, FR_TYPE_TIME_DELTA);
5069 XLAT_REGISTER_VOID("time.is_dst", xlat_func_time_is_dst, FR_TYPE_BOOL);
5070
5071 XLAT_REGISTER_ARGS("base64.encode", xlat_func_base64_encode, FR_TYPE_STRING, xlat_func_base64_encode_arg);
5072 XLAT_REGISTER_ARGS("base64.decode", xlat_func_base64_decode, FR_TYPE_OCTETS, xlat_func_base64_decode_arg);
5073 XLAT_REGISTER_ARGS("rand", xlat_func_rand, FR_TYPE_UINT64, xlat_func_rand_arg);
5074 XLAT_REGISTER_ARGS("map", xlat_func_map, FR_TYPE_BOOL, xlat_func_map_arg);
5075 XLAT_REGISTER_ARGS("module.call", xlat_func_module_call, FR_TYPE_VOID, xlat_func_module_call_arg);
5076
5077 XLAT_REGISTER_ARGS("str.rand", xlat_func_randstr, FR_TYPE_STRING, xlat_func_randstr_arg);
5078 XLAT_REGISTER_ARGS("randstr", xlat_func_randstr, FR_TYPE_STRING, xlat_func_randstr_arg);
5079 XLAT_NEW("str.rand");
5080
5081 XLAT_REGISTER_VOID("uuid.v4", xlat_func_uuid_v4, FR_TYPE_STRING);
5082 XLAT_REGISTER_VOID("uuid.v7", xlat_func_uuid_v7, FR_TYPE_STRING);
5083
5084 XLAT_REGISTER_ARGS("range", xlat_func_range, FR_TYPE_UINT64, xlat_func_range_arg);
5085
5086 if (unlikely((xlat = xlat_func_register(xlat_ctx, "unsafe", xlat_func_unsafe, FR_TYPE_VOID)) == NULL)) return -1;
5087 xlat_func_flags_set(xlat, (xlat_func_flags_t)(XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL));
5088 xlat_func_args_set(xlat, xlat_func_unsafe_args);
5089
5090 /*
5091 * All of these functions are pure.
5092 */
5093#define XLAT_REGISTER_PURE(_xlat, _func, _return_type, _arg) \
5094do { \
5095 if (unlikely((xlat = xlat_func_register(xlat_ctx, _xlat, _func, _return_type)) == NULL)) return -1; \
5096 xlat_func_args_set(xlat, _arg); \
5097 xlat_func_flags_set(xlat, (xlat_func_flags_t)(XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL)); \
5098} while (0)
5099
5100 XLAT_REGISTER_PURE("bin", xlat_func_bin, FR_TYPE_OCTETS, xlat_func_bin_arg);
5101 XLAT_REGISTER_PURE("hex", xlat_func_hex, FR_TYPE_STRING, xlat_func_hex_arg);
5102 XLAT_REGISTER_PURE("hash.md4", xlat_func_md4, FR_TYPE_OCTETS, xlat_func_md4_arg);
5103 XLAT_REGISTER_PURE("md4", xlat_func_md4, FR_TYPE_OCTETS, xlat_func_md4_arg);
5104 XLAT_NEW("hash.md4");
5105
5106 XLAT_REGISTER_PURE("hash.md5", xlat_func_md5, FR_TYPE_OCTETS, xlat_func_md5_arg);
5107 XLAT_REGISTER_PURE("md5", xlat_func_md5, FR_TYPE_OCTETS, xlat_func_md5_arg);
5108 XLAT_NEW("hash.md4");
5109
5110 if (unlikely((xlat = xlat_func_register(xlat_ctx, "regex.match", xlat_func_regex, FR_TYPE_STRING)) == NULL)) return -1;
5111 xlat_func_args_set(xlat, xlat_func_regex_args);
5112 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
5113 if (unlikely((xlat = xlat_func_register(xlat_ctx, "regex", xlat_func_regex, FR_TYPE_STRING)) == NULL)) return -1;
5114 xlat_func_args_set(xlat, xlat_func_regex_args);
5115 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
5116 XLAT_NEW("regex.match");
5117
5118 {
5119 static xlat_arg_parser_t const xlat_regex_safe_args[] = {
5120 { .type = FR_TYPE_STRING, .variadic = XLAT_ARG_VARIADIC_EMPTY_SQUASH, .concat = true },
5121 XLAT_ARG_PARSER_TERMINATOR
5122 };
5123
5124 static xlat_arg_parser_t const xlat_regex_escape_args[] = {
5125 { .type = FR_TYPE_STRING,
5126 .func = xlat_regex_escape, .safe_for = FR_REGEX_SAFE_FOR, .always_escape = true,
5127 .variadic = XLAT_ARG_VARIADIC_EMPTY_SQUASH, .concat = true },
5128 XLAT_ARG_PARSER_TERMINATOR
5129 };
5130
5131 if (unlikely((xlat = xlat_func_register(xlat_ctx, "regex.safe",
5132 xlat_transparent, FR_TYPE_STRING)) == NULL)) return -1;
5133 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
5134 xlat_func_args_set(xlat, xlat_regex_safe_args);
5135 xlat_func_safe_for_set(xlat, FR_REGEX_SAFE_FOR);
5136
5137 if (unlikely((xlat = xlat_func_register(xlat_ctx, "regex.escape",
5138 xlat_transparent, FR_TYPE_STRING)) == NULL)) return -1;
5139 xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
5140 xlat_func_args_set(xlat, xlat_regex_escape_args);
5141 xlat_func_safe_for_set(xlat, FR_REGEX_SAFE_FOR);
5142 }
5143
5144#define XLAT_REGISTER_HASH(_name, _func) do { \
5145 XLAT_REGISTER_PURE("hash." _name, _func, FR_TYPE_OCTETS, xlat_func_sha_arg); \
5146 XLAT_REGISTER_PURE(_name, _func, FR_TYPE_OCTETS, xlat_func_sha_arg); \
5147 XLAT_NEW("hash." _name); \
5148 } while (0)
5149
5150 XLAT_REGISTER_HASH("sha1", xlat_func_sha1);
5151
5152#ifdef HAVE_OPENSSL_EVP_H
5153 XLAT_REGISTER_HASH("sha2_224", xlat_func_sha2_224);
5154 XLAT_REGISTER_HASH("sha2_256", xlat_func_sha2_256);
5155 XLAT_REGISTER_HASH("sha2_384", xlat_func_sha2_384);
5156 XLAT_REGISTER_HASH("sha2_512", xlat_func_sha2_512);
5157 XLAT_REGISTER_HASH("sha2", xlat_func_sha2_256);
5158
5159# ifdef HAVE_EVP_BLAKE2S256
5160 XLAT_REGISTER_HASH("blake2s_256", xlat_func_blake2s_256);
5161# endif
5162# ifdef HAVE_EVP_BLAKE2B512
5163 XLAT_REGISTER_HASH("blake2b_512", xlat_func_blake2b_512);
5164# endif
5165
5166 XLAT_REGISTER_HASH("sha3_224", xlat_func_sha3_224);
5167 XLAT_REGISTER_HASH("sha3_256", xlat_func_sha3_256);
5168 XLAT_REGISTER_HASH("sha3_384", xlat_func_sha3_384);
5169 XLAT_REGISTER_HASH("sha3_512", xlat_func_sha3_512);
5170 XLAT_REGISTER_HASH("sha3", xlat_func_sha3_256);
5171#endif
5172
5173 XLAT_REGISTER_PURE("string", xlat_transparent, FR_TYPE_STRING, xlat_func_string_arg);
5174 xlat->deprecated = true;
5175 XLAT_REGISTER_PURE("strlen", xlat_func_strlen, FR_TYPE_SIZE, xlat_func_strlen_arg);
5176 XLAT_NEW("length");
5177
5178 XLAT_REGISTER_PURE("str.utf8", xlat_func_str_utf8, FR_TYPE_BOOL, xlat_func_str_utf8_arg);
5179 XLAT_REGISTER_PURE("str.printable", xlat_func_str_printable, FR_TYPE_BOOL, xlat_func_str_printable_arg);
5180
5181 XLAT_REGISTER_PURE("str.lower", xlat_func_tolower, FR_TYPE_STRING, xlat_change_case_arg);
5182 XLAT_REGISTER_PURE("tolower", xlat_func_tolower, FR_TYPE_STRING, xlat_change_case_arg);
5183 XLAT_NEW("str.lower");
5184
5185 XLAT_REGISTER_PURE("str.upper", xlat_func_toupper, FR_TYPE_STRING, xlat_change_case_arg);
5186 XLAT_REGISTER_PURE("toupper", xlat_func_toupper, FR_TYPE_STRING, xlat_change_case_arg);
5187 XLAT_NEW("str.upper");
5188
5189 XLAT_REGISTER_PURE("url.quote", xlat_func_urlquote, FR_TYPE_STRING, xlat_func_urlquote_arg);
5190 XLAT_REGISTER_PURE("urlquote", xlat_func_urlquote, FR_TYPE_STRING, xlat_func_urlquote_arg);
5191 XLAT_NEW("url.quote");
5192
5193 XLAT_REGISTER_PURE("url.unquote", xlat_func_urlunquote, FR_TYPE_STRING, xlat_func_urlunquote_arg);
5194 XLAT_REGISTER_PURE("urlunquote", xlat_func_urlunquote, FR_TYPE_STRING, xlat_func_urlunquote_arg);
5195 XLAT_NEW("url.unquote");
5196
5197 XLAT_REGISTER_PURE("eval", xlat_func_eval, FR_TYPE_VOID, xlat_func_eval_arg);
5198
5199 if (xlat_profiling_init() < 0) return -1;
5200
5201 return xlat_register_expressions();
5202}
5203
5204int xlat_global_init(void)
5205{
5206 int ret;
5207 fr_atexit_global_once_ret(&ret, _xlat_global_init, _xlat_global_free, NULL);
5208 return ret;
5209}
buffer
static int const char char buffer[256]
Definition acutest.h:641
file
int const char * file
Definition acutest.h:855
args
va_list args
Definition acutest.h:923
fmt
static int const char * fmt
Definition acutest.h:638
fr_base16_encode
#define fr_base16_encode(_out, _in)
Definition base16.h:71
fr_base16_decode
#define fr_base16_decode(_err, _out, _in, _no_trailing)
Definition base16.h:109
fr_base64_encode
#define fr_base64_encode(_out, _in, _add_padding)
Definition base64.h:71
fr_base64_decode
#define fr_base64_decode(_out, _in, _expect_padding, _no_trailing)
Definition base64.h:78
FR_BASE64_DEC_LENGTH
#define FR_BASE64_DEC_LENGTH(_inlen)
Definition base64.h:41
FR_BASE64_ENC_LENGTH
#define FR_BASE64_ENC_LENGTH(_inlen)
Encode/decode binary data using printable characters (base64 format)
Definition base64.h:40
stop
static bool stop
Definition radmin.c:68
request
static uint8_t request[4]
Definition bio_dedup_tests.c:34
UNCONST
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:203
RCSID
#define RCSID(id)
Definition build.h:603
DIAG_OFF_OPTIONAL
#define DIAG_OFF_OPTIONAL(_x)
Definition build.h:577
L
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:245
unlikely
#define unlikely(_x)
Definition build.h:486
UNUSED
#define UNUSED
Definition build.h:415
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:437
cf_section
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:106
dict
fr_dict_t * dict
Definition common.c:31
root_da
fr_dict_attr_t const * root_da
Definition common.c:32
fr_dbuff_used
#define fr_dbuff_used(_dbuff_or_marker)
Return the number of bytes remaining between the start of the dbuff or marker and the current positio...
Definition dbuff.h:819
fr_dbuff_start
#define fr_dbuff_start(_dbuff_or_marker)
Return the 'start' position of a dbuff or marker.
Definition dbuff.h:950
FR_DBUFF_TALLOC_THREAD_LOCAL
#define FR_DBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
Create a function local and thread local extensible dbuff.
Definition dbuff.h:598
FR_DBUFF_TMP
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
Definition dbuff.h:556
fr_dcursor_next
static void * fr_dcursor_next(fr_dcursor_t *cursor)
Advanced the cursor to the next item.
Definition dcursor.h:288
fr_dcursor_append
static int fr_dcursor_append(fr_dcursor_t *cursor, void *v)
Insert a single item at the end of the list.
Definition dcursor.h:406
fr_dcursor_current
static void * fr_dcursor_current(fr_dcursor_t *cursor)
Return the item the cursor current points to.
Definition dcursor.h:337
fr_dcursor_head
static void * fr_dcursor_head(fr_dcursor_t *cursor)
Rewind cursor to the start of the list.
Definition dcursor.h:232
fr_dcursor_list
#define fr_dcursor_list(_cursor)
Definition dcursor.h:812
fr_dcursor_s
Definition dcursor.h:91
MEM
#define MEM(x)
Definition debug.h:38
fr_dict_global_ctx_iter_next
fr_dict_t * fr_dict_global_ctx_iter_next(fr_dict_global_ctx_iter_t *iter)
Definition dict_util.c:5029
fr_dict_vendor_t::name
char const * name
Vendor name.
Definition dict.h:298
fr_dict_attr_common_parent
fr_dict_attr_t const * fr_dict_attr_common_parent(fr_dict_attr_t const *a, fr_dict_attr_t const *b, bool is_ancestor)
Find a common ancestor that two TLV type attributes share.
Definition dict_util.c:2365
fr_dict_compatible
bool fr_dict_compatible(fr_dict_t const *dict1, fr_dict_t const *dict2)
See if two dictionaries have the same end parent.
Definition dict_util.c:2948
fr_dict_global_ctx_iter_init
fr_dict_t * fr_dict_global_ctx_iter_init(fr_dict_global_ctx_iter_t *iter)
Iterate protocols by name.
Definition dict_util.c:5022
fr_dict_root
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2717
fr_dict_dl
dl_t * fr_dict_dl(fr_dict_t const *dict)
Definition dict_util.c:2727
fr_dict_vendor_t::pen
uint32_t pen
Private enterprise number.
Definition dict.h:294
fr_dict_internal
fr_dict_t const * fr_dict_internal(void)
Definition dict_util.c:5065
fr_dict_vendor_by_da
fr_dict_vendor_t const * fr_dict_vendor_by_da(fr_dict_attr_t const *da)
Look up a vendor by one of its child attributes.
Definition dict_util.c:2964
fr_dict_vendor_t
Private enterprise.
Definition dict.h:293
value
Test enumeration values.
Definition dict_test.h:92
dl_loader_init
dl_loader_t * dl_loader_init(TALLOC_CTX *ctx, void *uctx, bool uctx_free, bool defer_symbol_init)
Initialise structures needed by the dynamic linker.
Definition dl.c:907
dl_by_name
dl_t * dl_by_name(dl_loader_t *dl_loader, char const *name, void *uctx, bool uctx_free)
Search for a dl's shared object in various locations.
Definition dl.c:470
dl_loader_s
A dynamic loader.
Definition dl.c:81
dl_s::handle
void * handle
Handle returned by dlopen.
Definition dl.h:61
dl_s
Module handle.
Definition dl.h:57
fr_dlist_head
static void * fr_dlist_head(fr_dlist_head_t const *list_head)
Return the HEAD item of a list or NULL if the list is empty.
Definition dlist.h:468
fr_dlist_num_elements
static unsigned int fr_dlist_num_elements(fr_dlist_head_t const *head)
Return the number of elements in the dlist.
Definition dlist.h:921
fr_dlist_next
static void * fr_dlist_next(fr_dlist_head_t const *list_head, void const *ptr)
Get the next item in a list.
Definition dlist.h:537
xlat_func_time_now
static xlat_action_t xlat_func_time_now(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
Return the current time as a FR_TYPE_DATE.
Definition xlat_builtin.c:4168
xlat_func_next_time
static xlat_action_t xlat_func_next_time(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Calculate number of seconds until the next n hour(s), day(s), week(s), year(s).
Definition xlat_builtin.c:1638
xlat_func_unsafe
static xlat_action_t xlat_func_unsafe(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Mark every argument as safe for nothing.
Definition xlat_builtin.c:977
xlat_func_lpad
static xlat_action_t xlat_func_lpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
lpad a string
Definition xlat_builtin.c:1846
xlat_func_bin
static xlat_action_t xlat_func_bin(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Convert hex string to binary.
Definition xlat_builtin.c:2132
xlat_func_pairs_debug
static xlat_action_t xlat_func_pairs_debug(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Print out attribute info.
Definition xlat_builtin.c:291
xlat_func_subst
static xlat_action_t xlat_func_subst(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Perform regex substitution.
Definition xlat_builtin.c:3888
xlat_func_urlunquote
static xlat_action_t xlat_func_urlunquote(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
URLdecode special characters.
Definition xlat_builtin.c:4421
xlat_pair_decode
static xlat_action_t xlat_pair_decode(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Decode any protocol attribute / options.
Definition xlat_builtin.c:4502
xlat_func_base64_decode
static xlat_action_t xlat_func_base64_decode(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Decode base64 string.
Definition xlat_builtin.c:2073
xlat_func_hmac_md5
static xlat_action_t xlat_func_hmac_md5(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Generate the HMAC-MD5 of a string or attribute.
Definition xlat_builtin.c:2504
xlat_func_base64_encode
static xlat_action_t xlat_func_base64_encode(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Encode string or attribute as base64.
Definition xlat_builtin.c:2025
xlat_func_log_info
static xlat_action_t xlat_func_log_info(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Log something at INFO level.
Definition xlat_builtin.c:1270
xlat_func_log_warn
static xlat_action_t xlat_func_log_warn(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Log something at WARN level.
Definition xlat_builtin.c:1345
xlat_func_map
static xlat_action_t xlat_func_map(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Processes fmt as a map string and applies it to the current request.
Definition xlat_builtin.c:1472
xlat_func_debug
static xlat_action_t xlat_func_debug(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Dynamically change the debugging level for the current request.
Definition xlat_builtin.c:100
xlat_func_log_debug
static xlat_action_t xlat_func_log_debug(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Log something at DEBUG level.
Definition xlat_builtin.c:1295
xlat_func_log_dst
static xlat_action_t xlat_func_log_dst(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Change the log destination to the named one.
Definition xlat_builtin.c:1382
xlat_func_string_arg
static xlat_arg_parser_t const xlat_func_string_arg[]
Calculate any digest supported by OpenSSL EVP_MD.
Definition xlat_builtin.c:3468
xlat_func_module_call
static xlat_action_t xlat_func_module_call(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Calls a named virtual module.
Definition xlat_builtin.c:1577
xlat_func_block
static xlat_action_t xlat_func_block(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Block for the specified duration.
Definition xlat_builtin.c:2203
xlat_func_concat
static xlat_action_t xlat_func_concat(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Concatenate string representation of values of given attributes using separator.
Definition xlat_builtin.c:2377
xlat_func_urlquote
static xlat_action_t xlat_func_urlquote(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
URLencode special characters.
Definition xlat_builtin.c:4336
xlat_func_rpad
static xlat_action_t xlat_func_rpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Right pad a string.
Definition xlat_builtin.c:1942
xlat_func_md4
static xlat_action_t xlat_func_md4(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Calculate the MD4 hash of a string or attribute.
Definition xlat_builtin.c:2634
xlat_func_explode
static xlat_action_t xlat_func_explode(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Split a string into multiple new strings based on a delimiter.
Definition xlat_builtin.c:1021
xlat_func_pairs_print
static xlat_action_t xlat_func_pairs_print(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Encode attributes as a series of string attribute/value pairs.
Definition xlat_builtin.c:2715
xlat_func_time_request
static xlat_action_t xlat_func_time_request(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, UNUSED fr_value_box_list_t *args)
Return the request receive time as a FR_TYPE_DATE.
Definition xlat_builtin.c:4199
xlat_func_regex
static xlat_action_t xlat_func_regex(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Get named subcapture value from previous regex.
Definition xlat_builtin.c:3261
xlat_func_substr
static xlat_action_t xlat_func_substr(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Extract a substring from string / octets data.
Definition xlat_builtin.c:3629
xlat_func_length
static xlat_action_t xlat_func_length(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Return the on-the-wire size of the boxes in bytes.
Definition xlat_builtin.c:2603
xlat_func_immutable_attr
static xlat_action_t xlat_func_immutable_attr(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Mark one or more attributes as immutable.
Definition xlat_builtin.c:1102
xlat_func_rand
static xlat_action_t xlat_func_rand(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Generate a random integer value.
Definition xlat_builtin.c:2765
xlat_pair_encode
static xlat_action_t xlat_pair_encode(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Encode protocol attributes / options.
Definition xlat_builtin.c:4664
xlat_func_log_err
static xlat_action_t xlat_func_log_err(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Log something at ERROR level.
Definition xlat_builtin.c:1320
xlat_func_hmac_sha1
static xlat_action_t xlat_func_hmac_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Generate the HMAC-SHA1 of a string or attribute.
Definition xlat_builtin.c:2522
xlat_func_eval
static xlat_action_t xlat_func_eval(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Dynamically evaluate an expansion string.
Definition xlat_builtin.c:1748
xlat_func_time_is_dst
static xlat_action_t xlat_func_time_is_dst(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
Return whether we are in daylight savings or not.
Definition xlat_builtin.c:4237
xlat_func_integer
static xlat_action_t xlat_func_integer(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Print data as integer, not as VALUE.
Definition xlat_builtin.c:1143
xlat_func_time
static xlat_action_t xlat_func_time(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Return the time as a FR_TYPE_DATE.
Definition xlat_builtin.c:4070
xlat_func_toupper
static xlat_action_t xlat_func_toupper(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Convert a string to uppercase.
Definition xlat_builtin.c:4314
xlat_func_uuid_v7
static xlat_action_t xlat_func_uuid_v7(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
Generate a version 7 UUID.
Definition xlat_builtin.c:3100
xlat_func_uuid_v4
static xlat_action_t xlat_func_uuid_v4(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
Generate a version 4 UUID.
Definition xlat_builtin.c:3060
xlat_func_hex
static xlat_action_t xlat_func_hex(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Print data as hex, not as VALUE.
Definition xlat_builtin.c:2426
xlat_func_md5
static xlat_action_t xlat_func_md5(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Calculate the MD5 hash of a string or attribute.
Definition xlat_builtin.c:2674
xlat_func_subnet_netmask
static xlat_action_t xlat_func_subnet_netmask(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Calculate the subnet mask from a IPv4 prefix.
Definition xlat_builtin.c:4582
xlat_func_sha1
static xlat_action_t xlat_func_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Calculate the SHA1 hash of a string or attribute.
Definition xlat_builtin.c:3368
xlat_func_str_printable
static xlat_action_t xlat_func_str_printable(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Return whether a string has only printable chars.
Definition xlat_builtin.c:3532
xlat_func_range
static xlat_action_t xlat_func_range(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Generate a range of uint64 numbers.
Definition xlat_builtin.c:3153
xlat_func_cast
xlat_action_t xlat_func_cast(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Cast one or more output value-boxes to the given type.
Definition xlat_builtin.c:2243
xlat_func_randstr
static xlat_action_t xlat_func_randstr(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Generate a string of random chars.
Definition xlat_builtin.c:2820
xlat_func_tolower
static xlat_action_t xlat_func_tolower(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Convert a string to lowercase.
Definition xlat_builtin.c:4295
xlat_func_subnet_broadcast
static xlat_action_t xlat_func_subnet_broadcast(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Calculate the broadcast address from a IPv4 prefix.
Definition xlat_builtin.c:4618
xlat_func_str_utf8
static xlat_action_t xlat_func_str_utf8(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Return whether a string is valid UTF-8.
Definition xlat_builtin.c:3588
xlat_func_time_offset
static xlat_action_t xlat_func_time_offset(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *args)
Return the current time offset from gmt.
Definition xlat_builtin.c:4218
xlat_func_strlen
static xlat_action_t xlat_func_strlen(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Print length of given string.
Definition xlat_builtin.c:3489
fr_hash_iter_s
Stores the state of the current iteration operation.
Definition hash.h:41
talloc_free
talloc_free(hp)
fr_hmac_md5
int fr_hmac_md5(uint8_t digest[MD5_DIGEST_LENGTH], uint8_t const *in, size_t inlen, uint8_t const *key, size_t key_len)
Calculate HMAC using internal MD5 implementation.
Definition hmac_md5.c:119
fr_hmac_sha1
int fr_hmac_sha1(uint8_t digest[static SHA1_DIGEST_LENGTH], uint8_t const *in, size_t inlen, uint8_t const *key, size_t key_len)
Calculate HMAC using internal SHA1 implementation.
Definition hmac_sha1.c:123
unlang_interpret_frame_talloc_ctx
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:2053
unlang_interpret_push_section
int unlang_interpret_push_section(unlang_result_t *p_result, request_t *request, CONF_SECTION *cs, unlang_frame_conf_t const *conf)
Push a configuration section onto the request stack for later interpretation.
Definition interpret.c:1535
unlang_interpret_event_list
fr_event_list_t * unlang_interpret_event_list(request_t *request)
Get the event list for the current interpreter.
Definition interpret.c:2538
FRAME_CONF
#define FRAME_CONF(_default_rcode, _top_frame)
Definition interpret.h:158
UNLANG_SUB_FRAME
#define UNLANG_SUB_FRAME
Definition interpret.h:37
unlang_result_t
Definition interpret.h:139
log_dst_by_name
fr_log_t * log_dst_by_name(char const *name)
Get a logging destination by name.
Definition log.c:1132
PERROR
#define PERROR(_fmt,...)
Definition log.h:233
REXDENT
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:460
RWDEBUG
#define RWDEBUG(fmt,...)
Definition log.h:378
RDEBUG_ENABLED3
#define RDEBUG_ENABLED3
True if request debug level 1-3 messages are enabled.
Definition log.h:352
REDEBUG3
#define REDEBUG3(fmt,...)
Definition log.h:390
RERROR
#define RERROR(fmt,...)
Definition log.h:315
RPERROR
#define RPERROR(fmt,...)
Definition log.h:319
REMARKER
#define REMARKER(_str, _marker_idx, _marker,...)
Output string with error marker, showing where format error occurred.
Definition log.h:515
RINFO
#define RINFO(fmt,...)
Definition log.h:313
RMARKER
#define RMARKER(_type, _lvl, _str, _marker_idx, _marker,...)
Output string with error marker, showing where format error occurred.
Definition log.h:486
RPEDEBUG
#define RPEDEBUG(fmt,...)
Definition log.h:393
RDEBUG4
#define RDEBUG4(fmt,...)
Definition log.h:361
RDEBUG_ENABLED4
#define RDEBUG_ENABLED4
True if request debug level 1-4 messages are enabled.
Definition log.h:353
RIDEBUG2
#define RIDEBUG2(fmt,...)
Definition log.h:369
REDEBUG2
#define REDEBUG2(fmt,...)
Definition log.h:389
RIDEBUG3
#define RIDEBUG3(fmt,...)
Definition log.h:370
RINDENT
#define RINDENT()
Indent R* messages by one level.
Definition log.h:447
map_to_vp
int map_to_vp(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, map_t const *map, UNUSED void *uctx)
Convert a map to a fr_pair_t.
Definition map.c:1566
map_to_request
int map_to_request(request_t *request, map_t const *map, radius_map_getvalue_t func, void *ctx)
Convert map_t to fr_pair_t (s) and add them to a request_t.
Definition map.c:1846
map_afrom_attr_str
int map_afrom_attr_str(TALLOC_CTX *ctx, map_t **out, char const *vp_str, tmpl_rules_t const *lhs_rules, tmpl_rules_t const *rhs_rules)
Convert a value pair string to valuepair map.
Definition map.c:1465
fr_time
#define fr_time()
Definition event.c:58
fr_mkdir
ssize_t fr_mkdir(int *fd_out, char const *path, ssize_t len, mode_t mode, fr_mkdir_func_t func, void *uctx)
Create directories that are missing in the specified path.
Definition file.c:218
fr_filename_ok
bool fr_filename_ok(char const *filename, char const *end, bool allow_dir)
See if a filename is OK.
Definition file.c:1028
fr_filename_escape
const fr_sbuff_escape_rules_t fr_filename_escape
Definition file.c:927
fr_filename_escape_dots
const fr_sbuff_escape_rules_t fr_filename_escape_dots
Definition file.c:943
fr_filename_allowed_by_list
bool fr_filename_allowed_by_list(char const *filename, char const *end, char const *const *array)
See if a filename is allowed by a list.
Definition file.c:1131
L_DBG_LVL_DISABLE
@ L_DBG_LVL_DISABLE
Don't print messages.
Definition log.h:65
L_DBG_LVL_2
@ L_DBG_LVL_2
2nd highest priority debug messages (-xx | -X).
Definition log.h:68
L_DBG_LVL_MAX
@ L_DBG_LVL_MAX
Lowest priority debug messages (-xxxxx | -Xxxx).
Definition log.h:71
L_DST_NULL
@ L_DST_NULL
Discard log messages.
Definition log.h:80
L_DST_FILES
@ L_DST_FILES
Log to a file on disk.
Definition log.h:76
L_WARN
@ L_WARN
Warning.
Definition log.h:54
main_config
main_config_t const * main_config
Main server configuration.
Definition main_config.c:56
main_config_s::limit
main_config_limit_t limit
limit files, exec, etc.
Definition main_config.h:113
main_config_limit_t::files_is_set
bool files_is_set
if we have a limit { files { ... } } section.
Definition main_config.h:48
main_config_limit_t::readonly_files
char const ** readonly_files
where file....() is limited to for read
Definition main_config.h:51
main_config_limit_t::allowed_files
char const ** allowed_files
where file....() is limited to for read / write
Definition main_config.h:50
fr_md4_calc
void fr_md4_calc(uint8_t out[static MD4_DIGEST_LENGTH], uint8_t const *in, size_t inlen)
Calculate the MD4 hash of the contents of a buffer.
Definition md4.c:473
MD4_DIGEST_LENGTH
#define MD4_DIGEST_LENGTH
Definition md4.h:22
MD5_DIGEST_LENGTH
#define MD5_DIGEST_LENGTH
Definition merged_model.c:285
uint16_t
unsigned short uint16_t
Definition merged_model.c:25
fr_type_t
fr_type_t
Definition merged_model.c:117
FR_TYPE_TIME_DELTA
@ FR_TYPE_TIME_DELTA
A period of time measured in nanoseconds.
Definition merged_model.c:150
FR_TYPE_FLOAT32
@ FR_TYPE_FLOAT32
Single precision floating point.
Definition merged_model.c:145
FR_TYPE_IPV4_ADDR
@ FR_TYPE_IPV4_ADDR
32 Bit IPv4 Address.
Definition merged_model.c:123
FR_TYPE_INT8
@ FR_TYPE_INT8
8 Bit signed integer.
Definition merged_model.c:140
FR_TYPE_ETHERNET
@ FR_TYPE_ETHERNET
48 Bit Mac-Address.
Definition merged_model.c:130
FR_TYPE_IPV6_PREFIX
@ FR_TYPE_IPV6_PREFIX
IPv6 Prefix.
Definition merged_model.c:126
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:120
FR_TYPE_NULL
@ FR_TYPE_NULL
Invalid (uninitialised) attribute type.
Definition merged_model.c:118
FR_TYPE_UINT16
@ FR_TYPE_UINT16
16 Bit unsigned integer.
Definition merged_model.c:135
FR_TYPE_INT64
@ FR_TYPE_INT64
64 Bit signed integer.
Definition merged_model.c:143
FR_TYPE_INT16
@ FR_TYPE_INT16
16 Bit signed integer.
Definition merged_model.c:141
FR_TYPE_DATE
@ FR_TYPE_DATE
Unix time stamp, always has value >2^31.
Definition merged_model.c:148
FR_TYPE_COMBO_IP_PREFIX
@ FR_TYPE_COMBO_IP_PREFIX
IPv4 or IPv6 address prefix depending on length.
Definition merged_model.c:129
FR_TYPE_UINT8
@ FR_TYPE_UINT8
8 Bit unsigned integer.
Definition merged_model.c:134
FR_TYPE_UINT32
@ FR_TYPE_UINT32
32 Bit unsigned integer.
Definition merged_model.c:136
FR_TYPE_INT32
@ FR_TYPE_INT32
32 Bit signed integer.
Definition merged_model.c:142
FR_TYPE_UINT64
@ FR_TYPE_UINT64
64 Bit unsigned integer.
Definition merged_model.c:137
FR_TYPE_IPV6_ADDR
@ FR_TYPE_IPV6_ADDR
128 Bit IPv6 Address.
Definition merged_model.c:125
FR_TYPE_IPV4_PREFIX
@ FR_TYPE_IPV4_PREFIX
IPv4 Prefix.
Definition merged_model.c:124
FR_TYPE_VOID
@ FR_TYPE_VOID
User data.
Definition merged_model.c:164
FR_TYPE_BOOL
@ FR_TYPE_BOOL
A truth value.
Definition merged_model.c:132
FR_TYPE_SIZE
@ FR_TYPE_SIZE
Unsigned integer capable of representing any memory address on the local system.
Definition merged_model.c:152
FR_TYPE_COMBO_IP_ADDR
@ FR_TYPE_COMBO_IP_ADDR
IPv4 or IPv6 address depending on length.
Definition merged_model.c:128
FR_TYPE_IFID
@ FR_TYPE_IFID
Interface ID.
Definition merged_model.c:127
FR_TYPE_OCTETS
@ FR_TYPE_OCTETS
Raw octets.
Definition merged_model.c:121
FR_TYPE_GROUP
@ FR_TYPE_GROUP
A grouping of other attributes.
Definition merged_model.c:161
FR_TYPE_FLOAT64
@ FR_TYPE_FLOAT64
Double precision floating point.
Definition merged_model.c:146
uint32_t
unsigned int uint32_t
Definition merged_model.c:27
ssize_t
long int ssize_t
Definition merged_model.c:21
fr_md5_calc
void fr_md5_calc(uint8_t out[static MD5_DIGEST_LENGTH], uint8_t const *in, size_t inlen)
Perform a single digest operation on a single input buffer.
Definition merged_model.c:288
fr_sbuff_err_t
fr_sbuff_err_t
Definition merged_model.c:75
uint8_t
unsigned char uint8_t
Definition merged_model.c:24
fr_slen_t
ssize_t fr_slen_t
Definition merged_model.c:29
size_t
unsigned long int size_t
Definition merged_model.c:22
fr_dbuff_t
Definition merged_model.c:56
fr_dict_attr_t
Definition merged_model.c:170
fr_dict_t
Definition merged_model.c:241
fr_sbuff_t
Definition merged_model.c:37
fr_value_box_t
Definition merged_model.c:173
request_t
Definition merged_model.c:253
fr_snprint_uint128
size_t fr_snprint_uint128(char *out, size_t outlen, uint128_t const num)
Write 128bit unsigned integer to buffer.
Definition misc.c:401
gmtime_r
struct tm * gmtime_r(time_t const *l_clock, struct tm *result)
Definition missing.c:205
localtime_r
struct tm * localtime_r(time_t const *l_clock, struct tm *result)
Definition missing.c:162
module_rlm_virtual_by_name
CONF_SECTION * module_rlm_virtual_by_name(char const *asked_name)
Definition module_rlm.c:796
fr_pair_list_parent
fr_pair_t * fr_pair_list_parent(fr_pair_list_t const *list)
Return a pointer to the parent pair which contains this list.
Definition pair.c:928
fr_pair_update_by_da_parent
int fr_pair_update_by_da_parent(fr_pair_t *parent, fr_pair_t **out, fr_dict_attr_t const *da)
Return the first fr_pair_t matching the fr_dict_attr_t or alloc a new fr_pair_t and its subtree (and ...
Definition pair.c:1547
fr_pair_delete
int fr_pair_delete(fr_pair_list_t *list, fr_pair_t *vp)
Remove fr_pair_t from a list and free.
Definition pair.c:1778
fr_utf8_str
fr_slen_t fr_utf8_str(uint8_t const *str, ssize_t inlen)
Validate a complete UTF8 string.
Definition print.c:153
fr_utf8_char
size_t fr_utf8_char(uint8_t const *str, ssize_t inlen)
Checks for utf-8, taken from http://www.w3.org/International/questions/qa-forms-utf-8.
Definition print.c:39
encode_ctx
static fr_internal_encode_ctx_t encode_ctx
Definition proto_ldap_sync.c:34
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:37
REDEBUG
#define REDEBUG(fmt,...)
Definition radclient-ng.h:52
RDEBUG_ENABLED2
#define RDEBUG_ENABLED2()
Definition radclient-ng.h:50
RDEBUG2
#define RDEBUG2(fmt,...)
Definition radclient-ng.h:54
RDEBUG
#define RDEBUG(fmt,...)
Definition radclient-ng.h:53
done
static bool done
Definition radclient.c:80
fill
#define fill(_expr)
fr_rand
uint32_t fr_rand(void)
Return a 32-bit random number.
Definition rand.c:128
RLM_MODULE_NOOP
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:54
request_attr_request
fr_dict_attr_t const * request_attr_request
Definition request.c:43
request_log_prepend
void request_log_prepend(request_t *request, fr_log_t *log_dst, fr_log_lvl_t lvl)
Prepend another logging destination to the list.
Definition request.c:92
RAD_REQUEST_LVL_NONE
#define RAD_REQUEST_LVL_NONE
No debug messages should be printed.
Definition request.h:313
name
static char const * name
Definition rlm_redis_ippool_tool.c:140
fr_sbuff_adv_to_str
char * fr_sbuff_adv_to_str(fr_sbuff_t *sbuff, size_t len, char const *needle, size_t needle_len)
Wind position to the first instance of the specified needle.
Definition sbuff.c:2151
fr_sbuff_adv_to_chr
char * fr_sbuff_adv_to_chr(fr_sbuff_t *sbuff, size_t len, char c)
Wind position to first instance of specified char.
Definition sbuff.c:2115
fr_sbuff_in_bstrncpy
ssize_t fr_sbuff_in_bstrncpy(fr_sbuff_t *sbuff, char const *str, size_t len)
Copy bytes into the sbuff up to the first \0.
Definition sbuff.c:1553
fr_sbuff_in_sprintf
ssize_t fr_sbuff_in_sprintf(fr_sbuff_t *sbuff, char const *fmt,...)
Print using a fmt string to an sbuff.
Definition sbuff.c:1680
fr_sbuff_next_if_char
bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c)
Return true if the current char matches, and if it does, advance.
Definition sbuff.c:2247
fr_sbuff_start
#define fr_sbuff_start(_sbuff_or_marker)
fr_sbuff_set
#define fr_sbuff_set(_dst, _src)
FR_SBUFF_IN
#define FR_SBUFF_IN(_start, _len_or_end)
fr_sbuff_adv_past_whitespace
#define fr_sbuff_adv_past_whitespace(_sbuff, _len, _tt)
fr_sbuff_current
#define fr_sbuff_current(_sbuff_or_marker)
fr_sbuff_unescape_rules_t::name
char const * name
Name for rule set to aid we debugging.
Definition sbuff.h:210
FR_SBUFF
#define FR_SBUFF(_sbuff_or_marker)
fr_sbuff_advance
#define fr_sbuff_advance(_sbuff_or_marker, _len)
fr_sbuff_init_in
#define fr_sbuff_init_in(_out, _start, _len_or_end)
fr_sbuff_remaining
#define fr_sbuff_remaining(_sbuff_or_marker)
fr_sbuff_len
#define fr_sbuff_len(_sbuff_or_marker)
FR_SBUFF_OUT
#define FR_SBUFF_OUT(_start, _len_or_end)
fr_sbuff_move
#define fr_sbuff_move(_out, _in, _len)
fr_sbuff_used
#define fr_sbuff_used(_sbuff_or_marker)
fr_sbuff_behind
#define fr_sbuff_behind(_sbuff_or_marker)
fr_sbuff_ahead
#define fr_sbuff_ahead(_sbuff_or_marker)
FR_SBUFF_TALLOC_THREAD_LOCAL
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
fr_sbuff_ptr_s
Definition sbuff.h:83
fr_sbuff_unescape_rules_t
Set of parsing rules for *unescape_until functions.
Definition merged_model.c:202
tmpl_type_to_str
static char const * tmpl_type_to_str(tmpl_type_t type)
Return a static string containing the type name.
Definition tmpl.h:661
tmpl_rules_s::attr
tmpl_attr_rules_t attr
Rules/data for parsing attribute references.
Definition tmpl.h:346
TMPL_TYPE_ATTR
@ TMPL_TYPE_ATTR
Reference to one or more attributes.
Definition tmpl.h:149
TMPL_TYPE_XLAT
@ TMPL_TYPE_XLAT
Pre-parsed xlat expansion.
Definition tmpl.h:153
TMPL_TYPE_EXEC
@ TMPL_TYPE_EXEC
Callout to an external script or program.
Definition tmpl.h:157
TMPL_TYPE_REGEX_XLAT_UNRESOLVED
@ TMPL_TYPE_REGEX_XLAT_UNRESOLVED
A regular expression with unresolved xlat functions or attribute references.
Definition tmpl.h:204
TMPL_TYPE_DATA
@ TMPL_TYPE_DATA
Value in native boxed format.
Definition tmpl.h:145
TMPL_TYPE_DATA_UNRESOLVED
@ TMPL_TYPE_DATA_UNRESOLVED
Unparsed literal string.
Definition tmpl.h:186
tmpl_rules_s
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:343
fr_sha1_init
void fr_sha1_init(fr_sha1_ctx *context)
Definition sha1.c:93
fr_sha1_final
void fr_sha1_final(uint8_t digest[static SHA1_DIGEST_LENGTH], fr_sha1_ctx *context)
Definition sha1.c:141
fr_sha1_update
void fr_sha1_update(fr_sha1_ctx *context, uint8_t const *in, size_t len)
Definition sha1.c:105
SHA1_DIGEST_LENGTH
#define SHA1_DIGEST_LENGTH
Definition sha1.h:29
fr_sha1_ctx
Definition sha1.h:33
FR_SIGNAL_NONE
@ FR_SIGNAL_NONE
No signals.
Definition signal.h:39
buff
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:37
snprintf
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
strings
PRIVATE void strings()
inst
eap_aka_sim_process_conf_t * inst
Definition state_machine.c:3670
type
fr_aka_sim_id_type_t type
Definition state_machine.c:3673
vp
fr_pair_t * vp
Definition state_machine.c:2287
strlcpy
size_t strlcpy(char *dst, char const *src, size_t siz)
Definition strlcpy.c:34
fr_log_s
Definition log.h:93
fr_log_s::parent
fr_log_t * parent
Log destination this was cloned from.
Definition log.h:118
fr_log_s::dst
fr_log_dst_t dst
Log destination.
Definition log.h:94
fr_log_s::fd
int fd
File descriptor to write messages to.
Definition log.h:109
fr_log_s::file
char const * file
Path to log file.
Definition log.h:110
map_s
Value pair map.
Definition map.h:77
map_s::lhs
tmpl_t * lhs
Typically describes the attribute to add, modify or compare.
Definition map.h:78
map_s::rhs
tmpl_t * rhs
Typically describes a literal value or a src attribute to copy or compare.
Definition map.h:79
pair_list_s
Definition pair.h:52
tmpl_attr_rules_s::dict_def
fr_dict_t const * dict_def
Default dictionary to use with unqualified attribute references.
Definition tmpl.h:280
value_pair_s
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
value_pair_s::da
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
fr_syserror
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
fr_table_value_by_str
#define fr_table_value_by_str(_table, _name, _def)
Convert a string to a value using a sorted or ordered table.
Definition table.h:685
fr_table_value_by_substr
#define fr_table_value_by_substr(_table, _name, _name_len, _def)
Convert a partial string to a value using an ordered or sorted table.
Definition table.h:725
fr_table_num_ordered_t
An element in an arbitrarily ordered array of name to num mappings.
Definition table.h:57
fr_table_num_sorted_t
An element in a lexicographically sorted array of name to num mappings.
Definition table.h:49
talloc_bstrndup
char * talloc_bstrndup(TALLOC_CTX *ctx, char const *in, size_t inlen)
Binary safe strndup function.
Definition talloc.c:693
talloc_bstr_append
char * talloc_bstr_append(TALLOC_CTX *ctx, char *to, char const *from, size_t from_len)
Append a bstr to a bstr.
Definition talloc.c:721
talloc_get_type_abort_const
#define talloc_get_type_abort_const
Definition talloc.h:117
talloc_strdup
#define talloc_strdup(_ctx, _str)
Definition talloc.h:149
talloc_strlen
static size_t talloc_strlen(char const *s)
Returns the length of a talloc array containing a string.
Definition talloc.h:143
fr_test_point_pair_decode_t::test_ctx
fr_test_point_ctx_alloc_t test_ctx
Allocate a test ctx for the encoder.
Definition test_point.h:86
fr_test_point_pair_encode_t::test_ctx
fr_test_point_ctx_alloc_t test_ctx
Allocate a test ctx for the encoder.
Definition test_point.h:94
fr_test_point_pair_decode_t::func
fr_pair_decode_t func
Decoder for pairs.
Definition test_point.h:87
fr_test_point_pair_encode_t::func
fr_pair_encode_t func
Encoder for pairs.
Definition test_point.h:95
fr_test_point_pair_decode_t
Entry point for pair decoders.
Definition test_point.h:85
fr_test_point_pair_encode_t
Entry point for pair encoders.
Definition test_point.h:93
fr_time_is_dst
bool fr_time_is_dst(void)
Whether or not we're daylight savings.
Definition time.c:1248
fr_unix_time_from_str
int fr_unix_time_from_str(fr_unix_time_t *date, char const *date_str, fr_time_res_t hint)
Convert string in various formats to a fr_unix_time_t.
Definition time.c:828
fr_time_gmtoff
fr_time_delta_t fr_time_gmtoff(void)
Get the offset to gmt.
Definition time.c:1240
fr_time_delta_to_timespec
#define fr_time_delta_to_timespec(_delta)
Convert a delta to a timespec.
Definition time.h:684
fr_time_to_msec
static int64_t fr_time_to_msec(fr_time_t when)
Convert an fr_time_t (internal time) to number of msec since the unix epoch (wallclock time)
Definition time.h:729
fr_unix_time_to_sec
static int64_t fr_unix_time_to_sec(fr_unix_time_t delta)
Definition time.h:506
fr_time_delta_wrap
#define fr_time_delta_wrap(_time)
Definition time.h:152
FR_TIME_RES_SEC
@ FR_TIME_RES_SEC
Definition time.h:50
NSEC
#define NSEC
Definition time.h:379
fr_unix_time_unwrap
static uint64_t fr_unix_time_unwrap(fr_unix_time_t time)
Definition time.h:161
fr_time_delta_sub
static fr_time_delta_t fr_time_delta_sub(fr_time_delta_t a, fr_time_delta_t b)
Definition time.h:261
fr_time_to_unix_time
static fr_unix_time_t fr_time_to_unix_time(fr_time_t when)
Convert an fr_time_t (internal time) to our version of unix time (wallclock time)
Definition time.h:706
fr_time_delta_from_timespec
static fr_time_delta_t fr_time_delta_from_timespec(struct timespec const *ts)
Definition time.h:623
fr_unix_time_s
"Unix" time.
Definition time.h:95
fr_tokens
char const * fr_tokens[T_TOKEN_LAST]
Definition token.c:146
dl
static dl_t * dl
Definition unit_test_attribute.c:268
unlang_xlat_yield
xlat_action_t unlang_xlat_yield(request_t *request, xlat_func_t resume, xlat_func_signal_t signal, fr_signal_t sigmask, void *rctx)
Yield a request back to the interpreter from within a module.
Definition xlat.c:543
unlang_xlat_push
int unlang_xlat_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
Push a pre-compiled xlat onto the stack for evaluation.
Definition xlat.c:269
unlang_xlat_init
void unlang_xlat_init(void)
Register xlat operation with the interpreter.
Definition xlat.c:805
xlat_arg_parser_t::type
fr_type_t type
Type to cast argument to.
Definition xlat.h:145
xlat_is_literal
bool xlat_is_literal(xlat_exp_head_t const *head)
Check to see if the expansion consists entirely of value-box elements.
Definition xlat_tokenize.c:2097
XLAT_ARG_PARSER_CURSOR
#define XLAT_ARG_PARSER_CURSOR
Definition xlat.h:152
xlat_action_t
xlat_action_t
Definition xlat.h:37
XLAT_ACTION_FAIL
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
XLAT_ACTION_YIELD
@ XLAT_ACTION_YIELD
An xlat function pushed a resume frame onto the stack.
Definition xlat.h:42
XLAT_ACTION_PUSH_UNLANG
@ XLAT_ACTION_PUSH_UNLANG
An xlat function pushed an unlang frame onto the unlang stack.
Definition xlat.h:39
XLAT_ACTION_DONE
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
XLAT_ARG_VARIADIC_EMPTY_KEEP
@ XLAT_ARG_VARIADIC_EMPTY_KEEP
Empty argument groups are left alone, and either passed through as empty groups or null boxes.
Definition xlat.h:127
XLAT_ARG_VARIADIC_EMPTY_SQUASH
@ XLAT_ARG_VARIADIC_EMPTY_SQUASH
Empty argument groups are removed.
Definition xlat.h:126
xlat_arg_parser_t::concat
unsigned int concat
Concat boxes together.
Definition xlat.h:137
xlat_arg_parser_t::variadic
xlat_arg_parser_variadic_t variadic
All additional boxes should be processed using this definition.
Definition xlat.h:143
XLAT_RESULT_SUCCESS
#define XLAT_RESULT_SUCCESS(_p_result)
Definition xlat.h:492
XLAT_ARGS
#define XLAT_ARGS(_list,...)
Populate local variables with value boxes from the input list.
Definition xlat.h:373
xlat_arg_parser_t::required
unsigned int required
Argument must be present, and non-empty.
Definition xlat.h:136
xlat_arg_parser_t::single
unsigned int single
Argument must only contain a single box.
Definition xlat.h:138
xlat_resolve
int xlat_resolve(xlat_exp_head_t *head, xlat_res_rules_t const *xr_rules)
Walk over an xlat tree recursively, resolving any unresolved functions or references.
Definition xlat_tokenize.c:2168
XLAT_ARG_PARSER_TERMINATOR
#define XLAT_ARG_PARSER_TERMINATOR
Definition xlat.h:160
xlat_tokenize_expression
fr_slen_t xlat_tokenize_expression(TALLOC_CTX *ctx, xlat_exp_head_t **head, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Definition xlat_expr.c:3227
xlat_arg_parser_t
Definition for a single argument consumed by an xlat function.
Definition xlat.h:135
xlat_res_rules_t
Definition xlat.h:154
fr_pair_aprint
static fr_slen_t fr_pair_aprint(TALLOC_CTX *ctx, char **out, fr_dict_attr_t const *parent, fr_pair_t const *vp) 1(fr_pair_print
fr_pair_list_next
fr_pair_t * fr_pair_list_next(fr_pair_list_t const *list, fr_pair_t const *item))
Get the next item in a valuepair list after a specific entry.
Definition pair_inline.c:69
fr_pair_set_immutable
static void fr_pair_set_immutable(fr_pair_t *vp)
Definition pair.h:712
fr_pair_print_name
static fr_slen_t quote ssize_t fr_pair_print_name(fr_sbuff_t *out, fr_dict_attr_t const *parent, fr_pair_t const **vp_p)
Print an attribute name.
Definition pair_print.c:136
fr_pair_dcursor_init
#define fr_pair_dcursor_init(_cursor, _list)
Initialises a special dcursor with callbacks that will maintain the attr sublists correctly.
Definition pair.h:605
parent
static fr_slen_t parent
Definition pair.h:864
fr_strerror_clear
void fr_strerror_clear(void)
Clears all pending messages from the talloc pools.
Definition strerror.c:581
fr_strerror_printf
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
fr_type_table
fr_table_num_ordered_t const fr_type_table[]
Map data types to names representing those types.
Definition types.c:31
fr_type_table_len
size_t fr_type_table_len
Definition types.c:87
FR_TYPE_ATTR
@ FR_TYPE_ATTR
A contains an attribute reference.
Definition types.h:83
fr_type_is_structural
#define fr_type_is_structural(_x)
Definition types.h:392
FR_TYPE_NON_LEAF
#define FR_TYPE_NON_LEAF
Definition types.h:318
fr_type_is_string
#define fr_type_is_string(_x)
Definition types.h:348
fr_type_is_numeric
#define fr_type_is_numeric(_x)
Definition types.h:382
FR_TYPE_STRUCTURAL
#define FR_TYPE_STRUCTURAL
Definition types.h:316
fr_type_is_null
#define fr_type_is_null(_x)
Definition types.h:347
fr_type_is_leaf
#define fr_type_is_leaf(_x)
Definition types.h:393
fr_type_to_str
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:454
FR_TYPE_LEAF
#define FR_TYPE_LEAF
Definition types.h:317
FR_TYPE_NUMERIC
#define FR_TYPE_NUMERIC
Definition types.h:306
fr_value_box_network_length
size_t fr_value_box_network_length(fr_value_box_t const *value)
Get the size of the value held by the fr_value_box_t.
Definition value.c:1431
fr_value_box_mark_unsafe
void fr_value_box_mark_unsafe(fr_value_box_t *vb)
Mark a value-box as "unsafe".
Definition value.c:7528
fr_value_box_print
ssize_t fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
Print one boxed value to a string.
Definition value.c:6293
fr_value_box_mem_alloc
int fr_value_box_mem_alloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted)
Pre-allocate an octets buffer for filling by the caller.
Definition value.c:5161
fr_value_box_cast
int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src)
Convert one type of fr_value_box_t to another.
Definition value.c:4071
fr_value_box_list_aprint
char * fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules)
Concatenate the string representations of a list of value boxes together.
Definition value.c:7219
fr_value_box_mem_realloc
int fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len)
Change the length of a buffer already allocated to a value box.
Definition value.c:5194
fr_value_box_cast_in_place
int fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
Convert one type of fr_value_box_t to another in place.
Definition value.c:4326
fr_value_box_clear_value
void fr_value_box_clear_value(fr_value_box_t *data)
Clear/free any existing value.
Definition value.c:4461
fr_value_box_strdup
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated string to a fr_value_box_t.
Definition value.c:4763
fr_value_box_safety_set
void fr_value_box_safety_set(fr_value_box_t *box, fr_value_box_safety_t const *safety)
Replace the safety of a box.
Definition value.c:7627
fr_value_box_list_concat_as_string
ssize_t fr_value_box_list_concat_as_string(fr_value_box_safety_t *safety, fr_sbuff_t *sbuff, fr_value_box_list_t *list, char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules, fr_value_box_list_action_t proc_action, fr_value_box_safe_for_t safe_for, bool flatten)
Concatenate a list of value boxes together.
Definition value.c:6576
fr_value_box_safety_copy_changed
void fr_value_box_safety_copy_changed(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
Definition value.c:7571
fr_value_box_safety_merge
void fr_value_box_safety_merge(fr_value_box_t *out, fr_value_box_t const *in)
Merge safety results.
Definition value.c:7616
fr_value_box_strdup_shallow
void fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Assign a buffer containing a nul terminated string to a box, but don't copy it.
Definition value.c:4873
fr_value_box_safety_copy
void fr_value_box_safety_copy(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
Definition value.c:7558
fr_value_box_bstr_alloc
int fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted)
Alloc and assign an empty \0 terminated string to a fr_value_box_t.
Definition value.c:4940
fr_value_box_clear
void fr_value_box_clear(fr_value_box_t *data)
Clear/free any existing value and metadata.
Definition value.c:4509
fr_value_box_list_tainted
bool fr_value_box_list_tainted(fr_value_box_list_t const *head)
Check to see if any list members (or their children) are tainted.
Definition value.c:7385
fr_value_box_bstr_realloc
int fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len)
Change the length of a buffer already allocated to a value box.
Definition value.c:4973
fr_value_box_bstrndup
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Copy a string to to a fr_value_box_t.
Definition value.c:5014
fr_value_box_bstrdup_buffer_shallow
int fr_value_box_bstrdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Assign a talloced buffer containing a nul terminated string to a box, but don't copy it.
Definition value.c:5122
fr_value_box_memdup
int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Copy a buffer to a fr_value_box_t.
Definition value.c:5255
fr_value_box_list_concat_in_place
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:6793
FR_VALUE_BOX_LIST_FREE
@ FR_VALUE_BOX_LIST_FREE
Definition value.h:267
FR_VALUE_BOX_LIST_FREE_BOX
@ FR_VALUE_BOX_LIST_FREE_BOX
Free each processed box.
Definition value.h:264
fr_value_box_alloc
#define fr_value_box_alloc(_ctx, _type, _enumv)
Allocate a value box of a specific type.
Definition value.h:668
in
static fr_sbuff_err_t char size_t fr_sbuff_t * in
Definition value.h:1061
fr_value_box_safety_t::safe_for
fr_value_box_safe_for_t safe_for
A unique value to indicate if that value box is safe for consumption by a particular module for a par...
Definition value.h:187
data
static fr_slen_t data
Definition value.h:1366
fr_value_box_acopy
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:775
fr_value_box_is_safe_for
#define fr_value_box_is_safe_for(_box, _safe_for)
Definition value.h:1131
out
static fr_sbuff_err_t char ** out
Definition value.h:1061
fr_box_is_variable_size
#define fr_box_is_variable_size(_x)
Definition value.h:495
len
static fr_sbuff_err_t char size_t * len
Definition value.h:1061
fr_value_box_get_cursor
#define fr_value_box_get_cursor(_dst)
Definition value.h:1293
VALUE_BOX_VERIFY
#define VALUE_BOX_VERIFY(_x)
Definition value.h:1388
VALUE_BOX_LIST_VERIFY
#define VALUE_BOX_LIST_VERIFY(_x)
Definition value.h:1389
nonnull
int nonnull(2, 5))
fr_value_box_alloc_null
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:679
fr_value_box_list_foreach
#define fr_value_box_list_foreach(_list_head, _iter)
Definition value.h:253
fr_box_bool
#define fr_box_bool(_val)
Definition value.h:362
FR_VALUE_BOX_SAFE_FOR_ANY
#define FR_VALUE_BOX_SAFE_FOR_ANY
Definition value.h:178
fr_value_box_safety_t
The safety of a value.
Definition value.h:186
virtual_server_dict_by_cs
fr_dict_t const * virtual_server_dict_by_cs(CONF_SECTION const *cs)
Return the namespace for specified CONF_SECTION.
Definition virtual_servers.c:591
xlat_func_bin_arg
static xlat_arg_parser_t const xlat_func_bin_arg[]
Definition xlat_builtin.c:2116
xlat_protocol_register_cbor
static int xlat_protocol_register_cbor(void)
Definition xlat_builtin.c:4858
xlat_func_map_arg
static xlat_arg_parser_t const xlat_func_map_arg[]
Definition xlat_builtin.c:1455
xlat_func_file_tail
static xlat_action_t xlat_func_file_tail(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:607
XLAT_REGISTER_VOID
#define XLAT_REGISTER_VOID(_xlat, _func, _return_type)
xlat_func_log_dst_args
static xlat_arg_parser_t const xlat_func_log_dst_args[]
Definition xlat_builtin.c:1366
XLAT_FILE_ALLOWED
#define XLAT_FILE_ALLOWED(_vb, _p)
Definition xlat_builtin.c:494
hmac_type
hmac_type
Definition xlat_builtin.c:2463
HMAC_MD5
@ HMAC_MD5
Definition xlat_builtin.c:2464
HMAC_SHA1
@ HMAC_SHA1
Definition xlat_builtin.c:2465
xlat_func_time_args
static xlat_arg_parser_t const xlat_func_time_args[]
Definition xlat_builtin.c:4048
xlat_func_base64_encode_arg
static xlat_arg_parser_t const xlat_func_base64_encode_arg[]
Definition xlat_builtin.c:2011
xlat_eval_rctx_t::last_result
unlang_result_t last_result
Definition xlat_builtin.c:1720
xlat_change_case
static xlat_action_t xlat_change_case(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED request_t *request, fr_value_box_list_t *args, bool upper)
Change case of a string.
Definition xlat_builtin.c:4256
_log_dst_free
static int _log_dst_free(fr_log_t *log)
Definition xlat_builtin.c:1360
xlat_module_call_rctx_t::last_result
unlang_result_t last_result
Definition xlat_builtin.c:1542
xlat_pair_encode_args
static xlat_arg_parser_t const xlat_pair_encode_args[]
Definition xlat_builtin.c:4647
filename_xlat_escape
static int filename_xlat_escape(fr_value_box_t *vb, UNUSED void *uctx)
Definition xlat_builtin.c:322
xlat_func_unsafe_args
static xlat_arg_parser_t const xlat_func_unsafe_args[]
Definition xlat_builtin.c:958
xlat_hmac
static xlat_action_t xlat_hmac(TALLOC_CTX *ctx, fr_dcursor_t *out, fr_value_box_list_t *args, uint8_t *digest, int digest_len, hmac_type type)
Definition xlat_builtin.c:2468
xlat_func_signal_raise_args
static xlat_arg_parser_t const xlat_func_signal_raise_args[]
Definition xlat_builtin.c:3979
xlat_debug_attr_vp
static void xlat_debug_attr_vp(request_t *request, fr_pair_t const *vp, fr_dict_attr_t const *da)
Definition xlat_builtin.c:155
xlat_func_log_arg
static xlat_arg_parser_t const xlat_func_log_arg[]
Definition xlat_builtin.c:1256
xlat_func_file_mkdir
static xlat_action_t xlat_func_file_mkdir(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:912
xlat_func_sha_arg
static xlat_arg_parser_t const xlat_func_sha_arg[]
Definition xlat_builtin.c:3354
xlat_func_cast_args
static xlat_arg_parser_t const xlat_func_cast_args[]
Definition xlat_builtin.c:2225
xlat_transparent
xlat_action_t xlat_transparent(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *args)
Common function to move boxes from input list to output list.
Definition xlat_builtin.c:263
xlat_func_file_exists
static xlat_action_t xlat_func_file_exists(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:496
xlat_func_hex_arg
static xlat_arg_parser_t const xlat_func_hex_arg[]
Definition xlat_builtin.c:2410
xlat_func_substr_args
static xlat_arg_parser_t const xlat_func_substr_args[]
Definition xlat_builtin.c:3608
xlat_func_file_head
static xlat_action_t xlat_func_file_head(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:519
xlat_func_block_args
static xlat_arg_parser_t const xlat_func_block_args[]
Definition xlat_builtin.c:2186
xlat_func_subnet_args
static xlat_arg_parser_t const xlat_func_subnet_args[]
Definition xlat_builtin.c:4568
xlat_pair_encode_inst_t::tp_encode
fr_test_point_pair_encode_t const * tp_encode
Definition xlat_builtin.c:61
xlat_func_module_call_arg
static xlat_arg_parser_t const xlat_func_module_call_arg[]
Definition xlat_builtin.c:1547
XLAT_REGISTER_PURE
#define XLAT_REGISTER_PURE(_xlat, _func, _return_type, _arg)
xlat_func_str_printable_arg
static xlat_arg_parser_t const xlat_func_str_printable_arg[]
Definition xlat_builtin.c:3511
xlat_func_randstr_arg
static xlat_arg_parser_t const xlat_func_randstr_arg[]
Definition xlat_builtin.c:2789
xlat_func_eval_arg
static xlat_arg_parser_t const xlat_func_eval_arg[]
Definition xlat_builtin.c:1739
xlat_func_subst_args
static xlat_arg_parser_t const xlat_func_subst_args[]
Definition xlat_builtin.c:3866
xlat_func_explode_args
static xlat_arg_parser_t const xlat_func_explode_args[]
Definition xlat_builtin.c:999
xlat_protocols_register
int xlat_protocols_register(void)
Register xlats for any loaded dictionaries.
Definition xlat_builtin.c:4876
xlat_func_str_utf8_arg
static xlat_arg_parser_t const xlat_func_str_utf8_arg[]
Definition xlat_builtin.c:3571
REPETITION_MAX
#define REPETITION_MAX
cbor_loader
static dl_loader_t * cbor_loader
Definition xlat_builtin.c:4856
xlat_change_case_arg
static xlat_arg_parser_t const xlat_change_case_arg[]
Definition xlat_builtin.c:4278
xlat_func_strlen_arg
static xlat_arg_parser_t const xlat_func_strlen_arg[]
Definition xlat_builtin.c:3473
xlat_protocol_register
static int xlat_protocol_register(fr_dict_t const *dict)
Definition xlat_builtin.c:4836
xlat_file_allowed
bool xlat_file_allowed(request_t *request, fr_value_box_t const *vb, int oflags)
Definition xlat_builtin.c:433
xlat_func_md5_arg
static xlat_arg_parser_t const xlat_func_md5_arg[]
Definition xlat_builtin.c:2660
xlat_global_init
int xlat_global_init(void)
Definition xlat_builtin.c:5204
xlat_func_urlquote_arg
static xlat_arg_parser_t const xlat_func_urlquote_arg[]
Definition xlat_builtin.c:4322
xlat_pair_cursor_args
static xlat_arg_parser_t const xlat_pair_cursor_args[]
Definition xlat_builtin.c:150
xlat_func_file_size
static xlat_action_t xlat_func_file_size(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:579
ungroup
static void ungroup(fr_dcursor_t *out, fr_value_box_list_t *in)
Definition xlat_builtin.c:2554
xlat_func_md4_arg
static xlat_arg_parser_t const xlat_func_md4_arg[]
Definition xlat_builtin.c:2620
xlat_regex_escape
int xlat_regex_escape(fr_value_box_t *vb, UNUSED void *uctx)
Escape a value box so that it is safe to use as a regular expression.
Definition xlat_builtin.c:3224
xlat_func_join_args
static xlat_arg_parser_t const xlat_func_join_args[]
Definition xlat_builtin.c:2530
xlat_module_call_resume
static xlat_action_t xlat_module_call_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
Just serves to push the result up the stack.
Definition xlat_builtin.c:1555
XLAT_NEW
#define XLAT_NEW(_x)
xlat_eval_resume
static xlat_action_t xlat_eval_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, xlat_ctx_t const *xctx, UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
Just serves to push the result up the stack.
Definition xlat_builtin.c:1727
XLAT_REGISTER_HASH
#define XLAT_REGISTER_HASH(_name, _func)
xlat_func_debug_args
static xlat_arg_parser_t const xlat_func_debug_args[]
Definition xlat_builtin.c:86
hextab
static char const hextab[]
Definition xlat_builtin.c:48
FR_FILENAME_SAFE_FOR
#define FR_FILENAME_SAFE_FOR
Definition xlat_builtin.c:320
xlat_func_signal_raise
static xlat_action_t xlat_func_signal_raise(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:3984
xlat_pair_decode_uctx_t::tp_decode
fr_test_point_pair_decode_t * tp_decode
Definition xlat_builtin.c:52
xlat_func_pad_args
static xlat_arg_parser_t const xlat_func_pad_args[]
Definition xlat_builtin.c:1826
xlat_pair_encode_instantiate
static int xlat_pair_encode_instantiate(xlat_inst_ctx_t const *xctx)
Definition xlat_builtin.c:4639
uuid_print_vb
static int uuid_print_vb(fr_value_box_t *vb, uint32_t vals[4])
Convert a UUID in an array of uint32_t to the conventional string representation.
Definition xlat_builtin.c:2990
xlat_func_urlunquote_arg
static xlat_arg_parser_t const xlat_func_urlunquote_arg[]
Definition xlat_builtin.c:4405
xlat_func_file_touch
static xlat_action_t xlat_func_file_touch(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:883
xlat_pair_decode_uctx_t::dict
fr_dict_t const * dict
Restrict xlat to this namespace.
Definition xlat_builtin.c:53
xlat_pair_decode_args
static xlat_arg_parser_t const xlat_pair_decode_args[]
Definition xlat_builtin.c:4485
xlat_func_rand_arg
static xlat_arg_parser_t const xlat_func_rand_arg[]
Definition xlat_builtin.c:2749
uuid_set_variant
static void uuid_set_variant(uint32_t vals[4], uint8_t variant)
Definition xlat_builtin.c:3025
xlat_func_concat_args
static xlat_arg_parser_t const xlat_func_concat_args[]
Definition xlat_builtin.c:2357
xlat_func_join
static xlat_action_t xlat_func_join(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Join a series of arguments to form a single list.
Definition xlat_builtin.c:2540
xlat_func_file_name_count_args
static xlat_arg_parser_t const xlat_func_file_name_count_args[]
Definition xlat_builtin.c:422
xlat_arg_copy_out
void xlat_arg_copy_out(TALLOC_CTX *ctx, fr_dcursor_t *out, fr_value_box_list_t *in, fr_value_box_t *vb)
Copy an argument from the input list to the output cursor.
Definition xlat_builtin.c:74
xlat_func_range_arg
static xlat_arg_parser_t const xlat_func_range_arg[]
Definition xlat_builtin.c:3136
xlat_func_integer_args
static xlat_arg_parser_t const xlat_func_integer_args[]
Definition xlat_builtin.c:1127
_xlat_global_init
static int _xlat_global_init(UNUSED void *uctx)
Global initialisation for xlat.
Definition xlat_builtin.c:4923
XLAT_REGISTER_ARGS
#define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args)
xlat_module_call_rctx_t::ex
xlat_exp_head_t * ex
Definition xlat_builtin.c:1543
xlat_func_file_cat
static xlat_action_t xlat_func_file_cat(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:802
xlat_func_file_rm
static xlat_action_t xlat_func_file_rm(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:859
xlat_eval_rctx_t::ex
xlat_exp_head_t * ex
Definition xlat_builtin.c:1721
xlat_func_length_args
static xlat_arg_parser_t const xlat_func_length_args[]
Definition xlat_builtin.c:2584
xlat_func_ungroup
static xlat_action_t xlat_func_ungroup(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request, fr_value_box_list_t *in)
Ungroups all of its arguments into one flat list.
Definition xlat_builtin.c:2570
xlat_protocol_register_by_name
static int xlat_protocol_register_by_name(dl_t *dl, char const *name, fr_dict_t const *dict)
Definition xlat_builtin.c:4789
xlat_func_file_cat_args
static xlat_arg_parser_t const xlat_func_file_cat_args[]
Definition xlat_builtin.c:795
uuid_set_version
static void uuid_set_version(uint32_t vals[4], uint8_t version)
Definition xlat_builtin.c:3017
xlat_func_file_rmdir
static xlat_action_t xlat_func_file_rmdir(TALLOC_CTX *ctx, fr_dcursor_t *out, UNUSED xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *args)
Definition xlat_builtin.c:935
xlat_pair_decode_instantiate
static int xlat_pair_decode_instantiate(xlat_inst_ctx_t const *xctx)
Definition xlat_builtin.c:4631
UUID_CHARS
#define UUID_CHARS(_v, _num)
xlat_debug_attr_list
static void xlat_debug_attr_list(request_t *request, fr_pair_list_t const *list, fr_dict_attr_t const *parent)
Definition xlat_builtin.c:137
xlat_func_file_name_args
xlat_arg_parser_t const xlat_func_file_name_args[]
Definition xlat_builtin.c:416
xlat_ctx
static TALLOC_CTX * xlat_ctx
Definition xlat_builtin.c:49
xlat_func_next_time_args
static xlat_arg_parser_t const xlat_func_next_time_args[]
Definition xlat_builtin.c:1622
_xlat_global_free
static int _xlat_global_free(UNUSED void *uctx)
De-register all xlat functions we created.
Definition xlat_builtin.c:4903
xlat_func_base64_decode_arg
static xlat_arg_parser_t const xlat_func_base64_decode_arg[]
Definition xlat_builtin.c:2059
xlat_hmac_args
static xlat_arg_parser_t const xlat_hmac_args[]
Definition xlat_builtin.c:2489
xlat_func_regex_args
static xlat_arg_parser_t const xlat_func_regex_args[]
Definition xlat_builtin.c:3243
xlat_pair_decode_inst_t::decode_uctx
xlat_pair_decode_uctx_t const * decode_uctx
Definition xlat_builtin.c:57
xlat_eval_rctx_t
Definition xlat_builtin.c:1719
xlat_module_call_rctx_t
Definition xlat_builtin.c:1541
xlat_pair_decode_inst_t
Definition xlat_builtin.c:56
xlat_pair_decode_uctx_t
Definition xlat_builtin.c:51
xlat_pair_encode_inst_t
Definition xlat_builtin.c:60
xlat_ctx_s::rctx
void * rctx
Resume context.
Definition xlat_ctx.h:54
xlat_ctx_s::ex
xlat_exp_t const * ex
Tokenized expression.
Definition xlat_ctx.h:55
xlat_inst_ctx_s::ex
xlat_exp_t * ex
Tokenized expression to use in expansion.
Definition xlat_ctx.h:64
xlat_ctx_s::inst
void const * inst
xlat instance data.
Definition xlat_ctx.h:50
xlat_inst_ctx_s::uctx
void * uctx
Passed to the registration function.
Definition xlat_ctx.h:66
xlat_inst_ctx_s::inst
void * inst
xlat instance data to populate.
Definition xlat_ctx.h:63
xlat_ctx_s
An xlat calling ctx.
Definition xlat_ctx.h:49
xlat_inst_ctx_s
An xlat instantiation ctx.
Definition xlat_ctx.h:62
xlat_time_res_attr
fr_dict_attr_t const * xlat_time_res_attr(char const *res)
Definition xlat_eval.c:127
xlat_eval_init
int xlat_eval_init(void)
Definition xlat_eval.c:2045
xlat_eval_free
void xlat_eval_free(void)
Definition xlat_eval.c:2067
xlat_register_expressions
int xlat_register_expressions(void)
Definition xlat_expr.c:1890
xlat_func_free
void xlat_func_free(void)
Definition xlat_func.c:567
xlat_func_flags_set
void xlat_func_flags_set(xlat_t *x, xlat_func_flags_t flags)
Specify flags that alter the xlat's behaviour.
Definition xlat_func.c:401
xlat_func_args_set
int xlat_func_args_set(xlat_t *x, xlat_arg_parser_t const args[])
Register the arguments of an xlat.
Definition xlat_func.c:374
xlat_func_register
xlat_t * xlat_func_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type)
Register an xlat function.
Definition xlat_func.c:225
xlat_func_init
int xlat_func_init(void)
Definition xlat_func.c:551
xlat_func_find
xlat_t * xlat_func_find(char const *in, ssize_t inlen)
Definition xlat_func.c:77
xlat_func_instantiate_set
#define xlat_func_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx)
Set a callback for global instantiation of xlat functions.
Definition xlat_func.h:95
xlat_func_safe_for_set
#define xlat_func_safe_for_set(_xlat, _escaped)
Set the escaped values for output boxes.
Definition xlat_func.h:84
xlat_func_flags_t
xlat_func_flags_t
Definition xlat_func.h:36
XLAT_FUNC_FLAG_PURE
@ XLAT_FUNC_FLAG_PURE
Definition xlat_func.h:38
XLAT_FUNC_FLAG_INTERNAL
@ XLAT_FUNC_FLAG_INTERNAL
Definition xlat_func.h:39
xlat_decode_value_box_list
ssize_t xlat_decode_value_box_list(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, void *decode_ctx, fr_pair_decode_t decode, fr_value_box_list_t *in)
Decode all of the value boxes into the output cursor.
Definition xlat_pair.c:90
xlat_profiling_init
int xlat_profiling_init(void)
Register the control functions for every profiler that the build compiled in.
Definition xlat_profiling.c:331
XLAT_GROUP
@ XLAT_GROUP
encapsulated string of xlats
Definition xlat_priv.h:118
xlat_s::deprecated
bool deprecated
this function was deprecated
Definition xlat_priv.h:70
xlat_exp_s::type
xlat_type_t _CONST type
type of this expansion.
Definition xlat_priv.h:157
xlat_exp_head_s
Definition xlat_priv.h:190
xlat_exp_s
An xlat expansion node.
Definition xlat_priv.h:150
xlat_s
Definition xlat_priv.h:59
Generated by   doxygen 1.9.8