/*
 * Copyright (C) 2007 voice-system.ro
 * Copyright (C) 2009 asipto.com
 *
 * 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
 *
 */

/*! \file
 * \brief Support for transformations
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

#include "../../core/dprint.h"
#include "../../core/mem/mem.h"
#include "../../core/ut.h"
#include "../../core/trim.h"
#include "../../core/pvapi.h"
#include "../../core/dset.h"
#include "../../core/basex.h"
#include "../../core/action.h"
#include "../../core/hashes.h"

#include "../../core/parser/parse_param.h"
#include "../../core/parser/parse_uri.h"
#include "../../core/parser/parse_to.h"
#include "../../core/parser/parse_nameaddr.h"

#include "../../core/strutils.h"
#include "../../core/crypto/shautils.h"
#include "pv_trans.h"


static char _tr_empty_buf[2] = {0};
static str _tr_empty = { _tr_empty_buf, 0 };
static str _tr_uri = {0, 0};
static struct sip_uri _tr_parsed_uri;
static param_t* _tr_uri_params = NULL;

/*! transformation buffer size */
#define TR_BUFFER_SIZE 65536
#define TR_BUFFER_SLOTS	8

/*! transformation buffer */
static char **_tr_buffer_list = NULL;

static char *_tr_buffer = NULL;

static int _tr_buffer_idx = 0;

/*!
 *
 */
int tr_init_buffers(void)
{
	int i;

	_tr_buffer_list = (char**)malloc(TR_BUFFER_SLOTS * sizeof(char*));
	if(_tr_buffer_list==NULL)
		return -1;
	for(i=0; i<TR_BUFFER_SLOTS; i++) {
		_tr_buffer_list[i] = (char*)malloc(TR_BUFFER_SIZE);
		if(_tr_buffer_list[i]==NULL)
			return -1;
	}
	return 0;
}

/*!
 *
 */
char *tr_set_crt_buffer(void)
{
	_tr_buffer = _tr_buffer_list[_tr_buffer_idx];
	_tr_buffer_idx = (_tr_buffer_idx + 1) % TR_BUFFER_SLOTS;
	return _tr_buffer;
}

#define tr_string_clone_result do { \
		if(val->rs.len>TR_BUFFER_SIZE-1) { \
			LM_ERR("result is too big (cfg line: %d)\n", get_cfg_crt_line()); \
			return -1; \
		} \
		strncpy(_tr_buffer, val->rs.s, val->rs.len); \
		val->rs.s = _tr_buffer; \
	} while(0);

/* -- helper functions */

/* Encode 7BIT PDU */
static int pdu_7bit_encode(str sin) {
	int i, j;
	unsigned char hex;
	unsigned char nleft;
	unsigned char fill;
	char HexTbl[] = {"0123456789ABCDEF"};

	nleft = 1;
	j = 0;
	for(i = 0; i < sin.len; i++) {
		hex = (unsigned char)(*(sin.s)) >> (nleft - 1);
		fill = *(sin.s+1) << (8-nleft);
		hex = hex | fill;
		_tr_buffer[j++] = HexTbl[hex >> 4];
		_tr_buffer[j++] = HexTbl[hex & 0x0F];
		nleft++;
		if(nleft == 8) {
			sin.s++;
			i++;
			nleft = 1;
		}
		sin.s++;
	}
	_tr_buffer[j] = '\0';
	return j;
}

/* Decode 7BIT PDU */
static int pdu_7bit_decode(str sin) {
	int i, j;
	unsigned char nleft = 1;
	unsigned char fill = 0;
	unsigned char oldfill = 0;
	j = 0;
	for(i = 0; i < sin.len; i += 2) {
		_tr_buffer[j] = (unsigned char)hex_to_char(sin.s[i]) << 4;
		_tr_buffer[j] |= (unsigned char)hex_to_char(sin.s[i+1]);
		fill = (unsigned char)_tr_buffer[j];
		fill >>= (8 - nleft);
		_tr_buffer[j] <<= (nleft -1 );
		_tr_buffer[j] &= 0x7F;
		_tr_buffer[j] |= oldfill;
		oldfill = fill;
		j++;
		nleft++;
		if(nleft == 8) {
			_tr_buffer[j++] = oldfill;
			nleft = 1;
			oldfill = 0;
		}
	}
	_tr_buffer[j] = '\0';
	return j;
}

/* Get only the numeric part of string, e.g.
 * 040/123-456 => 040123456 */
static int getNumericValue(str sin) {
	int i, j = 0;
	for(i = 0; i < sin.len; i ++) {
		if (sin.s[i] >= '0' && sin.s[i] <= '9') {
			_tr_buffer[j++] = sin.s[i];
		}
	}
	_tr_buffer[j] = '\0';
	return j;
}

/* -- transformations functions */

/*!
 * \brief Evaluate string transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_string(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	int i, j, n, m, max;
	char *p, *s;
	char c;
	str st, st2;
	pv_value_t v, w;
	time_t t;
	uint32_t sz1, sz2;
	struct tm tmv;

	if(val==NULL || val->flags&PV_VAL_NULL)
		return -1;

	tr_set_crt_buffer();

	switch(subtype)
	{
		case TR_S_LEN:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);

			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			val->ri = val->rs.len;
			val->rs.s = int2str(val->ri, &val->rs.len);
			break;
		case TR_S_INT:
			if(!(val->flags&PV_VAL_INT))
			{
				if(str2sint(&val->rs, &val->ri)!=0)
					return -1;
			} else {
				if(!(val->flags&PV_VAL_STR))
					val->rs.s = int2str(val->ri, &val->rs.len);
			}

			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			break;
		case TR_S_RMWS:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len >= TR_BUFFER_SIZE - 1)
				return -1;
			j = 0;
			for(i=0; i < val->rs.len; i++) {
				if(val->rs.s[i] != ' ' && val->rs.s[i] != '\t'
						&& val->rs.s[i] != '\r' && val->rs.s[i] != '\n') {
					_tr_buffer[j] = val->rs.s[i];
					j++;
				}
			}
			_tr_buffer[j] = '\0';
			val->flags = PV_VAL_STR;
			val->ri = 0;
			val->rs.s = _tr_buffer;
			val->rs.len = j;
			break;
		case TR_S_MD5:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);

			compute_md5(_tr_buffer, val->rs.s, val->rs.len);
			_tr_buffer[MD5_LEN] = '\0';
			val->flags = PV_VAL_STR;
			val->ri = 0;
			val->rs.s = _tr_buffer;
			val->rs.len = MD5_LEN;
			break;
		case TR_S_SHA256:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			compute_sha256(_tr_buffer, (u_int8_t*)val->rs.s, val->rs.len);
			_tr_buffer[SHA256_DIGEST_STRING_LENGTH -1] = '\0';
			val->flags = PV_VAL_STR;
			val->ri = 0;
			val->rs.s = _tr_buffer;
			val->rs.len = SHA256_DIGEST_STRING_LENGTH -1 ;
			break;
		case TR_S_SHA384:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			compute_sha384(_tr_buffer, (u_int8_t*)val->rs.s, val->rs.len);
			_tr_buffer[SHA384_DIGEST_STRING_LENGTH -1] = '\0';
			val->flags = PV_VAL_STR;
			val->ri = 0;
			val->rs.s = _tr_buffer;
			val->rs.len = SHA384_DIGEST_STRING_LENGTH -1;
			break;
		case TR_S_SHA512:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			compute_sha512(_tr_buffer, (u_int8_t*)val->rs.s, val->rs.len);
			_tr_buffer[SHA512_DIGEST_STRING_LENGTH -1] = '\0';
			val->flags = PV_VAL_STR;
			val->ri = 0;
			val->rs.s = _tr_buffer;
			val->rs.len = SHA512_DIGEST_STRING_LENGTH -1;
			break;
		case TR_S_ENCODEHEXA:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE/2-1)
				return -1;
			j = 0;
			for(i=0; i<val->rs.len; i++)
			{
				_tr_buffer[j++] = fourbits2char[(unsigned char)val->rs.s[i] >> 4];
				_tr_buffer[j++] = fourbits2char[val->rs.s[i] & 0xf];
			}
			_tr_buffer[j] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = j;
			break;
		case TR_S_DECODEHEXA:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE*2-1)
				return -1;
			for(i=0; i<val->rs.len/2; i++)
			{
				if(val->rs.s[2*i]>='0'&&val->rs.s[2*i]<='9')
					_tr_buffer[i] = (val->rs.s[2*i]-'0') << 4;
				else if(val->rs.s[2*i]>='a'&&val->rs.s[2*i]<='f')
					_tr_buffer[i] = (val->rs.s[2*i]-'a'+10) << 4;
				else if(val->rs.s[2*i]>='A'&&val->rs.s[2*i]<='F')
					_tr_buffer[i] = (val->rs.s[2*i]-'A'+10) << 4;
				else return -1;

				if(val->rs.s[2*i+1]>='0'&&val->rs.s[2*i+1]<='9')
					_tr_buffer[i] += val->rs.s[2*i+1]-'0';
				else if(val->rs.s[2*i+1]>='a'&&val->rs.s[2*i+1]<='f')
					_tr_buffer[i] += val->rs.s[2*i+1]-'a'+10;
				else if(val->rs.s[2*i+1]>='A'&&val->rs.s[2*i+1]<='F')
					_tr_buffer[i] += val->rs.s[2*i+1]-'A'+10;
				else return -1;
			}
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ENCODE7BIT:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len > (TR_BUFFER_SIZE*7/8) -1)
				return -1;
			i = pdu_7bit_encode(val->rs);
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_DECODE7BIT:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE/2-1)
				return -1;
			i = pdu_7bit_decode(val->rs);
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_NUMERIC:
			if(!(val->flags&PV_VAL_STR))
				return -1;
			if(val->rs.len>TR_BUFFER_SIZE)
				return -1;
			i = getNumericValue(val->rs);
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ENCODEBASE58:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			st.len = TR_BUFFER_SIZE-1;
			st.s = b58_encode(_tr_buffer, &st.len, val->rs.s, val->rs.len);
			if (st.s==NULL)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = st.s;
			val->rs.len = st.len;
			break;
		case TR_S_DECODEBASE58:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			st.len = TR_BUFFER_SIZE-1;
			st.s = b58_decode(_tr_buffer, &st.len, val->rs.s, val->rs.len);
			if (st.s==NULL)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = st.s;
			val->rs.len = st.len;
			break;
		case TR_S_ENCODEBASE64:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64_enc((unsigned char *) val->rs.s, val->rs.len,
					(unsigned char *) _tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0)
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_DECODEBASE64:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64_dec((unsigned char *) val->rs.s, val->rs.len,
					(unsigned char *) _tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0 || (i == 0 && val->rs.len > 0))
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ENCODEBASE64T:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64_enc((unsigned char *) val->rs.s, val->rs.len,
					(unsigned char *) _tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0)
				return -1;
			if (i>1 && _tr_buffer[i-1] == '=') {
				i--;
				if (i>1 && _tr_buffer[i-1] == '=') {
					i--;
				}
			}
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_DECODEBASE64T:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len % 4) {
				if(val->rs.len + 4 >= TR_BUFFER_SIZE-1) {
					LM_ERR("not enough space to insert padding\n");
					return -1;
				}
				memcpy(_tr_buffer, val->rs.s, val->rs.len);
				for(i=0; i < (4 - (val->rs.len % 4)); i++) {
					_tr_buffer[val->rs.len + i] = '=';
				}
				st.s = _tr_buffer;
				st.len = val->rs.len + (4 - (val->rs.len % 4));
				/* move to next buffer */
				tr_set_crt_buffer();
				i = base64_dec((unsigned char *) st.s, st.len,
						(unsigned char *) _tr_buffer, TR_BUFFER_SIZE-1);
			} else {
				i = base64_dec((unsigned char *) val->rs.s, val->rs.len,
						(unsigned char *) _tr_buffer, TR_BUFFER_SIZE-1);
			}
			if (i < 0 || (i == 0 && val->rs.len > 0))
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ENCODEBASE64URL:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64url_enc(val->rs.s, val->rs.len,
					_tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0)
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_DECODEBASE64URL:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64url_dec(val->rs.s, val->rs.len,
					_tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0 || (i == 0 && val->rs.len > 0))
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ENCODEBASE64URLT:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			i = base64url_enc(val->rs.s, val->rs.len,
					_tr_buffer, TR_BUFFER_SIZE-1);
			if (i < 0)
				return -1;
			if (i>1 && _tr_buffer[i-1] == '=') {
				i--;
				if (i>1 && _tr_buffer[i-1] == '=') {
					i--;
				}
			}
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_DECODEBASE64URLT:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len % 4) {
				if(val->rs.len + 4 >= TR_BUFFER_SIZE-1) {
					LM_ERR("not enough space to insert padding\n");
					return -1;
				}
				memcpy(_tr_buffer, val->rs.s, val->rs.len);
				for(i=0; i < (4 - (val->rs.len % 4)); i++) {
					_tr_buffer[val->rs.len + i] = '=';
				}
				st.s = _tr_buffer;
				st.len = val->rs.len + (4 - (val->rs.len % 4));
				/* move to next buffer */
				tr_set_crt_buffer();
				i = base64url_dec(st.s, st.len,
						_tr_buffer, TR_BUFFER_SIZE-1);
			} else {
				i = base64url_dec(val->rs.s, val->rs.len,
						_tr_buffer, TR_BUFFER_SIZE-1);
			}
			if (i < 0 || (i == 0 && val->rs.len > 0))
				return -1;
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ESCAPECOMMON:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE/2-1)
				return -1;
			i = escape_common(_tr_buffer, val->rs.s, val->rs.len);
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_UNESCAPECOMMON:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			i = unescape_common(_tr_buffer, val->rs.s, val->rs.len);
			_tr_buffer[i] = '\0';
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = i;
			break;
		case TR_S_ESCAPEUSER:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE/2-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (escape_user(&val->rs, &st))
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;
		case TR_S_UNESCAPEUSER:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (unescape_user(&val->rs, &st))
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;
		case TR_S_ESCAPEPARAM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE/2-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (escape_param(&val->rs, &st) < 0)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;
		case TR_S_UNESCAPEPARAM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (unescape_param(&val->rs, &st) < 0)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;
		case TR_S_ESCAPECSV:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (escape_csv(&val->rs, &st))
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;
		case TR_S_SUBSTR:
			if(tp==NULL || tp->next==NULL)
			{
				LM_ERR("substr invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(tp->type==TR_PARAM_NUMBER)
			{
				i = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("substr cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				i = v.ri;
			}
			if(tp->next->type==TR_PARAM_NUMBER)
			{
				j = tp->next->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->next->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("substr cannot get p2 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				j = v.ri;
			}
			LM_DBG("i=%d j=%d\n", i, j);
			if(j<0)
			{
				LM_ERR("substr negative offset (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			val->flags = PV_VAL_STR;
			val->ri = 0;
			if(i>=0)
			{
				if(i>=val->rs.len)
				{
					LM_ERR("substr out of range (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				if(i+j>=val->rs.len) j=0;
				if(j==0)
				{ /* to end */
					val->rs.s += i;
					val->rs.len -= i;
					tr_string_clone_result;
					break;
				}
				val->rs.s += i;
				val->rs.len = j;
				tr_string_clone_result;
				break;
			}
			i = -i;
			if(i>val->rs.len)
			{
				LM_ERR("substr out of range (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(i<j) j=0;
			if(j==0)
			{ /* to end */
				val->rs.s += val->rs.len-i;
				val->rs.len = i;
				tr_string_clone_result;
				break;
			}
			val->rs.s += val->rs.len-i;
			val->rs.len = j;
			tr_string_clone_result;
			break;

		case TR_S_SELECT:
			if(tp==NULL || tp->next==NULL)
			{
				LM_ERR("select invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(tp->type==TR_PARAM_NUMBER)
			{
				i = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("select cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				i = v.ri;
			}
			if(tp->next->v.s.len>1) {
				switch(tp->next->v.s.s[1]) {
					case '\\':
						c = '\\';
					break;
					case 'n':
						c = '\n';
					break;
					case 'r':
						c = '\r';
					break;
					case 't':
						c = '\t';
					break;
					default:
						LM_ERR("invalid select escape char (cfg line: %d)\n",
							get_cfg_crt_line());
						return -1;
				}
			} else {
				c = tp->next->v.s.s[0];
			}
			val->flags = PV_VAL_STR;
			val->ri = 0;
			if(i<0)
			{
				s = val->rs.s+val->rs.len-1;
				p = s;
				i = -i;
				i--;
				while(p>=val->rs.s)
				{
					if(*p==c)
					{
						if(i==0)
							break;
						s = p-1;
						i--;
					}
					p--;
				}
				if(i==0)
				{
					val->rs.s = p+1;
					val->rs.len = s-p;
				} else {
					val->rs = _tr_empty;
				}
			} else {
				s = val->rs.s;
				p = s;
				while(p<val->rs.s+val->rs.len)
				{
					if(*p==c)
					{
						if(i==0)
							break;
						s = p + 1;
						i--;
					}
					p++;
				}
				if(i==0)
				{
					val->rs.s = s;
					val->rs.len = p-s;
				} else {
					val->rs = _tr_empty;
				}
			}
			tr_string_clone_result;
			break;

		case TR_S_TOLOWER:
			if(!(val->flags&PV_VAL_STR))
			{
				val->rs.s = int2str(val->ri, &val->rs.len);
				val->flags |= PV_VAL_STR;
				break;
			}
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = val->rs.len;
			for (i=0; i<st.len; i++)
				st.s[i]=(val->rs.s[i]>='A' && val->rs.s[i]<='Z')
					?('a' + val->rs.s[i] -'A'):val->rs.s[i];
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;

		case TR_S_TOUPPER:
			if(!(val->flags&PV_VAL_STR))
			{
				val->rs.s = int2str(val->ri, &val->rs.len);
				val->flags |= PV_VAL_STR;
				break;
			}
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = val->rs.len;
			for (i=0; i<st.len; i++)
				st.s[i]=(val->rs.s[i]>='a' && val->rs.s[i]<='z')
					?('A' + val->rs.s[i] -'a'):val->rs.s[i];
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;

		case TR_S_STRIP:
		case TR_S_STRIPTAIL:
			if(tp==NULL)
			{
				LM_ERR("strip invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(tp->type==TR_PARAM_NUMBER)
			{
				i = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("select cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				i = v.ri;
			}
			val->flags = PV_VAL_STR;
			val->ri = 0;
			if(i<=0)
				break;
			if(i>=val->rs.len)
			{
				_tr_buffer[0] = '\0';
				val->rs.s = _tr_buffer;
				val->rs.len = 0;
				break;
			}
			if(subtype==TR_S_STRIP)
				val->rs.s += i;
			val->rs.len -= i;
			tr_string_clone_result;
			break;


		case TR_S_STRIPTO:
			if(tp==NULL)
			{
				LM_ERR("stripto invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);

			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("stripto cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}

			val->flags = PV_VAL_STR;
			val->ri = 0;
			for(i=0; i<val->rs.len; i++)
			{
				if(val->rs.s[i] == st.s[0])
					break;
			}
			if(i>=val->rs.len)
			{
				_tr_buffer[0] = '\0';
				val->rs.s = _tr_buffer;
				val->rs.len = 0;
				break;
			}
			val->rs.s += i;
			val->rs.len -= i;
			tr_string_clone_result;
			break;

		case TR_S_PREFIXES:
		case TR_S_PREFIXES_QUOT:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);


			/* Set maximum prefix length */
			max = val->rs.len;
			if(tp!=NULL) {
				if(tp->type==TR_PARAM_NUMBER) {
					if (tp->v.n > 0 && tp->v.n < max)
						max = tp->v.n;
				} else {
					if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
							|| (!(v.flags&PV_VAL_INT)))
					{
						LM_ERR("prefixes cannot get max (cfg line: %d)\n",
								get_cfg_crt_line());
						return -1;
					}
					if (v.ri > 0 && v.ri < max)
						max  = v.ri;
				}
			}

			if(max * (max/2 + (subtype==TR_S_PREFIXES_QUOT ? 1 : 3)) > TR_BUFFER_SIZE-1) {
				LM_ERR("prefixes buffer too short (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}

			j = 0;
			for (i=1; i <= max; i++) {
				if (subtype==TR_S_PREFIXES_QUOT)
					_tr_buffer[j++] = '\'';
				memcpy(&(_tr_buffer[j]), val->rs.s, i);
				j += i;
				if (subtype==TR_S_PREFIXES_QUOT)
					_tr_buffer[j++] = '\'';
				_tr_buffer[j++] = ',';
			}
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = (j>0)?(j-1):0;
			break;


		case TR_S_REPLACE:
			if(tp==NULL || tp->next==NULL)
			{
				LM_ERR("select invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);

			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("replace cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}

			if(tp->next->type==TR_PARAM_STRING)
			{
				st2 = tp->next->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->next->v.data, &w)!=0
						|| (!(w.flags&PV_VAL_STR)) || w.rs.len<=0)
				{
					LM_ERR("replace cannot get p2 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st2 = w.rs;
			}

			val->flags = PV_VAL_STR;
			val->ri = 0;

			i = 0;
			j = 0;
			max = val->rs.len - st.len;
			while (i < val->rs.len && j < TR_BUFFER_SIZE) {
				if (i <= max && val->rs.s[i] == st.s[0]
						&& strncmp(val->rs.s+i, st.s, st.len) == 0) {
					strncpy(_tr_buffer+j, st2.s, st2.len);
					i += st.len;
					j += st2.len;
				} else {
					_tr_buffer[j++] = val->rs.s[i++];
				}
			}
			val->rs.s = _tr_buffer;
			val->rs.len = j;
			break;

		case TR_S_TIMEFORMAT:
			if(tp==NULL)
			{
				LM_ERR("timeformat invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_INT) && (str2int(&val->rs,
							(unsigned int*) &val->ri)!=0))
			{
				LM_ERR("value is not numeric (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("timeformat cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}
			s = pkg_malloc(st.len + 1);
			if (s==NULL)
			{
				LM_ERR("no more pkg memory (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			memcpy(s, st.s, st.len);
			s[st.len] = '\0';
			t = val->ri;
			localtime_r(&t, &tmv);
			val->rs.len = strftime(_tr_buffer, TR_BUFFER_SIZE-1, s, &tmv);
			pkg_free(s);
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			break;

		case TR_S_TRIM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-2)
				return -1;
			memcpy(_tr_buffer, val->rs.s, val->rs.len);
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			trim(&val->rs);
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_RTRIM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-2)
				return -1;
			memcpy(_tr_buffer, val->rs.s, val->rs.len);
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			trim_trailing(&val->rs);
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_LTRIM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-2)
				return -1;
			memcpy(_tr_buffer, val->rs.s, val->rs.len);
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			trim_leading(&val->rs);
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_RM:
			if(tp==NULL)
			{
				LM_ERR("invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-2)
				return -1;
			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
				if(memchr(st.s, '\\', st.len)) {
					p = pv_get_buffer();
					if(st.len>=pv_get_buffer_size()-1)
						return -1;
					j=0;
					for(i=0; i<st.len-1; i++) {
						if(st.s[i]=='\\') {
							switch(st.s[i+1]) {
								case 'n':
									p[j++] = '\n';
									break;
								case 'r':
									p[j++] = '\r';
									break;
								case 't':
									p[j++] = '\t';
									break;
								case '\\':
									p[j++] = '\\';
									break;
								default:
									p[j++] = st.s[i+1];
							}
							i++;
						} else {
							p[j++] = st.s[i];
						}
					}
					if(i==st.len-1)
						p[j++] = st.s[i];
					p[j] = '\0';
					st.s = p;
					st.len = j;
				}
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("cannot get parameter value (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}
			LM_DBG("removing [%.*s](%d) in [%.*s](%d)\n",
					st.len, st.s, st.len, val->rs.len, val->rs.s, val->rs.len);
			val->flags = PV_VAL_STR;
			val->ri = 0;

			i = 0;
			j = 0;
			max = val->rs.len - st.len;
			while (i < val->rs.len && j < TR_BUFFER_SIZE) {
				if (i <= max && val->rs.s[i] == st.s[0]
						&& strncmp(val->rs.s+i, st.s, st.len) == 0) {
					i += st.len;
				} else {
					_tr_buffer[j++] = val->rs.s[i++];
				}
			}
			val->rs.s = _tr_buffer;
			val->rs.s[j] = '\0';
			val->rs.len = j;
			break;

		case TR_S_URLENCODEPARAM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (urlencode(&val->rs, &st) < 0)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;

		case TR_S_URLDECODEPARAM:
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(val->rs.len>TR_BUFFER_SIZE-1)
				return -1;
			st.s = _tr_buffer;
			st.len = TR_BUFFER_SIZE;
			if (urldecode(&val->rs, &st) < 0)
				return -1;
			memset(val, 0, sizeof(pv_value_t));
			val->flags = PV_VAL_STR;
			val->rs = st;
			break;

		case TR_S_COREHASH:
			if(!(val->flags&PV_VAL_STR))
				st.s = int2str(val->ri, &st.len);
			else
				st = val->rs;

			sz1 = 0;
			if(tp != NULL) {
				if(tp->type==TR_PARAM_NUMBER) {
						sz1 = (uint) tp->v.n;
				} else {
					if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
							|| (!(v.flags&PV_VAL_INT)))
					{
							LM_ERR("corehash cannot get size (cfg line: %d)\n",
								get_cfg_crt_line());
						return -1;
					}
					sz1  = (uint) v.ri;
				}
			}

			sz2 = core_hash(&st, NULL, sz1);

			if((val->rs.s = int2strbuf((unsigned long)sz2, _tr_buffer,
						INT2STR_MAX_LEN, &val->rs.len))==NULL) {
				LM_ERR("failed to convert core hash id to string\n");
				return -1;
			}
			val->flags = PV_VAL_STR;
			val->ri = 0;
			break;

		case TR_S_UNQUOTE:
			if(!(val->flags&PV_VAL_STR)) {
				val->rs.s = int2str(val->ri, &val->rs.len);
				break;
			}
			if(val->rs.len<2) {
				break;
			}
			if(val->rs.len>TR_BUFFER_SIZE-2) {
				LM_ERR("value too large: %d\n", val->rs.len);
				return -1;
			}
			if((val->rs.s[0] == val->rs.s[val->rs.len-1])
					&& (val->rs.s[0] == '"' || val->rs.s[0] == '\'')) {
				memcpy(_tr_buffer, val->rs.s+1, val->rs.len-2);
				val->rs.len -= 2;
			} else {
				memcpy(_tr_buffer, val->rs.s, val->rs.len);
			}
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_UNBRACKET:
			if(!(val->flags&PV_VAL_STR)) {
				val->rs.s = int2str(val->ri, &val->rs.len);
				break;
			}
			if(val->rs.len<2) {
				break;
			}
			if(val->rs.len>TR_BUFFER_SIZE-2) {
				LM_ERR("value too large: %d\n", val->rs.len);
				return -1;
			}
			if((val->rs.s[0] == '(' && val->rs.s[val->rs.len-1] == ')')
					|| (val->rs.s[0] == '[' && val->rs.s[val->rs.len-1] == ']')
					|| (val->rs.s[0] == '{' && val->rs.s[val->rs.len-1] == '}')
					|| (val->rs.s[0] == '<' && val->rs.s[val->rs.len-1] == '>')) {
				memcpy(_tr_buffer, val->rs.s+1, val->rs.len-2);
				val->rs.len -= 2;
			} else {
				memcpy(_tr_buffer, val->rs.s, val->rs.len);
			}
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_COUNT:
			if(tp==NULL)
			{
				LM_ERR("invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR)) {
				val->rs.s = int2str(val->ri, &val->rs.len);
			}
			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("cannot get parameter value (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}
			LM_DBG("counting [%.*s](%d) in [%.*s](%d)\n",
					st.len, st.s, st.len, val->rs.len, val->rs.s, val->rs.len);
			j = 0;
			for(i=0; i<val->rs.len; i++) {
				if(val->rs.s[i]==st.s[0]) {
					j++;
				}
			}
			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			val->ri = j;
			val->rs.s = int2str(j, &val->rs.len);
			break;

		case TR_S_BEFORE:
		case TR_S_RBEFORE:
			if(tp==NULL)
			{
				LM_ERR("invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR)) {
				val->rs.s = int2str(val->ri, &val->rs.len);
			}
			if(val->rs.len>TR_BUFFER_SIZE-2) {
				LM_ERR("value too large: %d\n", val->rs.len);
				return -1;
			}
			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("cannot get parameter value (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}
			if(subtype==TR_S_BEFORE) {
				for(i=0; i<val->rs.len; i++) {
					if(val->rs.s[i]==st.s[0]) {
						break;
					}
				}
			} else {
				for(i=val->rs.len-1; i>=0; i++) {
					if(val->rs.s[i]==st.s[0]) {
						break;
					}
				}
			}

			if(i==0) {
				_tr_buffer[0] = '\0';
				val->rs.len = 0;
			} else {
				memcpy(_tr_buffer, val->rs.s, i);
				val->rs.len = i;
			}
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_AFTER:
		case TR_S_RAFTER:
			if(tp==NULL)
			{
				LM_ERR("invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR)) {
				val->rs.s = int2str(val->ri, &val->rs.len);
			}
			if(val->rs.len>TR_BUFFER_SIZE-2) {
				LM_ERR("value too large: %d\n", val->rs.len);
				return -1;
			}
			if(tp->type==TR_PARAM_STRING)
			{
				st = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("cannot get parameter value (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				st = v.rs;
			}
			if(subtype==TR_S_AFTER) {
				for(i=0; i<val->rs.len; i++) {
					if(val->rs.s[i]==st.s[0]) {
						break;
					}
				}
			} else {
				for(i=val->rs.len-1; i>=0; i++) {
					if(val->rs.s[i]==st.s[0]) {
						break;
					}
				}
			}
			if(i>=val->rs.len-1) {
				_tr_buffer[0] = '\0';
				val->rs.len = 0;
			} else {
				memcpy(_tr_buffer, val->rs.s+i+1, val->rs.len-i-1);
				val->rs.len = val->rs.len-i-1;
			}
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.s[val->rs.len] = '\0';
			break;

		case TR_S_FMTLINES:
		case TR_S_FMTLINET:
			if(tp==NULL || tp->next==NULL)
			{
				LM_ERR("substr invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(!(val->flags&PV_VAL_STR))
				val->rs.s = int2str(val->ri, &val->rs.len);
			if(tp->type==TR_PARAM_NUMBER)
			{
				n = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("fmtline cannot get p1 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				n = v.ri;
			}
			if(tp->next->type==TR_PARAM_NUMBER)
			{
				m = tp->next->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->next->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("fmtline cannot get p2 (cfg line: %d)\n",
							get_cfg_crt_line());
					return -1;
				}
				m = v.ri;
			}
			if(n<=0 || m<0) {
				LM_ERR("fmtline with invalid parameters (cfg line: %d)\n",
						get_cfg_crt_line());
				return -1;
			}
			if(n==0 || m>=val->rs.len) {
				if(val->rs.len>TR_BUFFER_SIZE-2) {
					LM_ERR("value too large: %d\n", val->rs.len);
					return -1;
				}

				memcpy(_tr_buffer, val->rs.s, val->rs.len);
				val->flags = PV_VAL_STR;
				val->rs.s = _tr_buffer;
				val->rs.s[val->rs.len] = '\0';
			}
			if(val->rs.len + (((val->rs.len)/n)*(2+m)) > TR_BUFFER_SIZE-2) {
				LM_ERR("value too large: %d\n", val->rs.len);
				return -1;
			}

			p = _tr_buffer;
			for(i=0; i<val->rs.len; i++) {
				if(i!=0 && (i/n)==0) {
					*p = '\r';
					p++;
					*p = '\n';
					p++;
					for(j=0; j<m; j++) {
						if(subtype==TR_S_FMTLINES) {
							*p = ' ';
						} else {
							*p = '\t';
						}
						p++;
					}
				}
				*p = val->rs.s[i];
				p++;
			}
			val->flags = PV_VAL_STR;
			val->rs.s = _tr_buffer;
			val->rs.len = p - _tr_buffer;
			val->rs.s[val->rs.len] = '\0';
			break;

		default:
			LM_ERR("unknown subtype %d (cfg line: %d)\n",
					subtype, get_cfg_crt_line());
			return -1;
	}
	return 0;
}


/*!
 * \brief Evaluate URI transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_uri(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	pv_value_t v;
	str sv;
	param_hooks_t phooks;
	param_t *pit=NULL;
	str sproto;
	int dlen = 0;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	if(_tr_uri.len==0 || _tr_uri.len!=val->rs.len ||
			strncmp(_tr_uri.s, val->rs.s, val->rs.len)!=0)
	{
		if(val->rs.len>_tr_uri.len)
		{
			if(_tr_uri.s) pkg_free(_tr_uri.s);
			_tr_uri.s = (char*)pkg_malloc((val->rs.len+1)*sizeof(char));
			if(_tr_uri.s==NULL)
			{
				LM_ERR("no more private memory\n");
				if(_tr_uri_params != NULL)
				{
					free_params(_tr_uri_params);
					_tr_uri_params = 0;
				}
				memset(&_tr_uri, 0, sizeof(str));
				memset(&_tr_parsed_uri, 0, sizeof(struct sip_uri));
				return -1;
			}
		}
		_tr_uri.len = val->rs.len;
		memcpy(_tr_uri.s, val->rs.s, val->rs.len);
		_tr_uri.s[_tr_uri.len] = '\0';
		/* reset old values */
		memset(&_tr_parsed_uri, 0, sizeof(struct sip_uri));
		if(_tr_uri_params != NULL)
		{
			free_params(_tr_uri_params);
			_tr_uri_params = 0;
		}
		if(_tr_uri.len>4 && _tr_uri.s[_tr_uri.len-1]==';') {
			dlen = 1;
		}
		/* parse uri -- params only when requested */
		if(parse_uri(_tr_uri.s, _tr_uri.len - dlen, &_tr_parsed_uri)!=0)
		{
			LM_ERR("invalid uri [%.*s]\n", val->rs.len,
					val->rs.s);
			if(_tr_uri_params != NULL)
			{
				free_params(_tr_uri_params);
				_tr_uri_params = 0;
			}
			pkg_free(_tr_uri.s);
			memset(&_tr_uri, 0, sizeof(str));
			memset(&_tr_parsed_uri, 0, sizeof(struct sip_uri));
			return -1;
		}
	}
	memset(val, 0, sizeof(pv_value_t));
	val->flags = PV_VAL_STR;

	switch(subtype)
	{
		case TR_URI_USER:
			val->rs = (_tr_parsed_uri.user.s)?_tr_parsed_uri.user:_tr_empty;
			break;
		case TR_URI_HOST:
			val->rs = (_tr_parsed_uri.host.s)?_tr_parsed_uri.host:_tr_empty;
			break;
		case TR_URI_PASSWD:
			val->rs = (_tr_parsed_uri.passwd.s)?_tr_parsed_uri.passwd:_tr_empty;
			break;
		case TR_URI_DURI:
		case TR_URI_SAOR:
		case TR_URI_SURI:
			if(_tr_uri.len >= TR_BUFFER_SIZE) {
				LM_WARN("uri too long [%.*s] (%d)\n",
						_tr_uri.len, _tr_uri.s, _tr_uri.len);
				val->rs = _tr_empty;
				break;
			}

			tr_set_crt_buffer();
			sv.s = _tr_uri.s;
			sv.len = 0;
			while(sv.len<_tr_uri.len) {
				if(_tr_uri.s[sv.len]==':') {
					break;
				}
				sv.len++;
			}
			if(_tr_uri.s[sv.len]!=':') {
				LM_WARN("uri schema not found [%.*s] (%d)\n",
						_tr_uri.len, _tr_uri.s, _tr_uri.len);
				val->rs = _tr_empty;
				break;
			}
			sv.len++;
			memcpy(_tr_buffer, sv.s, sv.len);
			sv.s = _tr_buffer;
			sv.len++;
			if((_tr_parsed_uri.user.len > 0)
					&& (subtype != TR_URI_DURI)) {
				memcpy(sv.s + sv.len, _tr_parsed_uri.user.s,
						_tr_parsed_uri.user.len);
				sv.len += _tr_parsed_uri.user.len;
				sv.s[sv.len] = '@';
				sv.len++;
			}
			if(_tr_parsed_uri.host.len > 0) {
				memcpy(sv.s + sv.len, _tr_parsed_uri.host.s,
						_tr_parsed_uri.host.len);
				sv.len += _tr_parsed_uri.host.len;
			}
			if(subtype != TR_URI_SAOR) {
				if(_tr_parsed_uri.port.len > 0) {
					sv.s[sv.len] = ':';
					sv.len++;
					memcpy(sv.s + sv.len, _tr_parsed_uri.port.s,
							_tr_parsed_uri.port.len);
					sv.len += _tr_parsed_uri.port.len;
				}
				if(_tr_parsed_uri.transport_val.len > 0) {
					memcpy(sv.s + sv.len, ";transport=", 11);
					sv.len += 11;
					memcpy(sv.s + sv.len, _tr_parsed_uri.transport_val.s,
							_tr_parsed_uri.transport_val.len);
					sv.len += _tr_parsed_uri.transport_val.len;
				}
			}
			sv.s[sv.len] = '\0';
			val->rs = sv;
			break;
		case TR_URI_PORT:
			val->flags |= PV_TYPE_INT|PV_VAL_INT;
			val->rs = (_tr_parsed_uri.port.s)?_tr_parsed_uri.port:_tr_empty;
			val->ri = _tr_parsed_uri.port_no;
			break;
		case TR_URI_PARAMS:
			val->rs = (_tr_parsed_uri.sip_params.s)?_tr_parsed_uri.sip_params:_tr_empty;
			break;
		case TR_URI_PARAM:
			if(tp==NULL)
			{
				LM_ERR("param invalid parameters\n");
				return -1;
			}
			if(_tr_parsed_uri.sip_params.len<=0)
			{
				val->rs = _tr_empty;
				val->flags = PV_VAL_STR;
				val->ri = 0;
				break;
			}

			if(_tr_uri_params == NULL)
			{
				sv = _tr_parsed_uri.sip_params;
				if (parse_params(&sv, CLASS_ANY, &phooks, &_tr_uri_params)<0)
					return -1;
			}
			if(tp->type==TR_PARAM_STRING)
			{
				sv = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("param cannot get p1\n");
					return -1;
				}
				sv = v.rs;
			}
			for (pit = _tr_uri_params; pit; pit=pit->next)
			{
				if (pit->name.len==sv.len
						&& strncasecmp(pit->name.s, sv.s, sv.len)==0)
				{
					val->rs = pit->body;
					goto done;
				}
			}
			val->rs = _tr_empty;
			break;
		case TR_URI_HEADERS:
			val->rs = (_tr_parsed_uri.headers.s)?_tr_parsed_uri.headers:
				_tr_empty;
			break;
		case TR_URI_TRANSPORT:
			val->rs = (_tr_parsed_uri.transport_val.s)?
				_tr_parsed_uri.transport_val:_tr_empty;
			break;
		case TR_URI_TTL:
			val->rs = (_tr_parsed_uri.ttl_val.s)?
				_tr_parsed_uri.ttl_val:_tr_empty;
			break;
		case TR_URI_UPARAM:
			val->rs = (_tr_parsed_uri.user_param_val.s)?
				_tr_parsed_uri.user_param_val:_tr_empty;
			break;
		case TR_URI_MADDR:
			val->rs = (_tr_parsed_uri.maddr_val.s)?
				_tr_parsed_uri.maddr_val:_tr_empty;
			break;
		case TR_URI_METHOD:
			val->rs = (_tr_parsed_uri.method_val.s)?
				_tr_parsed_uri.method_val:_tr_empty;
			break;
		case TR_URI_LR:
			val->rs = (_tr_parsed_uri.lr_val.s)?
				_tr_parsed_uri.lr_val:_tr_empty;
			break;
		case TR_URI_R2:
			val->rs = (_tr_parsed_uri.r2_val.s)?
				_tr_parsed_uri.r2_val:_tr_empty;
			break;
		case TR_URI_SCHEME:
			val->rs.s = _tr_uri.s;
			val->rs.len = 0;
			while(val->rs.len<_tr_uri.len) {
				if(_tr_uri.s[val->rs.len]==':') {
					break;
				}
				val->rs.len++;
			}
			break;
		case TR_URI_TOSOCKET:
			if(get_valid_proto_string(_tr_parsed_uri.proto, 1, 0, &sproto)<0) {
				LM_WARN("unknown transport protocol\n");
				val->rs = _tr_empty;
				break;
			}
			tr_set_crt_buffer();
			val->rs.len = snprintf(_tr_buffer, TR_BUFFER_SIZE,
					"%.*s:%.*s:%d", sproto.len, sproto.s,
					_tr_parsed_uri.host.len, _tr_parsed_uri.host.s,
					(_tr_parsed_uri.port_no!=0)
							?(int)_tr_parsed_uri.port_no:5060);
			if(val->rs.len<=0 || val->rs.len>=TR_BUFFER_SIZE) {
				LM_WARN("error converting uri to socket address [%.*s]\n",
						_tr_uri.len, _tr_uri.s);
				val->rs = _tr_empty;
				break;
			}
			val->rs.s = _tr_buffer;
			break;
		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}
done:
	return 0;
}

static str _tr_params_str = {0, 0};
static param_t* _tr_params_list = NULL;
static char _tr_params_separator = ';';


/*!
 * \brief Evaluate parameter transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_paramlist(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	pv_value_t v;
	pv_value_t vs;
	str sv;
	int n, i;
	char separator = ';';
	param_hooks_t phooks;
	param_t *pit=NULL;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	if (tp != NULL)
	{
		if (subtype == TR_PL_COUNT)
		{
			if(tp->type != TR_PARAM_STRING) {
				if(pv_get_spec_value(msg, (pv_spec_t*)tp->v.data, &vs)!=0
						|| (!(vs.flags&PV_VAL_STR)) || vs.rs.len<=0)
				{
					LM_ERR("value cannot get p1\n");
					return -1;
				}
				separator = vs.rs.s[0];
			} else {
				if(tp->v.s.len != 1)
					return -1;
				separator = tp->v.s.s[0];
			}
		} else if (tp->next != NULL) {
			if(tp->next->type != TR_PARAM_STRING
					|| tp->next->v.s.len != 1)
				return -1;
			separator = tp->next->v.s.s[0];
		}
	}

	if(_tr_params_str.len==0 || _tr_params_str.len!=val->rs.len ||
			strncmp(_tr_params_str.s, val->rs.s, val->rs.len)!=0 ||
			_tr_params_separator != separator)
	{
		_tr_params_separator = separator;

		if(val->rs.len>_tr_params_str.len)
		{
			if(_tr_params_str.s) pkg_free(_tr_params_str.s);
			_tr_params_str.s = (char*)pkg_malloc((val->rs.len+1)*sizeof(char));
			if(_tr_params_str.s==NULL)
			{
				LM_ERR("no more private memory\n");
				memset(&_tr_params_str, 0, sizeof(str));
				if(_tr_params_list != NULL)
				{
					free_params(_tr_params_list);
					_tr_params_list = 0;
				}
				return -1;
			}
		}
		_tr_params_str.len = val->rs.len;
		memcpy(_tr_params_str.s, val->rs.s, val->rs.len);
		_tr_params_str.s[_tr_params_str.len] = '\0';

		/* reset old values */
		if(_tr_params_list != NULL)
		{
			free_params(_tr_params_list);
			_tr_params_list = 0;
		}

		/* parse params */
		sv = _tr_params_str;
		if(sv.len>1 && sv.s[sv.len - 1] == _tr_params_separator) {
			sv.len--;
		}
		if (parse_params2(&sv, CLASS_ANY, &phooks, &_tr_params_list,
					_tr_params_separator)<0)
			return -1;
	}

	if(_tr_params_list==NULL)
		return -1;

	memset(val, 0, sizeof(pv_value_t));
	val->flags = PV_VAL_STR;

	switch(subtype)
	{
		case TR_PL_VALUE:
		case TR_PL_IN:
			if(tp==NULL)
			{
				LM_ERR("value invalid parameters\n");
				return -1;
			}

			if(tp->type==TR_PARAM_STRING)
			{
				sv = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("value cannot get p1\n");
					return -1;
				}
				sv = v.rs;
			}

			for (pit = _tr_params_list; pit; pit=pit->next)
			{
				if (pit->name.len==sv.len
						&& strncasecmp(pit->name.s, sv.s, sv.len)==0)
				{
					if(subtype==TR_PL_IN) {
						val->ri = 1;
						val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
						val->rs.s = int2str(val->ri, &val->rs.len);
					} else {
						val->rs = pit->body;
					}
					goto done;
				}
			}
			if(subtype==TR_PL_IN) {
				val->ri = 0;
				val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
				val->rs.s = int2str(val->ri, &val->rs.len);
			} else {
				val->rs = _tr_empty;
			}
			break;

		case TR_PL_VALUEAT:
			if(tp==NULL)
			{
				LM_ERR("name invalid parameters\n");
				return -1;
			}

			if(tp->type==TR_PARAM_NUMBER)
			{
				n = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("name cannot get p1\n");
					return -1;
				}
				n = v.ri;
			}
			if(n<0)
			{
				n = -n;
				n--;
				for (pit = _tr_params_list; pit; pit=pit->next)
				{
					if(n==0)
					{
						val->rs = pit->body;
						goto done;
					}
					n--;
				}
			} else {
				/* ugly hack -- params are in reverse order
				 * - first count then find */
				i = 0;
				for (pit = _tr_params_list; pit; pit=pit->next)
					i++;
				if(n<i)
				{
					n = i - n - 1;
					for (pit = _tr_params_list; pit; pit=pit->next)
					{
						if(n==0)
						{
							val->rs = pit->body;
							goto done;
						}
						n--;
					}
				}
			}
			val->rs = _tr_empty;
			break;

		case TR_PL_NAME:
			if(tp==NULL)
			{
				LM_ERR("name invalid parameters\n");
				return -1;
			}

			if(tp->type==TR_PARAM_NUMBER)
			{
				n = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("name cannot get p1\n");
					return -1;
				}
				n = v.ri;
			}
			if(n<0)
			{
				n = -n;
				n--;
				for (pit = _tr_params_list; pit; pit=pit->next)
				{
					if(n==0)
					{
						val->rs = pit->name;
						goto done;
					}
					n--;
				}
			} else {
				/* ugly hack -- params are in reverse order
				 * - first count then find */
				i = 0;
				for (pit = _tr_params_list; pit; pit=pit->next)
					i++;
				if(n<i)
				{
					n = i - n - 1;
					for (pit = _tr_params_list; pit; pit=pit->next)
					{
						if(n==0)
						{
							val->rs = pit->name;
							goto done;
						}
						n--;
					}
				}
			}
			val->rs = _tr_empty;
			break;

		case TR_PL_COUNT:
			val->ri = 0;
			for (pit = _tr_params_list; pit; pit=pit->next)
				val->ri++;
			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			val->rs.s = int2str(val->ri, &val->rs.len);
			break;

		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}
done:
	return 0;
}

static str _tr_nameaddr_str = {0, 0};
static name_addr_t _tr_nameaddr;


/*!
 * \brief Evaluate name-address transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_nameaddr(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	str sv;
	int ret;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	if(_tr_nameaddr_str.len==0 || _tr_nameaddr_str.len!=val->rs.len ||
			strncmp(_tr_nameaddr_str.s, val->rs.s, val->rs.len)!=0)
	{
		if(val->rs.len>_tr_nameaddr_str.len)
		{
			if(_tr_nameaddr_str.s)
				pkg_free(_tr_nameaddr_str.s);
			_tr_nameaddr_str.s = (char*)pkg_malloc((val->rs.len+1)*sizeof(char));

			if(_tr_nameaddr_str.s==NULL)
			{
				LM_ERR("no more private memory\n");
				memset(&_tr_nameaddr_str, 0, sizeof(str));
				memset(&_tr_nameaddr, 0, sizeof(name_addr_t));
				return -1;
			}
		}
		_tr_nameaddr_str.len = val->rs.len;
		memcpy(_tr_nameaddr_str.s, val->rs.s, val->rs.len);
		_tr_nameaddr_str.s[_tr_nameaddr_str.len] = '\0';

		/* reset old values */
		memset(&_tr_nameaddr, 0, sizeof(name_addr_t));

		/* parse params */
		sv = _tr_nameaddr_str;
		ret = parse_nameaddr(&sv, &_tr_nameaddr);
		if (ret < 0) {
			if(ret != -3) return -1;
			/* -3 means no "<" found so treat whole nameaddr as an URI */
			_tr_nameaddr.uri = _tr_nameaddr_str;
			_tr_nameaddr.name = _tr_empty;
			_tr_nameaddr.len = _tr_nameaddr_str.len;
		}
	}

	memset(val, 0, sizeof(pv_value_t));
	val->flags = PV_VAL_STR;

	switch(subtype)
	{
		case TR_NA_URI:
			val->rs = (_tr_nameaddr.uri.s)?_tr_nameaddr.uri:_tr_empty;
			break;
		case TR_NA_LEN:
			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			val->ri = _tr_nameaddr.len;
			val->rs.s = int2str(val->ri, &val->rs.len);
			break;
		case TR_NA_NAME:
			val->rs = (_tr_nameaddr.name.s)?_tr_nameaddr.name:_tr_empty;
			break;

		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}
	return 0;
}

static str _tr_tobody_str = {0, 0};
static struct to_body _tr_tobody = {0};

/*!
 * \brief Evaluate To-Body transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_tobody(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	str sv;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	if(_tr_tobody_str.len==0 || _tr_tobody_str.len!=val->rs.len ||
			strncmp(_tr_tobody_str.s, val->rs.s, val->rs.len)!=0)
	{
		if(_tr_tobody_str.s==NULL || val->rs.len>_tr_tobody_str.len)
		{
			if(_tr_tobody_str.s)
				pkg_free(_tr_tobody_str.s);
			_tr_tobody_str.s = (char*)pkg_malloc((val->rs.len+3)*sizeof(char));

			if(_tr_tobody_str.s==NULL)
			{
				LM_ERR("no more private memory\n");
				free_to_params(&_tr_tobody);
				memset(&_tr_tobody, 0, sizeof(struct to_body));
				memset(&_tr_tobody_str, 0, sizeof(str));
				return -1;
			}
		}
		_tr_tobody_str.len = val->rs.len;
		memcpy(_tr_tobody_str.s, val->rs.s, val->rs.len);
		_tr_tobody_str.s[_tr_tobody_str.len] = '\r';
		_tr_tobody_str.s[_tr_tobody_str.len+1] = '\n';
		_tr_tobody_str.s[_tr_tobody_str.len+2] = '\0';

		/* reset old values */
		free_to_params(&_tr_tobody);
		memset(&_tr_tobody, 0, sizeof(struct to_body));

		/* parse params */
		sv = _tr_tobody_str;
		parse_to(sv.s, sv.s + sv.len + 2, &_tr_tobody);
		if (_tr_tobody.error == PARSE_ERROR)
		{
			free_to_params(&_tr_tobody);
			memset(&_tr_tobody, 0, sizeof(struct to_body));
			pkg_free(_tr_tobody_str.s);
			memset(&_tr_tobody_str, 0, sizeof(str));
			return -1;
		}
		if (parse_uri(_tr_tobody.uri.s, _tr_tobody.uri.len,
					&_tr_tobody.parsed_uri)<0)
		{
			free_to_params(&_tr_tobody);
			memset(&_tr_tobody, 0, sizeof(struct to_body));
			pkg_free(_tr_tobody_str.s);
			memset(&_tr_tobody_str, 0, sizeof(str));
			return -1;
		}
	}

	memset(val, 0, sizeof(pv_value_t));
	val->flags = PV_VAL_STR;

	switch(subtype)
	{
		case TR_TOBODY_URI:
			val->rs = (_tr_tobody.uri.s)?_tr_tobody.uri:_tr_empty;
			break;
		case TR_TOBODY_TAG:
			val->rs = (_tr_tobody.tag_value.s)?_tr_tobody.tag_value:_tr_empty;
			break;
		case TR_TOBODY_DISPLAY:
			val->rs = (_tr_tobody.display.s)?_tr_tobody.display:_tr_empty;
			break;
		case TR_TOBODY_URI_USER:
			val->rs = (_tr_tobody.parsed_uri.user.s)
				?_tr_tobody.parsed_uri.user:_tr_empty;
			break;
		case TR_TOBODY_URI_HOST:
			val->rs = (_tr_tobody.parsed_uri.host.s)
				?_tr_tobody.parsed_uri.host:_tr_empty;
			break;
		case TR_TOBODY_PARAMS:
			if(_tr_tobody.param_lst!=NULL)
			{
				val->rs.s = _tr_tobody.param_lst->name.s;
				val->rs.len = _tr_tobody_str.s + _tr_tobody_str.len
					- val->rs.s;
			} else val->rs = _tr_empty;
			break;

		default:
			LM_ERR("unknown subtype %d\n", subtype);
			return -1;
	}
	return 0;
}

void *memfindrchr(const void *buf, int c, size_t n)
{
	int i;
	unsigned char *p;

	p = (unsigned char*)buf;

	for (i=n-1; i>=0; i--) {
		if (p[i] == (unsigned char)c) {
			return (void*)(p+i);
		}
	}
	return NULL;
}

/*!
 * \brief Evaluate line transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_line(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	pv_value_t v;
	str sv;
	str mv;
	char *p;
	int n, i;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	switch(subtype)
	{
		case TR_LINE_SW:
			if(tp==NULL)
			{
				LM_ERR("value invalid parameters\n");
				return -1;
			}

			if(tp->type==TR_PARAM_STRING)
			{
				sv = tp->v.s;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_STR)) || v.rs.len<=0)
				{
					LM_ERR("value cannot get p1\n");
					return -1;
				}
				sv = v.rs;
			}

			if(val->rs.len < sv.len)
			{
				val->rs = _tr_empty;
				goto done;
			}
			p = val->rs.s;
			do {
				if(strncmp(p, sv.s, sv.len)==0)
				{
					/* match */
					mv.s = p;
					p += sv.len;
					p = memchr(p, '\n', (val->rs.s + val->rs.len) - p);
					if(p==NULL)
					{
						/* last line */
						mv.len = (val->rs.s + val->rs.len) - mv.s;
					} else {
						mv.len = p - mv.s;
					}
					val->rs = mv;
					goto done;
				}
				p = memchr(p, '\n', (val->rs.s + val->rs.len) - p);
			} while(p && ((++p)<=val->rs.s+val->rs.len-sv.len));
			val->rs = _tr_empty;
			break;

		case TR_LINE_AT:
			if(tp==NULL)
			{
				LM_ERR("name invalid parameters\n");
				return -1;
			}

			if(tp->type==TR_PARAM_NUMBER)
			{
				n = tp->v.n;
			} else {
				if(pv_get_spec_value(msg, (pv_spec_p)tp->v.data, &v)!=0
						|| (!(v.flags&PV_VAL_INT)))
				{
					LM_ERR("name cannot get p1\n");
					return -1;
				}
				n = v.ri;
			}
			if(n<0)
			{
				p = val->rs.s + val->rs.len - 1;
				if(*p=='\n')
					p--;
				mv.s = p;
				n = -n;
				i=1;
				p = memfindrchr(val->rs.s, '\n', p - val->rs.s);
				if(p!=NULL)
					p--;
				while(i<n && p)
				{
					mv.s = p;
					p = memfindrchr(val->rs.s, '\n', p - val->rs.s);
					if(p!=NULL)
						p--;
					i++;
				}
				if(i==n)
				{
					if(p==NULL)
					{
						/* first line */
						mv.len = mv.s - val->rs.s + 1;
						mv.s = val->rs.s;
					} else {
						mv.len = mv.s - p - 1;
						mv.s = p + 2;
					}
					val->rs = mv;
					goto done;
				}
			} else {
				p = val->rs.s;
				i = 0;
				while(i<n && p)
				{
					p = memchr(p, '\n', (val->rs.s + val->rs.len) - p);
					if(p!=NULL)
						p++;
					i++;
				}
				if(i==n && p!=NULL)
				{
					/* line found */
					mv.s = p;
					p = memchr(p, '\n', (val->rs.s + val->rs.len) - p);
					if(p==NULL)
					{
						/* last line */
						mv.len = (val->rs.s + val->rs.len) - mv.s;
					} else {
						mv.len = p - mv.s;
					}
					val->rs = mv;
					goto done;
				}
			}
			val->rs = _tr_empty;
			break;

		case TR_LINE_COUNT:
			n = 0;
			if(val->rs.len>0) {
				for(i=0; i<val->rs.len; i++) {
					if(val->rs.s[i]=='\n') {
						n++;
					}
				}
				if(val->rs.s[val->rs.len-1]!='\n') {
					n++;
				}
			}
			val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			val->ri = n;
			val->rs.s = int2str(val->ri, &val->rs.len);
			break;

		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}
done:
	if(val->rs.len>0)
	{
		/* skip ending '\r' if present */
		if(val->rs.s[val->rs.len-1]=='\r')
			val->rs.len--;
	}
	val->flags = PV_VAL_STR;
	return 0;
}

/*!
 * \brief Evaluate urialias transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_urialias(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	str sv;

	if(val==NULL || (!(val->flags&PV_VAL_STR)) || val->rs.len<=0)
		return -1;

	switch(subtype)
	{
		case TR_URIALIAS_ENCODE:
			tr_set_crt_buffer();
			sv.s = _tr_buffer;
			sv.len = TR_BUFFER_SIZE;
			if(ksr_uri_alias_encode(&val->rs, &sv)<0) {
				LM_WARN("error converting uri to alias [%.*s]\n",
						val->rs.len, val->rs.s);
				val->rs = _tr_empty;
				break;
			}
			val->rs = sv;
			break;
		case TR_URIALIAS_DECODE:
			tr_set_crt_buffer();
			sv.s = _tr_buffer;
			sv.len = TR_BUFFER_SIZE;
			if(ksr_uri_alias_decode(&val->rs, &sv)<0) {
				LM_WARN("error converting uri to alias [%.*s]\n",
						val->rs.len, val->rs.s);
				val->rs = _tr_empty;
				break;
			}
			val->rs = sv;
			break;

		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}

	val->flags = PV_VAL_STR;
	return 0;
}


/*!
 * \brief Evaluate val transformations
 * \param msg SIP message
 * \param tp transformation
 * \param subtype transformation type
 * \param val pseudo-variable
 * \return 0 on success, -1 on error
 */
int tr_eval_val(struct sip_msg *msg, tr_param_t *tp, int subtype,
		pv_value_t *val)
{
	str sv;
	int emode = 0;

	if(val==NULL)
		return -1;

	switch(subtype)
	{
		case TR_VAL_N0:
			if(val->flags&PV_VAL_NULL) {
				val->ri = 0;
				tr_set_crt_buffer();
				val->rs.s = _tr_buffer;
				val->rs.s[0] = '0';
				val->rs.s[1] = '\0';
				val->rs.len = 1;
				val->flags = PV_TYPE_INT|PV_VAL_INT|PV_VAL_STR;
			}
			break;
		case TR_VAL_NE:
			if(val->flags&PV_VAL_NULL) {
				val->ri = 0;
				tr_set_crt_buffer();
				val->rs.s = _tr_buffer;
				val->rs.s[0] = '\0';
				val->rs.len = 0;
				val->flags = PV_VAL_STR;
			}
			break;
		case TR_VAL_JSON:
			if(val->flags&PV_VAL_NULL) {
				val->ri = 0;
				tr_set_crt_buffer();
				val->rs.s = _tr_buffer;
				val->rs.s[0] = '\0';
				val->rs.len = 0;
				val->flags = PV_VAL_STR;
			} else if(val->flags&PV_VAL_STR) {
				ksr_str_json_escape(&val->rs, &sv, &emode);
				if(sv.s==NULL) {
					LM_ERR("failed to escape the value\n");
					return -1;
				}
				if(emode==0) {
					/* no escape was needed */
					return 0;
				}
				if(sv.len >= TR_BUFFER_SIZE - 1) {
					free(sv.s);
					LM_ERR("escaped value is too long\n");
					return -1;
				}
				tr_set_crt_buffer();
				memcpy(_tr_buffer, sv.s, sv.len);
				_tr_buffer[sv.len] = '\0';
				val->rs.s = _tr_buffer;
				val->rs.len = sv.len;
				free(sv.s);
			}
			break;
		case TR_VAL_JSONQE:
			if(val->flags&PV_VAL_NULL) {
				val->ri = 0;
				tr_set_crt_buffer();
				val->rs.s = _tr_buffer;
				val->rs.s[0] = '"';
				val->rs.s[1] = '"';
				val->rs.s[2] = '\0';
				val->rs.len = 2;
				val->flags = PV_VAL_STR;
			} else if(val->flags&PV_TYPE_INT) {
				/* no change needed */
				return 0;
			} else if(val->flags&PV_VAL_STR) {
				ksr_str_json_escape(&val->rs, &sv, &emode);
				if(sv.s==NULL) {
					LM_ERR("failed to escape the value\n");
					return -1;
				}
				if(emode==0) {
					/* no escape was needed */
					return 0;
				}
				if(sv.len >= TR_BUFFER_SIZE - 3) {
					free(sv.s);
					LM_ERR("escaped value is too long\n");
					return -1;
				}
				tr_set_crt_buffer();
				_tr_buffer[0] = '"';
				memcpy(_tr_buffer + 1, sv.s, sv.len);
				_tr_buffer[sv.len + 1] = '"';
				_tr_buffer[sv.len + 2] = '\0';
				val->rs.s = _tr_buffer;
				val->rs.len = sv.len + 2;
				free(sv.s);
			}
			break;

		default:
			LM_ERR("unknown subtype %d\n",
					subtype);
			return -1;
	}

	return 0;
}


#define _tr_parse_nparam(_p, _p0, _tp, _spec, _n, _sign, _in, _s) \
	while(is_in_str(_p, _in) && (*_p==' ' || *_p=='\t' || *_p=='\n')) _p++; \
	if(*_p==PV_MARKER) \
	{ /* pseudo-variable */ \
		_spec = (pv_spec_t*)pkg_malloc(sizeof(pv_spec_t)); \
		if(_spec==NULL) \
		{ \
			LM_ERR("no more private memory!\n"); \
			goto error; \
		} \
		_s.s = _p; _s.len = _in->s + _in->len - _p; \
		_p0 = pv_parse_spec(&_s, _spec); \
		if(_p0==NULL) \
		{ \
			LM_ERR("invalid spec in substr transformation: %.*s!\n", \
					_in->len, _in->s); \
			goto error; \
		} \
		_p = _p0; \
		_tp = (tr_param_t*)pkg_malloc(sizeof(tr_param_t)); \
		if(_tp==NULL) \
		{ \
			LM_ERR("no more private memory!\n"); \
			goto error; \
		} \
		memset(_tp, 0, sizeof(tr_param_t)); \
		_tp->type = TR_PARAM_SPEC; \
		_tp->v.data = (void*)_spec; \
	} else { \
		if(*_p=='+' || *_p=='-' || (*_p>='0' && *_p<='9')) \
		{ /* number */ \
			_sign = 1; \
			if(*_p=='-') { \
				_p++; \
				_sign = -1; \
			} else if(*_p=='+') _p++; \
			_n = 0; \
			while(is_in_str(_p, _in) && (*_p==' ' || *_p=='\t' || *_p=='\n')) \
			_p++; \
			while(is_in_str(_p, _in) && *_p>='0' && *_p<='9') \
			{ \
				_n = _n*10 + *_p - '0'; \
				_p++; \
			} \
			_tp = (tr_param_t*)pkg_malloc(sizeof(tr_param_t)); \
			if(_tp==NULL) \
			{ \
				LM_ERR("no more private memory!\n"); \
				goto error; \
			} \
			memset(_tp, 0, sizeof(tr_param_t)); \
			_tp->type = TR_PARAM_NUMBER; \
			_tp->v.n = sign*n; \
		} else { \
			LM_ERR("tinvalid param in transformation: %.*s!!\n", \
					_in->len, _in->s); \
			goto error; \
		} \
	}

/**
 * _m: 1 - the parameter value can be the TR_PARAM_MARKER; 0 - not allowed
 */
#define _tr_parse_sparamx(_p, _p0, _tp, _spec, _ps, _in, _s, _m) \
	while(is_in_str(_p, _in) && (*_p==' ' || *_p=='\t' || *_p=='\n')) _p++; \
	if(*_p==PV_MARKER) \
	{ /* pseudo-variable */ \
		_spec = (pv_spec_t*)pkg_malloc(sizeof(pv_spec_t)); \
		if(_spec==NULL) { \
			LM_ERR("no more private memory!\n"); \
			goto error; \
		} \
		_s.s = _p; _s.len = _in->s + _in->len - _p; \
		_p0 = pv_parse_spec(&_s, _spec); \
		if(_p0==NULL) { \
			LM_ERR("invalid spec in substr transformation: %.*s!\n", \
					_in->len, _in->s); \
			goto error; \
		} \
		_p = _p0; \
		_tp = (tr_param_t*)pkg_malloc(sizeof(tr_param_t)); \
		if(_tp==NULL) { \
			LM_ERR("no more private memory!\n"); \
			goto error; \
		} \
		memset(_tp, 0, sizeof(tr_param_t)); \
		_tp->type = TR_PARAM_SPEC; \
		_tp->v.data = (void*)_spec; \
	} else { /* string */ \
		_ps = _p; \
		while(is_in_str(_p, _in) && *_p!='\t' && *_p!='\n' \
				&& *_p!=TR_PARAM_MARKER && *_p!=TR_RBRACKET) \
			_p++; \
		if(*_p=='\0') { \
			LM_ERR("invalid param in transformation: %.*s!!\n", \
					_in->len, _in->s); \
			goto error; \
		} \
		if(_m && *_p==TR_PARAM_MARKER) { \
			_p++; \
			if(*_p=='\0') { \
				LM_ERR("invalid param in transformation: %.*s!!!\n", \
					_in->len, _in->s); \
				goto error; \
			} \
		} \
		_tp = (tr_param_t*)pkg_malloc(sizeof(tr_param_t)); \
		if(_tp==NULL) { \
			LM_ERR("no more private memory!!\n"); \
			goto error; \
		} \
		memset(_tp, 0, sizeof(tr_param_t)); \
		_tp->type = TR_PARAM_STRING; \
		_tp->v.s.s = _ps; \
		_tp->v.s.len = _p - _ps; \
	}

#define _tr_parse_sparam(_p, _p0, _tp, _spec, _ps, _in, _s) \
	_tr_parse_sparamx(_p, _p0, _tp, _spec, _ps, _in, _s, 0)

/*!
 * \brief Helper fuction to parse a string transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_string(str* in, trans_t *t)
{
	char *p;
	char *p0;
	char *ps;
	str name;
	str s;
	pv_spec_t *spec = NULL;
	int n;
	int sign;
	tr_param_t *tp = NULL;

	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_STRING;
	t->trf = tr_eval_string;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==3 && strncasecmp(name.s, "len", 3)==0)
	{
		t->subtype = TR_S_LEN;
		goto done;
	} else if(name.len==3 && strncasecmp(name.s, "int", 3)==0) {
		t->subtype = TR_S_INT;
		goto done;
	} else if(name.len==3 && strncasecmp(name.s, "md5", 3)==0) {
		t->subtype = TR_S_MD5;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "rmws", 4)==0) {
		t->subtype = TR_S_RMWS;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "sha256", 6)==0) {
		t->subtype = TR_S_SHA256;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "sha384", 6)==0) {
		t->subtype = TR_S_SHA384;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "sha512", 6)==0) {
		t->subtype = TR_S_SHA512;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "tolower", 7)==0) {
		t->subtype = TR_S_TOLOWER;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "toupper", 7)==0) {
		t->subtype = TR_S_TOUPPER;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "numeric", 7)==0) {
		t->subtype = TR_S_NUMERIC;
		goto done;
	} else if(name.len==11 && strncasecmp(name.s, "encode.hexa", 11)==0) {
		t->subtype = TR_S_ENCODEHEXA;
		goto done;
	} else if(name.len==11 && strncasecmp(name.s, "decode.hexa", 11)==0) {
		t->subtype = TR_S_DECODEHEXA;
		goto done;
	} else if(name.len==11 && strncasecmp(name.s, "encode.7bit", 11)==0) {
		t->subtype = TR_S_ENCODE7BIT;
		goto done;
	} else if(name.len==11 && strncasecmp(name.s, "decode.7bit", 11)==0) {
		t->subtype = TR_S_DECODE7BIT;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "encode.base58", 13)==0) {
		t->subtype = TR_S_ENCODEBASE58;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "decode.base58", 13)==0) {
		t->subtype = TR_S_DECODEBASE58;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "encode.base64", 13)==0) {
		t->subtype = TR_S_ENCODEBASE64;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "decode.base64", 13)==0) {
		t->subtype = TR_S_DECODEBASE64;
		goto done;
	} else if(name.len==14 && strncasecmp(name.s, "encode.base64t", 14)==0) {
		t->subtype = TR_S_ENCODEBASE64T;
		goto done;
	} else if(name.len==14 && strncasecmp(name.s, "decode.base64t", 14)==0) {
		t->subtype = TR_S_DECODEBASE64T;
		goto done;
	} else if(name.len==16 && strncasecmp(name.s, "encode.base64url", 16)==0) {
		t->subtype = TR_S_ENCODEBASE64URL;
		goto done;
	} else if(name.len==16 && strncasecmp(name.s, "decode.base64url", 16)==0) {
		t->subtype = TR_S_DECODEBASE64URL;
		goto done;
	} else if(name.len==17 && strncasecmp(name.s, "encode.base64urlt", 17)==0) {
		t->subtype = TR_S_ENCODEBASE64URLT;
		goto done;
	} else if(name.len==17 && strncasecmp(name.s, "decode.base64urlt", 17)==0) {
		t->subtype = TR_S_DECODEBASE64URLT;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "escape.common", 13)==0) {
		t->subtype = TR_S_ESCAPECOMMON;
		goto done;
	} else if(name.len==15 && strncasecmp(name.s, "unescape.common", 15)==0) {
		t->subtype = TR_S_UNESCAPECOMMON;
		goto done;
	} else if(name.len==11 && strncasecmp(name.s, "escape.user", 11)==0) {
		t->subtype = TR_S_ESCAPEUSER;
		goto done;
	} else if(name.len==13 && strncasecmp(name.s, "unescape.user", 13)==0) {
		t->subtype = TR_S_UNESCAPEUSER;
		goto done;
	} else if(name.len==12 && strncasecmp(name.s, "escape.param", 12)==0) {
		t->subtype = TR_S_ESCAPEPARAM;
		goto done;
	} else if(name.len==14 && strncasecmp(name.s, "unescape.param", 14)==0) {
		t->subtype = TR_S_UNESCAPEPARAM;
		goto done;
	} else if(name.len==10 && strncasecmp(name.s, "escape.csv", 10)==0) {
		t->subtype = TR_S_ESCAPECSV;
		goto done;
	} else if(name.len==8 && strncasecmp(name.s, "prefixes", 8)==0) {
		t->subtype = TR_S_PREFIXES;
		if(*p!=TR_PARAM_MARKER)
			goto done;
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid prefixes transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==15 && strncasecmp(name.s, "prefixes.quoted", 15)==0) {
		t->subtype = TR_S_PREFIXES_QUOT;
		if(*p!=TR_PARAM_MARKER)
			goto done;
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid prefixes transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "substr", 6)==0) {
		t->subtype = TR_S_SUBSTR;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid substr transformation: %.*s!\n", in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid substr transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		if(tp->type==TR_PARAM_NUMBER && tp->v.n<0)
		{
			LM_ERR("substr negative offset\n");
			goto error;
		}
		t->params->next = tp;
		tp = 0;
		while(is_in_str(p, in) && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid substr transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "select", 6)==0) {
		t->subtype = TR_S_SELECT;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid select transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_PARAM_MARKER || *(p+1)=='\0')
		{
			LM_ERR("invalid select transformation: %.*s!\n", in->len, in->s);
			goto error;
		}
		p++;
		tp = (tr_param_t*)pkg_malloc(sizeof(tr_param_t));
		if(tp==NULL)
		{
			LM_ERR("no more private memory!\n");
			goto error;
		}
		memset(tp, 0, sizeof(tr_param_t));
		tp->type = TR_PARAM_STRING;
		tp->v.s.s = p;
		tp->v.s.len = 1;
		if(*p=='\\') {
			p++;
			if(*p=='\\' || *p=='n' || *p=='r' || *p=='t') {
				tp->v.s.len = 2;
			} else {
				LM_ERR("unexpected escape char: %c\n", *p);
				goto error;
			}
		}
		t->params->next = tp;
		tp = 0;
		p++;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid select transformation: %.*s (c:%c/%d - p:%d)!!\n",
					in->len, in->s, *p, *p, (int)(p - in->s));
			goto error;
		}
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "strip", 5)==0) {
		t->subtype = TR_S_STRIP;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid strip transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid strip transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==9 && strncasecmp(name.s, "striptail", 9)==0) {
		t->subtype = TR_S_STRIPTAIL;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid striptail transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid striptail transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "stripto", 7)==0) {
		t->subtype = TR_S_STRIPTO;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid stripto transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid strip transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "ftime", 5)==0) {
		t->subtype = TR_S_TIMEFORMAT;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid ftime transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid ftime transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "replace", 7)==0) {
		t->subtype = TR_S_REPLACE;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid replace transformation: %.*s!\n", in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid replace transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params->next = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid replace transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==8 && strncasecmp(name.s, "corehash", 8)==0) {
		t->subtype = TR_S_COREHASH;
		if(*p==TR_PARAM_MARKER)
		{
			p++;
			_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
			t->params = tp;
		}
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid corehash transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "trim", 4)==0) {
		t->subtype = TR_S_TRIM;
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "rtrim", 5)==0) {
		t->subtype = TR_S_RTRIM;
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "ltrim", 5)==0) {
		t->subtype = TR_S_LTRIM;
		goto done;
	} else if(name.len==2 && strncasecmp(name.s, "rm", 2)==0) {
		t->subtype = TR_S_RM;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid ftime transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid rm transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==15 && strncasecmp(name.s, "urlencode.param", 15)==0) {
		t->subtype = TR_S_URLENCODEPARAM;
		goto done;
	} else if(name.len==15 && strncasecmp(name.s, "urldecode.param", 15)==0) {
		t->subtype = TR_S_URLDECODEPARAM;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "unquote", 7)==0) {
		t->subtype = TR_S_UNQUOTE;
		goto done;
	} else if(name.len==9 && strncasecmp(name.s, "unbracket", 9)==0) {
		t->subtype = TR_S_UNBRACKET;
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "count", 5)==0) {
		t->subtype = TR_S_COUNT;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid count transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid count transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "before", 6)==0) {
		t->subtype = TR_S_BEFORE;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid before transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid before transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "after", 5)==0) {
		t->subtype = TR_S_AFTER;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid after transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid after transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "rbefore", 7)==0) {
		t->subtype = TR_S_RBEFORE;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid rbefore transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid rbefore transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "rafter", 6)==0) {
		t->subtype = TR_S_RAFTER;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid rafter transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid rafter transformation: %.*s!!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==8 && (strncasecmp(name.s, "fmtlines", 8)==0
				|| strncasecmp(name.s, "fmtlinet", 8)==0)) {
		if(name.s[7]=='s' || name.s[7]=='S') {
			t->subtype = TR_S_FMTLINES;
		} else {
			t->subtype = TR_S_FMTLINET;
		}
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid fmtline%c transformation: %.*s!\n", name.s[7],
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		if(tp->type==TR_PARAM_NUMBER && tp->v.n<0)
		{
			LM_ERR("fmtline%c negative line length value\n", name.s[7]);
			goto error;
		}

		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid fmtline%c transformation: %.*s!\n",
					 name.s[7], in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s);
		if(tp->type==TR_PARAM_NUMBER && tp->v.n<0)
		{
			LM_ERR("fmtline%c negative padding lenght value\n", name.s[7]);
			goto error;
		}
		t->params->next = tp;
		tp = 0;
		while(is_in_str(p, in) && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid fmtline%c transformation: %.*s!!\n",
					name.s[7], in->len, in->s);
			goto error;
		}
		goto done;
	}

	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	if(tp)
		tr_param_free(tp);
	if(spec)
		pv_spec_free(spec);
	return NULL;
done:
	t->name = name;
	return p;
}


/*!
 * \brief Helper fuction to parse a URI transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_uri(str* in, trans_t *t)
{
	char *p;
	char *p0;
	char *ps;
	str name;
	str s;
	pv_spec_t *spec = NULL;
	tr_param_t *tp = NULL;

	if(in==NULL || in->s==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_URI;
	t->trf = tr_eval_uri;

	/* find next token */
	while(*p && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n", in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==4 && strncasecmp(name.s, "user", 4)==0)
	{
		t->subtype = TR_URI_USER;
		goto done;
	} else if((name.len==4 && strncasecmp(name.s, "host", 4)==0)
			|| (name.len==6 && strncasecmp(name.s, "domain", 6)==0)) {
		t->subtype = TR_URI_HOST;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "passwd", 6)==0) {
		t->subtype = TR_URI_PASSWD;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "port", 4)==0) {
		t->subtype = TR_URI_PORT;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "saor", 4)==0) {
		t->subtype = TR_URI_SAOR;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "suri", 4)==0) {
		t->subtype = TR_URI_SURI;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "duri", 4)==0) {
		t->subtype = TR_URI_DURI;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "params", 6)==0) {
		t->subtype = TR_URI_PARAMS;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "headers", 7)==0) {
		t->subtype = TR_URI_HEADERS;
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "param", 5)==0) {
		t->subtype = TR_URI_PARAM;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid param transformation: %.*s\n", in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid param transformation: %.*s!\n", in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==9 && strncasecmp(name.s, "transport", 9)==0) {
		t->subtype = TR_URI_TRANSPORT;
		goto done;
	} else if(name.len==3 && strncasecmp(name.s, "ttl", 3)==0) {
		t->subtype = TR_URI_TTL;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "uparam", 6)==0) {
		t->subtype = TR_URI_UPARAM;
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "maddr", 5)==0) {
		t->subtype = TR_URI_MADDR;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "method", 6)==0) {
		t->subtype = TR_URI_METHOD;
		goto done;
	} else if(name.len==2 && strncasecmp(name.s, "lr", 2)==0) {
		t->subtype = TR_URI_LR;
		goto done;
	} else if(name.len==2 && strncasecmp(name.s, "r2", 2)==0) {
		t->subtype = TR_URI_R2;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "scheme", 6)==0) {
		t->subtype = TR_URI_SCHEME;
		goto done;
	} else if(name.len==8 && strncasecmp(name.s, "tosocket", 8)==0) {
		t->subtype = TR_URI_TOSOCKET;
		goto done;
	}

	LM_ERR("unknown transformation: %.*s/%.*s!\n", in->len,
			in->s, name.len, name.s);
error:
	if(spec)
		pv_spec_free(spec);
	return NULL;

done:
	t->name = name;
	return p;
}


/*!
 * \brief Helper fuction to parse a parameter transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_paramlist(str* in, trans_t *t)
{
	char *p;
	char *p0;
	char *ps;
	char *start_pos;
	str s;
	str name;
	int n;
	int sign;
	pv_spec_t *spec = NULL;
	tr_param_t *tp = NULL;

	if(in==NULL || in->s==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_PARAMLIST;
	t->trf = tr_eval_paramlist;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==5 && strncasecmp(name.s, "value", 5)==0) {
		t->subtype = TR_PL_VALUE;
	} else if(name.len==2 && strncasecmp(name.s, "in", 2)==0) {
		t->subtype = TR_PL_IN;
	} else if(name.len==7 && strncasecmp(name.s, "valueat", 7)==0) {
		t->subtype = TR_PL_VALUEAT;
	} else if(name.len==4 && strncasecmp(name.s, "name", 4)==0) {
		t->subtype = TR_PL_NAME;
	} else if(name.len==5 && strncasecmp(name.s, "count", 5)==0) {
		t->subtype = TR_PL_COUNT;
	} else {
		goto unknown;
	}

	if(t->subtype == TR_PL_COUNT) {
		if(*p==TR_PARAM_MARKER) {
			start_pos = ++p;
			_tr_parse_sparamx(p, p0, tp, spec, ps, in, s, 1);
			t->params = tp;
			tp = 0;
			if (t->params->type != TR_PARAM_SPEC && p - start_pos != 1) {
				LM_ERR("invalid separator in transformation: "
						"%.*s\n", in->len, in->s);
				goto error;
			}
			while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
			if(*p!=TR_RBRACKET) {
				LM_ERR("invalid name transformation: %.*s!\n",
						in->len, in->s);
				goto error;
			}
		}
		goto done;
	}

	/* now transformations with mandatory parameters */
	if(*p!=TR_PARAM_MARKER)
	{
		LM_ERR("invalid %.*s transformation: %.*s\n",
				name.len, name.s, in->len, in->s);
		goto error;
	}
	p++;

	if(t->subtype == TR_PL_VALUE || t->subtype == TR_PL_IN) {
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
	} else if(t->subtype == TR_PL_VALUEAT || t->subtype == TR_PL_NAME) {
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s)
			t->params = tp;
		tp = 0;
		while(is_in_str(p, in) && (*p==' ' || *p=='\t' || *p=='\n')) p++;
	}

	if(*p==TR_PARAM_MARKER) {
		start_pos = ++p;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params->next = tp;
		tp = 0;
		if (p - start_pos != 1) {
			LM_ERR("invalid separator in transformation: "
					"%.*s\n", in->len, in->s);
			goto error;
		}
	}

	while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
	if(*p!=TR_RBRACKET) {
		LM_ERR("invalid %.*s transformation: %.*s!\n",
				name.len, name.s, in->len, in->s);
		goto error;
	}

done:
	t->name = name;
	return p;

unknown:
	LM_ERR("unknown transformation: %.*s/%.*s!\n",
			in->len, in->s, name.len, name.s);
error:
	if(spec)
		pv_spec_free(spec);
	return NULL;
}


/*!
 * \brief Helper fuction to parse a name-address transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_nameaddr(str* in, trans_t *t)
{
	char *p;
	str name;

	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_NAMEADDR;
	t->trf = tr_eval_nameaddr;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==3 && strncasecmp(name.s, "uri", 3)==0)
	{
		t->subtype = TR_NA_URI;
		goto done;
	} else if(name.len==3 && strncasecmp(name.s, "len", 3)==0)
	{
		t->subtype = TR_NA_LEN;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "name", 4)==0) {
		t->subtype = TR_NA_NAME;
		goto done;
	}


	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	return NULL;
done:
	t->name = name;
	return p;
}

/*!
 * \brief Helper fuction to parse a name-address transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_tobody(str* in, trans_t *t)
{
	char *p;
	str name;

	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_TOBODY;
	t->trf = tr_eval_tobody;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==3 && strncasecmp(name.s, "uri", 3)==0)
	{
		t->subtype = TR_TOBODY_URI;
		goto done;
	} else if(name.len==3 && strncasecmp(name.s, "tag", 3)==0) {
		t->subtype = TR_TOBODY_TAG;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "user", 4)==0) {
		t->subtype = TR_TOBODY_URI_USER;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "host", 4)==0) {
		t->subtype = TR_TOBODY_URI_HOST;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "params", 6)==0) {
		t->subtype = TR_TOBODY_PARAMS;
		goto done;
	} else if(name.len==7 && strncasecmp(name.s, "display", 7)==0) {
		t->subtype = TR_TOBODY_DISPLAY;
		goto done;
	}


	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	return NULL;
done:
	t->name = name;
	return p;
}

/*!
 * \brief Helper fuction to parse a line transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_line(str* in, trans_t *t)
{
	char *p;
	char *p0;
	char *ps;
	str s;
	str name;
	int n;
	int sign;
	pv_spec_t *spec = NULL;
	tr_param_t *tp = NULL;


	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_LINE;
	t->trf = tr_eval_line;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0')
	{
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==2 && strncasecmp(name.s, "at", 2)==0)
	{
		t->subtype = TR_LINE_AT;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid name transformation: %.*s\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_nparam(p, p0, tp, spec, n, sign, in, s)
			t->params = tp;
		tp = 0;
		while(is_in_str(p, in) && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid name transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}

		goto done;
	} else if(name.len==2 && strncasecmp(name.s, "sw", 2)==0) {
		t->subtype = TR_LINE_SW;
		if(*p!=TR_PARAM_MARKER)
		{
			LM_ERR("invalid value transformation: %.*s\n",
					in->len, in->s);
			goto error;
		}
		p++;
		_tr_parse_sparam(p, p0, tp, spec, ps, in, s);
		t->params = tp;
		tp = 0;
		while(*p && (*p==' ' || *p=='\t' || *p=='\n')) p++;
		if(*p!=TR_RBRACKET)
		{
			LM_ERR("invalid value transformation: %.*s!\n",
					in->len, in->s);
			goto error;
		}
		goto done;
	} else if(name.len==5 && strncasecmp(name.s, "count", 5)==0) {
		t->subtype = TR_LINE_COUNT;
		goto done;
	}


	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	return NULL;
done:
	t->name = name;
	return p;
}

/*!
 * \brief Helper fuction to parse urialias transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_urialias(str* in, trans_t *t)
{
	char *p;
	str name;


	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_URIALIAS;
	t->trf = tr_eval_urialias;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0') {
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==6 && strncasecmp(name.s, "encode", 6)==0) {
		t->subtype = TR_URIALIAS_ENCODE;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "decode", 6)==0) {
		t->subtype = TR_URIALIAS_DECODE;
		goto done;
	}


	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	return NULL;

done:
	t->name = name;
	return p;
}


/*!
 * \brief Helper fuction to parse val transformation
 * \param in parsed string
 * \param t transformation
 * \return pointer to the end of the transformation in the string - '}', null on error
 */
char* tr_parse_val(str* in, trans_t *t)
{
	char *p;
	str name;


	if(in==NULL || t==NULL)
		return NULL;

	p = in->s;
	name.s = in->s;
	t->type = TR_VAL;
	t->trf = tr_eval_val;

	/* find next token */
	while(is_in_str(p, in) && *p!=TR_PARAM_MARKER && *p!=TR_RBRACKET) p++;
	if(*p=='\0') {
		LM_ERR("invalid transformation: %.*s\n",
				in->len, in->s);
		goto error;
	}
	name.len = p - name.s;
	trim(&name);

	if(name.len==2 && strncasecmp(name.s, "n0", 2)==0) {
		t->subtype = TR_VAL_N0;
		goto done;
	} else if(name.len==2 && strncasecmp(name.s, "ne", 2)==0) {
		t->subtype = TR_VAL_NE;
		goto done;
	} else if(name.len==4 && strncasecmp(name.s, "json", 4)==0) {
		t->subtype = TR_VAL_JSON;
		goto done;
	} else if(name.len==6 && strncasecmp(name.s, "jsonqe", 6)==0) {
		t->subtype = TR_VAL_JSONQE;
		goto done;
	}


	LM_ERR("unknown transformation: %.*s/%.*s/%d!\n", in->len, in->s,
			name.len, name.s, name.len);
error:
	return NULL;

done:
	t->name = name;
	return p;
}
