/*
 * Copyright (C) 2010 VoIP Embedded Inc. <http://www.voipembedded.com/>
 *
 *
 * 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:
 * --------
 * 2010年11月09日 Initial revision (Ovidiu Sas)
 */

#include "parse_from.h"
#include "parse_to.h"
#include "parse_call_info.h"
#include <stdlib.h>
#include <string.h>
#include "../dprint.h"
#include "msg_parser.h"
#include "../ut.h"
#include "../errinfo.h"
#include "../mem/mem.h"


/*
 * This method is used to parse Call-Info header.
 *
 * params: msg : sip msg
 * returns 0 on success,
 * -1 on failure.
 */
int parse_call_info_header( struct sip_msg *msg )
{
 struct call_info_body *callinfo_b, *old_callinfo_b=NULL;
 struct to_body *call_info_b;
 struct hdr_field *call_info;
 void **parsed;
 char *tmp, *end, *start;
 unsigned int len;

 if ( !msg->call_info &&
	 (parse_headers(msg, HDR_CALL_INFO_F,0)==-1 || !msg->call_info)) {
	return -1;
 }

 call_info=msg->call_info;

 /* maybe the header is already parsed! */
 if (call_info->parsed)
	return 0;

 parsed = &(call_info->parsed);

 while(*parsed == NULL)
{

 len = call_info->body.len+1;
 start = call_info->body.s;
 end = start + len;
 LM_DBG("parsing the whole body [%.*s]\n", len, call_info->body.s);

 for( tmp=call_info->body.s; tmp<=end; tmp++) {
 if (*tmp == ',' || tmp==end) {
	 LM_DBG("[%.*s]\n",(int)(tmp-start),start);

	 callinfo_b = pkg_malloc(sizeof(struct call_info_body));
	 if (callinfo_b == NULL) {
		LM_ERR("out of pkg_memory\n");
		goto error;
	 }
	 memset(callinfo_b, 0, sizeof(struct call_info_body));

	 /* now parse it!! */
	 call_info_b = &(callinfo_b->call_info_body);
	 parse_to(start, tmp, call_info_b);
	 if (call_info_b->error == PARSE_ERROR) {
		LM_ERR("bad Call-Info header\n");
		pkg_free(call_info_b);
		set_err_info(OSER_EC_PARSER, OSER_EL_MEDIUM,
		 "error parsing Call-Info header");
		set_err_reply(400, "bad header");
		goto error;
	 }

	 /* Save the first parsed body */
	 if (*parsed == NULL)
	 	*parsed = callinfo_b;
	 else
		old_callinfo_b->next = callinfo_b;

	 old_callinfo_b = callinfo_b;

	 start = tmp + 1;
	}
 }
 call_info = call_info->sibling;
 LM_DBG("done ... next call_info [%p]\n", call_info);
 if (call_info == NULL) {
	break;
 }
 parsed = &(call_info->parsed);
}

 return 0;

error:
 return -1;
}

inline static void free_call_info_param_list(struct to_param *param_lst)
{
 struct to_param *foo;
 while(param_lst){
	foo=param_lst->next;
	//LM_DBG(".. free [%p]->[%.*s]\n", param_lst, param_lst->name.len, param_lst->name.s);
	pkg_free(param_lst);
	param_lst=foo;
 }
 return;
}

void free_call_info(struct call_info_body *callinfo_b)
{
 struct call_info_body *foo;
 while(callinfo_b){
	//LM_DBG("freeing callinfo\n");
	foo=callinfo_b;
	callinfo_b=callinfo_b->next;
	if (foo->call_info_body.param_lst)
	 free_call_info_param_list(foo->call_info_body.param_lst);
	//LM_DBG(". free [%p]->[%.*s]\n", foo, foo->call_info_body.body.len, foo->call_info_body.body.s);
	pkg_free(foo);
	//LM_DBG("done freeing callinfo\n");
 }
 return;
}