mod_fix.c

/*
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips 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
 *
 * opensips 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
 */

/*!
 * \file
 * \brief Generic fixup functions for module function parameter.
 * - \ref FixupNameFormat
 */

#include <stdio.h>
#include <stdlib.h>

#include "mem/mem.h"
#include "str.h"
#include "ut.h"
#include "error.h"
#include "mod_fix.h"

static char *re_buff=NULL;
static int re_buff_len = 0;
int fixup_regcomp(regex_t **re, str *re_str, int dup_nt)
{
	char *regex;

	if (dup_nt) {
		if (re_str->len + 1 > re_buff_len) {
			re_buff = pkg_realloc(re_buff,re_str->len + 1);
			if (re_buff == NULL) {
				LM_ERR("No more pkg \n");
				return E_OUT_OF_MEM;
			}

			re_buff_len = re_str->len + 1;
		}

		memcpy(re_buff,re_str->s,re_str->len);
		re_buff[re_str->len] = 0;

		regex = re_buff;
	} else
		regex = re_str->s;

	if ((*re = pkg_malloc(sizeof **re)) == 0) {
		LM_ERR("no more pkg memory\n");
		return E_OUT_OF_MEM;
	}
	if (regcomp(*re, regex, (REG_EXTENDED|REG_ICASE|REG_NEWLINE))) {
		LM_ERR("bad re %s\n", regex);
		pkg_free(*re);
		return E_BAD_RE;
	}

	return 0;
}

static inline gparam_p alloc_gp(void)
{
	gparam_p gp;

	gp = pkg_malloc(sizeof *gp);
	if (!gp) {
		LM_ERR("no more pkg memory\n");
		return NULL;
	}
	memset(gp, 0, sizeof *gp);

	return gp;
}

int fix_cmd(struct cmd_param *params, action_elem_t *elems)
{
	int i;
	struct cmd_param *param;
	gparam_p gp = NULL;
	int ret;
	pv_elem_t *pve;
	regex_t *re = NULL;

	for (param=params, i=1; param->flags; param++, i++) {
		if ((elems[i].type == NOSUBTYPE) ||
			(elems[i].type == NULLV_ST)) {
			if (param->flags & CMD_PARAM_OPT) {
				if (param->fixup && (param->flags & CMD_PARAM_FIX_NULL)) {
					if ((gp = alloc_gp()) == NULL)
						return E_OUT_OF_MEM;

					gp->v.val = NULL;
					if (param->fixup(&gp->v.val) < 0) {
						LM_ERR("Fixup failed for param [%d]\n", i);
						ret = E_UNSPEC;
						goto error;
					}
					gp->type = GPARAM_TYPE_FIXUP;
				}

				goto fill_elems;
			} else {
				LM_BUG("Mandatory parameter missing\n");
				ret = E_BUG;
				goto error;
			}
		}

		if ((gp = alloc_gp()) == NULL)
			return E_OUT_OF_MEM;

		if (param->flags & CMD_PARAM_INT) {

			if (elems[i].type == NUMBER_ST) {
				if (param->fixup) {
					gp->v.val = (void *)&elems[i].u.number;
					if (param->fixup(&gp->v.val) < 0) {
						LM_ERR("Fixup failed for param [%d]\n", i);
						ret = E_UNSPEC;
						goto error;
					}
					gp->type = GPARAM_TYPE_FIXUP;
				} else {
					gp->v.ival = elems[i].u.number;
					gp->type = GPARAM_TYPE_INT;
				}
			} else if (elems[i].type == SCRIPTVAR_ST) {
				gp->v.pvs = elems[i].u.data;
				gp->type = GPARAM_TYPE_PVS;
			} else {
				LM_ERR("Param [%d] expected to be an integer "
					"or variable\n", i);
				return E_CFG;
			}

		} else if (param->flags & CMD_PARAM_STR) {

			if (elems[i].type == STR_ST) {
				if (pv_parse_format(&elems[i].u.s, &pve) < 0) {
					LM_ERR("Failed to parse formatted string in param "
						"[%d]\n",i);
					ret = E_UNSPEC;
					goto error;
				}

				if ((param->flags & CMD_PARAM_NO_EXPAND) ||
				    (!pve->next && pve->spec.type == PVT_NONE)) {

					/* ignoring/no variables in the provided string */
					pv_elem_free_all(pve);

					if (param->fixup) {
						gp->v.val = (void *)&elems[i].u.s;
						if (param->fixup(&gp->v.val) < 0) {
							LM_ERR("Fixup failed for param [%d]\n", i);
							ret = E_UNSPEC;
							goto error;
						}
						gp->type = GPARAM_TYPE_FIXUP;
					} else {
						gp->v.sval = elems[i].u.s;
						gp->type = GPARAM_TYPE_STR;
					}
				} else {
					gp->v.pve = pve;
					gp->type = GPARAM_TYPE_PVE;
				}
			} else if (elems[i].type == SCRIPTVAR_ST) {
				gp->v.pvs = elems[i].u.data;
				gp->type = GPARAM_TYPE_PVS;
			} else {
				LM_ERR("Param [%d] expected to be a string "
					"or variable\n", i);
				ret = E_CFG;
				goto error;
			}

		} else if (param->flags & CMD_PARAM_VAR) {

			if (elems[i].type != SCRIPTVAR_ST) {
				LM_ERR("Param [%d] expected to be a variable\n",i);
				ret = E_CFG;
				goto error;
			}

			if (param->fixup) {
				gp->v.val = elems[i].u.data;
				if (param->fixup(&gp->v.val) < 0) {
					LM_ERR("Fixup failed for param [%d]\n", i);
					ret = E_UNSPEC;
					goto error;
				}
				gp->type = GPARAM_TYPE_FIXUP;
			} else {
				gp->v.pvs = elems[i].u.data;
				gp->type = GPARAM_TYPE_PVS;
			}

		} else if (param->flags & CMD_PARAM_REGEX) {

			if (elems[i].type == STR_ST) {
				if (pv_parse_format(&elems[i].u.s, &pve) < 0) {
					LM_ERR("Failed to parse formatted string in param "
						"[%d]\n",i);
					ret = E_UNSPEC;
					goto error;
				}
				if (!pve->next && pve->spec.type == PVT_NONE) {
					/* no variables in the provided string */
					pv_elem_free_all(pve);

					ret = fixup_regcomp(&re, &elems[i].u.s, 0);
					if (ret < 0)
						return ret;

					if (param->fixup) {
						gp->v.val = re;
						if (param->fixup(&gp->v.val) < 0) {
							LM_ERR("Fixup failed for param [%d]\n", i);
							ret = E_UNSPEC;
							goto error;
						}
						gp->type = GPARAM_TYPE_FIXUP;
					} else {
						gp->v.re = re;
						gp->type = GPARAM_TYPE_REGEX;
					}
				} else {
					gp->v.pve = pve;
					gp->type = GPARAM_TYPE_PVE;
				}
			} else if (elems[i].type == SCRIPTVAR_ST) {
				gp->v.pvs = elems[i].u.data;
				gp->type = GPARAM_TYPE_PVS;
			} else {
				LM_ERR("Param [%d] expected to be a string "
					"or variable\n", i);
				ret = E_CFG;
				goto error;
			}

		} else {
			LM_BUG("Bad command parameter type\n");
			ret = E_BUG;
			goto error;
		}

fill_elems:
		elems[i].u.data = (void*)gp;
	}

	return 0;
error:
	if (gp)
		pkg_free(gp);
	if (re)
		pkg_free(re);
	return ret;
}

int get_cmd_fixups(struct sip_msg* msg, struct cmd_param *params,
				action_elem_t *elems, void **cmdp, pv_value_t *tmp_vals)
{
	int i;
	struct cmd_param *param;
	gparam_p gp;
	regex_t *re = NULL;
	int ret;

	for (param=params, i=1; param->flags; param++, i++) {
		gp = (gparam_p)elems[i].u.data;
		if (!gp) {
			cmdp[i-1] = NULL;
			continue;
		}

		if (param->flags & CMD_PARAM_INT) {

			switch (gp->type) {
			case GPARAM_TYPE_INT:
				cmdp[i-1] = (void*)&gp->v.ival;
				break;
			case GPARAM_TYPE_PVS:
				if (pv_get_spec_value(msg, gp->v.pvs, &tmp_vals[i]) != 0) {
					LM_ERR("Failed to get spec value in param [%d]\n", i);
					return E_UNSPEC;
				}
				if (tmp_vals[i].flags & PV_VAL_NULL ||
					!(tmp_vals[i].flags & PV_VAL_INT)) {
					LM_ERR("Variable in param [%d] is not an integer\n", i);
					return E_UNSPEC;
				}

				cmdp[i-1] = (void *)&tmp_vals[i].ri;

				/* run fixup as we now have the value of the variable */
				if (param->fixup && param->fixup(&cmdp[i-1]) < 0) {
					LM_ERR("Fixup failed for param [%d]\n", i);
					return E_UNSPEC;
				}

				break;
			case GPARAM_TYPE_FIXUP:
				/* fixup was possible at startup */
				cmdp[i-1] = gp->v.val;
				break;
			default:
				LM_BUG("Bad type for generic parameter\n");
				return E_BUG;
			}

		} else if (param->flags & CMD_PARAM_STR) {

			switch (gp->type) {
			case GPARAM_TYPE_STR:
				cmdp[i-1] = (void*)&gp->v.sval;
				break;
			case GPARAM_TYPE_PVE:
				if (pv_printf_s(msg, gp->v.pve, &tmp_vals[i].rs) != 0) {
					LM_ERR("Failed to print formatted string in param [%d]\n", i);
					return E_UNSPEC;
				}

				cmdp[i-1] = &tmp_vals[i].rs;

				if (param->fixup && param->fixup(&cmdp[i-1]) < 0) {
					LM_ERR("Fixup failed for param [%d]\n", i);
					return E_UNSPEC;
				}

				break;
			case GPARAM_TYPE_PVS:
				if (pv_get_spec_value(msg, gp->v.pvs, &tmp_vals[i]) != 0) {
					LM_ERR("Failed to get spec value in param [%d]\n", i);
					return E_UNSPEC;
				}
				if (tmp_vals[i].flags & PV_VAL_NULL ||
					!(tmp_vals[i].flags & PV_VAL_STR)) {
					LM_ERR("Variable in param [%d] is not a string\n", i);
					return E_UNSPEC;
				}

				cmdp[i-1] = &tmp_vals[i].rs;

				if (param->fixup && param->fixup(&cmdp[i-1]) < 0) {
					LM_ERR("Fixup failed for param [%d]\n", i);
					return E_UNSPEC;
				}

				break;
			case GPARAM_TYPE_FIXUP:
				cmdp[i-1] = gp->v.val;
				break;
			default:
				LM_BUG("Bad type for generic parameter\n");
				return E_BUG;
			}

		} else if (param->flags & CMD_PARAM_VAR) {

			switch (gp->type) {
			case GPARAM_TYPE_PVS:
				cmdp[i-1] = (void *)gp->v.pvs;
				break;
			case GPARAM_TYPE_FIXUP:
				cmdp[i-1] = gp->v.val;
				break;
			default:
				LM_BUG("Bad type for generic parameter\n");
				return E_BUG;
			}

		} else if (param->flags & CMD_PARAM_REGEX) {

			switch (gp->type) {
			case GPARAM_TYPE_REGEX:
				cmdp[i-1] = (void*)&gp->v.re;
				break;
			case GPARAM_TYPE_PVE:
				if (pv_printf_s(msg, gp->v.pve, &tmp_vals[i].rs) != 0) {
					LM_ERR("Failed to print formatted string in param [%d]\n", i);
					return E_UNSPEC;
				}

				ret = fixup_regcomp(&re, &tmp_vals[i].rs, 1);
				if (ret < 0)
					return ret;
				cmdp[i-1] = re;

				if (param->fixup) {
					if (param->fixup(&cmdp[i-1]) < 0) {
						LM_ERR("Fixup failed for param [%d]\n", i);
						ret = E_UNSPEC;
					}

					regfree(re);
					pkg_free(re);

					if (ret < 0)
						return ret;
				}

				break;
			case GPARAM_TYPE_PVS:
				if (pv_get_spec_value(msg, gp->v.pvs, &tmp_vals[i]) != 0) {
					LM_ERR("Failed to get spec value in param [%d]\n", i);
					return E_UNSPEC;
				}
				if (tmp_vals[i].flags & PV_VAL_NULL ||
					!(tmp_vals[i].flags & PV_VAL_STR)) {
					LM_ERR("Variable in param [%d] is not a string\n", i);
					return E_UNSPEC;
				}

				ret = fixup_regcomp(&re, &tmp_vals[i].rs, 1);
				if (ret < 0)
					return ret;
				cmdp[i-1] = re;

				if (param->fixup) {
					if (param->fixup(&cmdp[i-1]) < 0) {
						LM_ERR("Fixup failed for param [%d]\n", i);
						ret = E_UNSPEC;
					}

					regfree(re);
					pkg_free(re);

					if (ret < 0)
						return ret;
				}

				break;
			case GPARAM_TYPE_FIXUP:
				cmdp[i-1] = gp->v.val;
				break;
			default:
				LM_BUG("Bad type for generic parameter\n");
				return E_BUG;
			}

		} else {
			LM_BUG("Bad command parameter type\n");
			return E_BUG;
		}
	}

	return 0;
}

int free_cmd_fixups(struct cmd_param *params, action_elem_t *elems, void **cmdp)
{
	int i;
	struct cmd_param *param;
	gparam_p gp;

	for (param=params, i=1; param->flags; param++, i++) {
		gp = (gparam_p)elems[i].u.data;
		if (!gp)
			continue;

		if (param->flags & CMD_PARAM_INT) {
			if (param->free_fixup && gp->type == GPARAM_TYPE_PVS)
				if (param->free_fixup(&cmdp[i-1]) < 0) {
					LM_ERR("Failed to free fixup for param [%d]\n", i);
					return E_UNSPEC;
				}
		} else if (param->flags & CMD_PARAM_STR) {
			if (param->free_fixup && (gp->type == GPARAM_TYPE_PVS ||
				gp->type == GPARAM_TYPE_PVE))
				if (param->free_fixup(&cmdp[i-1]) < 0) {
					LM_ERR("Failed to free fixup for param [%d]\n", i);
					return E_UNSPEC;
				}
		} else if (param->flags & CMD_PARAM_REGEX) {
			if (gp->type == GPARAM_TYPE_PVS || gp->type == GPARAM_TYPE_PVE) {
				if (param->fixup) {
					if (param->free_fixup && param->free_fixup(&cmdp[i-1]) < 0) {
						LM_ERR("Failed to free fixup for param [%d]\n", i);
						return E_UNSPEC;
					}
				} else {
					regfree((regex_t*)cmdp[i-1]);
					pkg_free(cmdp[i-1]);
				}
			}
		} else if (param->flags & CMD_PARAM_VAR) {
			continue;
		} else {
			LM_BUG("Bad command parameter type\n");
			return E_BUG;
		}
	}

	return 0;
}