#if HAVE_CRT
 #define _CRTDBG_MAP_ALLOC 
 #include <stdlib.h> 
 #include <crtdbg.h>
 #endif //HAVE_CRT
 /*

 * Copyright (C) 2020, University of the Basque Country (UPV/EHU)

 * Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
 *
 * The original file was part of Open Source Doubango Framework
 * Copyright (C) 2010-2011 Mamadou Diop.
 * Copyright (C) 2012 Doubango Telecom <http://doubango.org>
 *
 * This file is part of Open Source Doubango Framework.
 *
 * DOUBANGO 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 3 of the License, or
 * (at your option) any later version.
 *
 * DOUBANGO 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 DOUBANGO.
 *
 */
 
 
 /**@file tsip_dialog_message.c
  * @brief SIP dialog message (Client side).
  *
  * @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
  *
 
  */
 #include "tinysip/dialogs/tsip_dialog_message.h"
 #include "tinysip/parsers/tsip_parser_uri.h"
 
 #include "tinysip/api/tsip_api_message.h"
 
 #include "tinysip/headers/tsip_header_Dummy.h"
 #include "tinysip/headers/tsip_header_Min_Expires.h"
 #include "tinysdp/parsers/tsdp_parser_message.h"
 #include "tinysip/transactions/tsip_transac_layer.h"
 #include "tinymedia/content/tmedia_content_multipart.h"
 
 
 
 #include "tsk_memory.h"
 #include "tsk_debug.h"
 #include "tsk_time.h"
 #include "tsk_common.h"

 
 #if HAVE_LIBXML2
 #include <libxml/tree.h>
 #include <libxml/parser.h>
 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>
 #include <tsip.h>
 #include <tinysip.h>
 #include <tinysip/tsip_ssession.h>
 
 #endif
 

 #define VALUE_CONTENT_TYPE_MESSAGE_MBMS "application/vnd.3gpp.mcptt-mbms-usage-info+xml"
 #define VALUE_CONTENT_TYPE_MULTIPART "multipart/mixed"
 #define DEBUG_STATE_MACHINE											1
 #define TSIP_DIALOG_MESSAGE_SIGNAL(self, type, code, phrase, message)	\
 	tsip_message_event_signal(type, TSIP_DIALOG(self)->ss, code, phrase, message)
 
 /* ======================== internal functions ======================== */
 static int send_MESSAGE(tsip_dialog_message_t *self);
 static int receive_MESSAGE(tsip_dialog_message_t *self,const tsip_request_t *request);
 static int tsip_dialog_message_OnTerminated(tsip_dialog_message_t *self);
 static tsk_buffer_t* tsip_dialog_message_create_mcpttinfo(const tsip_dialog_message_t* self);

 /*static*/ int tsip_dialog_message_msession_configure(tsip_dialog_message_t *self);
 /* ======================== transitions ======================== */
 static int tsip_dialog_message_Started_2_Sending_X_sendMESSAGE(va_list *app);
 static int tsip_dialog_message_Started_2_Receiving_X_recvMESSAGE(va_list *app);
 static int tsip_dialog_message_Sending_2_Sending_X_1xx(va_list *app);
 static int tsip_dialog_message_Sending_2_Terminated_X_2xx(va_list *app);
 static int tsip_dialog_message_Sending_2_Sending_X_401_407_421_494(va_list *app);
 static int tsip_dialog_message_Sending_2_Terminated_X_300_to_699(va_list *app);
 static int tsip_dialog_message_Sending_2_Terminated_X_cancel(va_list *app);
 static int tsip_dialog_message_Receiving_2_Terminated_X_accept(va_list *app);
 static int tsip_dialog_message_Receiving_2_Terminated_X_reject(va_list *app);
 static int tsip_dialog_message_Any_2_Terminated_X_transportError(va_list *app);
 static int tsip_dialog_message_Any_2_Terminated_X_Error(va_list *app);
 
 /* ======================== conds ======================== */
 
 /* ======================== actions ======================== */
 typedef enum _fsm_action_e
 {
 	_fsm_action_sendMESSAGE = tsip_atype_message_send,
 	_fsm_action_accept = tsip_atype_accept,
 	_fsm_action_reject = tsip_atype_reject,
 	_fsm_action_cancel = tsip_atype_cancel,
 	_fsm_action_shutdown = tsip_atype_shutdown,
 	_fsm_action_transporterror = tsip_atype_transport_error,
 
 	_fsm_action_receiveMESSAGE = 0xFF,
 	_fsm_action_1xx,
 	_fsm_action_2xx,
 	_fsm_action_401_407_421_494,
 	_fsm_action_300_to_699,
 	_fsm_action_error,
 }
 _fsm_action_t;
 
 /* ======================== states ======================== */
 typedef enum _fsm_state_e
 {
 	_fsm_state_Started,
 	_fsm_state_Sending,
 	_fsm_state_Receiving,
 	_fsm_state_Terminated
 }
 _fsm_state_t;
 
 
 static int tsip_dialog_message_event_callback(const tsip_dialog_message_t *self, tsip_dialog_event_type_t type, const tsip_message_t *msg)
 {
 	int ret = -1;
 
 	switch(type)
 	{
 	case tsip_dialog_i_msg:
 		{
 			if(msg){
 				if(TSIP_MESSAGE_IS_RESPONSE(msg)){
 					const tsip_action_t* action = tsip_dialog_keep_action(TSIP_DIALOG(self), msg) ? TSIP_DIALOG(self)->curr_action : tsk_null;
 					if(TSIP_RESPONSE_IS_1XX(msg)){
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_1xx, msg, action);
 					}
 					else if(TSIP_RESPONSE_IS_2XX(msg)){
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_2xx, msg, action);
 					}
 					else if(TSIP_RESPONSE_CODE(msg) == 401 || TSIP_RESPONSE_CODE(msg) == 407 || TSIP_RESPONSE_CODE(msg) == 421 || TSIP_RESPONSE_CODE(msg) == 494){
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_401_407_421_494, msg, action);
 					}
 					else if(TSIP_RESPONSE_IS_3456(msg)){
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_300_to_699, msg, action);
 					}
 					else{ /* Should never happen */
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_error, msg, action);
 					}
 				}
 				else if (TSIP_REQUEST_IS_MESSAGE(msg)){ /* have been checked by dialog layer...but */
 					// REQUEST ==> Incoming MESSAGE
 					//
 					ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_receiveMESSAGE, msg, tsk_null);
 				}
 			}
 			break;
 		}
 
 	case tsip_dialog_canceled:
 		{
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_cancel, msg, tsk_null);
 			break;
 		}
 
 	case tsip_dialog_terminated:
 	case tsip_dialog_timedout:
 	case tsip_dialog_error:
 	case tsip_dialog_transport_error:
 		{
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_transporterror, msg, tsk_null);
 			break;
 		}
             
     default: break;
 	}
 
 	return ret;
 }
 
 tsip_dialog_message_t* tsip_dialog_message_create(const tsip_ssession_handle_t* ss)
 {
 	return tsk_object_new(tsip_dialog_message_def_t, ss);
 }
 
 int tsip_dialog_message_init(tsip_dialog_message_t *self)
 {
 	//const tsk_param_t* param;
 
 	/* Initialize the state machine. */
 	tsk_fsm_set(TSIP_DIALOG_GET_FSM(self),
 			
 			/*=======================
 			* === Started === 
 			*/
 			// Started -> (send) -> Sending
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Started, _fsm_action_sendMESSAGE, _fsm_state_Sending, tsip_dialog_message_Started_2_Sending_X_sendMESSAGE, "tsip_dialog_message_Started_2_Sending_X_sendMESSAGE"),
 			// Started -> (receive) -> Receiving
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Started, _fsm_action_receiveMESSAGE, _fsm_state_Receiving, tsip_dialog_message_Started_2_Receiving_X_recvMESSAGE, "tsip_dialog_message_Started_2_Receiving_X_recvMESSAGE"),
 			// Started -> (Any) -> Started
 			TSK_FSM_ADD_ALWAYS_NOTHING(_fsm_state_Started, "tsip_dialog_message_Started_2_Started_X_any"),
 			
 
 			/*=======================
 			* === Sending === 
 			*/
 			// Sending -> (1xx) -> Sending
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_1xx, _fsm_state_Sending, tsip_dialog_message_Sending_2_Sending_X_1xx, "tsip_dialog_message_Sending_2_Sending_X_1xx"),
 			// Sending -> (2xx) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_2xx, _fsm_state_Terminated, tsip_dialog_message_Sending_2_Terminated_X_2xx, "tsip_dialog_message_Sending_2_Terminated_X_2xx"),
 			// Sending -> (401/407/421/494) -> Sending
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_401_407_421_494, _fsm_state_Sending, tsip_dialog_message_Sending_2_Sending_X_401_407_421_494, "tsip_dialog_message_Sending_2_Sending_X_401_407_421_494"),
 			// Sending -> (300_to_699) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_300_to_699, _fsm_state_Terminated, tsip_dialog_message_Sending_2_Terminated_X_300_to_699, "tsip_dialog_message_Sending_2_Terminated_X_300_to_699"),
 			// Sending -> (cancel) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_cancel, _fsm_state_Terminated, tsip_dialog_message_Sending_2_Terminated_X_cancel, "tsip_dialog_message_Sending_2_Terminated_X_cancel"),
 			// Sending -> (shutdown) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Sending, _fsm_action_shutdown, _fsm_state_Terminated, tsk_null, "tsip_dialog_message_Sending_2_Terminated_X_shutdown"),
 			// Sending -> (Any) -> Sending
 			TSK_FSM_ADD_ALWAYS_NOTHING(_fsm_state_Sending, "tsip_dialog_message_Sending_2_Sending_X_any"),
 
 			/*=======================
 			* === Receiving === 
 			*/
 			// Receiving -> (accept) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Receiving, _fsm_action_accept, _fsm_state_Terminated, tsip_dialog_message_Receiving_2_Terminated_X_accept, "tsip_dialog_message_Receiving_2_Terminated_X_accept"),
 			// Receiving -> (rejected) -> Terminated
 			TSK_FSM_ADD_ALWAYS(_fsm_state_Receiving, _fsm_action_reject, _fsm_state_Terminated, tsip_dialog_message_Receiving_2_Terminated_X_reject, "tsip_dialog_message_Receiving_2_Terminated_X_reject"),
 			// Receiving -> (Any) -> Receiving
 			TSK_FSM_ADD_ALWAYS_NOTHING(_fsm_state_Receiving, "tsip_dialog_message_Receiving_2_Receiving_X_any"),
 
 			/*=======================
 			* === Any === 
 			*/
 			// Any -> (transport error) -> Terminated
 			TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_transporterror, _fsm_state_Terminated, tsip_dialog_message_Any_2_Terminated_X_transportError, "tsip_dialog_message_Any_2_Terminated_X_transportError"),
 			// Any -> (transport error) -> Terminated
 			TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_error, _fsm_state_Terminated, tsip_dialog_message_Any_2_Terminated_X_Error, "tsip_dialog_message_Any_2_Terminated_X_Error"),
 
 			TSK_FSM_ADD_NULL());
 
 	TSIP_DIALOG(self)->callback = TSIP_DIALOG_EVENT_CALLBACK_F(tsip_dialog_message_event_callback);
 
 	return 0;
 }
 
 
 //--------------------------------------------------------
 //				== STATE MACHINE BEGIN ==
 //--------------------------------------------------------
 
 
 /* Started -> (sendMESSAGE) -> Sending
 */
 int tsip_dialog_message_Started_2_Sending_X_sendMESSAGE(va_list *app)
 {
 	tsip_dialog_message_t *self;
 
 	self = va_arg(*app, tsip_dialog_message_t *);
 
 	TSIP_DIALOG(self)->running = tsk_true;
 
 	return send_MESSAGE(self);
 }
 
 /* Started -> (recvMESSAGE) -> Receiving
 */
 int tsip_dialog_message_Started_2_Receiving_X_recvMESSAGE(va_list *app)
 {
 	int result=0;
 	tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);
 	const tsip_request_t *request = va_arg(*app, const tsip_request_t *);

     result=receive_MESSAGE(self,request);
 

 	return result;
 }
 
 /*	Sending -> (1xx) -> Sending
 */
 int tsip_dialog_message_Sending_2_Sending_X_1xx(va_list *app)
 {
 	/*tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);*/
 	/*const tsip_response_t *response = va_arg(*app, const tsip_response_t *);*/
 
 	return 0;
 }
 
 /*	Sending -> (2xx) -> Sending
 */
 int tsip_dialog_message_Sending_2_Terminated_X_2xx(va_list *app)
 {
 	tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);
 	const tsip_response_t *response = va_arg(*app, const tsip_response_t *);
 
 	/* Alert the user. */
 	TSIP_DIALOG_MESSAGE_SIGNAL(self, tsip_ao_message, 
 		TSIP_RESPONSE_CODE(response), TSIP_RESPONSE_PHRASE(response), response);
 
 	/* Reset curr action */
 	tsip_dialog_set_curr_action(TSIP_DIALOG(self), tsk_null);
 
 	return 0;
 }
 
 /*	Sending -> (401/407/421/494) -> Sending
 */
 int tsip_dialog_message_Sending_2_Sending_X_401_407_421_494(va_list *app)
 {
 	tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);
 	const tsip_response_t *response = va_arg(*app, const tsip_response_t *);
 	int ret;
 	
 	if((ret = tsip_dialog_update(TSIP_DIALOG(self), response))){
 		// Alert the user
 		TSIP_DIALOG_MESSAGE_SIGNAL(self, tsip_ao_message, 
 								   TSIP_RESPONSE_CODE(response), TSIP_RESPONSE_PHRASE(response), response);
 		
 		return ret;
 	}
 	
 	return send_MESSAGE(self);
 }
 
 /*	Sending -> (300 to 699) -> Terminated
 */
 int tsip_dialog_message_Sending_2_Terminated_X_300_to_699(va_list *app)
 {
 	tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);
 	const tsip_response_t *response = va_arg(*app, const tsip_response_t *);
 
 	/* set last error (or info) */
 	tsip_dialog_set_lasterror(TSIP_DIALOG(self), TSIP_RESPONSE_PHRASE(response), TSIP_RESPONSE_CODE(response));
 
 	/* Alert the user. */
 	TSIP_DIALOG_MESSAGE_SIGNAL(self, tsip_ao_message, 
 		TSIP_RESPONSE_CODE(response), TSIP_RESPONSE_PHRASE(response), response);
 
 	return 0;
 }
 
 /*	Sending -> (cancel) -> Terminated
 */
 int tsip_dialog_message_Sending_2_Terminated_X_cancel(va_list *app)
 {
 	tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);
 	/* const tsip_message_t *message = va_arg(*app, const tsip_message_t *); */
 
 	/* RFC 3261 - 9.1 Client Behavior
 	   A CANCEL request SHOULD NOT be sent to cancel a request other than INVITE.
 	*/
 
 	/* Cancel all transactions associated to this dialog (will also be done when the dialog is destroyed (worth nothing)) */
 	tsip_transac_layer_cancel_by_dialog(TSIP_DIALOG_GET_STACK(self)->layer_transac, TSIP_DIALOG(self));
 
 	/* Alert the user */
 	TSIP_DIALOG_SIGNAL(self, tsip_event_code_dialog_request_cancelled, "MESSAGE cancelled");
 
 	return 0;
 }
 
 /*	Receiving -> (accept) -> Terminated
 */
 int tsip_dialog_message_Receiving_2_Terminated_X_accept(va_list *app)
 {
 	tsip_dialog_message_t *self;
 	const tsip_action_t* action;
 
 	self = va_arg(*app, tsip_dialog_message_t *);
 	va_arg(*app, tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 	
 	if(!self->request){
 		TSK_DEBUG_ERROR("There is non MESSAGE to accept()");
 		/* Not an error ...but do not update current action */
 	}
 	else{
 		tsip_response_t *response;
 		int ret;
 
 		/* curr_action is only used for outgoing requests */
 		/* tsip_dialog_set_curr_action(TSIP_DIALOG(self), action); */
 
 		/* send 200 OK */
 		if((response = tsip_dialog_response_new(TSIP_DIALOG(self), 200, "OK", self->request))){
 			tsip_dialog_apply_action(response, action); /* apply action params to "this" response */
 			if((ret = tsip_dialog_response_send(TSIP_DIALOG(self), response))){
 				TSK_DEBUG_ERROR("Failed to send SIP response.");
 				TSK_OBJECT_SAFE_FREE(response);
 				return ret;
 			}
 			TSK_OBJECT_SAFE_FREE(response);
 		}
 		else{
 			TSK_DEBUG_ERROR("Failed to create SIP response.");
 			return -1;
 		}
 	}
 
 	return 0;
 }
 
 /*	Receiving -> (reject) -> Terminated
 */
 int tsip_dialog_message_Receiving_2_Terminated_X_reject(va_list *app)
 {
 	tsip_dialog_message_t *self;
 	const tsip_action_t* action;
 
 	self = va_arg(*app, tsip_dialog_message_t *);
 	va_arg(*app, tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 	
 	if(!self->request){
 		TSK_DEBUG_ERROR("There is non MESSAGE to reject()");
 		/* Not an error ...but do not update current action */
 	}
 	else{
 		tsip_response_t *response;
 		int ret;
 
 		/* curr_action is only used for outgoing requests */
 		/* tsip_dialog_set_curr_action(TSIP_DIALOG(self), action); */
 
 		/* send 486 Rejected */
 		if((response = tsip_dialog_response_new(TSIP_DIALOG(self), 486, "Rejected", self->request))){
 			tsip_dialog_apply_action(response, action); /* apply action params to "this" response */
 			if((ret = tsip_dialog_response_send(TSIP_DIALOG(self), response))){
 				TSK_DEBUG_ERROR("Failed to send SIP response.");
 				TSK_OBJECT_SAFE_FREE(response);
 				return ret;
 			}
 			TSK_OBJECT_SAFE_FREE(response);
 		}
 		else{
 			TSK_DEBUG_ERROR("Failed to create SIP response.");
 			return -1;
 		}
 	}
 
 	return 0;
 }
 
 /*	Any -> (transport error) -> Terminated
 */
 int tsip_dialog_message_Any_2_Terminated_X_transportError(va_list *app)
 {
 	/*tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);*/
 	/*const tsip_message_t *message = va_arg(*app, const tsip_message_t *);*/
 
 	return 0;
 }
 
 /*	Any -> (error) -> Terminated
 */
 int tsip_dialog_message_Any_2_Terminated_X_Error(va_list *app)
 {
 	/*tsip_dialog_message_t *self = va_arg(*app, tsip_dialog_message_t *);*/
 	/*const tsip_message_t *message = va_arg(*app, const tsip_message_t *);*/
 
 	return 0;
 }
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //				== STATE MACHINE END ==
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 int send_MESSAGE(tsip_dialog_message_t *self)
 {
 	tsip_dialog_t* dialog_message=tsk_null;
 	tsip_request_t* request = tsk_null;
 	int ret = -1;
 	char* type_Content_Type="Content-Type";
 	char* value_Content_Type_Location="application/vnd.3gpp.mcptt-location-info+xml";
 	char* value_Content_Type_Mbms="application/vnd.3gpp.mcptt-mbms-usage-info+xml";
 	const tsip_header_t* hdr;
 	tsk_buffer_t* mcptt_info;

 	tmedia_multipart_body_t* body = tsk_null;
 	tmedia_content_multipart_t* content = tsk_null;
 	tmedia_content_multipart_t* mcptt_info_content = tsk_null;
 	tsk_size_t i;
 	char* content_type_hdr  = tsk_null;
 	char* body_string  = tsk_null;

 	tsk_buffer_t* body_buffer = tsk_buffer_create_null();

 	tsk_bool_t control_accept_contact=tsk_false;
 	if(!self){
 		return -1;
 	}
 

     if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt_group) != tmedia_mcptt_group){
 		// MCPTT Private Call
         if(TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_caller_uri==tsk_null){
             TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_caller_uri=tsip_uri_tostring(TSIP_DIALOG_GET_SS(self)->to,tsk_false, tsk_false);
         }
     }else{
 		// MCPTT Group Call
         if(TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_group_uri==tsk_null){
             TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_group_uri=tsip_uri_tostring(TSIP_DIALOG_GET_SS(self)->to,tsk_false, tsk_false);
         }
 
         if(TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_caller_uri==tsk_null){
             TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_caller_uri=tsip_uri_tostring(TSIP_DIALOG_GET_SS(self)->to,tsk_false, tsk_false);
         }
     }
 
 	//MCPTT

 	if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt) == tmedia_mcptt){
 		//The request_uri is PSI in New Invite to MCPTT
 		tsip_dialog_request_configure_mcptt(TSIP_DIALOG(self));
 	}
 
 	dialog_message=TSIP_DIALOG(self);
 	if(!(request = tsip_dialog_request_new(dialog_message, "MESSAGE"))){
 		return -2;
 	}
 
 	//Generate Header for mcptt_location message
 	if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt) == tmedia_mcptt){
 		TSIP_HEADER_ADD_PARAM(request->Contact, "+g.3gpp.icsi-ref", "\"urn%3Aurn-7%3A3gpp-service.ims.icsi.mcptt\"");
 			TSIP_HEADER_ADD_PARAM(request->Contact, "+g.3gpp.mcptt",tsk_null);
 	}
 	
 
 	if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt_location) == tmedia_mcptt_location){
 		//insert in head Content type
 		//insert Context-Type
 		//Create Body
 		if(TSIP_DIALOG(self)->curr_action && TSIP_DIALOG(self)->curr_action->payload){
 			tsip_message_add_content(request, value_Content_Type_Location, TSK_BUFFER_DATA(TSIP_DIALOG(self)->curr_action->payload), TSK_BUFFER_SIZE(TSIP_DIALOG(self)->curr_action->payload));
 		}
 	}else 
 		if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt_mbms) == tmedia_mcptt_mbms){
 
 		//insert in head Content type
 		//insert Context-Type
 		//Create Body multipart/mixed
 
 		for(i=0,control_accept_contact=tsk_false; (hdr = tsip_message_get_headerAt(request, tsip_htype_Dummy, i)); i++)
 		{		
 			const tsip_header_Dummy_t* dummy_hdr = (const tsip_header_Dummy_t*)hdr;
 
 			if(tsk_strcmp(dummy_hdr->name, "Accept-Contact") == 0)
 			{
 				/*
 				Accept-Contact: *;+g.3gpp.mcptt;require;explicit
 				Accept-Contact: *;+g.3gpp.icsi-ref="urn%3Aurn-7%3A3gpp-service.ims.icsi.mcptt";require;explicit
 				*/
 				//Accept-Contact 
 				TSIP_HEADER_ADD_PARAM(dummy_hdr,"+g.3gpp.mcptt;require;explicit", tsk_null);
 				TSIP_HEADER_ADD_PARAM(dummy_hdr,"+g.3gpp.icsi-ref=\"urn:urn-7:3gpp-service.ims.icsi.mcptt\";require;explicit", tsk_null);
 				control_accept_contact=tsk_true;
 				break;
 			}
 		}
 		if(control_accept_contact==tsk_false){
 				tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Accept-Contact", "*;+g.3gpp.mcptt;require;explicit+g.3gpp.icsi-ref=\"urn%3Aurn-7%3A3gpp-service.ims.icsi.mcptt\";require;explicit"),
 				tsk_null
 				);
 		}
 
 
 		if(TSIP_DIALOG(self)->curr_action && TSIP_DIALOG(self)->curr_action->payload){
 
 			mcptt_info = tsip_dialog_message_create_mcpttinfo(self);
 			body = tmedia_content_multipart_body_create("multipart/mixed", tsk_null);
 			if(body)
 			{
 				//mcpt-info
 				mcptt_info_content = tmedia_content_multipart_create(TSK_BUFFER_DATA(mcptt_info), TSK_BUFFER_SIZE(mcptt_info), "application/vnd.3gpp.mcptt-info+xml",tsk_null);
 				if(mcptt_info_content){
 					tmedia_content_multipart_body_add_content(body, mcptt_info_content);
 				}
 				//Content-Type: application/vnd.3gpp.mcptt-mbms-usage-info+xml
 				content = tmedia_content_multipart_create( TSK_BUFFER_DATA(TSIP_DIALOG(self)->curr_action->payload), TSK_BUFFER_SIZE(TSIP_DIALOG(self)->curr_action->payload),value_Content_Type_Mbms,tsk_null);
 				if(content){
 					tmedia_content_multipart_body_add_content(body,content);
 				}
 				body_string = tmedia_content_multipart_body_tostring(body);
 				content_type_hdr = tmedia_content_multipart_body_get_header(body);
 
 			}
 			tsip_message_add_content(request, content_type_hdr,body_string,tsk_strlen(body_string));
 		}
 
 	}else

 	/* apply action params to the request */
 	if(TSIP_DIALOG(self)->curr_action)
 		tsip_dialog_apply_action(request, TSIP_DIALOG(self)->curr_action);
 
 	
 
 	ret = tsip_dialog_request_send(TSIP_DIALOG(self), request);
 	TSK_OBJECT_SAFE_FREE(request);
 
 	return ret;
 }
 
 //Use in MCPTT for MBMS
 int receive_MESSAGE(tsip_dialog_message_t *self,const tsip_request_t *request)
 {
 	tsdp_message_t* sdp_ro = tsk_null;
 	tsip_message_t* sipmessage=tsk_null;
 	tmedia_multipart_body_t* mp_body = tsk_null;
 	tmedia_content_multipart_t* mp_content = tsk_null;
 	tmedia_content_multipart_t* mp_content_sdp = tsk_null;
 	tmedia_ro_type_t ro_type = tmedia_ro_type_none;
 	const tsdp_header_M_t* multicast_media_mcptt_audio = tsk_null;
 	const tsdp_header_M_t* multicast_media_mcptt_mux = tsk_null;
 	const tsdp_header_M_t* multicast_media_mcptt_mux_2 = tsk_null;
 	const tsdp_header_M_t* multicast_media_mcptt = tsk_null;
 //	const char* addrs;
 	uint32_t port;
 	tsip_ssession_t* session=tsk_null;
 	int ret=0;
 	uint32_t local_ssrc = 0;
 	char* boundary = tsk_null;
 //	tsk_list_item_t *item;
 	//const tsdp_message_t* sdp_lo;
 	char* sdp=tsk_null;
 	sipmessage=(tsip_message_t*)request;
 	if(sipmessage!=tsk_null && tsk_striequals(VALUE_CONTENT_TYPE_MULTIPART, TSIP_MESSAGE_CONTENT_TYPE(sipmessage))){
 		//multipart/mixed
 		boundary = tsip_header_get_param_value((tsip_header_t*)sipmessage->Content_Type, "boundary");
 			if(boundary != tsk_null) 

 			{

 				mp_body = tmedia_content_multipart_body_parse(TSIP_MESSAGE_CONTENT_DATA(sipmessage), TSIP_MESSAGE_CONTENT_DATA_LENGTH(sipmessage), VALUE_CONTENT_TYPE_MULTIPART, boundary);

                 if(mp_body != tsk_null) {
                     //mp_content is xml of MBMS
                     mp_content = tmedia_content_multipart_body_get_content(mp_body,
                                                                            VALUE_CONTENT_TYPE_MESSAGE_MBMS);
                     //mp_content_sdp is the data in char* of SDP
                     mp_content_sdp = tmedia_content_multipart_body_get_content(mp_body,
                                                                                "application/sdp");
                     if (mp_content != tsk_null && mp_content_sdp != tsk_null)//MBMS service
                     {
 
                         self->msession_mgr = tmedia_session_mgr_create(tmedia_audio,
                                                                        TSIP_DIALOG_GET_STACK(
                                                                                self)->network.local_ip[TSIP_TRANSPORT_IDX_UDP],
                                                                        TNET_SOCKET_TYPE_IS_IPV6(
                                                                                TSIP_DIALOG_GET_STACK(
                                                                                        self)->network.proxy_cscf_type[TSIP_TRANSPORT_IDX_UDP]),
                                                                        tsk_true);
                         //sdp_ro es the parse data in SDP. sdp_ro is a list
 
                         if (!(sdp_ro = tsdp_message_parse(mp_content_sdp->data,
                                                           mp_content_sdp->data_size))) {
                             TSK_DEBUG_ERROR("Failed to parse remote sdp message:\n [%.*s]",
                                             mp_content->data_size, (const char *) mp_content->data);
                             return -2;
                         } else {
                             sdp = tsdp_message_tostring(sdp_ro);
                         }
 
                         if (!(multicast_media_mcptt_audio = tsdp_message_find_media(sdp_ro,
                                                                                     "audio"))) {
                             return -1;
                         }
                         if (!(multicast_media_mcptt_mux = tsdp_message_find_media_at_index(sdp_ro,
                                                                                            "application",
                                                                                            0))) {
                             return -1;
                         }
                         multicast_media_mcptt = multicast_media_mcptt_mux;
                         if (!(multicast_media_mcptt_mux_2 = tsdp_message_find_media_at_index(sdp_ro,
                                                                                              "application",
                                                                                              1)) &&
                             multicast_media_mcptt_mux->port == 9) {
                             return -1;
                         } else {
                             multicast_media_mcptt = multicast_media_mcptt_mux_2;
                         }
 
 
 
                         //session=TSIP_DIALOG_GET_SS(self);
                         port = multicast_media_mcptt->port;
                         //session->stack->pttMCPTTMbms.port_manager=port;
 #if HAVE_CRT //Debug memory
                         //addrs=(char*)malloc(tsk_strlen(multicast_media_mcptt->C->addr) + 1);
 
 #else
                         //addrs=(char*)tsk_malloc(tsk_strlen(multicast_media_mcptt->C->addr) + 1);
 
 #endif //HAVE_CRT
                         //strcpy(addrs,multicast_media_mcptt->C->addr);
                         //session->stack->pttMCPTTMbms.addr_multicast=addrs;
 
                         /*
                         tsk_list_lock(TSIP_DIALOG_GET_STACK(self)->ssessions);
                         tsk_list_foreach(item,TSIP_DIALOG_GET_STACK(self)->ssessions){
                             va_list ap;
                             if (!(audio_session2 = item->data) || !(audio_session2->type & tmedia_mcptt)){
                                 va_end(ap);
                                 continue;
                             }
 
                             va_end(ap);
                             break;
                         }
                         */
                         /*
                         if(sdp_ro){
 
 
 
                             //session->stack->pttMCPTTMbms.sdp_ro=tsdp_message_clone(sdp_ro);
                             if (tmedia_session_mgr_is_new_ro(self->msession_mgr, sdp_ro)) {
                                 ret = tsip_dialog_message_msession_configure(self);
                             }
 
                             if((ret = tmedia_session_mgr_set_ro(self->msession_mgr, sdp_ro, ro_type))){
                                 TSK_DEBUG_ERROR("Failed to set remote offer");
                                 return -2;
                             }
 
                         }
 
 
 
 
                         local_ssrc = tmedia_session_mgr_audio_get_ssrc(self->msession_mgr);
                         audio_session = tmedia_session_mgr_find(self->msession_mgr, tmedia_audio);
                         tmedia_session_mgr_set(self->msession_mgr,
                             TMEDIA_SESSION_SET_INT32(tmedia_mcptt, "local_ssrc", local_ssrc),
                             TMEDIA_SESSION_SET_POBJECT(tmedia_mcptt, "audio_session", audio_session),
                             TMEDIA_SESSION_SET_NULL());
                         audio_session = tmedia_session_mgr_find(self->msession_mgr,tmedia_mcptt);
                         audio_session->lo_held = tsk_true;
                         */
                         //TSK_OBJECT_SAFE_FREE(mp_content);
                         /*if(addrs != tsk_null){
                             TSK_OBJECT_SAFE_FREE(addrs);
                         }*/
                         if (sdp_ro != tsk_null) {
                             TSK_OBJECT_SAFE_FREE(sdp_ro);
                         }
                     } else if (mp_content != tsk_null) {
                         TSK_DEBUG_ERROR("The new message isn't valid.");
                     }
                 }

 			}
 	}
 	
 	if(boundary!=tsk_null){
 		TSK_OBJECT_SAFE_FREE(boundary);
 	}
 	if(mp_body!=tsk_null){
 		TSK_OBJECT_SAFE_FREE(mp_body);
 	}
 
 	/* Alert the user. */
 	if(sdp!=tsk_null){
 		ret=TSIP_DIALOG_MESSAGE_SIGNAL(self, tsip_i_message, 
 			tsip_event_code_dialog_request_incoming, sdp, request);

 	}else {
         ret=TSIP_DIALOG_MESSAGE_SIGNAL(self, tsip_i_message,
             tsip_event_code_dialog_request_incoming, "incoming message", request);

 	}
 
 	/* Update last incoming MESSAGE */
 	TSK_OBJECT_SAFE_FREE(self->request);
 	self->request = tsk_object_ref((void*)request);
 
 	return ret;
 }
 
 int tsip_dialog_message_msession_configure(tsip_dialog_message_t *self)
 {
 	/*
 	tmedia_srtp_mode_t srtp_mode;
 	tmedia_mode_t avpf_mode;
 	tsk_bool_t is_rtcweb_enabled;
 	tsk_bool_t is_webrtc2sip_mode_enabled;
 	
 	if(!self || !self->msession_mgr){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	is_webrtc2sip_mode_enabled = (TSIP_DIALOG_GET_STACK(self)->network.mode == tsip_stack_mode_webrtc2sip);
 	is_rtcweb_enabled = (((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.profile == tmedia_profile_rtcweb);
 	srtp_mode = is_rtcweb_enabled ? tmedia_srtp_mode_mandatory : ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.srtp_mode;
 	avpf_mode = is_rtcweb_enabled ? tmedia_mode_mandatory : ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.avpf_mode;
 
 	// set callback functions
 	tmedia_session_mgr_set_onerror_cbfn(self->msession_mgr, self, tsip_dialog_message_msession_onerror_cb);
 	tmedia_session_mgr_set_rfc5168_cbfn(self->msession_mgr, self, tsip_dialog_invite_msession_rfc5168_cb);
 
 	// set params
 	return tmedia_session_mgr_set(self->msession_mgr,
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "srtp-mode", srtp_mode),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "avpf-mode", avpf_mode),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "webrtc2sip-mode-enabled", is_webrtc2sip_mode_enabled), // hack the media stack
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "rtcp-enabled", self->use_rtcp),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "rtcpmux-enabled", self->use_rtcpmux),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "codecs-supported", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.codecs),
 			
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "bypass-encoding", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.bypass_encoding),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "bypass-decoding", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.bypass_decoding),
 
 			TMEDIA_SESSION_SET_INT32(tmedia_audio, "rtp-ssrc", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.rtp.ssrc.audio),
 			TMEDIA_SESSION_SET_INT32(tmedia_video, "rtp-ssrc", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.rtp.ssrc.video),
 			
 			TMEDIA_SESSION_SET_STR(self->msession_mgr->type, "dtls-file-ca", TSIP_DIALOG_GET_STACK(self)->security.tls.ca),
 			TMEDIA_SESSION_SET_STR(self->msession_mgr->type, "dtls-file-pbk", TSIP_DIALOG_GET_STACK(self)->security.tls.pbk),
 			TMEDIA_SESSION_SET_STR(self->msession_mgr->type, "dtls-file-pvk", TSIP_DIALOG_GET_STACK(self)->security.tls.pvk),
 			TMEDIA_SESSION_SET_INT32(self->msession_mgr->type, "dtls-cert-verify", TSIP_DIALOG_GET_STACK(self)->security.tls.verify),
 
 			TMEDIA_SESSION_SET_INT32(tmedia_video, "fps", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.video_fps),
 			TMEDIA_SESSION_SET_INT32(tmedia_video, "bandwidth-max-upload", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.video_bw_up),
 			TMEDIA_SESSION_SET_INT32(tmedia_video, "bandwidth-max-download", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.video_bw_down),
 			TMEDIA_SESSION_SET_INT32(tmedia_video, "pref-size", ((tsip_ssession_t*)TSIP_DIALOG(self)->ss)->media.video_pref_size),
 
 			tsk_null);
 			*/
 	return 0;
 }
 
 int tsip_dialog_message_OnTerminated(tsip_dialog_message_t *self)
 {
 	TSK_DEBUG_INFO("=== MESSAGE Dialog terminated ===");
 
 	/* Alert the user */
 	TSIP_DIALOG_SIGNAL(self, tsip_event_code_dialog_terminated, 
 		TSIP_DIALOG(self)->last_error.phrase ? TSIP_DIALOG(self)->last_error.phrase : "Dialog terminated");
 
 	/* Remove from the dialog layer. */
 	return tsip_dialog_remove(TSIP_DIALOG(self));
 }
 //MCPTT mbms
 static tsk_buffer_t* tsip_dialog_message_create_mcpttinfo(const tsip_dialog_message_t* self)
 {
 	tsip_stack_t* ptsip_stack_t;
 	tsk_buffer_t* output = tsk_buffer_create_null();
 /*
 #if HAVE_LIBXML2
 	ret = tsk_null;
 #else*/
 	tmedia_type_t type;
 	const char* head  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 						"<mcpttinfo xmlns=\"urn:3gpp:ns:mcpttInfo:1.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\r\n"
 						"<mcptt-Params>\r\n";
 	const char* headout  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 						"<mcpttinfo>\r\n"
 						"<mcptt-Params>\r\n";
 	const char* tabInitSessionType =  "<session-type>";
 	const char* tabEndSessionType =  "</session-type>\r\n";
 	const char* tabInitMCPTTID =  "<mcptt-calling-user-id>\r\n";
 	const char* tabEndMCPTTID =  "</mcptt-calling-user-id>\r\n";
 	const char* tabInitGroupID =  "<mcptt-calling-group-id>\r\n";
 	const char* tabEndGroupID =  "</mcptt-calling-group-id>\r\n";
 	const char* tabInitMcpttURI= "<mcpttURI>";
 	const char* tabEndMcpttURI= "</mcpttURI>\r\n";
 	const char* tabInitRequestUri =  "<mcptt-request-uri type=\"Normal\">";
 	const char* tabInitRequestUri_old =  "<mcptt-request-uri>";
 	const char* tabEndRequestUri =  "</mcptt-request-uri>\r\n";
 	const char* tail =  "</mcptt-Params>\r\n"
 						"</mcpttinfo>\r\n";
 	ptsip_stack_t=TSIP_DIALOG_GET_STACK(self);
 	if(ptsip_stack_t->pttMCPTT.mcptt_namespace!=tsk_false){
 		tsk_buffer_append_2(output, "%s", head);
 	}else{
 		tsk_buffer_append_2(output, "%s", headout);
 	}
 	
 	type=TSIP_DIALOG_GET_SS(self)->media.type;
 
 	if((type & tmedia_mbms) == tmedia_mbms){
 		//<session-type>
 			tsk_buffer_append_2(output, "%s", tabInitRequestUri);
 			tsk_buffer_append_2(output, "%s", tabInitMcpttURI);
 
 		tsk_buffer_append_2(output, "%s", tsip_uri_tostring(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_id,tsk_true, tsk_false));
 			tsk_buffer_append_2(output, "%s", tabEndMcpttURI);
 		
 		
 		tsk_buffer_append_2(output, "%s", tabEndRequestUri);
 		//<mcptt-calling-user-id>
 		/*
 		tsk_buffer_append_2(output, "%s", tabInitMCPTTID);
 		tsk_buffer_append_2(output, "%s\r\n", tsip_uri_tostring(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_id,tsk_true, tsk_false));
 		tsk_buffer_append_2(output, "%s", tabEndMCPTTID);
 		*/
 	}
 	tsk_buffer_append_2(output, "%s", tail);
 		
 	
 
 	
 	return output;
 }
 
 
 
 
 
 
 
 
 
 //========================================================
 //	SIP dialog MESSAGE object definition
 //
 static tsk_object_t* tsip_dialog_message_ctor(tsk_object_t * self, va_list * app)
 {
 	tsip_dialog_message_t *dialog = self;
 	if(dialog){
 		tsip_ssession_handle_t *ss = va_arg(*app, tsip_ssession_handle_t *);
 
 		/* Initialize base class */
 		tsip_dialog_init(TSIP_DIALOG(self), tsip_dialog_MESSAGE, tsk_null, ss, _fsm_state_Started, _fsm_state_Terminated);
 
 		/* FSM */
 		TSIP_DIALOG_GET_FSM(self)->debug = DEBUG_STATE_MACHINE;
 		tsk_fsm_set_callback_terminated(TSIP_DIALOG_GET_FSM(self), TSK_FSM_ONTERMINATED_F(tsip_dialog_message_OnTerminated), (const void*)dialog);
 
 		/* Initialize the class itself */
 		tsip_dialog_message_init(self);
 	}
 	return self;
 }
 
 static tsk_object_t* tsip_dialog_message_dtor(tsk_object_t * self)
 { 
 	tsip_dialog_message_t *dialog = self;
 	if(dialog){
 		/* DeInitialize base class (will cancel all transactions) */
 		tsip_dialog_deinit(TSIP_DIALOG(self));
 
 		/* DeInitialize self */
 		TSK_OBJECT_SAFE_FREE(dialog->request);
 
 		TSK_DEBUG_INFO("*** MESSAGE Dialog destroyed ***");
 	}
 	return self;
 }
 
 static int tsip_dialog_message_cmp(const tsk_object_t *obj1, const tsk_object_t *obj2)
 {
 	return tsip_dialog_cmp(obj1, obj2);
 }
 
 static const tsk_object_def_t tsip_dialog_message_def_s = 
 {
 	sizeof(tsip_dialog_message_t),
 	tsip_dialog_message_ctor, 
 	tsip_dialog_message_dtor,
 	tsip_dialog_message_cmp, 
 };

 const tsk_object_def_t *tsip_dialog_message_def_t = &tsip_dialog_message_def_s;