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 */ 71static int 72count_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 91void 92modstack_init(struct module_stack* stack) 93{ 94 stack->num = 0; 95 stack->mod = NULL; 96} 97 98int 99modstack_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 char * s = md; 124 snprintf(md, sizeof(md), "%s", module_conf); 125 /* Leading spaces are present on errors. */ 126 while (*s && isspace((unsigned char)*s)) 127 s++; 128 if(strchr(s, ' ')) *(strchr(s, ' ')) = 0; 129 if(strchr(s, '\t')) *(strchr(s, '\t')) = 0; 130 log_err("Unknown value in module-config, module: '%s'." 131 " This module is not present (not compiled in)," 132 " See the list of linked modules with unbound -V", s); 133 return 0; 134 } 135 } 136 return 1; 137} 138 139/** The list of module names */ 140const char** 141module_list_avail(void) 142{ 143 /* these are the modules available */ 144 static const char* names[] = { 145 "dns64", 146#ifdef WITH_PYTHONMODULE 147 "python", 148#endif 149#ifdef WITH_DYNLIBMODULE 150 "dynlib", 151#endif 152#ifdef USE_CACHEDB 153 "cachedb", 154#endif 155#ifdef USE_IPSECMOD 156 "ipsecmod", 157#endif 158#ifdef CLIENT_SUBNET 159 "subnetcache", 160#endif 161#ifdef USE_IPSET 162 "ipset", 163#endif 164 "respip", 165 "validator", 166 "iterator", 167 NULL}; 168 return names; 169} 170 171/** func block get function type */ 172typedef struct module_func_block* (*fbgetfunctype)(void); 173 174/** The list of module func blocks */ 175static fbgetfunctype* 176module_funcs_avail(void) 177{ 178 static struct module_func_block* (*fb[])(void) = { 179 &dns64_get_funcblock, 180#ifdef WITH_PYTHONMODULE 181 &pythonmod_get_funcblock, 182#endif 183#ifdef WITH_DYNLIBMODULE 184 &dynlibmod_get_funcblock, 185#endif 186#ifdef USE_CACHEDB 187 &cachedb_get_funcblock, 188#endif 189#ifdef USE_IPSECMOD 190 &ipsecmod_get_funcblock, 191#endif 192#ifdef CLIENT_SUBNET 193 &subnetmod_get_funcblock, 194#endif 195#ifdef USE_IPSET 196 &ipset_get_funcblock, 197#endif 198 &respip_get_funcblock, 199 &val_get_funcblock, 200 &iter_get_funcblock, 201 NULL}; 202 return fb; 203} 204 205struct 206module_func_block* module_factory(const char** str) 207{ 208 int i = 0; 209 const char* s = *str; 210 const char** names = module_list_avail(); 211 fbgetfunctype* fb = module_funcs_avail(); 212 while(*s && isspace((unsigned char)*s)) 213 s++; 214 while(names[i]) { 215 if(strncmp(names[i], s, strlen(names[i])) == 0) { 216 s += strlen(names[i]); 217 *str = s; 218 return (*fb[i])(); 219 } 220 i++; 221 } 222 return NULL; 223} 224 225int 226modstack_setup(struct module_stack* stack, const char* module_conf, 227 struct module_env* env) 228{ 229 int i; 230 if(stack->num != 0) 231 modstack_desetup(stack, env); 232 /* fixed setup of the modules */ 233 if(!modstack_config(stack, module_conf)) { 234 return 0; 235 } 236 env->need_to_validate = 0; /* set by module init below */ 237 for(i=0; i<stack->num; i++) { 238 verbose(VERB_OPS, "init module %d: %s", 239 i, stack->mod[i]->name); 240 fptr_ok(fptr_whitelist_mod_init(stack->mod[i]->init)); 241 if(!(*stack->mod[i]->init)(env, i)) { 242 log_err("module init for module %s failed", 243 stack->mod[i]->name); 244 return 0; 245 } 246 } 247 return 1; 248} 249 250void 251modstack_desetup(struct module_stack* stack, struct module_env* env) 252{ 253 int i; 254 for(i=0; i<stack->num; i++) { 255 fptr_ok(fptr_whitelist_mod_deinit(stack->mod[i]->deinit)); 256 (*stack->mod[i]->deinit)(env, i); 257 } 258 stack->num = 0; 259 free(stack->mod); 260 stack->mod = NULL; 261} 262 263int 264modstack_find(struct module_stack* stack, const char* name) 265{ 266 int i; 267 for(i=0; i<stack->num; i++) { 268 if(strcmp(stack->mod[i]->name, name) == 0) 269 return i; 270 } 271 return -1; 272} 273 274size_t 275mod_get_mem(struct module_env* env, const char* name) 276{ 277 int m = modstack_find(&env->mesh->mods, name); 278 if(m != -1) { 279 fptr_ok(fptr_whitelist_mod_get_mem(env->mesh-> 280 mods.mod[m]->get_mem)); 281 return (*env->mesh->mods.mod[m]->get_mem)(env, m); 282 } 283 return 0; 284} 285