/*
 * Copyright (C) 2008 iptelorg GmbH
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <string.h>

#include "../mem/mem.h"
#include "../ut.h"
#include "cfg_struct.h"
#include "cfg.h"
#include "cfg_ctx.h"
#include "cfg_script.h"

/* allocates memory for a new config script variable
 * The value of the variable is not set!
 */
cfg_script_var_t *new_cfg_script_var(char *gname, char *vname, unsigned int type,
					char *descr)
{
	cfg_group_t	*group;
	cfg_script_var_t	*var, **last_var;
	int	gname_len, vname_len, descr_len;

	LM_DBG("declaring %s.%s\n", gname, vname);

	if (cfg_shmized) {
		LM_ERR("too late variable declaration, "
			"the config has been already shmized\n");
		return NULL;
	}

	gname_len = strlen(gname);
	vname_len = strlen(vname);
	/* the group may have been already declared */
	group = cfg_lookup_group(gname, gname_len);
	if (group) {
		if (group->dynamic == CFG_GROUP_STATIC) {
			/* the group has been already declared by a module or by the core */
			LM_ERR("configuration group has been already declared: %s\n",
				gname);
			return NULL;
		}
		/* the dynamic or empty group is found */
		/* verify that the variable does not exist */
		for (	var = (cfg_script_var_t *)group->vars;
			var;
			var = var->next
		) {
			if ((var->name_len == vname_len) &&
			(memcmp(var->name, vname, vname_len) == 0)) {
				LM_ERR("variable already exists: %s.%s\n", gname, vname);
				return NULL;
			}
		}
		if (group->dynamic == CFG_GROUP_UNKNOWN)
			group->dynamic = CFG_GROUP_DYNAMIC;

	} else {
		/* create a new group with NULL values, we will fix it later,
		when all the variables are known */
		group = cfg_new_group(gname, gname_len,
					0 /* num */, NULL /* mapping */,
					NULL /* vars */, 0 /* size */, NULL /* handle */);
		if (!group) goto error;
		group->dynamic = CFG_GROUP_DYNAMIC;
	}

	switch (type) {
	case CFG_VAR_INT:
		group->size = ROUND_INT(group->size);
		group->size += sizeof(int);
		break;

	case CFG_VAR_STR:
		group->size = ROUND_POINTER(group->size);
		group->size += sizeof(str);
		break;

	default:
		LM_ERR("unsupported variable type\n");
		return NULL;
	}

	group->num++;
	if (group->num > CFG_MAX_VAR_NUM) {
		LM_ERR("too many variables (%d) within a single group,"
				" the limit is %d. Increase CFG_MAX_VAR_NUM, or split the group"
				" into multiple definitions.\n",
			group->num, CFG_MAX_VAR_NUM);
		return NULL;
	}

	var = (cfg_script_var_t *)pkg_malloc(sizeof(cfg_script_var_t));
	if (!var) goto error;
	memset(var, 0, sizeof(cfg_script_var_t));
	var->type = type;

	/* Add the variable to the end of the group.
	 * The order is important because the padding depends on that.
	 * The list will be travelled later again, which must be done in
	 * the same order. */
	last_var = (cfg_script_var_t **)(void **)&group->vars;
	while ((*last_var))
		last_var = &((*last_var)->next);
	*last_var = var;
	var->next = NULL;

	/* clone the name of the variable */
	var->name = (char *)pkg_malloc(sizeof(char) * (vname_len + 1));
	if (!var->name) goto error;
	memcpy(var->name, vname, vname_len + 1);
	var->name_len = vname_len;

	if (descr) {
		/* save the description */
		descr_len = strlen(descr);
		var->descr = (char *)pkg_malloc(sizeof(char) * (descr_len + 1));
		if (!var->descr) goto error;
		memcpy(var->descr, descr, descr_len + 1);
	}

	return var;

error:
	PKG_MEM_ERROR;
	return NULL;
}

/* Rewrite the value of an already declared script variable before forking.
 * Return value:
 * 	 0: success
 *	-1: error
 *	 1: variable not found
 */
int cfg_set_script_var(cfg_group_t *group, str *var_name,
			void *val, unsigned int val_type)
{
	cfg_script_var_t	*var;
	void	*v;
	str	s;

	if (cfg_shmized || (group->dynamic != CFG_GROUP_DYNAMIC)) {
		LM_ERR("not a dynamic group before forking\n");
		return -1;
	}

	for (	var = (cfg_script_var_t *)(void *)group->vars;
		var;
		var = var->next
	) {
		if ((var->name_len == var_name->len)
			&& (memcmp(var->name, var_name->s, var_name->len) == 0)
		) {
			switch (var->type) {
			case CFG_VAR_INT:
				if (convert_val(val_type, val, CFG_INPUT_INT, &v))
					goto error;
				if ((var->min || var->max)
					&& ((var->min > (int)(long)v) || (var->max < (int)(long)v))
				) {
					LM_ERR("integer value is out of range\n");
					goto error;
				}
				var->val.i = (int)(long)v;
				break;

			case CFG_VAR_STR:
				if (convert_val(val_type, val, CFG_INPUT_STR, &v))
					goto error;
				if (((str *)v)->s) {
					s.len = ((str *)v)->len;
					s.s = pkg_malloc(sizeof(char) * (s.len + 1));
					if (!s.s) {
						PKG_MEM_ERROR;
						goto error;
					}
					memcpy(s.s, ((str *)v)->s, s.len);
					s.s[s.len] = '\0';
				} else {
					s.s = NULL;
					s.len = 0;
				}
				if (var->val.s.s)
					pkg_free(var->val.s.s);
				var->val.s = s;
				break;

			default:
				LM_ERR("unsupported variable type\n");
				goto error;
			}

			convert_val_cleanup();
			return 0;
		}
	}

	return 1;

error:
	LM_ERR("failed to set the script variable: %.*s.%.*s\n",
			group->name_len, group->name,
			var_name->len, var_name->s);
	return -1;
}

/* fix-up the dynamically declared group:
 *  - allocate memory for the arrays
 *  - set the values within the memory block
 */
int cfg_script_fixup(cfg_group_t *group, unsigned char *block)
{
	cfg_mapping_t		*mapping = NULL;
	cfg_def_t		*def = NULL;
	void			**handle = NULL;
	int			i, offset;
	cfg_script_var_t	*script_var, *script_var2;
	str			s;

	if(group==NULL || group->vars==NULL) {
		LM_ERR("invalid group parameter: %p\n", group);
		return -1;
	}
	mapping = (cfg_mapping_t *)pkg_malloc(sizeof(cfg_mapping_t)*group->num);
	if (!mapping) goto error;
	memset(mapping, 0, sizeof(cfg_mapping_t)*group->num);

	/* The variable definition array must look like as if it was declared
	 * in C code, thus, add an additional slot at the end with NULL values */
	def = (cfg_def_t *)pkg_malloc(sizeof(cfg_def_t)*(group->num + 1));
	if (!def) goto error;
	memset(def, 0, sizeof(cfg_def_t)*(group->num + 1));

	/* fill the definition and the mapping arrays */
	offset = 0;
	for (	i = 0, script_var = (cfg_script_var_t *)group->vars;
		script_var;
		i++, script_var = script_var->next
	) {
		/* there has been already memory allocated for the name */
		def[i].name = script_var->name;
		def[i].type = script_var->type | (script_var->type << CFG_INPUT_SHIFT);
		def[i].descr = script_var->descr;
		def[i].min = script_var->min;
		def[i].max = script_var->max;

		mapping[i].def = &(def[i]);
		mapping[i].name_len = script_var->name_len;
		mapping[i].pos = i;

		switch (script_var->type) {
		case CFG_VAR_INT:
			offset = ROUND_INT(offset);
			mapping[i].offset = offset;

			*(int *)(block + offset) = script_var->val.i;

			offset += sizeof(int);
			break;

		case CFG_VAR_STR:
			offset = ROUND_POINTER(offset);
			mapping[i].offset = offset;

			if (cfg_clone_str(&(script_var->val.s), &s)) goto error;
			memcpy(block + offset, &s, sizeof(str));
			mapping[i].flag |= cfg_var_shmized;

			offset += sizeof(str);
			break;
		}
	}

	/* Sanity check for the group size, make sure that the
	 * newly calculated size equals the already calculated
	 * group size. */
	if (offset != group->size) {
		LM_ERR("BUG: incorrect group size: %d; previously calculated value: %d \n", offset, group->size);
		goto error;
	}

	/* allocate a handle even if it will not be used to
	directly access the variable, like handle->variable
	cfg_get_* functions access the memory block via the handle
	to make sure that it is always safe, thus, it must be created */
	handle = (void **)pkg_malloc(sizeof(void *));
	if (!handle) goto error;
	*handle = NULL;
	group->handle = handle;

	group->mapping = mapping;

	/* everything went fine, we can free the temporary list */
	script_var = (cfg_script_var_t *)group->vars;
	group->vars = NULL;
	while (script_var) {
		script_var2 = script_var->next;
		if ((script_var->type == CFG_VAR_STR) && script_var->val.s.s)
			pkg_free(script_var->val.s.s);
		pkg_free(script_var);
		script_var = script_var2;
	}

	return 0;

error:
	if (mapping) pkg_free(mapping);
	if (def) pkg_free(def);
	if (handle) pkg_free(handle);

	PKG_MEM_ERROR;
	return -1;
}

/* destory a dynamically allocated group definition */
void cfg_script_destroy(cfg_group_t *group)
{
	int	i;
	cfg_script_var_t	*script_var, *script_var2;

	if (group->mapping && group->mapping->def) {
		for (i=0; i<group->num; i++) {
			if (group->mapping->def[i].name)
				pkg_free(group->mapping->def[i].name);
			if (group->mapping->def[i].descr)
				pkg_free(group->mapping->def[i].descr);
		}
		pkg_free(group->mapping->def);
	}
	if (group->mapping) pkg_free(group->mapping);
	if (group->handle) pkg_free(group->handle);

	/* it may happen that the temporary var list
	still exists because the fixup failed and did not complete */
	script_var = (cfg_script_var_t *)group->vars;
	while (script_var) {
		script_var2 = script_var->next;
		if ((script_var->type == CFG_VAR_STR) && script_var->val.s.s)
			pkg_free(script_var->val.s.s);
		pkg_free(script_var);
		script_var = script_var2;
	}
}
