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
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE 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 "dns64/dns64.h"
  47 #include "iterator/iterator.h"
  48 #include "validator/validator.h"
  49
  50 #ifdef WITH_PYTHONMODULE
  51 #include "pythonmod/pythonmod.h"
  52 #endif
  53
  54 /** count number of modules (words) in the string */
  55 static int
  56 count_modules(const char* s)
  57 {
  58         int num = 0;
  59         if(!s)
  60                 return 0;
  61         while(*s) {
  62                 /* skip whitespace */
  63                 while(*s && isspace((unsigned char)*s))
  64                         s++;
  65                 if(*s && !isspace((unsigned char)*s)) {
  66                         /* skip identifier */
  67                         num++;
  68                         while(*s && !isspace((unsigned char)*s))
  69                                 s++;
  70                 }
  71         }
  72         return num;
  73 }
  74
  75 void
  76 modstack_init(struct module_stack* stack)
  77 {
  78         stack->num = 0;
  79         stack->mod = NULL;
  80 }
  81
  82 int
  83 modstack_config(struct module_stack* stack, const char* module_conf)
  84 {
  85         int i;
  86         verbose(VERB_QUERY, "module config: \"%s\"", module_conf);
  87         stack->num = count_modules(module_conf);
  88         if(stack->num == 0) {
  89                 log_err("error: no modules specified");
  90                 return 0;
  91         }
  92         if(stack->num > MAX_MODULE) {
  93                 log_err("error: too many modules (%d max %d)",
  94                         stack->num, MAX_MODULE);
  95                 return 0;
  96         }
  97         stack->mod = (struct module_func_block**)calloc((size_t)
  98                 stack->num, sizeof(struct module_func_block*));
  99         if(!stack->mod) {
 100                 log_err("out of memory");
 101                 return 0;
 102         }
 103         for(i=0; i<stack->num; i++) {
 104                 stack->mod[i] = module_factory(&module_conf);
 105                 if(!stack->mod[i]) {
 106                         log_err("Unknown value for next module: '%s'",
 107                                 module_conf);
 108                         return 0;
 109                 }
 110         }
 111         return 1;
 112 }
 113
 114 /** The list of module names */
 115 const char**
 116 module_list_avail(void)
 117 {
 118         /* these are the modules available */
 119         static const char* names[] = {
 120                 "dns64",
 121 #ifdef WITH_PYTHONMODULE
 122                 "python",
 123 #endif
 124                 "validator",
 125                 "iterator",
 126                 NULL};
 127         return names;
 128 }
 129
 130 /** func block get function type */
 131 typedef struct module_func_block* (*fbgetfunctype)(void);
 132
 133 /** The list of module func blocks */
 134 static fbgetfunctype*
 135 module_funcs_avail(void)
 136 {
 137         static struct module_func_block* (*fb[])(void) = {
 138                 &dns64_get_funcblock,
 139 #ifdef WITH_PYTHONMODULE
 140                 &pythonmod_get_funcblock,
 141 #endif
 142                 &val_get_funcblock,
 143                 &iter_get_funcblock,
 144                 NULL};
 145         return fb;
 146 }
 147
 148 struct
 149 module_func_block* module_factory(const char** str)
 150 {
 151         int i = 0;
 152         const char* s = *str;
 153         const char** names = module_list_avail();
 154         fbgetfunctype* fb = module_funcs_avail();
 155         while(*s && isspace((unsigned char)*s))
 156                 s++;
 157         while(names[i]) {
 158                 if(strncmp(names[i], s, strlen(names[i])) == 0) {
 159                         s += strlen(names[i]);
 160                         *str = s;
 161                         return (*fb[i])();
 162                 }
 163                 i++;
 164         }
 165         return NULL;
 166 }
 167
 168 int
 169 modstack_setup(struct module_stack* stack, const char* module_conf,
 170         struct module_env* env)
 171 {
 172         int i;
 173         if(stack->num != 0)
 174                 modstack_desetup(stack, env);
 175         /* fixed setup of the modules */
 176         if(!modstack_config(stack, module_conf)) {
 177                 return 0;
 178         }
 179         env->need_to_validate = 0; /* set by module init below */
 180         for(i=0; i<stack->num; i++) {
 181                 verbose(VERB_OPS, "init module %d: %s",
 182                         i, stack->mod[i]->name);
 183                 fptr_ok(fptr_whitelist_mod_init(stack->mod[i]->init));
 184                 if(!(*stack->mod[i]->init)(env, i)) {
 185                         log_err("module init for module %s failed",
 186                                 stack->mod[i]->name);
 187                         return 0;
 188                 }
 189         }
 190         return 1;
 191 }
 192
 193 void
 194 modstack_desetup(struct module_stack* stack, struct module_env* env)
 195 {
 196         int i;
 197         for(i=0; i<stack->num; i++) {
 198                 fptr_ok(fptr_whitelist_mod_deinit(stack->mod[i]->deinit));
 199                 (*stack->mod[i]->deinit)(env, i);
 200         }
 201         stack->num = 0;
 202         free(stack->mod);
 203         stack->mod = NULL;
 204 }
 205
 206 int
 207 modstack_find(struct module_stack* stack, const char* name)
 208 {
 209         int i;
 210         for(i=0; i<stack->num; i++) {
 211                 if(strcmp(stack->mod[i]->name, name) == 0)
 212                         return i;
 213         }
 214         return -1;
 215 }