modstack.c revision 285206 
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 */
55static int
56count_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
75void
76modstack_init(struct module_stack* stack)
77{
78	stack->num = 0;
79	stack->mod = NULL;
80}
81
82int
83modstack_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 */
115const char**
116module_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 */
131typedef struct module_func_block* (*fbgetfunctype)(void);
132
133/** The list of module func blocks */
134static fbgetfunctype*
135module_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
148struct
149module_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
168int
169modstack_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
193void
194modstack_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
206int
207modstack_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}
216