modstack.c revision 269257 
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 "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 */
54static int
55count_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
74void
75modstack_init(struct module_stack* stack)
76{
77	stack->num = 0;
78	stack->mod = NULL;
79}
80
81int
82modstack_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 */
114const char**
115module_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 */
129typedef struct module_func_block* (*fbgetfunctype)(void);
130
131/** The list of module func blocks */
132static fbgetfunctype*
133module_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
145struct
146module_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
165int
166modstack_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
190void
191modstack_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
203int
204modstack_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}
213