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
  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 #include "respip/respip.h"
  50
  51 #ifdef WITH_PYTHONMODULE
  52 #include "pythonmod/pythonmod.h"
  53 #endif
  54 #ifdef WITH_DYNLIBMODULE
  55 #include "dynlibmod/dynlibmod.h"
  56 #endif
  57 #ifdef USE_CACHEDB
  58 #include "cachedb/cachedb.h"
  59 #endif
  60 #ifdef USE_IPSECMOD
  61 #include "ipsecmod/ipsecmod.h"
  62 #endif
  63 #ifdef CLIENT_SUBNET
  64 #include "edns-subnet/subnetmod.h"
  65 #endif
  66 #ifdef USE_IPSET
  67 #include "ipset/ipset.h"
  68 #endif
  69
  70 /** count number of modules (words) in the string */
  71 static int
  72 count_modules(const char* s)
  73 {
  74         int num = 0;
  75         if(!s)
  76                 return 0;
  77         while(*s) {
  78                 /* skip whitespace */
  79                 while(*s && isspace((unsigned char)*s))
  80                         s++;
  81                 if(*s && !isspace((unsigned char)*s)) {
  82                         /* skip identifier */
  83                         num++;
  84                         while(*s && !isspace((unsigned char)*s))
  85                                 s++;
  86                 }
  87         }
  88         return num;
  89 }
  90
  91 void
  92 modstack_init(struct module_stack* stack)
  93 {
  94         stack->num = 0;
  95         stack->mod = NULL;
  96 }
  97
  98 int
  99 modstack_config(struct module_stack* stack, const char* module_conf)
 100 {
 101         int i;
 102         verbose(VERB_QUERY, "module config: \"%s\"", module_conf);
 103         stack->num = count_modules(module_conf);
 104         if(stack->num == 0) {
 105                 log_err("error: no modules specified");
 106                 return 0;
 107         }
 108         if(stack->num > MAX_MODULE) {
 109                 log_err("error: too many modules (%d max %d)",
 110                         stack->num, MAX_MODULE);
 111                 return 0;
 112         }
 113         stack->mod = (struct module_func_block**)calloc((size_t)
 114                 stack->num, sizeof(struct module_func_block*));
 115         if(!stack->mod) {
 116                 log_err("out of memory");
 117                 return 0;
 118         }
 119         for(i=0; i<stack->num; i++) {
 120                 stack->mod[i] = module_factory(&module_conf);
 121                 if(!stack->mod[i]) {
 122                         char md[256];
 123                         snprintf(md, sizeof(md), "%s", module_conf);
 124                         if(strchr(md, ' ')) *(strchr(md, ' ')) = 0;
 125                         if(strchr(md, '\t')) *(strchr(md, '\t')) = 0;
 126                         log_err("Unknown value in module-config, module: '%s'."
 127                                 " This module is not present (not compiled in),"
 128                                 " See the list of linked modules with unbound -h",
 129                                 md);
 130                         return 0;
 131                 }
 132         }
 133         return 1;
 134 }
 135
 136 /** The list of module names */
 137 const char**
 138 module_list_avail(void)
 139 {
 140         /* these are the modules available */
 141         static const char* names[] = {
 142                 "dns64",
 143 #ifdef WITH_PYTHONMODULE
 144                 "python",
 145 #endif
 146 #ifdef WITH_DYNLIBMODULE
 147                 "dynlib",
 148 #endif
 149 #ifdef USE_CACHEDB
 150                 "cachedb",
 151 #endif
 152 #ifdef USE_IPSECMOD
 153                 "ipsecmod",
 154 #endif
 155 #ifdef CLIENT_SUBNET
 156                 "subnetcache",
 157 #endif
 158 #ifdef USE_IPSET
 159                 "ipset",
 160 #endif
 161                 "respip",
 162                 "validator",
 163                 "iterator",
 164                 NULL};
 165         return names;
 166 }
 167
 168 /** func block get function type */
 169 typedef struct module_func_block* (*fbgetfunctype)(void);
 170
 171 /** The list of module func blocks */
 172 static fbgetfunctype*
 173 module_funcs_avail(void)
 174 {
 175         static struct module_func_block* (*fb[])(void) = {
 176                 &dns64_get_funcblock,
 177 #ifdef WITH_PYTHONMODULE
 178                 &pythonmod_get_funcblock,
 179 #endif
 180 #ifdef WITH_DYNLIBMODULE
 181                 &dynlibmod_get_funcblock,
 182 #endif
 183 #ifdef USE_CACHEDB
 184                 &cachedb_get_funcblock,
 185 #endif
 186 #ifdef USE_IPSECMOD
 187                 &ipsecmod_get_funcblock,
 188 #endif
 189 #ifdef CLIENT_SUBNET
 190                 &subnetmod_get_funcblock,
 191 #endif
 192 #ifdef USE_IPSET
 193                 &ipset_get_funcblock,
 194 #endif
 195                 &respip_get_funcblock,
 196                 &val_get_funcblock,
 197                 &iter_get_funcblock,
 198                 NULL};
 199         return fb;
 200 }
 201
 202 struct
 203 module_func_block* module_factory(const char** str)
 204 {
 205         int i = 0;
 206         const char* s = *str;
 207         const char** names = module_list_avail();
 208         fbgetfunctype* fb = module_funcs_avail();
 209         while(*s && isspace((unsigned char)*s))
 210                 s++;
 211         while(names[i]) {
 212                 if(strncmp(names[i], s, strlen(names[i])) == 0) {
 213                         s += strlen(names[i]);
 214                         *str = s;
 215                         return (*fb[i])();
 216                 }
 217                 i++;
 218         }
 219         return NULL;
 220 }
 221
 222 int
 223 modstack_setup(struct module_stack* stack, const char* module_conf,
 224         struct module_env* env)
 225 {
 226         int i;
 227         if(stack->num != 0)
 228                 modstack_desetup(stack, env);
 229         /* fixed setup of the modules */
 230         if(!modstack_config(stack, module_conf)) {
 231                 return 0;
 232         }
 233         env->need_to_validate = 0; /* set by module init below */
 234         for(i=0; i<stack->num; i++) {
 235                 verbose(VERB_OPS, "init module %d: %s",
 236                         i, stack->mod[i]->name);
 237                 fptr_ok(fptr_whitelist_mod_init(stack->mod[i]->init));
 238                 if(!(*stack->mod[i]->init)(env, i)) {
 239                         log_err("module init for module %s failed",
 240                                 stack->mod[i]->name);
 241                         return 0;
 242                 }
 243         }
 244         return 1;
 245 }
 246
 247 void
 248 modstack_desetup(struct module_stack* stack, struct module_env* env)
 249 {
 250         int i;
 251         for(i=0; i<stack->num; i++) {
 252                 fptr_ok(fptr_whitelist_mod_deinit(stack->mod[i]->deinit));
 253                 (*stack->mod[i]->deinit)(env, i);
 254         }
 255         stack->num = 0;
 256         free(stack->mod);
 257         stack->mod = NULL;
 258 }
 259
 260 int
 261 modstack_find(struct module_stack* stack, const char* name)
 262 {
 263         int i;
 264         for(i=0; i<stack->num; i++) {
 265                 if(strcmp(stack->mod[i]->name, name) == 0)
 266                         return i;
 267         }
 268         return -1;
 269 }
 270
 271 size_t
 272 mod_get_mem(struct module_env* env, const char* name)
 273 {
 274         int m = modstack_find(&env->mesh->mods, name);
 275         if(m != -1) {
 276                 fptr_ok(fptr_whitelist_mod_get_mem(env->mesh->
 277                         mods.mod[m]->get_mem));
 278                 return (*env->mesh->mods.mod[m]->get_mem)(env, m);
 279         }
 280         return 0;
 281 }