/*

 * 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;

}