/*
 * Generic Parameter Parser
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * opensips is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * History:
 * -------
 * 2003-03-24 Created by janakj
 * 2003-04-07 shm duplication added (janakj)
 * 2003-04-07 URI class added (janakj)
 */

#include <string.h>
#include "../str.h"
#include "../ut.h"
#include "../dprint.h"
#include "../trim.h"
#include "../mem/mem.h"
#include "../mem/shm_mem.h"
#include "parse_param.h"


/*
 * Try to find out parameter name, recognized parameters
 * are q, expires and methods
 */
static inline void parse_contact_class(param_hooks_t* _h, param_t* _p)
{

	if (!_p->name.s) {
		LM_ERR("empty value\n");
		return;
	}
	switch(_p->name.s[0]) {
	case 'q':
	case 'Q':
		if (_p->name.len == 1) {
			_p->type = P_Q;
			_h->contact.q = _p;
		}
		break;

	case 'e':
	case 'E':
		if ((_p->name.len == 7) &&
		    (!strncasecmp(_p->name.s + 1, "xpires", 6))) {
			_p->type = P_EXPIRES;
			_h->contact.expires = _p;
		}
		break;

	case 'm':
	case 'M':
		if ((_p->name.len == 7) &&
		    (!strncasecmp(_p->name.s + 1, "ethods", 6))) {
			_p->type = P_METHODS;
			_h->contact.methods = _p;
		}
		break;

	case 'r':
	case 'R':
		if ((_p->name.len == 8) &&
		    (!strncasecmp(_p->name.s + 1, "eceived", 7))) {
			_p->type = P_RECEIVED;
			_h->contact.received = _p;
		}
		break;
	case '+':
		if ((_p->name.len == 13) &&
		    (!strncasecmp(_p->name.s + 1, "sip.instance", 12))) {
			_p->type = P_INSTANCE;
			_h->contact.instance = _p;
		}
		break;
	}
}


/*
 * Try to find out parameter name, recognized parameters
 * are transport, lr, r2, maddr
 */
static inline void parse_uri_class(param_hooks_t* _h, param_t* _p)
{

	if (!_p->name.s) {
		LM_ERR("empty value\n");
		return;
	}
	switch(_p->name.s[0]) {
	case 't':
	case 'T':
		if ((_p->name.len == 9) &&
		    (!strncasecmp(_p->name.s + 1, "ransport", 8))) {
			_p->type = P_TRANSPORT;
			_h->uri.transport = _p;
		} else if (_p->name.len == 2) {
			if (((_p->name.s[1] == 't') || (_p->name.s[1] == 'T')) &&
			    ((_p->name.s[2] == 'l') || (_p->name.s[2] == 'L'))) {
				_p->type = P_TTL;
				_h->uri.ttl = _p;
			}
		}
		break;

	case 'l':
	case 'L':
		if ((_p->name.len == 2) && ((_p->name.s[1] == 'r') || (_p->name.s[1] == 'R'))) {
			_p->type = P_LR;
			_h->uri.lr = _p;
		}
		break;

	case 'r':
	case 'R':
		if ((_p->name.len == 2) && (_p->name.s[1] == '2')) {
			_p->type = P_R2;
			_h->uri.r2 = _p;
		}
		break;

	case 'm':
	case 'M':
		if ((_p->name.len == 5) &&
		    (!strncasecmp(_p->name.s + 1, "addr", 4))) {
			_p->type = P_MADDR;
			_h->uri.maddr = _p;
		}
		break;

	case 'd':
	case 'D':
		if ((_p->name.len == 5) &&
		    (!strncasecmp(_p->name.s + 1, "stip", 4))) {
			_p->type = P_DSTIP;
			_h->uri.dstip = _p;
		} else if ((_p->name.len == 7) &&
			   (!strncasecmp(_p->name.s + 1, "stport", 6))) {
			_p->type = P_DSTPORT;
			_h->uri.dstport = _p;
		}
		break;
	}

}


/*
 * Parse quoted string in a parameter body
 * return the string without quotes in _r
 * parameter and update _s to point behind the
 * closing quote
 */
static inline int parse_quoted_param(str* _s, str* _r)
{
	char* end_quote;

	     /* The string must have at least
	      * surrounding quotes
	      */
	if (_s->len < 2) {
		return -1;
	}

	     /* Skip opening quote */
	_s->s++;
	_s->len--;


	     /* Find closing quote */
	end_quote = q_memchr(_s->s, '\"', _s->len);

	     /* Not found, return error */
	if (!end_quote) {
		return -2;
	}

	     /* Let _r point to the string without
	      * surrounding quotes
	      */
	_r->s = _s->s;
	_r->len = end_quote - _s->s;

	     /* Update _s parameter to point
	      * behind the closing quote
	      */
	_s->len -= (end_quote - _s->s + 1);
	_s->s = end_quote + 1;

	     /* Everything went OK */
	return 0;
}


/*
 * Parse unquoted token in a parameter body
 * let _r point to the token and update _s
 * to point right behind the token
 */
static inline int parse_token_param(str* _s, str* _r)
{
	int i;

	     /* There is nothing to parse,
	      * return error
	      */
	if (_s->len == 0) {
		return -1;
	}

	     /* Save the beginning of the
	      * token in _r->s
	      */
	_r->s = _s->s;

	     /* Iterate through the
	      * token body
	      */
	for(i = 0; i < _s->len; i++) {

		     /* All these characters
		      * mark end of the token
		      */
		switch(_s->s[i]) {
		case ' ':
		case '\t':
		case '\r':
		case '\n':
		case ',':
		case ';':
			     /* So if you find
			      * any of them
			      * stop iterating
			      */
			goto out;
		}
	}
 out:
	if (i == 0) {
		return -1;
        }

	     /* Save length of the token */
        _r->len = i;

	     /* Update _s parameter so it points
	      * right behind the end of the token
	      */
	_s->s = _s->s + i;
	_s->len -= i;

	     /* Everything went OK */
	return 0;
}


/*
 * Parse a parameter name
 */
static inline void parse_param_name(str* _s, pclass_t _c, param_hooks_t* _h, param_t* _p)
{

	if (!_s->s) {
		LM_DBG("empty parameter\n");
		return;
	}

	_p->name.s = _s->s;

	while(_s->len) {
		switch(_s->s[0]) {
		case ' ':
		case '\t':
		case '\r':
		case '\n':
		case ';':
		case ',':
		case '=':
			goto out;
		}
		_s->s++;
		_s->len--;
	}

 out:
	_p->name.len = _s->s - _p->name.s;

	switch(_c) {
	case CLASS_CONTACT: parse_contact_class(_h, _p); break;
	case CLASS_URI:     parse_uri_class(_h, _p);     break;
	default: break;
	}
}





/*
 * Parse body of a parameter. It can be quoted string or
 * a single token.
 */
static inline int parse_param_body(str* _s, param_t* _c)
{
	if (_s->s[0] == '\"') {
		if (parse_quoted_param(_s, &(_c->body)) < 0) {
			LM_ERR("failed to parse quoted string\n");
			return -2;
		}
	} else {
		if (parse_token_param(_s, &(_c->body)) < 0) {
			LM_ERR("failed to parse token\n");
			return -3;
		}
	}

	return 0;
}


/*
 * Parse parameters
 * _s is string containing parameters, it will be updated to point behind the parameters
 * _c is class of parameters
 * _h is pointer to structure that will be filled with pointer to well known parameters
 * linked list of parsed parameters will be stored in
 * the variable _p is pointing to
 * The function returns 0 on success and negative number
 * on an error
 */
int parse_params(str* _s, pclass_t _c, param_hooks_t* _h, param_t** _p)
{
	param_t* t;
	param_t* last;

	if (!_s || !_h || !_p) {
		LM_ERR("invalid parameter value\n");
		return -1;
	}

	memset(_h, 0, sizeof(param_hooks_t));
	last = NULL;
	*_p = 0;

	if (!_s->s) { /* no parameters at all -- we're done */
		LM_DBG("empty uri params, skipping\n");
		return 0;
	}

	LM_DBG("Parsing params for:[%.*s]\n",_s->len,_s->s);

	while(1) {
		t = (param_t*)pkg_malloc(sizeof(param_t));
		if (t == 0) {
			LM_ERR("no pkg memory left\n");
			goto error;
		}
		memset(t, 0, sizeof(param_t));

		parse_param_name(_s, _c, _h, t);
		trim_leading(_s);

		if (_s->len == 0) { /* The last parameter without body */
			t->len = t->name.len;
			goto ok;
		}

		if (_s->s[0] == '=') {
			_s->s++;
			_s->len--;
			trim_leading(_s);

			if (_s->len == 0) {
				LM_ERR("body missing\n");
				goto error;
			}

			if (parse_param_body(_s, t) < 0) {
				LM_ERR("failed to parse param body\n");
				goto error;
			}

			t->len = _s->s - t->name.s;

			trim_leading(_s);
			if (_s->len == 0) {
				goto ok;
			}
		} else {
			t->len = t->name.len;
		}

		if (_s->s[0]==',') goto ok; /* To be able to parse header parameters */
		if (_s->s[0]=='>') goto ok; /* To be able to parse URI parameters */

		if (_s->s[0] != ';') {
			LM_ERR("invalid character, ; expected, found %c \n",_s->s[0]);
			goto error;
		}

		_s->s++;
		_s->len--;
		trim_leading(_s);

		if (_s->len == 0) {
			LM_ERR("param name missing after ;\n");
			goto error;
		}

		if (last) {last->next=t;} else {*_p = t;}
		last = t;
	}

error:
	if (t) pkg_free(t);
	free_params(*_p);
	*_p = 0;
	return -2;

ok:
	if (last) {last->next=t;} else {*_p = t;}
	_h->last_param = last = t;
	return 0;
}


/*
 * Free linked list of parameters
 */
static inline void do_free_params(param_t* _p, int _shm)
{
	param_t* ptr;

	while(_p) {
		ptr = _p;
		_p = _p->next;
		if (_shm) shm_free(ptr);
		else pkg_free(ptr);
	}
}


/*
 * Free linked list of parameters
 */
void free_params(param_t* _p)
{
	do_free_params(_p, 0);
}


/*
 * Free linked list of parameters
 */
void shm_free_params(param_t* _p)
{
	do_free_params(_p, 1);
}


/*
 * Print a parameter structure, just for debugging
 */
static inline void print_param(param_t* _p)
{
	char* type;

	LM_DBG("---param(%p)---\n", _p);

	switch(_p->type) {
	case P_OTHER:     type = "P_OTHER";     break;
	case P_Q:         type = "P_Q";         break;
	case P_EXPIRES:   type = "P_EXPIRES";   break;
	case P_METHODS:   type = "P_METHODS";   break;
	case P_TRANSPORT: type = "P_TRANSPORT"; break;
	case P_LR:        type = "P_LR";        break;
	case P_R2:        type = "P_R2";        break;
	case P_MADDR:     type = "P_MADDR";     break;
	case P_TTL:       type = "P_TTL";       break;
	case P_RECEIVED:  type = "P_RECEIVED";  break;
	case P_DSTIP:     type = "P_DSTIP";     break;
	case P_DSTPORT:   type = "P_DSTPORT";   break;
	default:          type = "UNKNOWN";     break;
	}

	LM_DBG("type: %s\n", type);
	LM_DBG("name: \'%.*s\'\n", _p->name.len, _p->name.s);
	LM_DBG("body: \'%.*s\'\n", _p->body.len, _p->body.s);
	LM_DBG("len : %d\n", _p->len);
	LM_DBG("---/param---\n");
}


/*
 * Print linked list of parameters, just for debugging
 */
void print_params(param_t* _p)
{
	param_t* ptr;

	ptr = _p;
	while(ptr) {
		print_param(ptr);
		ptr = ptr->next;
	}
}


/*
 * Duplicate linked list of parameters
 */
static inline int do_duplicate_params(param_t** _n, param_t* _p, int _shm)
{
	param_t* last, *ptr, *t;

	if (!_n) {
		LM_ERR("invalid parameter value\n");
		return -1;
	}

	last = 0;
	*_n = 0;
	ptr = _p;
	while(ptr) {
		if (_shm) {
			t = (param_t*)shm_malloc(sizeof(param_t));
		} else {
			t = (param_t*)pkg_malloc(sizeof(param_t));
		}
		if (!t) {
			LM_ERR("no more pkg memory\n");
			goto err;
		}
		memcpy(t, ptr, sizeof(param_t));
		t->next = 0;

		if (!*_n) *_n = t;
		if (last) last->next = t;
		last = t;

		ptr = ptr->next;
	}
	return 0;

 err:
	do_free_params(*_n, _shm);
	return -2;
}


/*
 * Duplicate linked list of parameters
 */
int duplicate_params(param_t** _n, param_t* _p)
{
	return do_duplicate_params(_n, _p, 0);
}


/*
 * Duplicate linked list of parameters
 */
int shm_duplicate_params(param_t** _n, param_t* _p)
{
	return do_duplicate_params(_n, _p, 1);
}