Use CONF_SECTIONs directly in unlang_interpret

diff --git a/src/include/interpreter.h b/src/include/interpreter.h
index 554965c9c8bfb5a6cd9f493dce5145dc9d6666c0..67ee433b3ccc9d4ef4789955d71f7e1c45b8f6e8 100644 (file)
--- a/src/include/interpreter.h
+++ b/src/include/interpreter.h
@@ -132,7 +132,7 @@ static inline modcallable *mod_xlattocallable(modxlat *p)
        return (modcallable *)p;
 }
 
-rlm_rcode_t unlang_interpret(REQUEST *request, modcallable *c, rlm_components_t component);
+rlm_rcode_t unlang_interpret(REQUEST *request, CONF_SECTION *cs, rlm_components_t component);
 
 #ifdef __cplusplus
 }

diff --git a/src/main/interpreter.c b/src/main/interpreter.c
index f3c5dc53c968e10aceb3c5cd4632eb5fb3c8a9a3..bccdbd5b9235cfa89f34991a8cf910d668fd7afc 100644 (file)
--- a/src/main/interpreter.c
+++ b/src/main/interpreter.c
@@ -1013,12 +1013,14 @@ static int default_component_results[MOD_COUNT] = {
  *
  * What did Paul Graham say about Lisp...?
  */
-rlm_rcode_t unlang_interpret(REQUEST *request, modcallable *c, rlm_components_t component)
+rlm_rcode_t unlang_interpret(REQUEST *request, CONF_SECTION *cs, rlm_components_t component)
 {
        int priority;
        rlm_rcode_t result;
+       modcallable *c;
        unlang_stack_t stack;
 
+       c = cf_data_find(cs, "unlang");
        if (!c) return default_component_results[component];
 
        memset(&stack, 0, sizeof(stack));

diff --git a/src/main/modules.c b/src/main/modules.c
index f9b2274d90b79ac602caccb6bdff8ba4524eba8c..435fa37fb33d640f79349cf62e24b449515bd670 100644 (file)
--- a/src/main/modules.c
+++ b/src/main/modules.c
@@ -1965,84 +1965,64 @@ int modules_init(CONF_SECTION *root)
 static rlm_rcode_t indexed_modcall(rlm_components_t comp, int idx, REQUEST *request)
 {
        rlm_rcode_t rcode;
-       modcallable *list = NULL;
-       virtual_server_t *server;
        CONF_SECTION *cs;
+       char const *module;
+       char const *component;
 
-       /*
-        *      Find the correct virtual server.
-        */
-       cs = cf_section_sub_find_name2(main_config.config, "server", request->server);
-       if (!cs) {
-               RDEBUG("No such virtual server \"%s\"", request->server);
-               return RLM_MODULE_FAIL;
-       }
-
-       server = (virtual_server_t *)cf_data_find(cs, request->server);
-       rad_assert(server != NULL);
-
-       if (idx == 0) {
-               list = server->mc[comp];
-               if (!list) {
-                       if (server->name) {
-                               RDEBUG3("Empty %s section in virtual server \"%s\".  Using default return values.",
-                                       section_type_value[comp].section, server->name);
-                       } else {
-                               RDEBUG3("Empty %s section.  Using default return values.",
-                                       section_type_value[comp].section);
-                       }
-               }
-       } else {
-               indexed_modcallable *this;
+       rad_assert(request->server_cs != NULL);
 
-               this = lookup_by_index(server->components, comp, idx);
-               if (this) {
-                       list = this->modulelist;
-               } else {
-                       RDEBUG2("%s sub-section not found.  Ignoring.", section_type_value[comp].typename);
-               }
+       cs = cf_section_sub_find(request->server_cs, section_type_value[comp].section);
+       if (!cs) {
+               RDEBUG2("Empty %s section in virtual server \"%s\".  Using default return values.",
+                       section_type_value[comp].section, request->server);
+               goto call_unlang;
        }
 
-       if (server->subcs[comp]) {
-               if (idx == 0) {
-                       RDEBUG("Running section %s from file %s",
-                              section_type_value[comp].section,
-                              cf_section_filename(server->subcs[comp]));
-               } else {
-                       fr_dict_attr_t const *da;
-                       fr_dict_enum_t const *dv;
+       /*
+        *      Figure out which section to run.
+        */
+       if (!idx) {
+               RDEBUG("Running section %s from file %s",
+                      section_type_value[comp].section, cf_section_filename(cs));
+
+       } else {
+               fr_dict_attr_t const *da;
+               fr_dict_enum_t const *dv;
+               CONF_SECTION *subcs;
 
-                       da = fr_dict_attr_by_num(NULL, 0, section_type_value[comp].attr);
-                       if (!da) return RLM_MODULE_FAIL;
+               da = fr_dict_attr_by_num(NULL, 0, section_type_value[comp].attr);
+               if (!da) return RLM_MODULE_FAIL;
 
-                       dv = fr_dict_enum_by_da(NULL, da, idx);
-                       if (!dv) return RLM_MODULE_FAIL;
+               dv = fr_dict_enum_by_da(NULL, da, idx);
+               if (!dv) return RLM_MODULE_FAIL;
 
+               subcs = cf_section_sub_find_name2(cs, da->name, dv->name);
+               if (subcs) {
                        RDEBUG("Running %s %s from file %s",
-                              da->name, dv->name,
-                              cf_section_filename(server->subcs[comp]));
+                              da->name, dv->name, cf_section_filename(subcs));
+               } else {
+                       RDEBUG2("%s %s sub-section not found.  Using default return values.",
+                               da->name, dv->name);
                }
-       }
 
-       {
-               char const *module;
-               char const *component;
+               cs = subcs;
+       }
 
-               /*
-                *      This handles weird cases, where we're
-                *      looping back from inside a module like eap-gtc.
-                */
-               module = request->module;
-               component = request->component;
+       /*
+        *      Cache and restore these, as they're re-set when
+        *      looping back from inside a module like eap-gtc.
+        */
+call_unlang:
+       module = request->module;
+       component = request->component;
 
-               request->module = NULL;
-               request->component = section_type_value[comp].section;
+       request->module = NULL;
+       request->component = section_type_value[comp].section;
 
-               rcode = unlang_interpret(request, list, comp);
+       rcode = unlang_interpret(request, cs, comp);
 
-               request->component = component;
-               request->module = module;
-       }
+       request->component = component;
+       request->module = module;
 
        return rcode;
 }