The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
module_rlm.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: d753d92668e10b61f6817e861f66eb62acfadd94 $
19 *
20 * @file src/lib/server/module_rlm.c
21 * @brief Defines functions for rlm module (re-)initialisation.
22 *
23 * @copyright 2003,2006,2016 The FreeRADIUS server project
24 * @copyright 2016,2024 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
25 * @copyright 2000 Alan DeKok (aland@freeradius.org)
26 * @copyright 2000 Alan Curry (pacman@world.std.com)
27 */
28
29RCSID("$Id: d753d92668e10b61f6817e861f66eb62acfadd94 $")
30
31#include <freeradius-devel/server/cf_file.h>
32
33#include <freeradius-devel/server/global_lib.h>
34#include <freeradius-devel/server/modpriv.h>
35#include <freeradius-devel/server/module_rlm.h>
36#include <freeradius-devel/server/pair.h>
37
38#include <freeradius-devel/util/atexit.h>
39
40#include <freeradius-devel/unlang/compile.h>
41
42#include <freeradius-devel/unlang/xlat_func.h>
43#include <freeradius-devel/unlang/xlat_redundant.h>
44
45
46/** Lookup virtual module by name
47 */
49
50typedef struct {
51 fr_rb_node_t name_node; //!< Entry in the name tree.
52 char const *name; //!< module name
53 CONF_SECTION *cs; //!< CONF_SECTION where it is defined
56
57/** Compare virtual modules by name
58 */
59static int8_t module_rlm_virtual_name_cmp(void const *one, void const *two)
60{
61 module_rlm_virtual_t const *a = one;
62 module_rlm_virtual_t const *b = two;
63 int ret;
64
65 ret = strcmp(a->name, b->name);
66 return CMP(ret, 0);
67}
68
69/** Global module list for all backend modules
70 *
71 */
73
74/** Runtime instantiated list
75 *
76 */
78
79/** Print information on all loaded modules
80 *
81 */
86
87/** Initialise a module specific exfile handle
88 *
89 * @see exfile_init
90 *
91 * @param[in] ctx to bind the lifetime of the exfile handle to.
92 * @param[in] module section.
93 * @param[in] max_entries Max file descriptors to cache, and manage locks for.
94 * @param[in] max_idle Maximum time a file descriptor can be idle before it's closed.
95 * @param[in] locking Whether or not to lock the files.
96 * @param[in] trigger_prefix if NULL will be set automatically from the module CONF_SECTION.
97 * @param[in] trigger_args to make available in any triggers executed by the connection pool.
98 * @return
99 * - New connection pool.
100 * - NULL on error.
101 */
103 CONF_SECTION *module,
104 uint32_t max_entries,
105 fr_time_delta_t max_idle,
106 bool locking,
107 char const *trigger_prefix,
108 fr_pair_list_t *trigger_args)
109{
110 char trigger_prefix_buff[128];
111 exfile_t *handle;
112
113 if (!trigger_prefix) {
114 snprintf(trigger_prefix_buff, sizeof(trigger_prefix_buff), "modules.%s.file", cf_section_name1(module));
115 trigger_prefix = trigger_prefix_buff;
116 }
117
118 handle = exfile_init(ctx, max_entries, max_idle, locking);
119 if (!handle) return NULL;
120
121 exfile_enable_triggers(handle, cf_section_find(module, "file", NULL), trigger_prefix, trigger_args);
122
123 return handle;
124}
125
126/** Resolve polymorphic item's from a module's #CONF_SECTION to a subsection in another module
127 *
128 * This allows certain module sections to reference module sections in other instances
129 * of the same module and share #CONF_DATA associated with them.
130 *
131 * @verbatim
132 example {
133 data {
134 ...
135 }
136 }
137
138 example inst {
139 data = example
140 }
141 * @endverbatim
142 *
143 * @param[out] out where to write the pointer to a module's config section. May be NULL on success,
144 * indicating the config item was not found within the module #CONF_SECTION
145 * or the chain of module references was followed and the module at the end of the chain
146 * did not a subsection.
147 * @param[in] module #CONF_SECTION.
148 * @param[in] name of the polymorphic sub-section.
149 * @return
150 * - 0 on success with referenced section.
151 * - 1 on success with local section.
152 * - -1 on failure.
153 */
155{
156 CONF_PAIR *cp;
157 CONF_SECTION *cs;
158 CONF_DATA const *cd;
159
160
162 char const *inst_name;
163
164#define FIND_SIBLING_CF_KEY "find_sibling"
165
166 *out = NULL;
167
168 /*
169 * Is a real section (not referencing sibling module).
170 */
171 cs = cf_section_find(module, name, NULL);
172 if (cs) {
173 *out = cs;
174
175 return 0;
176 }
177
178 /*
179 * Item omitted completely from module config.
180 */
181 cp = cf_pair_find(module, name);
182 if (!cp) return 0;
183
185 cf_log_err(cp, "Module reference loop found");
186
187 return -1;
188 }
189 cd = cf_data_add(module, module, FIND_SIBLING_CF_KEY, false);
190
191 /*
192 * Item found, resolve it to a module instance.
193 * This triggers module loading, so we don't have
194 * instantiation order issues.
195 */
196 inst_name = cf_pair_value(cp);
197 mi = module_instance_by_name(rlm_modules_static, NULL, inst_name);
198 if (!mi) {
199 cf_log_err(cp, "Unknown module instance \"%s\"", inst_name);
200
201 return -1;
202 }
203
205 CONF_SECTION *parent = module;
206
207 /*
208 * Find the root of the config...
209 */
210 do {
211 CONF_SECTION *tmp;
212
214 if (!tmp) break;
215
216 parent = tmp;
217 } while (true);
218
219 if (unlikely(module_instantiate(module_instance_by_name(rlm_modules_static, NULL, inst_name)) < 0)) return -1;
220 }
221
222 /*
223 * Remove the config data we added for loop
224 * detection.
225 */
226 cf_data_remove_by_data(module, cd);
227
228 /*
229 * Check the module instances are of the same type.
230 */
231 if (strcmp(cf_section_name1(mi->conf), cf_section_name1(module)) != 0) {
232 cf_log_err(cp, "Referenced module is a rlm_%s instance, must be a rlm_%s instance",
234
235 return -1;
236 }
237
238 *out = cf_section_find(mi->conf, name, NULL);
239
240 return 1;
241}
242
244 char const *name, xlat_func_t func, fr_type_t return_type)
245{
246 module_instance_t *mi = mctx->mi;
247 module_rlm_instance_t *mri = talloc_get_type_abort(mi->uctx, module_rlm_instance_t);
249 xlat_t *x;
250 char inst_name[256];
251
252 fr_assert_msg(name != mctx->mi->name, "`name` must not be the same as the module "
253 "instance name. Pass a NULL `name` arg if this is required");
254
255 if (!name) {
256 name = mctx->mi->name;
257 } else {
258 if ((size_t)snprintf(inst_name, sizeof(inst_name), "%s.%s", mctx->mi->name, name) >= sizeof(inst_name)) {
259 ERROR("%s: Instance name too long", __FUNCTION__);
260 return NULL;
261 }
262 name = inst_name;
263 }
264
265 x = xlat_func_register(ctx, name, func, return_type);
266 if (unlikely(x == NULL)) return NULL;
267
268 xlat_mctx_set(x, mctx);
269
270 MEM(mrx = talloc(mi, module_rlm_xlat_t));
271 mrx->xlat = x;
272 mrx->mi = mi;
273
274 fr_dlist_insert_tail(&mri->xlats, mrx);
275
276 return x;
277}
278
279/** Initialise a module specific connection pool
280 *
281 * @see fr_pool_init
282 *
283 * @param[in] module section.
284 * @param[in] opaque data pointer to pass to callbacks.
285 * @param[in] c Callback to create new connections.
286 * @param[in] a Callback to check the status of connections.
287 * @param[in] log_prefix override, if NULL will be set automatically from the module CONF_SECTION.
288 * @param[in] trigger_prefix if NULL will be set automatically from the module CONF_SECTION.
289 * @param[in] trigger_args to make available in any triggers executed by the connection pool.
290 * @return
291 * - New connection pool.
292 * - NULL on error.
293 */
295 void *opaque,
298 char const *log_prefix,
299 char const *trigger_prefix,
300 fr_pair_list_t *trigger_args)
301{
302 CONF_SECTION *cs, *mycs;
303 char log_prefix_buff[128];
304 char trigger_prefix_buff[128];
305
306 fr_pool_t *pool;
307 char const *cs_name1, *cs_name2;
308
309 int ret;
310
311#define parent_name(_x) cf_section_name(cf_item_to_section(cf_parent(_x)))
312
313 cs_name1 = cf_section_name1(module);
314 cs_name2 = cf_section_name2(module);
315 if (!cs_name2) cs_name2 = cs_name1;
316
317 if (!trigger_prefix) {
318 snprintf(trigger_prefix_buff, sizeof(trigger_prefix_buff), "modules.%s.pool", cs_name1);
319 trigger_prefix = trigger_prefix_buff;
320 }
321
322 if (!log_prefix) {
323 snprintf(log_prefix_buff, sizeof(log_prefix_buff), "rlm_%s (%s)", cs_name1, cs_name2);
324 log_prefix = log_prefix_buff;
325 }
326
327 /*
328 * Get sibling's pool config section
329 */
330 ret = module_rlm_sibling_section_find(&cs, module, "pool");
331 switch (ret) {
332 case -1:
333 return NULL;
334
335 case 1:
336 DEBUG4("%s: Using pool section from \"%s\"", log_prefix, parent_name(cs));
337 break;
338
339 case 0:
340 DEBUG4("%s: Using local pool section", log_prefix);
341 break;
342 }
343
344 /*
345 * Get our pool config section
346 */
347 mycs = cf_section_find(module, "pool", NULL);
348 if (!mycs) {
349 DEBUG4("%s: Adding pool section to config item \"%s\" to store pool references", log_prefix,
350 cf_section_name(module));
351
352 mycs = cf_section_alloc(module, module, "pool", NULL);
353 }
354
355 /*
356 * Sibling didn't have a pool config section
357 * Use our own local pool.
358 */
359 if (!cs) {
360 DEBUG4("%s: \"%s.pool\" section not found, using \"%s.pool\"", log_prefix,
361 parent_name(cs), parent_name(mycs));
362 cs = mycs;
363 }
364
365 /*
366 * If fr_pool_init has already been called
367 * for this config section, reuse the previous instance.
368 *
369 * This allows modules to pass in the config sections
370 * they would like to use the connection pool from.
371 */
372 pool = cf_data_value(cf_data_find(cs, fr_pool_t, NULL));
373 if (!pool) {
374 DEBUG4("%s: No pool reference found for config item \"%s.pool\"", log_prefix, parent_name(cs));
375 pool = fr_pool_init(cs, cs, opaque, c, a, log_prefix);
376 if (!pool) return NULL;
377
378 fr_pool_enable_triggers(pool, trigger_prefix, trigger_args);
379
380 if (fr_pool_start(pool) < 0) {
381 ERROR("%s: Starting initial connections failed", log_prefix);
382 return NULL;
383 }
384
385 DEBUG4("%s: Adding pool reference %p to config item \"%s.pool\"", log_prefix, pool, parent_name(cs));
386 cf_data_add(cs, pool, NULL, false);
387 return pool;
388 }
389 fr_pool_ref(pool);
390
391 DEBUG4("%s: Found pool reference %p in config item \"%s.pool\"", log_prefix, pool, parent_name(cs));
392
393 /*
394 * We're reusing pool data add it to our local config
395 * section. This allows other modules to transitively
396 * reuse a pool through this module.
397 */
398 if (mycs != cs) {
399 DEBUG4("%s: Copying pool reference %p from config item \"%s.pool\" to config item \"%s.pool\"",
400 log_prefix, pool, parent_name(cs), parent_name(mycs));
401 cf_data_add(mycs, pool, NULL, false);
402 }
403
404 return pool;
405}
406
407/** Set the next section type if it's not already set
408 *
409 * @param[in] request The current request.
410 * @param[in] type_da to use. Usually attr_auth_type.
411 * @param[in] enumv Enumeration value of the specified type_da.
412 */
414{
415 fr_pair_t *vp;
416
417 switch (pair_update_control(&vp, type_da)) {
418 case 0:
419 fr_value_box_copy(vp, &vp->data, enumv->value);
420 vp->data.enumv = vp->da; /* So we get the correct string alias */
421 RDEBUG2("Setting control.%pP", vp);
422 return true;
423
424 case 1:
425 RDEBUG2("control.%s already set. Not setting to %s", vp->da->name, enumv->name);
426 return false;
427
428 default:
429 return false;
430 }
431}
432
433/** Iterate over an array of named module methods, looking for matches
434 *
435 * @param[in] mmg A structure containing a terminated array of
436 * module method bindings. pre-sorted using #section_name_cmp
437 * with name2 sublists populated.
438 * @param[in] section name1 of the method being called can be one of the following:
439 * - An itenfier.
440 * - CF_IDENT_ANY if the method is a wildcard.
441 * name2 of the method being called can be one of the following:
442 * - An itenfier.
443 * - NULL to match section names with only a name1.
444 * - CF_IDENT_ANY if the method is a wildcard.
445 * @return
446 * - The module_method_name_t on success.
447 * - NULL on not found.
448 */
449static CC_HINT(nonnull)
451{
452 module_method_group_t const *mmg_p = mmg;
454
455 while (mmg_p) {
456 /*
457 * This could potentially be improved by using a binary search
458 * but given the small number of items, reduced branches and
459 * sequential access just scanning the list, it's probably not
460 * worth it.
461 */
462 for (p = mmg_p->bindings; p->section; p++) {
463 switch (section_name_match(p->section, section)) {
464 case 1: /* match */
465 return p;
466
467 case -1: /* name1 didn't match, skip to the end of the sub-list */
468 p = fr_dlist_tail(&p->same_name1);
469 break;
470
471 case 0: /* name1 did match - see if we can find a matching name2 */
472 {
473 fr_dlist_head_t const *same_name1 = &p->same_name1;
474
475 while ((p = fr_dlist_next(same_name1, p))) {
476 if (section_name2_match(p->section, section)) return p;
477 }
478 p = fr_dlist_tail(same_name1);
479 }
480 break;
481 }
482#ifdef __clang_analyzer__
483 /* Will never be NULL, worse case, p doesn't change*/
484 if (!p) break;
485#endif
486 }
487
488 /*
489 * Failed to match, search the next deepest group in the chain.
490 */
491 mmg_p = mmg_p->next;
492 }
493
494 return NULL;
495}
496
497/** Dump the available bindings for the module into the strerror stack
498 *
499 * @note Methods from _all_ linked module method groups will be pushed onto the error stack.
500 *
501 * @param[in] mmg module method group to evaluate.
502 */
504{
505 module_method_group_t const *mmg_p = mmg;
506 module_method_binding_t const *mmb_p;
507 bool first = true;
508
509 while (mmg_p) {
510 mmb_p = mmg_p->bindings;
511
512 if (!mmb_p || !mmb_p[0].section) goto next;
513
514 if (first) {
515 fr_strerror_const_push("Available methods are:");
516 first = false;
517 }
518
519 for (; mmb_p->section; mmb_p++) {
520 char const *name1 = section_name_str(mmb_p->section->name1);
521 char const *name2 = section_name_str(mmb_p->section->name2);
522
523 fr_strerror_printf_push(" %s%s%s",
524 name1, name2 ? "." : "", name2 ? name2 : "");
525 }
526 next:
527 mmg_p = mmg_p->next;
528 }
529
530 if (first) {
531 fr_strerror_const_push("No methods available");
532 }
533}
534
535/** Find an existing module instance and verify it implements the specified method
536 *
537 * Extracts the method from the module name where the format is @verbatim <module>[.<method1>[.<method2>]] @endverbatim
538 * and ensures the module implements the specified method.
539 *
540 * @param[in] ctx to allocate the dynamic module key tmpl from.
541 * @param[out] mmc_out the result from resolving the module method,
542 * plus the key tmpl for dynamic modules.
543 * This is not allocated from the ctx to save the runtime
544 * dereference.
545 * @param[in] vs Virtual server to search for alternative module names in.
546 * @param[in] section Section name containing the module call.
547 * @param[in] name The module method call i.e. module[<key>][.<method>]
548 * @param[in] t_rules for resolving the dynamic module key.
549 * @return
550 * - The module instance on success.
551 * - NULL on not found
552 *
553 * If the module exists but the method doesn't exist, then `method` is set to NULL.
554 */
556 virtual_server_t const *vs, section_name_t const *section, fr_sbuff_t *name,
557 tmpl_rules_t const *t_rules)
558{
559 fr_sbuff_term_t const *dyn_tt = &FR_SBUFF_TERMS(
560 L(""),
561 L("\t"),
562 L("\n"),
563 L(" "),
564 L("[")
565 );
566
567 fr_sbuff_term_t const *elem_tt = &FR_SBUFF_TERMS(
568 L(""),
569 L("\t"),
570 L("\n"),
571 L(" "),
572 L(".")
573 );
574
575 fr_sbuff_t *elem1;
577 module_method_call_t mmc_tmp;
578 module_method_binding_t const *mmb;
579
580 fr_sbuff_marker_t meth_start;
581
582 fr_slen_t slen;
583 fr_sbuff_t our_name = FR_SBUFF(name);
584
585 mmc = mmc_out ? mmc_out : &mmc_tmp;
586 if (mmc_out) memset(mmc_out, 0, sizeof(*mmc_out));
587
588 /*
589 * Advance until the start of the dynamic selector
590 * (if it exists).
591 */
592 if (fr_sbuff_adv_until(&our_name, SIZE_MAX, dyn_tt, '\0') == 0) {
593 fr_strerror_printf("Invalid module method name");
594 return fr_sbuff_error(&our_name);
595 }
596
598
599 /*
600 * If the method string contains a '['
601 *
602 * Search for a dynamic module method, e.g. `elem1[<key>]`.
603 */
604 if (fr_sbuff_is_char(&our_name, '[')) {
605 fr_sbuff_marker_t end, s_end;
606 fr_sbuff_marker(&end, &our_name);
607
608 slen = tmpl_afrom_substr(ctx, &mmc->key, &our_name, T_BARE_WORD, NULL, t_rules);
609 if (slen < 0) {
610 fr_strerror_const_push("Invalid dynamic module selector expression");
611 talloc_free(mmc);
612 return slen;
613 }
614
615 if (!fr_sbuff_is_char(&our_name, ']')) {
616 fr_strerror_const_push("Missing terminating ']' for dynamic module selector");
617 error:
618 talloc_free(mmc);
619 return fr_sbuff_error(&our_name);
620 }
621 fr_sbuff_marker(&s_end, &our_name);
622
623 fr_sbuff_set_to_start(&our_name);
624 slen = fr_sbuff_out_bstrncpy(elem1, &our_name, fr_sbuff_ahead(&end));
625 if (slen < 0) {
626 fr_strerror_const("Module method string too long");
627 goto error;
628 }
629 mmc->mi = module_instance_by_name(rlm_modules_dynamic, NULL, elem1->start);
630 if (!mmc->mi) {
631 fr_strerror_printf("No such dynamic module '%s'", elem1->start);
632 goto error;
633 }
635
636 fr_sbuff_set(&our_name, &s_end);
637 fr_sbuff_advance(&our_name, 1); /* Skip the ']' */
638 /*
639 * With elem1.elem2.elem3
640 *
641 * Search for a static module matching one of the following:
642 *
643 * - elem1.elem2.elem3
644 * - elem1.elem2
645 * - elem1
646 */
647 } else {
648 char *p;
649
650 fr_sbuff_set_to_start(&our_name);
651
652 slen = fr_sbuff_out_bstrncpy_until(elem1, &our_name, SIZE_MAX, dyn_tt, NULL);
653 if (slen == 0) {
654 fr_strerror_const("Invalid module name");
655 goto error;
656 }
657 if (slen < 0) {
658 fr_strerror_const("Module method string too long");
659 goto error;
660 }
661
662 /*
663 * Now we have a mutable buffer, we can start chopping
664 * it up to find the module.
665 */
666 for (;;) {
667 mmc->mi = (module_instance_t *)module_rlm_static_by_name(NULL, elem1->start);
668 if (mmc->mi) {
670 break; /* Done */
671 }
672
673 p = strrchr(elem1->start, '.');
674 if (!p) break; /* No more '.' */
675 *p = '\0'; /* Chop off the last '.' */
676 }
677
678 if (!mmc->mi) {
679 fr_strerror_printf("No such module '%pV'", fr_box_strvalue_len(our_name.start, slen));
680 return -1;
681 }
682
683 fr_sbuff_set_to_start(&our_name);
684 fr_sbuff_advance(&our_name, strlen(elem1->start)); /* Advance past the module name */
685 if (fr_sbuff_is_char(&our_name, '.')) {
686 fr_sbuff_advance(&our_name, 1); /* Static module method, search directly */
687 } else {
688 fr_sbuff_marker(&meth_start, &our_name); /* for the errors... */
689 goto by_section; /* Get the method dynamically from the section*/
690 }
691 }
692
693 /*
694 * For both cases, the buffer should be pointing
695 * at the start of the method string.
696 */
697 fr_sbuff_marker(&meth_start, &our_name);
698
699 /*
700 * If a module method was provided, search for it in the named
701 * methods provided by the module.
702 *
703 * The method name should be either:
704 *
705 * - name1
706 * - name1.name2
707 */
708 {
709 section_name_t method;
710 fr_sbuff_t *elem2;
711
712 fr_sbuff_set_to_start(elem1); /* May have used this already for module lookups */
713
714 slen = fr_sbuff_out_bstrncpy_until(elem1, &our_name, SIZE_MAX, elem_tt, NULL);
715 if (slen < 0) {
716 fr_strerror_const("Module method string too long");
717 return fr_sbuff_error(&our_name);
718 }
719 if (slen == 0) goto by_section; /* This works for both dynamic and static modules */
720
722
723 if (fr_sbuff_is_char(&our_name, '.')) {
724 fr_sbuff_advance(&our_name, 1);
725 if (fr_sbuff_out_bstrncpy_until(elem2, &our_name, SIZE_MAX,
726 elem_tt, NULL) == MODULE_INSTANCE_LEN_MAX) {
727 fr_strerror_const("Module method string too long");
728 goto error;
729 }
730 }
731
732 method = (section_name_t) {
733 .name1 = elem1->start,
734 .name2 = fr_sbuff_used(elem2) ? elem2->start : NULL
735 };
736
737 mmb = module_binding_find(&mmc->rlm->method_group, &method);
738 if (!mmb) {
739 fr_strerror_printf("Module \"%s\" does not have method %s%s%s",
740 mmc->mi->name,
741 method.name1,
742 method.name2 ? "." : "",
743 method.name2 ? method.name2 : ""
744 );
745
747 return fr_sbuff_error(&meth_start);
748 }
749 mmc->mmb = *mmb; /* For locality of reference and fewer derefs */
750 if (mmc_out) section_name_dup(ctx, &mmc->asked, &method);
751
752 return fr_sbuff_set(name, &our_name);
753 }
754
755by_section:
756 /*
757 * First look for the section name in the module's
758 * bindings. If that fails, look for the alt
759 * section names from the virtual server section.
760 *
761 * If that fails, we're done.
762 */
763 mmb = module_binding_find(&mmc->rlm->method_group, section);
764 if (!mmb) {
765 section_name_t const **alt_p = virtual_server_section_methods(vs, section);
766 if (alt_p) {
767 for (; *alt_p; alt_p++) {
768 mmb = module_binding_find(&mmc->rlm->method_group, *alt_p);
769 if (mmb) {
770 if (mmc_out) section_name_dup(ctx, &mmc->asked, *alt_p);
771 break;
772 }
773 }
774 }
775 } else {
776 if (mmc_out) section_name_dup(ctx, &mmc->asked, section);
777 }
778 if (!mmb) {
779 fr_strerror_printf("Module \"%s\" has no method for section %s %s { ... }, i.e. %s%s%s",
780 mmc->mi->name,
781 section->name1,
782 section->name2 ? section->name2 : "",
783 section->name1,
784 section->name2 ? "." : "",
785 section->name2 ? section->name2 : ""
786 );
788
789 return fr_sbuff_error(&meth_start);
790 }
791 mmc->mmb = *mmb; /* For locality of reference and fewer derefs */
792
793 return fr_sbuff_set(name, &our_name);
794}
795
797{
799
802 .name = asked_name,
803 });
804 if (!inst) return NULL;
805
806 return inst->cs;
807}
808
813
818
819/** Create a virtual module.
820 *
821 * @param[in] cs that defines the virtual module.
822 * @return
823 * - 0 on success.
824 * - -1 on failure.
825 */
827{
828 char const *name;
829 bool all_same;
830 CONF_ITEM *sub_ci = NULL;
831 CONF_PAIR *cp;
834
836
837 /*
838 * Groups, etc. must have a name.
839 */
840 if ((strcmp(name, "group") == 0) ||
841 (strcmp(name, "redundant") == 0) ||
842 (strcmp(name, "redundant-load-balance") == 0) ||
843 (strcmp(name, "load-balance") == 0)) {
845 if (!name) {
846 cf_log_err(cs, "Keyword module must have a second name");
847 return -1;
848 }
849
850 /*
851 * name2 was already checked in modules_rlm_bootstrap()
852 */
854 } else {
855 cf_log_err(cs, "Module names cannot be unlang keywords '%s'", name);
856 return -1;
857 }
858
859 /*
860 * Ensure that the module doesn't exist.
861 */
863 if (mi) {
864 ERROR("Duplicate module \"%s\" in file %s[%d] and file %s[%d]",
865 name,
866 cf_filename(cs),
867 cf_lineno(cs),
868 cf_filename(mi->conf),
869 cf_lineno(mi->conf));
870 return -1;
871 }
872
873 /*
874 * Don't bother registering redundant xlats for a simple "group".
875 */
876 all_same = (strcmp(cf_section_name1(cs), "group") != 0);
877
878 {
879 module_t const *last = NULL;
880
881 /*
882 * Ensure that the modules we reference here exist.
883 */
884 while ((sub_ci = cf_item_next(cs, sub_ci))) {
885 if (cf_item_is_pair(sub_ci)) {
886 cp = cf_item_to_pair(sub_ci);
887 if (cf_pair_value(cp)) {
888 cf_log_err(sub_ci, "Cannot set return codes in a %s block", cf_section_name1(cs));
889 return -1;
890 }
891
893 if (!mi) {
894 cf_log_perr(sub_ci, "Failed resolving module reference '%s' in %s block",
896 return -1;
897 }
898
899 if (all_same) {
900 if (!last) {
901 last = mi->exported;
902 } else if (last != mi->exported) {
903 last = NULL;
904 all_same = false;
905 }
906 }
907 } else {
908 all_same = false;
909 }
910
911 /*
912 * Don't check subsections for now. That check
913 * happens later in the unlang compiler.
914 */
915 } /* loop over things in a virtual module section */
916 }
917
918 inst = talloc_zero(cs, module_rlm_virtual_t);
919 if (!inst) return -1;
920
921 inst->cs = cs;
922 MEM(inst->name = talloc_strdup(inst, name));
923 inst->all_same = all_same;
924
927 return -1;
928 }
929
930 return 0;
931}
932
933/** Generic conf_parser_t func for loading drivers
934 *
935 */
936int module_rlm_submodule_parse(TALLOC_CTX *ctx, void *out, void *parent,
937 CONF_ITEM *ci, conf_parser_t const *rule)
938{
939 conf_parser_t our_rule = *rule;
940
941 our_rule.uctx = &rlm_modules_static;
942
943 return module_submodule_parse(ctx, out, parent, ci, &our_rule);
944}
945
946/** Frees thread-specific data for all registered backend modules
947 *
948 */
953
954/** Allocates thread-specific data for all registered backend modules
955 *
956 * @param[in] ctx To allocate any thread-specific data in.
957 * @param[in] el to register events.
958 * @return
959 * - 0 if all modules were instantiated successfully.
960 * - -1 if a module failed instantiation.
961 */
966
967/** Performs the instantiation phase for all backend modules
968 *
969 * @return
970 * - 0 if all modules were instantiated successfully.
971 * - -1 if a module failed instantiation.
972 */
977
978/** Compare the section names of two module_method_binding_t structures
979 */
980static int8_t binding_name_cmp(void const *one, void const *two)
981{
982 module_method_binding_t const *a = one;
983 module_method_binding_t const *b = two;
984
985 return section_name_cmp(a->section, b->section);
986}
987
989{
990 module_method_binding_t *p, *srt_p;
991 fr_dlist_head_t bindings;
992 bool in_order = true;
993
994 /*
995 * Not all modules export module method bindings
996 */
997 if (!group || !group->bindings || group->validated) return 0;
998
999 fr_dlist_init(&bindings, module_method_binding_t, entry);
1000
1001 for (p = group->bindings; p->section; p++) {
1003 "First section identifier can't be NULL")) return -1;
1005 "Section identifiers can't both be null")) return -1;
1006
1007 /*
1008 * All the bindings go in a list so we can sort them
1009 * and produce the list in the correct order.
1010 */
1011 fr_dlist_insert_tail(&bindings, p);
1012 }
1013
1014 fr_dlist_sort(&bindings, binding_name_cmp);
1015
1016 /*
1017 * Iterate over the sorted list of bindings,
1018 * and the original list, to ensure they're
1019 * in the correct order.
1020 */
1021 for (srt_p = fr_dlist_head(&bindings), p = group->bindings;
1022 srt_p;
1023 srt_p = fr_dlist_next(&bindings, srt_p), p++) {
1024 if (p != srt_p) {
1025 in_order = false;
1026 break;
1027 }
1028 }
1029
1030 /*
1031 * Rebuild the binding list in the correct order.
1032 */
1033 if (!in_order) {
1034 module_method_binding_t *ordered;
1035
1036 MEM(ordered = talloc_array(NULL, module_method_binding_t, fr_dlist_num_elements(&bindings)));
1037 for (srt_p = fr_dlist_head(&bindings), p = ordered;
1038 srt_p;
1039 srt_p = fr_dlist_next(&bindings, srt_p), p++) {
1040 *p = *srt_p;
1041 }
1042 memcpy(group->bindings, ordered, fr_dlist_num_elements(&bindings) * sizeof(*ordered));
1043 talloc_free(ordered);
1044 }
1045
1046 /*
1047 * Build the "skip" list of name1 entries
1048 */
1049 {
1050 module_method_binding_t *last_binding = NULL;
1051
1052 for (p = group->bindings; p->section; p++) {
1053 if (!last_binding ||
1054 (
1055 (last_binding->section->name1 != p->section->name1) &&
1056 (
1057 (last_binding->section->name1 == CF_IDENT_ANY) ||
1058 (p->section->name1 == CF_IDENT_ANY) ||
1059 (strcmp(last_binding->section->name1, p->section->name1) != 0)
1060 )
1061 )
1062 ) {
1064 last_binding = p;
1065 }
1066 fr_dlist_insert_tail(&last_binding->same_name1, p);
1067 }
1068 }
1069 group->validated = true;
1070
1071 return module_method_group_validate(group->next);
1072}
1073
1080
1081/** Allocate a rlm module instance
1082 *
1083 * These have extra space allocated to hold the dlist of associated xlats.
1084 *
1085 * @param[in] ml Module list to allocate from.
1086 * @param[in] parent Parent module instance.
1087 * @param[in] type Type of module instance.
1088 * @param[in] mod_name Name of the module.
1089 * @param[in] inst_name Name of the instance.
1090 * @param[in] init_state Initial state of the module instance.
1091 * @return
1092 * - The allocated module instance on success.
1093 * - NULL on failure.
1094 */
1095static inline CC_HINT(always_inline)
1098 dl_module_type_t type, char const *mod_name, char const *inst_name,
1099 module_instance_state_t init_state)
1100{
1103
1104 mi = module_instance_alloc(ml, parent, type, mod_name, inst_name, init_state);
1105 if (unlikely(mi == NULL)) return NULL;
1106
1107 MEM(mri = talloc(mi, module_rlm_instance_t));
1108 module_instance_uctx_set(mi, mri);
1109
1111
1112 return mi;
1113}
1114
1116{
1117 char const *name;
1118 char const *inst_name;
1119 module_instance_t *mi = NULL;
1120 CONF_SECTION *actions;
1121
1122 /*
1123 * name2 can't be a keyword
1124 */
1125 name = cf_section_name2(mod_conf);
1127 invalid_name:
1128 cf_log_err(mod_conf, "Module names cannot be unlang keywords '%s'", name);
1129 return -1;
1130 }
1131
1132 name = cf_section_name1(mod_conf);
1133
1134 /*
1135 * For now, ignore name1 which is a keyword.
1136 */
1138 if (!cf_section_name2(mod_conf)) {
1139 cf_log_err(mod_conf, "Missing second name at '%s'", name);
1140 return -1;
1141 }
1142 if (module_rlm_bootstrap_virtual(mod_conf) < 0) return -1;
1143 return 0;
1144 }
1145
1146 /*
1147 * Skip inline templates, and disallow "template { ... }"
1148 */
1149 if (strcmp(name, "template") == 0) {
1150 if (!cf_section_name2(mod_conf)) goto invalid_name;
1151 return 0;
1152 }
1153
1154 if (module_instance_name_from_conf(&inst_name, mod_conf) < 0) goto invalid_name;
1155
1156 mi = module_rlm_instance_alloc(ml, NULL, DL_MODULE_TYPE_MODULE, name, inst_name, 0);
1157 if (unlikely(mi == NULL)) {
1158 cf_log_perr(mod_conf, "Failed loading module");
1159 return -1;
1160 }
1161
1162 /*
1163 * First time we've loaded the dl module, so we need to
1164 * check the module methods to make sure they're ordered
1165 * correctly, and to add the "skip list" style name2
1166 * entries.
1167 */
1168 if ((mi->module->refs == 1) && (module_method_validate(mi) < 0)) {
1169 talloc_free(mi);
1170 return -1;
1171 }
1172
1173 if (module_instance_conf_parse(mi, mod_conf) < 0) {
1174 cf_log_perr(mod_conf, "Failed parsing module config");
1175 talloc_free(mi);
1176 return -1;
1177 }
1178
1179 /*
1180 * Compile the default "actions" subsection, which includes retries.
1181 */
1182 actions = cf_section_find(mod_conf, "actions", NULL);
1183 if (actions && unlang_compile_actions(&mi->actions, actions, (mi->exported->flags & MODULE_TYPE_RETRY) != 0)) {
1184 talloc_free(mi);
1185 return -1;
1186 }
1187
1188 return 0;
1189}
1190
1191/** Bootstrap modules and virtual modules
1192 *
1193 * Parse the module config sections, and load and call each module's init() function.
1194 *
1195 * @param[in] root of the server configuration.
1196 * @return
1197 * - 0 if all modules were bootstrapped successfully.
1198 * - -1 if a module/virtual module failed to bootstrap.
1199 */
1201{
1202 CONF_SECTION *cs, *modules, *static_cs, *dynamic_cs;
1205
1206 /*
1207 * Ensure any libraries the modules depend on are instantiated
1208 */
1210
1211 /*
1212 * Remember where the modules were stored.
1213 */
1214 modules = cf_section_find(root, "modules", NULL);
1215 if (!modules) {
1216 WARN("Cannot find a \"modules\" section in the configuration file!");
1217 return 0;
1218 }
1219
1220 static_cs = cf_section_find(modules, "static", NULL);
1221 if (!static_cs) {
1222 static_cs = cf_section_alloc(modules, NULL, "static", NULL);
1223 cf_section_foreach(modules, mod_cs) {
1224 CONF_ITEM *prev;
1225 char const *name1 = cf_section_name1(mod_cs);
1226
1227 /*
1228 * Skip over the dynamic section
1229 */
1230 if ((strcmp(name1, "dynamic") == 0) && !cf_section_name2(mod_cs)) continue;
1231
1232 /*
1233 * Ignore this section if it is commented out with a magic name.
1234 */
1235 if (*name1 == '-') continue;
1236
1237 /*
1238 * Move all modules which are not in
1239 * the dynamic section into the static
1240 * section for backwards compatibility.
1241 */
1242 prev = cf_item_remove(modules, mod_cs);
1243 cf_item_add(static_cs, mod_cs);
1244
1245 /*
1246 * Find the previous item that's a section
1247 */
1248 while (prev && !cf_item_is_section(prev)) prev = cf_item_prev(modules, prev);
1249
1250 /*
1251 * Resume iterating from that item
1252 */
1253 mod_cs = cf_item_to_section(prev);
1254 }
1255 cf_item_add(modules, static_cs);
1256 }
1257 DEBUG2("#### Bootstrapping static modules ####");
1258 cf_log_debug(modules, " modules {");
1259 cf_log_debug(modules, " static {");
1260 cf_section_foreach(static_cs, mod_conf) {
1261 if (module_conf_parse(rlm_modules_static, mod_conf) < 0) return -1;
1262 }
1263 cf_log_debug(modules, " } # static");
1264
1265 /*
1266 * Now we have a module tree, run bootstrap on all the modules.
1267 * This will bootstrap modules and then submodules.
1268 */
1269 if (unlikely(modules_bootstrap(rlm_modules_static) < 0)) return -1;
1270
1271 if (fr_command_register_hook(NULL, NULL, static_cs, module_cmd_list_table) < 0) {
1272 PERROR("Failed registering radmin commands for modules");
1273 return -1;
1274 }
1275
1276 /*
1277 * Build the configuration and parse dynamic modules
1278 */
1279 dynamic_cs = cf_section_find(modules, "dynamic", NULL);
1280 if (dynamic_cs) {
1281 DEBUG2("#### Bootstrapping dynamic modules ####");
1282 /*
1283 * Parse and then instantiate any dynamic modules configure
1284 */
1285 cf_log_debug(modules, " dynamic {");
1286 cf_section_foreach(dynamic_cs, mod_conf) {
1287 if (unlikely(module_conf_parse(rlm_modules_dynamic, mod_conf) < 0)) return -1;
1288 }
1289 cf_log_debug(modules, " } # dynamic");
1290 if (unlikely(modules_bootstrap(rlm_modules_dynamic) < 0)) return -1;
1291 cf_log_debug(modules, " } # modules");
1292 }
1293
1294 /*
1295 * Check for duplicate policies. They're treated as
1296 * modules, so we might as well check them here.
1297 */
1298 cs = cf_section_find(root, "policy", NULL);
1299 if (cs) {
1300 cf_section_foreach(cs, policy_cs) {
1301 CONF_SECTION *problemcs;
1302 char const *name1 = cf_section_name1(policy_cs);
1303
1304 if (unlang_compile_is_keyword(name1)) {
1305 cf_log_err(policy_cs, "Policy name '%s' cannot be an unlang keyword", name1);
1306 return -1;
1307 }
1308
1309 if (cf_section_name2(policy_cs)) {
1310 cf_log_err(policy_cs, "Policies cannot have two names");
1311 return -1;
1312 }
1313
1314 problemcs = cf_section_find_next(cs, policy_cs, name1, CF_IDENT_ANY);
1315 if (!problemcs) continue;
1316
1317 cf_log_err(problemcs, "Duplicate policy '%s' is forbidden.",
1318 cf_section_name1(policy_cs));
1319 return -1;
1320 }
1321 }
1322
1323 /*
1324 * Now that all of the xlat things have been registered,
1325 * register our redundant xlats. But only when all of
1326 * the items in such a section are the same.
1327 */
1329 vm;
1330 vm = fr_rb_iter_next_inorder(&iter)) {
1331 if (!vm->all_same) continue;
1332
1333 if (xlat_register_redundant(vm->cs) < 0) return -1;
1334 }
1335
1336 return 0;
1337}
1338
1339/** Cleanup all global structures
1340 *
1341 * Automatically called on exit.
1342 */
1344{
1345 if (talloc_free(rlm_modules_static) < 0) return -1;
1346 rlm_modules_static = NULL;
1347 if (talloc_free(module_rlm_virtual_name_tree) < 0) return -1;
1349
1350 return 0;
1351}
1352
1353static int _modules_rlm_free_atexit(UNUSED void *uctx)
1354{
1355 return modules_rlm_free();
1356}
1357
1358/** Initialise the module list structure
1359 *
1360 */
1362{
1365 module_list_mask_set(rlm_modules_dynamic, MODULE_INSTANCE_INSTANTIATED); /* Ensure we never instantiate dynamic modules */
1366
1370
1371 return 0;
1372}
#define fr_atexit_global(_func, _uctx)
Add a free function to the global free list.
Definition atexit.h:59
#define RCSID(id)
Definition build.h:485
#define L(_str)
Helper for initialising arrays of string literals.
Definition build.h:209
#define CMP(_a, _b)
Same as CMP_PREFER_SMALLER use when you don't really care about ordering, you just want an ordering.
Definition build.h:112
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
void const * uctx
User data accessible by the cf_parse_t func.
Definition cf_parse.h:618
Defines a CONF_PAIR to C data type mapping.
Definition cf_parse.h:595
Internal data that is associated with a configuration section.
Definition cf_priv.h:124
Common header for all CONF_* types.
Definition cf_priv.h:49
Configuration AVP similar to a fr_pair_t.
Definition cf_priv.h:70
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
bool cf_item_is_pair(CONF_ITEM const *ci)
Determine if CONF_ITEM is a CONF_PAIR.
Definition cf_util.c:631
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1184
void * cf_data_value(CONF_DATA const *cd)
Return the user assigned value of CONF_DATA.
Definition cf_util.c:1762
char const * cf_section_name1(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1170
CONF_SECTION * cf_section_find(CONF_SECTION const *cs, char const *name1, char const *name2)
Find a CONF_SECTION with name1 and optionally name2.
Definition cf_util.c:1027
CONF_SECTION * cf_item_to_section(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_SECTION.
Definition cf_util.c:683
CONF_PAIR * cf_pair_find(CONF_SECTION const *cs, char const *attr)
Search for a CONF_PAIR with a specific name.
Definition cf_util.c:1438
char const * cf_section_name(CONF_SECTION const *cs)
Return name2 if set, else name1.
Definition cf_util.c:1196
bool cf_item_is_section(CONF_ITEM const *ci)
Determine if CONF_ITEM is a CONF_SECTION.
Definition cf_util.c:617
CONF_PAIR * cf_item_to_pair(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_PAIR.
Definition cf_util.c:663
CONF_SECTION * cf_section_find_next(CONF_SECTION const *cs, CONF_SECTION const *prev, char const *name1, char const *name2)
Return the next matching section.
Definition cf_util.c:1048
char const * cf_pair_value(CONF_PAIR const *pair)
Return the value of a CONF_PAIR.
Definition cf_util.c:1593
char const * cf_pair_attr(CONF_PAIR const *pair)
Return the attr of a CONF_PAIR.
Definition cf_util.c:1577
#define cf_item_add(_parent, _child)
Definition cf_util.h:83
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:289
#define cf_lineno(_cf)
Definition cf_util.h:104
#define cf_section_foreach(_parent, _iter)
Definition cf_util.h:152
#define cf_data_add(_cf, _data, _name, _free)
Definition cf_util.h:255
#define cf_data_find(_cf, _type, _name)
Definition cf_util.h:244
#define cf_data_remove_by_data(_cf, _cd)
Remove an item from a parent.
Definition cf_util.h:274
#define cf_item_prev(_parent, _curr)
Definition cf_util.h:95
#define cf_parent(_cf)
Definition cf_util.h:101
#define cf_item_remove(_parent, _child)
Definition cf_util.h:89
#define cf_item_next(_parent, _curr)
Definition cf_util.h:92
#define cf_log_perr(_cf, _fmt,...)
Definition cf_util.h:296
#define cf_section_alloc(_ctx, _parent, _name1, _name2)
Definition cf_util.h:140
#define cf_filename(_cf)
Definition cf_util.h:107
#define cf_log_debug(_cf, _fmt,...)
Definition cf_util.h:292
#define CF_IDENT_ANY
Definition cf_util.h:78
fr_command_register_hook_t fr_command_register_hook
Definition command.c:42
bool unlang_compile_is_keyword(const char *name)
Check if name is an unlang keyword.
Definition compile.c:5134
bool unlang_compile_actions(unlang_mod_actions_t *actions, CONF_SECTION *action_cs, bool module_retry)
Definition compile.c:1784
#define fr_cond_assert(_x)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:139
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
Definition debug.h:210
#define fr_cond_assert_msg(_x, _fmt,...)
Calls panic_action ifndef NDEBUG, else logs error and evaluates to value of _x.
Definition debug.h:156
#define MEM(x)
Definition debug.h:36
#define ERROR(fmt,...)
Definition dhcpclient.c:41
fr_value_box_t const * value
Enum value (what name maps to).
Definition dict.h:235
char const * name
Enum name.
Definition dict.h:232
Value of an enumerated attribute.
Definition dict.h:231
dl_module_type_t
Definition dl_module.h:65
@ DL_MODULE_TYPE_MODULE
Standard loadable module.
Definition dl_module.h:66
static void fr_dlist_sort(fr_dlist_head_t *list, fr_cmp_t cmp)
Sort a dlist using merge sort.
Definition dlist.h:1064
#define fr_dlist_init(_head, _type, _field)
Initialise the head structure of a doubly linked list.
Definition dlist.h:260
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:486
static unsigned int fr_dlist_num_elements(fr_dlist_head_t const *head)
Return the number of elements in the dlist.
Definition dlist.h:939
static void * fr_dlist_tail(fr_dlist_head_t const *list_head)
Return the TAIL item of a list or NULL if the list is empty.
Definition dlist.h:531
static int fr_dlist_insert_tail(fr_dlist_head_t *list_head, void *ptr)
Insert an item into the tail of a list.
Definition dlist.h:378
#define fr_dlist_talloc_init(_head, _type, _field)
Initialise the head structure of a doubly linked list.
Definition dlist.h:275
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:555
Head of a doubly linked list.
Definition dlist.h:51
exfile_t * exfile_init(TALLOC_CTX *ctx, uint32_t max_entries, fr_time_delta_t max_idle, bool locking)
Initialize a way for multiple threads to log to one or more files.
Definition exfile.c:147
void exfile_enable_triggers(exfile_t *ef, CONF_SECTION *conf, char const *trigger_prefix, fr_pair_list_t *trigger_args)
Enable triggers for an exfiles handle.
Definition exfile.c:195
int global_lib_instantiate(void)
Walk the tree of libraries and instantiate any which are pending.
Definition global_lib.c:218
#define PERROR(_fmt,...)
Definition log.h:228
#define DEBUG4(_fmt,...)
Definition log.h:267
talloc_free(reap)
Stores all information relating to an event list.
Definition event.c:377
static char const * mod_name(fr_listen_t *li)
Definition master.c:2887
fr_type_t
unsigned int uint32_t
size_t fr_sbuff_out_bstrncpy_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len, fr_sbuff_term_t const *tt, fr_sbuff_unescape_rules_t const *u_rules)
ssize_t fr_slen_t
fr_cmd_table_t module_cmd_list_table[]
Definition module.c:91
module_instance_t * mi
Instance of the module being instantiated.
Definition module_ctx.h:51
Temporary structure to hold arguments for instantiation calls.
Definition module_ctx.h:50
static module_list_t * rlm_modules_dynamic
Runtime instantiated list.
Definition module_rlm.c:77
static int _modules_rlm_free_atexit(UNUSED void *uctx)
void modules_rlm_thread_detach(void)
Frees thread-specific data for all registered backend modules.
Definition module_rlm.c:949
int modules_rlm_bootstrap(CONF_SECTION *root)
Bootstrap modules and virtual modules.
static int module_rlm_bootstrap_virtual(CONF_SECTION *cs)
Create a virtual module.
Definition module_rlm.c:826
static int8_t binding_name_cmp(void const *one, void const *two)
Compare the section names of two module_method_binding_t structures.
Definition module_rlm.c:980
static module_method_binding_t const * module_binding_find(module_method_group_t const *mmg, section_name_t const *section)
Iterate over an array of named module methods, looking for matches.
Definition module_rlm.c:450
fr_slen_t module_rlm_by_name_and_method(TALLOC_CTX *ctx, module_method_call_t *mmc_out, virtual_server_t const *vs, section_name_t const *section, fr_sbuff_t *name, tmpl_rules_t const *t_rules)
Find an existing module instance and verify it implements the specified method.
Definition module_rlm.c:555
xlat_t * module_rlm_xlat_register(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx, char const *name, xlat_func_t func, fr_type_t return_type)
Definition module_rlm.c:243
module_instance_t * module_rlm_dynamic_by_name(module_instance_t const *parent, char const *asked_name)
Definition module_rlm.c:809
char const * name
module name
Definition module_rlm.c:52
fr_rb_node_t name_node
Entry in the name tree.
Definition module_rlm.c:51
int module_rlm_sibling_section_find(CONF_SECTION **out, CONF_SECTION *module, char const *name)
Resolve polymorphic item's from a module's CONF_SECTION to a subsection in another module.
Definition module_rlm.c:154
static int8_t module_rlm_virtual_name_cmp(void const *one, void const *two)
Compare virtual modules by name.
Definition module_rlm.c:59
void module_rlm_list_debug(void)
Print information on all loaded modules.
Definition module_rlm.c:82
static int module_method_validate(module_instance_t *mi)
static fr_rb_tree_t * module_rlm_virtual_name_tree
Lookup virtual module by name.
Definition module_rlm.c:48
exfile_t * module_rlm_exfile_init(TALLOC_CTX *ctx, CONF_SECTION *module, uint32_t max_entries, fr_time_delta_t max_idle, bool locking, char const *trigger_prefix, fr_pair_list_t *trigger_args)
Initialise a module specific exfile handle.
Definition module_rlm.c:102
int module_rlm_submodule_parse(TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
Generic conf_parser_t func for loading drivers.
Definition module_rlm.c:936
module_instance_t * module_rlm_static_by_name(module_instance_t const *parent, char const *asked_name)
Definition module_rlm.c:814
bool module_rlm_section_type_set(request_t *request, fr_dict_attr_t const *type_da, fr_dict_enum_value_t const *enumv)
Set the next section type if it's not already set.
Definition module_rlm.c:413
fr_pool_t * module_rlm_connection_pool_init(CONF_SECTION *module, void *opaque, fr_pool_connection_create_t c, fr_pool_connection_alive_t a, char const *log_prefix, char const *trigger_prefix, fr_pair_list_t *trigger_args)
Initialise a module specific connection pool.
Definition module_rlm.c:294
static int module_conf_parse(module_list_t *ml, CONF_SECTION *mod_conf)
static void module_rlm_methods_to_strerror(module_method_group_t const *mmg)
Dump the available bindings for the module into the strerror stack.
Definition module_rlm.c:503
int modules_rlm_free(void)
Cleanup all global structures.
#define FIND_SIBLING_CF_KEY
int modules_rlm_thread_instantiate(TALLOC_CTX *ctx, fr_event_list_t *el)
Allocates thread-specific data for all registered backend modules.
Definition module_rlm.c:962
static module_instance_t * module_rlm_instance_alloc(module_list_t *ml, module_instance_t const *parent, dl_module_type_t type, char const *mod_name, char const *inst_name, module_instance_state_t init_state)
Allocate a rlm module instance.
#define parent_name(_x)
CONF_SECTION * module_rlm_virtual_by_name(char const *asked_name)
Definition module_rlm.c:796
static module_list_t * rlm_modules_static
Global module list for all backend modules.
Definition module_rlm.c:72
int modules_rlm_instantiate(void)
Performs the instantiation phase for all backend modules.
Definition module_rlm.c:973
int modules_rlm_init(void)
Initialise the module list structure.
static int module_method_group_validate(module_method_group_t *group)
Definition module_rlm.c:988
CONF_SECTION * cs
CONF_SECTION where it is defined.
Definition module_rlm.c:53
module_method_group_t method_group
named methods
Definition module_rlm.h:40
module_instance_t * mi
The module instance that registered the xlat.
Definition module_rlm.h:54
fr_dlist_head_t xlats
xlats registered to this module instance.
Definition module_rlm.h:44
module_instance_t * mi
The process modules also push module calls onto the stack for execution.
Definition module_rlm.h:63
xlat_t const * xlat
The xlat function.
Definition module_rlm.h:53
tmpl_t * key
Dynamic key, only set for dynamic modules.
Definition module_rlm.h:71
section_name_t asked
The actual <name1>.
Definition module_rlm.h:67
module_method_binding_t mmb
Method we're calling.
Definition module_rlm.h:70
module_rlm_t const * rlm
Cached module_rlm_t.
Definition module_rlm.h:66
static module_rlm_t * module_rlm_from_module(module_t *module)
Definition module_rlm.h:74
The output of module_rlm_by_name_and_method.
Definition module_rlm.h:62
An xlat function registered to a module.
Definition module_rlm.h:52
int fr_pool_start(fr_pool_t *pool)
Definition pool.c:1114
void fr_pool_ref(fr_pool_t *pool)
Increment pool reference by one.
Definition pool.c:1210
fr_pool_t * fr_pool_init(TALLOC_CTX *ctx, CONF_SECTION const *cs, void *opaque, fr_pool_connection_create_t c, fr_pool_connection_alive_t a, char const *log_prefix)
Create a new connection pool.
Definition pool.c:965
void fr_pool_enable_triggers(fr_pool_t *pool, char const *trigger_prefix, fr_pair_list_t *trigger_args)
Enable triggers for a connection pool.
Definition pool.c:931
A connection pool.
Definition pool.c:85
void *(* fr_pool_connection_create_t)(TALLOC_CTX *ctx, void *opaque, fr_time_delta_t timeout)
Create a new connection handle.
Definition pool.h:111
int(* fr_pool_connection_alive_t)(void *opaque, void *connection)
Check a connection handle is still viable.
Definition pool.h:126
#define fr_assert(_expr)
Definition rad_assert.h:38
#define RDEBUG2(fmt,...)
Definition radclient.h:54
#define DEBUG2(fmt,...)
Definition radclient.h:43
#define WARN(fmt,...)
Definition radclient.h:47
void * fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree)
Initialise an in-order iterator.
Definition rb.c:824
void * fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter)
Return the next node.
Definition rb.c:850
void * fr_rb_find(fr_rb_tree_t const *tree, void const *data)
Find an element in the tree, returning the data, not the node.
Definition rb.c:577
bool fr_rb_insert(fr_rb_tree_t *tree, void const *data)
Insert data into a tree.
Definition rb.c:626
#define fr_rb_inline_alloc(_ctx, _type, _field, _data_cmp, _data_free)
Allocs a red black tree.
Definition rb.h:271
Iterator structure for in-order traversal of an rbtree.
Definition rb.h:321
The main red black tree structure.
Definition rb.h:73
static char const * name
size_t fr_sbuff_adv_until(fr_sbuff_t *sbuff, size_t len, fr_sbuff_term_t const *tt, char escape_chr)
Wind position until we hit a character in the terminal set.
Definition sbuff.c:1854
size_t fr_sbuff_out_bstrncpy(fr_sbuff_t *out, fr_sbuff_t *in, size_t len)
Copy as many bytes as possible from a sbuff to a sbuff.
Definition sbuff.c:725
#define fr_sbuff_set(_dst, _src)
#define FR_SBUFF_TERMS(...)
Initialise a terminal structure with a list of sorted strings.
Definition sbuff.h:192
#define fr_sbuff_is_char(_sbuff_or_marker, _c)
#define fr_sbuff_error(_sbuff_or_marker)
#define FR_SBUFF(_sbuff_or_marker)
#define fr_sbuff_advance(_sbuff_or_marker, _len)
#define fr_sbuff_used(_sbuff_or_marker)
#define fr_sbuff_ahead(_sbuff_or_marker)
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
Set of terminal elements.
int8_t section_name_cmp(void const *one, void const *two)
Compare two sections.
Definition section.c:47
static int section_name2_match(section_name_t const *a, section_name_t const *b)
Definition section.h:60
static char const * section_name_str(char const *name)
Return a printable string for the section name.
Definition section.h:98
static int section_name_match(section_name_t const *a, section_name_t const *b)
Definition section.h:84
static void section_name_dup(TALLOC_CTX *ctx, section_name_t *dst, section_name_t const *src)
Definition section.h:105
char const * name2
Second section name. Usually a packet type like 'access-request', 'access-accept',...
Definition section.h:46
char const * name1
First section name. Usually a verb like 'recv', 'send', etc...
Definition section.h:45
Section name identifier.
Definition section.h:44
char const * name
Instance name e.g. user_database.
Definition module.h:336
@ MODULE_TYPE_RETRY
can handle retries
Definition module.h:50
module_flags_t flags
Flags that control how a module starts up and how a module is called.
Definition module.h:228
module_method_group_t * next
Next group in the list.
Definition module.h:167
CONF_SECTION * conf
Module's instance configuration.
Definition module.h:330
module_instance_state_t state
What's been done with this module so far.
Definition module.h:329
unlang_mod_actions_t actions
default actions and retries.
Definition module.h:304
bool validated
Set to true by module_method_group_validate.
Definition module.h:166
#define MODULE_INSTANCE_LEN_MAX
The maximum size of a module instance.
Definition module.h:147
fr_dlist_head_t same_name1
List of bindings with the same name1.
Definition module.h:179
module_instance_state_t
What state the module instance is currently in.
Definition module.h:244
@ MODULE_INSTANCE_INSTANTIATED
Module instance has been bootstrapped and instantiated.
Definition module.h:247
void * uctx
Extra data passed to module_instance_alloc.
Definition module.h:340
module_method_binding_t * bindings
named methods
Definition module.h:164
section_name_t const * section
Identifier for a section.
Definition module.h:174
module_t * exported
Public module structure.
Definition module.h:277
Module instance data.
Definition module.h:266
A list of modules.
Definition module.h:386
Named methods exported by a module.
Definition module.h:173
A group of methods exported by a module or added as an overlay.
Definition module.h:163
Struct exported by a rlm_* module.
Definition module.h:195
#define pair_update_control(_attr, _da)
Return or allocate a fr_pair_t in the control list.
Definition pair.h:140
ssize_t tmpl_afrom_substr(TALLOC_CTX *ctx, tmpl_t **out, fr_sbuff_t *in, fr_token_t quote, fr_sbuff_parse_rules_t const *p_rules, tmpl_rules_t const *t_rules))
Convert an arbitrary string into a tmpl_t.
Optional arguments passed to vp_tmpl functions.
Definition tmpl.h:332
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
void module_list_debug(module_list_t const *ml)
Print the contents of a module list.
Definition module.c:615
module_list_type_t const module_list_type_thread_local
Callbacks for a thread local list.
Definition module.c:582
module_instance_t * module_instance_by_name(module_list_t const *ml, module_instance_t const *parent, char const *asked_name)
Find an existing module instance by its name and parent.
Definition module.c:897
void module_list_mask_set(module_list_t *ml, module_instance_state_t mask)
Set a new bootstrap/instantiate state for a list.
Definition module.c:1829
module_instance_t * module_instance_alloc(module_list_t *ml, module_instance_t const *parent, dl_module_type_t type, char const *mod_name, char const *inst_name, module_instance_state_t init_state)
Allocate a new module and add it to a module list for later bootstrap/instantiation.
Definition module.c:1645
fr_slen_t module_instance_name_from_conf(char const **name, CONF_SECTION *conf)
Avoid boilerplate when setting the module instance name.
Definition module.c:729
void modules_thread_detach(module_list_t *ml)
Remove thread-specific data for a given module list.
Definition module.c:1003
int modules_thread_instantiate(TALLOC_CTX *ctx, module_list_t const *ml, fr_event_list_t *el)
Creates per-thread instance data for modules which need it.
Definition module.c:1154
int modules_instantiate(module_list_t const *ml)
Completes instantiation of modules.
Definition module.c:1275
module_list_t * module_list_alloc(TALLOC_CTX *ctx, module_list_type_t const *type, char const *name, bool write_protect)
Allocate a new module list.
Definition module.c:1851
void module_instance_uctx_set(module_instance_t *mi, void *uctx)
Set the uctx pointer for a module instance.
Definition module.c:1613
module_list_type_t const module_list_type_global
Callbacks for a global module list.
Definition module.c:528
int modules_bootstrap(module_list_t const *ml)
Bootstrap any modules which have not been bootstrapped already.
Definition module.c:1366
int module_instantiate(module_instance_t *instance)
Manually complete module setup by calling its instantiate function.
Definition module.c:1189
int module_submodule_parse(UNUSED TALLOC_CTX *ctx, void *out, void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
Generic callback for conf_parser_t to load a submodule.
Definition module.c:841
int module_instance_conf_parse(module_instance_t *mi, CONF_SECTION *conf)
Covert a CONF_SECTION into parsed module instance data.
Definition module.c:758
eap_aka_sim_process_conf_t * inst
fr_aka_sim_id_type_t type
fr_pair_t * vp
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
@ T_BARE_WORD
Definition token.h:120
static fr_event_list_t * el
xlat_action_t(* xlat_func_t)(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
xlat callback function
Definition xlat.h:228
static fr_slen_t parent
Definition pair.h:845
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
#define fr_strerror_printf_push(_fmt,...)
Add a message to an existing stack of messages at the tail.
Definition strerror.h:84
#define fr_strerror_const_push(_msg)
Definition strerror.h:227
#define fr_strerror_const(_msg)
Definition strerror.h:223
int fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src)
Copy value data verbatim duplicating any buffers.
Definition value.c:3963
#define fr_box_strvalue_len(_val, _len)
Definition value.h:297
int nonnull(2, 5))
static size_t char ** out
Definition value.h:1012
section_name_t const ** virtual_server_section_methods(virtual_server_t const *vs, section_name_t const *section)
Find the component for a section.
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:216
void xlat_mctx_set(xlat_t *x, module_inst_ctx_t const *mctx)
Associate a module calling ctx with the xlat.
Definition xlat_func.c:296
int xlat_register_redundant(CONF_SECTION *cs)
Registers a redundant xlat.