contrib/unbound/services/modstack.c

   1 /*
   2  * services/modstack.c - stack of modules
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  26  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file contains functions to help maintain a stack of modules.
  40  */
  41 #include "config.h"
  42 #include <ctype.h>
  43 #include "services/modstack.h"
  44 #include "util/module.h"
  45 #include "util/fptr_wlist.h"
  46 #include "iterator/iterator.h"
  47 #include "validator/validator.h"
  48
  49 #ifdef WITH_PYTHONMODULE
  50 #include "pythonmod/pythonmod.h"
  51 #endif
  52
  53 /** count number of modules (words) in the string */
  54 static int
  55 count_modules(const char* s)
  56 {
  57         int num = 0;
  58         if(!s)
  59                 return 0;
  60         while(*s) {
  61                 /* skip whitespace */
  62                 while(*s && isspace((int)*s))
  63                         s++;
  64                 if(*s && !isspace((int)*s)) {
  65                         /* skip identifier */
  66                         num++;
  67                         while(*s && !isspace((int)*s))
  68                                 s++;
  69                 }
  70         }
  71         return num;
  72 }
  73
  74 void
  75 modstack_init(struct module_stack* stack)
  76 {
  77         stack->num = 0;
  78         stack->mod = NULL;
  79 }
  80
  81 int
  82 modstack_config(struct module_stack* stack, const char* module_conf)
  83 {
  84         int i;
  85         verbose(VERB_QUERY, "module config: \"%s\"", module_conf);
  86         stack->num = count_modules(module_conf);
  87         if(stack->num == 0) {
  88                 log_err("error: no modules specified");
  89                 return 0;
  90         }
  91         if(stack->num > MAX_MODULE) {
  92                 log_err("error: too many modules (%d max %d)",
  93                         stack->num, MAX_MODULE);
  94                 return 0;
  95         }
  96         stack->mod = (struct module_func_block**)calloc((size_t)
  97                 stack->num, sizeof(struct module_func_block*));
  98         if(!stack->mod) {
  99                 log_err("out of memory");
 100                 return 0;
 101         }
 102         for(i=0; i<stack->num; i++) {
 103                 stack->mod[i] = module_factory(&module_conf);
 104                 if(!stack->mod[i]) {
 105                         log_err("Unknown value for next module: '%s'",
 106                                 module_conf);
 107                         return 0;
 108                 }
 109         }
 110         return 1;
 111 }
 112
 113 /** The list of module names */
 114 const char**
 115 module_list_avail(void)
 116 {
 117         /* these are the modules available */
 118         static const char* names[] = {
 119 #ifdef WITH_PYTHONMODULE
 120                 "python",
 121 #endif
 122                 "validator",
 123                 "iterator",
 124                 NULL};
 125         return names;
 126 }
 127
 128 /** func block get function type */
 129 typedef struct module_func_block* (*fbgetfunctype)(void);
 130
 131 /** The list of module func blocks */
 132 static fbgetfunctype*
 133 module_funcs_avail(void)
 134 {
 135         static struct module_func_block* (*fb[])(void) = {
 136 #ifdef WITH_PYTHONMODULE
 137                 &pythonmod_get_funcblock,
 138 #endif
 139                 &val_get_funcblock,
 140                 &iter_get_funcblock,
 141                 NULL};
 142         return fb;
 143 }
 144
 145 struct
 146 module_func_block* module_factory(const char** str)
 147 {
 148         int i = 0;
 149         const char* s = *str;
 150         const char** names = module_list_avail();
 151         fbgetfunctype* fb = module_funcs_avail();
 152         while(*s && isspace((int)*s))
 153                 s++;
 154         while(names[i]) {
 155                 if(strncmp(names[i], s, strlen(names[i])) == 0) {
 156                         s += strlen(names[i]);
 157                         *str = s;
 158                         return (*fb[i])();
 159                 }
 160                 i++;
 161         }
 162         return NULL;
 163 }
 164
 165 int
 166 modstack_setup(struct module_stack* stack, const char* module_conf,
 167         struct module_env* env)
 168 {
 169         int i;
 170         if(stack->num != 0)
 171                 modstack_desetup(stack, env);
 172         /* fixed setup of the modules */
 173         if(!modstack_config(stack, module_conf)) {
 174                 return 0;
 175         }
 176         env->need_to_validate = 0; /* set by module init below */
 177         for(i=0; i<stack->num; i++) {
 178                 verbose(VERB_OPS, "init module %d: %s",
 179                         i, stack->mod[i]->name);
 180                 fptr_ok(fptr_whitelist_mod_init(stack->mod[i]->init));
 181                 if(!(*stack->mod[i]->init)(env, i)) {
 182                         log_err("module init for module %s failed",
 183                                 stack->mod[i]->name);
 184                         return 0;
 185                 }
 186         }
 187         return 1;
 188 }
 189
 190 void
 191 modstack_desetup(struct module_stack* stack, struct module_env* env)
 192 {
 193         int i;
 194         for(i=0; i<stack->num; i++) {
 195                 fptr_ok(fptr_whitelist_mod_deinit(stack->mod[i]->deinit));
 196                 (*stack->mod[i]->deinit)(env, i);
 197         }
 198         stack->num = 0;
 199         free(stack->mod);
 200         stack->mod = NULL;
 201 }
 202
 203 int
 204 modstack_find(struct module_stack* stack, const char* name)
 205 {
 206         int i;
 207         for(i=0; i<stack->num; i++) {
 208                 if(strcmp(stack->mod[i]->name, name) == 0)
 209                         return i;
 210         }
 211         return -1;
 212 }