/*
 * services/modstack.c - stack of modules
 *
 * Copyright (c) 2007, NLnet Labs. All rights reserved.
 *
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * \file
 *
 * This file contains functions to help maintain a stack of modules.
 */
#include "config.h"
#include <ctype.h>
#include "services/modstack.h"
#include "util/module.h"
#include "util/fptr_wlist.h"
#include "dns64/dns64.h"
#include "iterator/iterator.h"
#include "validator/validator.h"
#include "respip/respip.h"

#ifdef WITH_PYTHONMODULE
#include "pythonmod/pythonmod.h"
#endif
#ifdef WITH_DYNLIBMODULE
#include "dynlibmod/dynlibmod.h"
#endif
#ifdef USE_CACHEDB
#include "cachedb/cachedb.h"
#endif
#ifdef USE_IPSECMOD
#include "ipsecmod/ipsecmod.h"
#endif
#ifdef CLIENT_SUBNET
#include "edns-subnet/subnetmod.h"
#endif
#ifdef USE_IPSET
#include "ipset/ipset.h"
#endif

/** count number of modules (words) in the string */
static int
count_modules(const char* s)
{
        int num = 0;
        if(!s)
                return 0;
        while(*s) {
                /* skip whitespace */
                while(*s && isspace((unsigned char)*s))
                        s++;
                if(*s && !isspace((unsigned char)*s)) {
                        /* skip identifier */
                        num++;
                        while(*s && !isspace((unsigned char)*s))
                                s++;
                }
        }
        return num;
}

void
modstack_init(struct module_stack* stack)
{
	stack->num = 0;
	stack->mod = NULL;
}

void
modstack_free(struct module_stack* stack)
{
	if(!stack)
		return;
        stack->num = 0;
        free(stack->mod);
        stack->mod = NULL;
}

int
modstack_config(struct module_stack* stack, const char* module_conf)
{
	int i;
	verbose(VERB_QUERY, "module config: \"%s\"", module_conf);
	stack->num = count_modules(module_conf);
	if(stack->num == 0) {
		log_err("error: no modules specified");
		return 0;
	}
	if(stack->num > MAX_MODULE) {
		log_err("error: too many modules (%d max %d)",
			stack->num, MAX_MODULE);
		return 0;
	}
	stack->mod = (struct module_func_block**)calloc((size_t)
		stack->num, sizeof(struct module_func_block*));
	if(!stack->mod) {
		log_err("out of memory");
		return 0;
	}
	for(i=0; i<stack->num; i++) {
		stack->mod[i] = module_factory(&module_conf);
		if(!stack->mod[i]) {
			char md[256];
			char * s = md;
			snprintf(md, sizeof(md), "%s", module_conf);
			/* Leading spaces are present on errors. */
			while (*s && isspace((unsigned char)*s))
				s++;
			if(strchr(s, ' ')) *(strchr(s, ' ')) = 0;
			if(strchr(s, '\t')) *(strchr(s, '\t')) = 0;
			log_err("Unknown value in module-config, module: '%s'."
				" This module is not present (not compiled in);"
				" see the list of linked modules with unbound -V", s);
			return 0;
		}
	}
	return 1;
}

/** The list of module names */
const char**
module_list_avail(void)
{
	/* these are the modules available */
	static const char* names[] = {
		"dns64",
#ifdef WITH_PYTHONMODULE
		"python",
#endif
#ifdef WITH_DYNLIBMODULE
		"dynlib",
#endif
#ifdef USE_CACHEDB
		"cachedb",
#endif
#ifdef USE_IPSECMOD
		"ipsecmod",
#endif
#ifdef CLIENT_SUBNET
		"subnetcache",
#endif
#ifdef USE_IPSET
		"ipset",
#endif
		"respip",
		"validator",
		"iterator",
		NULL};
	return names;
}

/** func block get function type */
typedef struct module_func_block* (*fbgetfunctype)(void);

/** The list of module func blocks */
static fbgetfunctype*
module_funcs_avail(void)
{
        static struct module_func_block* (*fb[])(void) = {
		&dns64_get_funcblock,
#ifdef WITH_PYTHONMODULE
		&pythonmod_get_funcblock,
#endif
#ifdef WITH_DYNLIBMODULE
		&dynlibmod_get_funcblock,
#endif
#ifdef USE_CACHEDB
		&cachedb_get_funcblock,
#endif
#ifdef USE_IPSECMOD
		&ipsecmod_get_funcblock,
#endif
#ifdef CLIENT_SUBNET
		&subnetmod_get_funcblock,
#endif
#ifdef USE_IPSET
		&ipset_get_funcblock,
#endif
		&respip_get_funcblock,
		&val_get_funcblock,
		&iter_get_funcblock,
		NULL};
	return fb;
}

struct
module_func_block* module_factory(const char** str)
{
        int i = 0;
        const char* s = *str;
	const char** names = module_list_avail();
	fbgetfunctype* fb = module_funcs_avail();
        while(*s && isspace((unsigned char)*s))
                s++;
	while(names[i]) {
                if(strncmp(names[i], s, strlen(names[i])) == 0) {
                        s += strlen(names[i]);
                        *str = s;
                        return (*fb[i])();
                }
		i++;
        }
        return NULL;
}

int
modstack_call_startup(struct module_stack* stack, const char* module_conf,
	struct module_env* env)
{
        int i;
        if(stack->num != 0)
		fatal_exit("unexpected already initialised modules");
        /* fixed setup of the modules */
        if(!modstack_config(stack, module_conf)) {
		return 0;
        }
        for(i=0; i<stack->num; i++) {
		if(stack->mod[i]->startup == NULL)
			continue;
                verbose(VERB_OPS, "startup module %d: %s",
                        i, stack->mod[i]->name);
                fptr_ok(fptr_whitelist_mod_startup(stack->mod[i]->startup));
                if(!(*stack->mod[i]->startup)(env, i)) {
                        log_err("module startup for module %s failed",
                                stack->mod[i]->name);
			return 0;
                }
        }
	return 1;
}

int
modstack_call_init(struct module_stack* stack, const char* module_conf,
	struct module_env* env)
{
        int i, changed = 0;
        env->need_to_validate = 0; /* set by module init below */
        for(i=0; i<stack->num; i++) {
		while(*module_conf && isspace((unsigned char)*module_conf))
			module_conf++;
                if(strncmp(stack->mod[i]->name, module_conf,
			strlen(stack->mod[i]->name))) {
			if(stack->mod[i]->startup || stack->mod[i]->destartup) {
				log_err("changed module ordering during reload not supported, for module that needs startup");
				return 0;
			} else {
				changed = 1;
			}
		}
		module_conf += strlen(stack->mod[i]->name);
	}
	if(changed) {
		modstack_free(stack);
		if(!modstack_config(stack, module_conf)) {
			return 0;
		}
	}

        for(i=0; i<stack->num; i++) {
                verbose(VERB_OPS, "init module %d: %s",
                        i, stack->mod[i]->name);
                fptr_ok(fptr_whitelist_mod_init(stack->mod[i]->init));
                if(!(*stack->mod[i]->init)(env, i)) {
                        log_err("module init for module %s failed",
                                stack->mod[i]->name);
			return 0;
                }
        }
	return 1;
}

void
modstack_call_deinit(struct module_stack* stack, struct module_env* env)
{
        int i;
        for(i=0; i<stack->num; i++) {
                fptr_ok(fptr_whitelist_mod_deinit(stack->mod[i]->deinit));
                (*stack->mod[i]->deinit)(env, i);
        }
}

void
modstack_call_destartup(struct module_stack* stack, struct module_env* env)
{
        int i;
        for(i=0; i<stack->num; i++) {
		if(stack->mod[i]->destartup == NULL)
			continue;
                fptr_ok(fptr_whitelist_mod_destartup(stack->mod[i]->destartup));
                (*stack->mod[i]->destartup)(env, i);
        }
}

int
modstack_find(struct module_stack* stack, const char* name)
{
	int i;
	for(i=0; i<stack->num; i++) {
		if(strcmp(stack->mod[i]->name, name) == 0)
			return i;
	}
	return -1;
}

size_t
mod_get_mem(struct module_env* env, const char* name)
{
	int m = modstack_find(&env->mesh->mods, name);
	if(m != -1) {
		fptr_ok(fptr_whitelist_mod_get_mem(env->mesh->
			mods.mod[m]->get_mem));
		return (*env->mesh->mods.mod[m]->get_mem)(env, m);
	}
	return 0;
}
