#if HAVE_CRT
 #define _CRTDBG_MAP_ALLOC 
 #include <stdlib.h> 
 #include <crtdbg.h>
 #endif //HAVE_CRT
 /*
 * Copyright (C) 2017, 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_invite.c
  * @brief SIP dialog INVITE as per RFC 3261.
  * The SOA machine is designed as per RFC 3264 and draft-ietf-sipping-sip-offeranswer-12.
  * MMTel services implementation follow 3GPP TS 24.173.
  *
  * @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
  *
 
  */
 #include "tinysip/dialogs/tsip_dialog_invite.h"
 

 //#include "tinysip/dialogs/tsip_dialog.h"

 #include "tinysip/dialogs/tsip_dialog_invite.common.h"
 
 #include "tinysip/transactions/tsip_transac_layer.h"
 #include "tinysip/transports/tsip_transport_layer.h"
 #include "tinysip/dialogs/tsip_dialog_layer.h"
 
 #include "tinysip/headers/tsip_header_Allow.h"
 #include "tinysip/headers/tsip_header_Dummy.h"
 #include "tinysip/headers/tsip_header_Max_Forwards.h"
 #include "tinysip/headers/tsip_header_Min_SE.h"
 #include "tinysip/headers/tsip_header_RAck.h"
 #include "tinysip/headers/tsip_header_Require.h"
 #include "tinysip/headers/tsip_header_RSeq.h"
 #include "tinysip/headers/tsip_header_Session_Expires.h"
 #include "tinysip/headers/tsip_header_Supported.h"
 #include "tinysip/headers/tsip_header_Priv_Answer_Mode.h"
 #include "tinysip/headers/tsip_header.h"
 #include "tinysip/authentication/tsip_challenge.h"
 #include "tinysip/authentication/tsip_bootstrapping.h"
 
 #include "tinysdp/parsers/tsdp_parser_message.h"
 
 #include "tinymedia/tmedia_defaults.h"
 #include "tinymedia/content/tmedia_content_multipart.h"
 
 #include "mbms/tnet_mbms.h"
 #include "tsk_memory.h"
 #include "tsk_debug.h"
 #include "tipsec.h"
 #include <math.h>
 #include <stdlib.h>
 
 
 
 #if HAVE_LIBXML2
 #include <libxml/tree.h>
 #include <libxml/parser.h>
 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>
 #endif
 
 #include <tnet_endianness.h>

 #include <tsip.h>
 #include <tinysip/tsip_ssession.h>

 
 // http://cdnet.stpi.org.tw/techroom/market/_pdf/2009/eetelecomm_09_009_OneVoiceProfile.pdf
 // 3GPP TS 26.114 (MMTel): Media handling and interaction
 // 3GPP TS 24.173 (MMTel): Supplementary Services
 //
 /* ======================== MMTel Supplementary Services ======================== 
 3GPP TS 24.607 : Originating Identification Presentation
 3GPP TS 24.608 : Terminating Identification Presentation
 3GPP TS 24.607 : Originating Identification Restriction
 3GPP TS 24.608 : Terminating Identification Restriction
 
 3GPP TS 24.604 : Communication Diversion Unconditional
 3GPP TS 24.604 : Communication Diversion on not Logged
 3GPP TS 24.604 : Communication Diversion on Busy 
 3GPP TS 24.604 : Communication Diversion on not Reachable
 3GPP TS 24.604 : Communication Diversion on No Reply
 3GPP TS 24.611 : Barring of All Incoming Calls
 3GPP TS 24.611 : Barring of All Outgoing Calls
 3GPP TS 24.611 : Barring of Outgoing International Calls
 3GPP TS 24.611 : Barring of Incoming Calls - When Roaming
 3GPP TS 24.610 : Communication Hold 
 3GPP TS 24.606 : Message Waiting Indication
 3GPP TS 24.615 : Communication Waiting
 3GPP TS 24.605 : Ad-Hoc Multi Party Conference
 */
 
 extern int tsip_dialog_add_session_headers(const tsip_dialog_t *self, tsip_request_t* request);
 
 /* ======================== internal functions ======================== */
 /*static*/ int tsip_dialog_invite_msession_start(tsip_dialog_invite_t *self);
 /*static*/ int tsip_dialog_invite_msession_configure(tsip_dialog_invite_t *self);
 /*static*/ int send_INVITEorUPDATE(tsip_dialog_invite_t *self, tsk_bool_t is_INVITE, tsk_bool_t force_sdp);
 /*static*/ int send_PRACK(tsip_dialog_invite_t *self, const tsip_response_t* r1xx);
 /*static*/ int send_ACK(tsip_dialog_invite_t *self, const tsip_response_t* r2xxINVITE);
 /*static*/ int send_RESPONSE(tsip_dialog_invite_t *self, const tsip_request_t* request, short code, const char* phrase, tsk_bool_t force_sdp);
 /*static*/ int send_ERROR(tsip_dialog_invite_t* self, const tsip_request_t* request, short code, const char* phrase, const char* reason);
 /*static*/ int send_BYE(tsip_dialog_invite_t *self);
 /*static*/ int send_CANCEL(tsip_dialog_invite_t *self);
 /*static*/ int tsip_dialog_invite_notify_parent(tsip_dialog_invite_t *self, const tsip_response_t* response);
 /*static*/ int send_INFO(tsip_dialog_invite_t *self, const char* content_type, const void* content_ptr, tsk_size_t content_size);
 static int tsip_dialog_invite_OnTerminated(tsip_dialog_invite_t *self);
 static int tsip_dialog_invite_msession_onerror_cb(const void* usrdata, const struct tmedia_session_s* session, const char* reason, tsk_bool_t is_fatal);
 static int tsip_dialog_invite_msession_rfc5168_cb(const void* usrdata, const struct tmedia_session_s* session, const char* reason, enum tmedia_session_rfc5168_cmd_e command);
 
 static tsk_buffer_t* tsip_dialog_invite_create_resource_list(const tsip_dialog_invite_t* self);
 static tsk_buffer_t* tsip_dialog_invite_create_mcpttinfo(const tsip_dialog_invite_t* self);
 static char* xml_to_string(xmlDocPtr doc);
 static tsk_buffer_t* tsip_dialog_200ok_create_mcpttinfo(const tsip_dialog_invite_t* self);
 /* ======================== external functions ======================== */
 extern int tsip_dialog_invite_ice_process_ro(tsip_dialog_invite_t * self, const tsdp_message_t* sdp_ro, tsk_bool_t is_remote_offer);
 extern int tsip_dialog_invite_ice_set_media_type(tsip_dialog_invite_t * self, tmedia_type_t media_type);
 extern int tsip_dialog_invite_stimers_cancel(tsip_dialog_invite_t* self);
 extern int tsip_dialog_invite_qos_timer_cancel(tsip_dialog_invite_t* self);
 extern int tsip_dialog_invite_qos_timer_schedule(tsip_dialog_invite_t* self);
 extern int tsip_dialog_invite_stimers_schedule(tsip_dialog_invite_t* self, uint64_t timeout);
 extern int tsip_dialog_invite_stimers_handle(tsip_dialog_invite_t* self, const tsip_message_t* message);
 extern int tsip_dialog_invite_hold_handle(tsip_dialog_invite_t* self, const tsip_request_t* rINVITEorUPDATE);
 
 extern int tsip_dialog_invite_ice_timers_set(tsip_dialog_invite_t *self, int64_t timeout);
 extern tsk_bool_t tsip_dialog_invite_ice_is_enabled(const tsip_dialog_invite_t * self);
 extern tsk_bool_t tsip_dialog_invite_ice_is_connected(const tsip_dialog_invite_t * self);
 extern int tsip_dialog_invite_ice_process_lo(tsip_dialog_invite_t * self, const tsdp_message_t* sdp_lo);
 
 /* ======================== transitions ======================== */
 static int x0000_Connected_2_Connected_X_oDTMF(va_list *app);
 static int x0000_Connected_2_Connected_X_oLMessage(va_list *app);
 static int x0000_Connected_2_Connected_X_iACK(va_list *app);
 static int x0000_Connected_2_Connected_X_iINVITEorUPDATE(va_list *app);
 static int x0000_Connected_2_Connected_X_oINVITE(va_list *app);
 
 
 static int x0000_Any_2_Any_X_i1xx(va_list *app);
 static int x0000_Any_2_Any_X_oINFO(va_list *app);
 static int x0000_Any_2_Any_X_iINFO(va_list *app);
 static int x0000_Any_2_Any_X_i401_407_Challenge(va_list *app);
 static int x0000_Any_2_Any_X_i2xxINVITEorUPDATE(va_list *app);
 
 static int x0000_Any_2_Any_X_iPRACK(va_list *app);
 static int x0000_Any_2_Any_X_iOPTIONS(va_list *app);
 static int x0000_Any_2_Trying_X_oBYE(va_list *app); /* If not Connected => Cancel will be called instead. See tsip_dialog_hangup() */
 static int x0000_Any_2_Terminated_X_iBYE(va_list *app);
 static int x0000_Any_2_Trying_X_shutdown(va_list *app);
 
 static int x9998_Any_2_Terminated_X_transportError(va_list *app);
 static int x9999_Any_2_Any_X_Error(va_list *app);
 
 /* ======================== conds ======================== */
 static tsk_bool_t _fsm_cond_is_resp2INVITE(tsip_dialog_invite_t* self, tsip_message_t* message)
 {
 	return TSIP_RESPONSE_IS_TO_INVITE(message);
 }
 static tsk_bool_t _fsm_cond_is_resp2UPDATE(tsip_dialog_invite_t* self, tsip_message_t* message)
 {
 	return TSIP_RESPONSE_IS_TO_UPDATE(message);
 }
 static tsk_bool_t _fsm_cond_is_resp2BYE(tsip_dialog_invite_t* self, tsip_message_t* message)
 {
 	return TSIP_RESPONSE_IS_TO_BYE(message);
 }
 static tsk_bool_t _fsm_cond_is_resp2PRACK(tsip_dialog_invite_t* self, tsip_message_t* message)
 {
 	return TSIP_RESPONSE_IS_TO_PRACK(message);
 }
 static tsk_bool_t _fsm_cond_is_resp2INFO(tsip_dialog_invite_t* self, tsip_message_t* message)
 {
 	return TSIP_RESPONSE_IS_TO_INFO(message);
 }
 
 /* ======================== actions ======================== */
 /* #include "tinysip/dialogs/tsip_dialog_invite.common.h" */
 
 /* ======================== states ======================== */
 /* #include "tinysip/dialogs/tsip_dialog_invite.common.h" */
 
 /* ICE handler */
 extern int tsip_dialog_invite_ice_init(tsip_dialog_invite_t *self);
 /* Client-Side dialog */
 extern int tsip_dialog_invite_client_init(tsip_dialog_invite_t *self);
 /* Server-Side dialog */
 extern int tsip_dialog_invite_server_init(tsip_dialog_invite_t *self);
 /* 3GPP TS 24.610: Communication Hold  */
 extern int tsip_dialog_invite_hold_init(tsip_dialog_invite_t *self);
 /* 3GPP TS 24.629: Explicit Communication Transfer (ECT) using IP Multimedia (IM) Core Network (CN) subsystem */
 extern int tsip_dialog_invite_ect_init(tsip_dialog_invite_t *self);
 /* RFC 4028: Session Timers */
 extern int tsip_dialog_invite_stimers_init(tsip_dialog_invite_t *self);
 /* RFC 3312: Integration of Resource Management and Session Initiation Protocol (SIP) */
 extern int tsip_dialog_invite_qos_init(tsip_dialog_invite_t *self);
 
 int tsip_dialog_invite_event_callback(const tsip_dialog_invite_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)){ /* Response */
 					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)){ // 100-199
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_i1xx, msg, action);
 					}
 					else if(TSIP_RESPONSE_IS_2XX(msg)){ // 200-299
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_i2xx, msg, action);
 					}
 					else if(TSIP_RESPONSE_CODE(msg) == 401 || TSIP_RESPONSE_CODE(msg) == 407){ // 401,407
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_i401_i407, msg, action);
 					}
 					else if(TSIP_RESPONSE_CODE(msg) == 422){ // 422
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_i422, msg, action);
 					}
 					else if(TSIP_RESPONSE_IS_3456(msg)){ // 300-699
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_i300_to_i699, msg, action);
 					}
 					else; // Ignore
 				}
 				else{ /* Request */
 					if(TSIP_REQUEST_IS_INVITE(msg)){ // INVITE
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iINVITE, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_UPDATE(msg)){ // UPDATE
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iUPDATE, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_PRACK(msg)){ // PRACK
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iPRACK, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_ACK(msg)){ // ACK
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iACK, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_OPTIONS(msg)){ // OPTIONS
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iOPTIONS, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_BYE(msg)){ // BYE
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iBYE, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_CANCEL(msg)){ // CANCEL
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iCANCEL, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_INFO(msg)){ // INFO
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iINFO, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_NOTIFY(msg)){ // NOTIFY
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iNOTIFY, msg, tsk_null);
 					}
 					else if(TSIP_REQUEST_IS_REFER(msg)){ // REFER
 						TSK_DEBUG_WARN("Receive notify 001.");
 						ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_iREFER, msg, tsk_null);
 					}
 				}
 			}
 			break;
 		}
 
 	case tsip_dialog_canceled:
 		{
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_oCANCEL, msg, tsk_null);
 			break;
 		}
 
 	case tsip_dialog_timedout:
 		{
 			// Do nothing if request type is "INFO"
 			if(!TSIP_MESSAGE_IS_REQUEST(msg) || !TSIP_REQUEST_IS_INFO(msg)){
 				ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_transporterror, msg, tsk_null);
 			}
 			break;
 		}
 	case tsip_dialog_terminated:
 	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;
 }
 
 /**Timer manager callback.
  *
  * @param self	The owner of the signaled timer. 
  * @param	timer_id		The identifier of the signaled timer.
  *
  * @return	Zero if succeed and non-zero error code otherwise.  
 **/
 int tsip_dialog_invite_timer_callback(const tsip_dialog_invite_t* self, tsk_timer_id_t timer_id)
 {
 	int ret = -1;
 
 	if(self){
 		if(timer_id == self->stimers.timer.id){
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_timerRefresh, tsk_null, tsk_null);
 		}
 		else if(timer_id == self->timer100rel.id){
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_timer100rel, tsk_null, tsk_null);
 		}
 		else if(timer_id == self->qos.timer.id){
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_timerRSVP, tsk_null, tsk_null);
 		}
 		else if(timer_id == self->timershutdown.id){
 			ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_shutdown_timedout, tsk_null, tsk_null);
 		}
 	}
 	return ret;
 }
 
 tsip_dialog_invite_t* tsip_dialog_invite_create(const tsip_ssession_handle_t* ss, const char* call_id)
 {
 	return tsk_object_new(tsip_dialog_invite_def_t,  ss, call_id);
 }
 
 int tsip_dialog_invite_init(tsip_dialog_invite_t *self)
 {
 	/* special cases (fsm) should be tried first */
 	
 	/* ICE */
 	tsip_dialog_invite_ice_init(self);
 	/* Client-Side dialog */
 	 tsip_dialog_invite_client_init(self);
 	/* Server-Side dialog */
 	tsip_dialog_invite_server_init(self);
 	/* 3GPP TS 24.610: Communication Hold  */
 	tsip_dialog_invite_hold_init(self);
 	/* 3GPP TS 24.629: Explicit Communication Transfer (ECT) using IP Multimedia (IM) Core Network (CN) subsystem */
 	tsip_dialog_invite_ect_init(self);
 	/* RFC 4028: Session Timers */
 	tsip_dialog_invite_stimers_init(self);
 	/* RFC 3312: Integration of Resource Management and Session Initiation Protocol (SIP) */
 	tsip_dialog_invite_qos_init(self);
 	
 	/* Initialize the state machine (all other cases) */
 	tsk_fsm_set(TSIP_DIALOG_GET_FSM(self),
 	
 		/*=======================
 		* === Started === 
 		*/
 		// Started -> (Any) -> Started
 		TSK_FSM_ADD_ALWAYS_NOTHING(_fsm_state_Started, "tsip_dialog_invite_Started_2_Started_X_any"),
 
 		/*=======================
 		* === Connected === 
 		*/
 		// Connected -> (Send DTMF) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_dtmf_send, _fsm_state_Connected, x0000_Connected_2_Connected_X_oDTMF, "x0000_Connected_2_Connected_X_oDTMF"),
 		// Connected -> (Send MSRP message) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_msrp_send_msg, _fsm_state_Connected, x0000_Connected_2_Connected_X_oLMessage, "x0000_Connected_2_Connected_X_oLMessage"),
 		// Connected -> (iACK) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_iACK, _fsm_state_Connected, x0000_Connected_2_Connected_X_iACK, "x0000_Connected_2_Connected_X_iACK"),
 		// Connected -> (iINVITE) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_iINVITE, _fsm_state_Connected, x0000_Connected_2_Connected_X_iINVITEorUPDATE, "x0000_Connected_2_Connected_X_iINVITE"),
 		// Connected -> (iUPDATE) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_iUPDATE, _fsm_state_Connected, x0000_Connected_2_Connected_X_iINVITEorUPDATE, "x0000_Connected_2_Connected_X_iUPDATE"),
 		// Connected -> (send reINVITE) -> Connected
 		TSK_FSM_ADD_ALWAYS(_fsm_state_Connected, _fsm_action_oINVITE, _fsm_state_Connected, x0000_Connected_2_Connected_X_oINVITE, "x0000_Connected_2_Connected_X_oINVITE"),
 				
 		/*=======================
 		* === BYE/SHUTDOWN === 
 		*/
 		// Any -> (oBYE) -> Trying
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_oBYE, _fsm_state_Trying, x0000_Any_2_Trying_X_oBYE, "x0000_Any_2_Trying_X_oBYE"),
 		// Any -> (iBYE) -> Terminated
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_iBYE, _fsm_state_Terminated, x0000_Any_2_Terminated_X_iBYE, "x0000_Any_2_Terminated_X_iBYE"),
 		// Any -> (i401/407 BYE) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i401_i407, _fsm_cond_is_resp2BYE, tsk_fsm_state_any, x0000_Any_2_Any_X_i401_407_Challenge, "x0000_Any_2_Any_X_i401_407_Challenge"),
 		// Any -> (i3xx-i6xx BYE) -> Terminated
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i300_to_i699, _fsm_cond_is_resp2BYE, _fsm_state_Terminated, tsk_null, "x0000_Any_2_Terminated_X_i3xxTOi6xxBYE"),
 		// Any -> (i2xxx BYE) -> Terminated
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i2xx, _fsm_cond_is_resp2BYE, _fsm_state_Terminated, tsk_null, "x0000_Any_2_Terminated_X_i2xxBYE"),
 		// Any -> (Shutdown) -> Trying
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_oShutdown, _fsm_state_Trying, x0000_Any_2_Trying_X_shutdown, "x0000_Any_2_Trying_X_shutdown"),
 		// Any -> (shutdown timedout) -> Terminated
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_shutdown_timedout, _fsm_state_Terminated, tsk_null, "tsip_dialog_invite_shutdown_timedout"),
 
 		
 		/*=======================
 		* === Any === 
 		*/
 		// Any -> (i1xx) -> Any
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_i1xx, tsk_fsm_state_any, x0000_Any_2_Any_X_i1xx, "x0000_Any_2_Any_X_i1xx"),
 		// Any -> (oINFO) -> Any
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_oINFO, tsk_fsm_state_any, x0000_Any_2_Any_X_oINFO, "x0000_Any_2_Any_X_oINFO"),
 		// Any -> (iINFO) -> Any
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_iINFO, tsk_fsm_state_any, x0000_Any_2_Any_X_iINFO, "x0000_Any_2_Any_X_iINFO"),
 		// Any -> (i401/407)
 		//
 		// Any -> (iPRACK) -> Any
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_iPRACK, tsk_fsm_state_any, x0000_Any_2_Any_X_iPRACK, "x0000_Any_2_Any_X_iPRACK"),
 		// Any -> (iOPTIONS) -> Any
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_iOPTIONS, tsk_fsm_state_any, x0000_Any_2_Any_X_iOPTIONS, "x0000_Any_2_Any_X_iOPTIONS"),
 		// Any -> (i2xx INVITE) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i2xx, _fsm_cond_is_resp2INVITE, tsk_fsm_state_any, x0000_Any_2_Any_X_i2xxINVITEorUPDATE, "x0000_Any_2_Any_X_i2xxINVITE"),
 		// Any -> (i2xx UPDATE) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i2xx, _fsm_cond_is_resp2UPDATE, tsk_fsm_state_any, x0000_Any_2_Any_X_i2xxINVITEorUPDATE, "x0000_Any_2_Any_X_i2xxUPDATE"),
 		// Any -> (i401/407 INVITE) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i401_i407, _fsm_cond_is_resp2INVITE, tsk_fsm_state_any, x0000_Any_2_Any_X_i401_407_Challenge, "x0000_Any_2_Any_X_i401_407_Challenge"),
 		// Any -> (i401/407  UPDATE) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i401_i407, _fsm_cond_is_resp2UPDATE, tsk_fsm_state_any, x0000_Any_2_Any_X_i401_407_Challenge, "x0000_Any_2_Any_X_i401_407_Challenge"),
 		// Any -> (i2xx PRACK) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i2xx, _fsm_cond_is_resp2PRACK, tsk_fsm_state_any, tsk_null, "x0000_Any_2_Any_X_i2xxPRACK"),
 		// Any -> (i2xx INFO) -> Any
 		TSK_FSM_ADD(tsk_fsm_state_any, _fsm_action_i2xx, _fsm_cond_is_resp2INFO, tsk_fsm_state_any, tsk_null, "x0000_Any_2_Any_X_i2xxINFO"),
 		// Any -> (transport error) -> Terminated
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_transporterror, _fsm_state_Terminated, x9998_Any_2_Terminated_X_transportError, "x9998_Any_2_Terminated_X_transportError"),
 		// Any -> (transport error) -> Terminated
 		TSK_FSM_ADD_ALWAYS(tsk_fsm_state_any, _fsm_action_error, _fsm_state_Terminated, x9999_Any_2_Any_X_Error, "x9999_Any_2_Any_X_Error"),
 
 		TSK_FSM_ADD_NULL());
 
 	/* Sets callback function */
 	TSIP_DIALOG(self)->callback = TSIP_DIALOG_EVENT_CALLBACK_F(tsip_dialog_invite_event_callback);
 
 	/* Timers */
 	self->timer100rel.id = TSK_INVALID_TIMER_ID;
 	self->stimers.timer.id = TSK_INVALID_TIMER_ID;
 	self->timershutdown.id = TSK_INVALID_TIMER_ID;
 	self->timershutdown.timeout = TSIP_DIALOG_SHUTDOWN_TIMEOUT;
 
 	return 0;
 }
 
 // start sending
 int tsip_dialog_invite_start(tsip_dialog_invite_t *self)
 {
 	int ret = -1;
 	if(self && !TSIP_DIALOG(self)->running){
 		if(!(ret = tsip_dialog_fsm_act(TSIP_DIALOG(self), _fsm_action_oINVITE, tsk_null, tsk_null))){
 			TSIP_DIALOG(self)->running = tsk_true;
 		}
 	}
 	return ret;
 }
 /**
 this function process the sdp in messages of 200 Ok and Invite received
 */
 int tsip_dialog_invite_process_ro(tsip_dialog_invite_t *self, const tsip_message_t* message)

 {//receive 200OK and Invite Destino.

 	tsdp_message_t* sdp_ro = tsk_null;
 	tmedia_type_t old_media_type;
 	tmedia_type_t new_media_type;
 	tsk_bool_t media_session_was_null;
 	int ret = 0;
 	tmedia_ro_type_t ro_type = tmedia_ro_type_none;
 	if(!self || !message){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}

     if (self->is_cancelling) {
         TSK_DEBUG_INFO("Cancelling the INVITE...ignore the incoming SDP");
         return 0;
     }
 
 	/* Parse SDP content */
 	if(TSIP_MESSAGE_HAS_CONTENT(message)){
 		if(tsk_striequals("application/sdp", TSIP_MESSAGE_CONTENT_TYPE(message))){
 			if(!(sdp_ro = tsdp_message_parse(TSIP_MESSAGE_CONTENT_DATA(message), TSIP_MESSAGE_CONTENT_DATA_LENGTH(message)))){

 				TSK_DEBUG_ERROR("Failed to parse remote sdp message");

 				return -2;
 			}
 			// ICE processing
 			if(self->supported.ice){
 				tsip_dialog_invite_ice_process_ro(self, sdp_ro, TSIP_MESSAGE_IS_REQUEST(message));
 			}
 		}

 		else if(tsk_striequals("multipart/mixed", TSIP_MESSAGE_CONTENT_TYPE(message))){

 			tmedia_multipart_body_t* mp_body = tsk_null;
 			tmedia_content_multipart_t* mp_content = tsk_null;
 			char* boundary = tsk_null;

 			boundary = tsip_header_get_param_value((tsip_header_t*)message->Content_Type, "boundary");

 			if(boundary == tsk_null) {
 				TSK_DEBUG_ERROR("content-type is not supportted");

 				return -3;
 			}
 
 			mp_body = tmedia_content_multipart_body_parse(TSIP_MESSAGE_CONTENT_DATA(message), TSIP_MESSAGE_CONTENT_DATA_LENGTH(message), "multipart/mixed", boundary);
 
 			if(mp_body == tsk_null){

 				TSK_DEBUG_ERROR("content-type is not supported or is not correct: multipart/mixed");

 				return -3;
 			}
 			//mp_content is the data in char* of SDP
 			mp_content = tmedia_content_multipart_body_get_content(mp_body, "application/sdp");
 
 			if(mp_content == tsk_null){

 				TSK_DEBUG_ERROR("content-type is not supportted application/sdp");

 				return -3;
 			}
 			//sdp_ro es the parse data in SDP. sdp_ro is a list
 			if(!(sdp_ro = tsdp_message_parse(mp_content->data, mp_content->data_size))){

 				TSK_DEBUG_ERROR("Failed to parse remote sdp message");

 				return -2;
 			}
 
 			TSK_OBJECT_SAFE_FREE(mp_body);
 		}

 		else if(tsk_striequals("application/vnd.3gpp.mcptt-info+xml", TSIP_MESSAGE_CONTENT_TYPE(message))) {

 			TSK_DEBUG_INFO("Ignoring incoming mcptt-info+xml content.");
 			return 0;
 		}
 		else{

 			TSK_DEBUG_ERROR("content-type is not supportted");

 			return -3;
 		}
 	}
 	else{
 		if(TSIP_DIALOG(self)->state == tsip_initial && TSIP_REQUEST_IS_INVITE(message)){ /* Bodiless initial INVITE */
 			TSIP_DIALOG_GET_SS(self)->media.type = tmedia_defaults_get_media_type(); // Default media for initial INVITE to send with the first reliable answer
 		}
 		else{
 			return 0;
 		}
 	}

 	ro_type = (TSIP_REQUEST_IS_INVITE(message) || TSIP_REQUEST_IS_UPDATE(message) || TSIP_REQUEST_IS_INFO(message)) // ACK/PRACK can only contain a response if the initial INVITE was bodiless. Added INFO message (PTT multicast)
 			? tmedia_ro_type_offer
 			:(TSIP_RESPONSE_IS_1XX(message) ? tmedia_ro_type_provisional : tmedia_ro_type_answer);
 	media_session_was_null = (self->msession_mgr == tsk_null);
 	//old_media_type is Type session old
 	old_media_type = TSIP_DIALOG_GET_SS(self)->media.type;
 	new_media_type = sdp_ro ? tmedia_type_from_sdp(sdp_ro) : old_media_type;
 

 
 
     //TEST:
 	// Check for mcpttinfo tag to see if it is a MCPTT call (for non Floor Control MCPTT calls)
 	if ((new_media_type & tmedia_mcptt) != tmedia_mcptt) { // or tmedia_audio_ptt_mcptt?
 		if (tsk_striequals("multipart/mixed", TSIP_MESSAGE_CONTENT_TYPE(message))) {
 			tmedia_multipart_body_t *mp_body = tsk_null;
 			tmedia_content_multipart_t *mp_content = tsk_null;
 			char *boundary = tsk_null;
 
 			boundary = tsip_header_get_param_value((tsip_header_t *) message->Content_Type, "boundary");
 			if (boundary != tsk_null) {
 				mp_body = tmedia_content_multipart_body_parse(TSIP_MESSAGE_CONTENT_DATA(message), TSIP_MESSAGE_CONTENT_DATA_LENGTH(message), "multipart/mixed", boundary);
 				if (mp_body != tsk_null) {
 					mp_content = tmedia_content_multipart_body_get_content(mp_body, "application/vnd.3gpp.mcptt-info+xml");
 					if (mp_content != tsk_null) {
                         old_media_type |= tmedia_mcptt; // or tmedia_audio_ptt_mcptt?
 					}
 				}
 			}
 		}
 	}
 
 
 
 

 	/* Create session Manager if not already done */
 	if(!self->msession_mgr){//if the message is UPDATE
 		int32_t transport_idx = TSIP_DIALOG_GET_STACK(self)->network.transport_idx_default;
 		TSIP_DIALOG_GET_SS(self)->media.type = new_media_type;
 		self->msession_mgr = tmedia_session_mgr_create(TSIP_DIALOG_GET_SS(self)->media.type, 
 			TSIP_DIALOG_GET_STACK(self)->network.local_ip[transport_idx], TNET_SOCKET_TYPE_IS_IPV6(TSIP_DIALOG_GET_STACK(self)->network.proxy_cscf_type[transport_idx]), tsk_true);
 		if(TSIP_DIALOG_GET_STACK(self)->natt.ctx){
 			tmedia_session_mgr_set_natt_ctx(self->msession_mgr, TSIP_DIALOG_GET_STACK(self)->natt.ctx, TSIP_DIALOG_GET_STACK(self)->network.aor.ip[transport_idx]);
 		}
 		ret = tmedia_session_mgr_set_ice_ctx(self->msession_mgr, self->ice.ctx_audio, self->ice.ctx_video);
 
 		ret = tmedia_session_mgr_set_poc_qoe(self->msession_mgr, TSIP_DIALOG_GET_SS(self)->media.poc_qoe.profile, TSIP_DIALOG_GET_SS(self)->media.poc_qoe.strength);
 	}
 	
 	if(sdp_ro){
 		if (tmedia_session_mgr_is_new_ro(self->msession_mgr, sdp_ro)) {
 			ret = tsip_dialog_invite_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");
 			goto bail;
 		}
 	}
 

 	// is media update?
 	// (old_media_type == new_media_type) means the new session are rejected. This is way we match the CSeq

 	if(!media_session_was_null &&
 			(old_media_type != new_media_type && (TSIP_MESSAGE_IS_RESPONSE(message) &&
 			self->cseq_out_media_update == message->CSeq->seq)) &&
 			(self->msession_mgr->sdp.lo && self->msession_mgr->sdp.ro)) {

 		// at this point the media session manager has been succeffuly started and all is ok
 		TSIP_DIALOG_GET_SS(self)->media.type = new_media_type;
 		TSIP_DIALOG_INVITE_SIGNAL(self, tsip_m_updated, 
 								  TSIP_RESPONSE_CODE(message), TSIP_RESPONSE_PHRASE(message), message);
 	}
 

 	/* start session manager */
 	if(!self->msession_mgr->started && (self->msession_mgr->sdp.lo && self->msession_mgr->sdp.ro)){
 		/* Set MSRP Callback */
 		if((self->msession_mgr->type & tmedia_msrp) == tmedia_msrp){
 			tmedia_session_mgr_set_msrp_cb(self->msession_mgr, TSIP_DIALOG_GET_SS(self)->userdata, TSIP_DIALOG_GET_SS(self)->media.msrp.callback);
 		}
 		/* starts session manager*/
 		ret = tsip_dialog_invite_msession_start(self);
 
 		if(ret == 0 && TSIP_DIALOG(self)->state == tsip_early){
 			TSIP_DIALOG_INVITE_SIGNAL(self, tsip_m_early_media, 
 				TSIP_RESPONSE_CODE(message), TSIP_RESPONSE_PHRASE(message), message);
 		}
 	}
 
 	
 bail:
 	TSK_OBJECT_SAFE_FREE(sdp_ro);
 
 	return ret;
 }
 
 
 //--------------------------------------------------------
 //				== STATE MACHINE BEGIN ==
 //--------------------------------------------------------
 
 int x0000_Connected_2_Connected_X_oDTMF(va_list *app)
 {
 	int ret;
 	tsip_dialog_invite_t *self;
 	const tsip_action_t* action;
 
 	self = va_arg(*app, tsip_dialog_invite_t *);
 	va_arg(*app, const tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 
 	if(action){
 		ret = tmedia_session_mgr_send_dtmf(self->msession_mgr, action->dtmf.event);
 	}
 	else{
 		TSK_DEBUG_ERROR("Invalid action");
 	}
 
 	return 0; /* always */
 }
 
 int x0000_Connected_2_Connected_X_oLMessage(va_list *app)
 {
 	int ret;
 	tsip_dialog_invite_t *self;
 	const tsip_action_t* action;
 
 	self = va_arg(*app, tsip_dialog_invite_t *);
 	va_arg(*app, const tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 
 	if(action && action->payload){
 		ret = tmedia_session_mgr_send_message(self->msession_mgr, action->payload->data, action->payload->size, 
 			action->media.params);
 	}
 	else{
 		TSK_DEBUG_ERROR("Invalid action");
 	}
 	
 	return 0;
 }
 
 /* Connected -> (iACK) -> Connected */
 int x0000_Connected_2_Connected_X_iACK(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_request_t *rACK = va_arg(*app, const tsip_request_t *);
 	int ret;
 
 	// Nothing to do (in future will be used to ensure the session)
     
     /* No longer waiting for the initial ACK */
     self->is_initial_iack_pending = tsk_false;
 	
 	/* Process remote offer */
 	if((ret = tsip_dialog_invite_process_ro(self, rACK))){
 		/* Send error */
 		return ret;
 	}
 
 	/* Starts media session if not already done */
 	if(!self->msession_mgr->started && (self->msession_mgr->sdp.lo && self->msession_mgr->sdp.ro)){
 		ret = tsip_dialog_invite_msession_start(self);
 	}
 
 	// starts ICE timers now that both parties receive the "candidates"
 	if(tsip_dialog_invite_ice_is_enabled(self)){
 		tsip_dialog_invite_ice_timers_set(self, (self->required.ice ? -1 : TSIP_DIALOG_INVITE_ICE_CONNCHECK_TIMEOUT));
 	}
 
 	/* alert the user */
 	TSIP_DIALOG_INVITE_SIGNAL(self, tsip_i_request, 
 			tsip_event_code_dialog_request_incoming, "Incoming Request", rACK);
 
 	return 0;
 }
 
 /* Connected -> (iINVITE or iUPDATE) -> Connected */
 int x0000_Connected_2_Connected_X_iINVITEorUPDATE(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_request_t *rINVITEorUPDATE = va_arg(*app, const tsip_request_t *);
 
 	int ret = 0;
 	tsk_bool_t bodiless_invite;
 	tmedia_type_t old_media_type = self->msession_mgr ? self->msession_mgr->type : tmedia_none;
 	tmedia_type_t new_media_type;
 	tsk_bool_t force_sdp;
 
 	/* process remote offer */
 	if((ret = tsip_dialog_invite_process_ro(self, rINVITEorUPDATE))){
 		/* Send error */
 		return ret;
 	}
 
 	// force SDP in 200 OK even if the request has the same SDP version
 	force_sdp = TSIP_MESSAGE_HAS_CONTENT(rINVITEorUPDATE);
 	
 	// get new media_type after processing the remote offer
 	new_media_type = self->msession_mgr ? self->msession_mgr->type : tmedia_none;
 	
 	/** response to bodiless iINVITE always contains SDP as explained below
 		RFC3261 - 14.1 UAC Behavior 
 		   The same offer-answer model that applies to session descriptions in 
 		   INVITEs (Section 13.2.1) applies to re-INVITEs.  As a result, a UAC 
 		   that wants to add a media stream, for example, will create a new 
 		   offer that contains this media stream, and send that in an INVITE 
 		   request to its peer.  It is important to note that the full 
 		   description of the session, not just the change, is sent.  This 
 		   supports stateless session processing in various elements, and 
 		   supports failover and recovery capabilities.  Of course, a UAC MAY 
 		   send a re-INVITE with no session description, in which case the first 
 		   reliable non-failure response to the re-INVITE will contain the offer 
 		   (in this specification, that is a 2xx response).
 	*/
 	bodiless_invite = !TSIP_MESSAGE_HAS_CONTENT(rINVITEorUPDATE) && TSIP_REQUEST_IS_INVITE(rINVITEorUPDATE);
 
 	/* session timers (must be before sending response) */
 	if(self->stimers.timer.timeout){
 		tsip_dialog_invite_stimers_handle(self, rINVITEorUPDATE);
 	}
 
 	/* hold/resume */
 	tsip_dialog_invite_hold_handle(self, rINVITEorUPDATE);
 
 	// send the response
 	ret = send_RESPONSE(self, rINVITEorUPDATE, 200, "OK",
 		(self->msession_mgr && (force_sdp || bodiless_invite || self->msession_mgr->ro_changed || self->msession_mgr->state_changed || (old_media_type != new_media_type))));
 
 	/* alert the user */
 	TSIP_DIALOG_INVITE_SIGNAL(self, tsip_i_request, 
 			tsip_event_code_dialog_request_incoming, "Incoming Request.", rINVITEorUPDATE);
 
 	return ret;
 }
 
 /* Connected -> (send reINVITE) -> Connected */
 static int x0000_Connected_2_Connected_X_oINVITE(va_list *app)
 {
 	int ret;
 	tsk_bool_t mediaType_changed;
 	tsip_dialog_invite_t *self;
 	const tsip_action_t* action;
 	
 	self = va_arg(*app, tsip_dialog_invite_t *);
 	va_arg(*app, const tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 	
 	/* Get Media type from the action */
 	mediaType_changed = (TSIP_DIALOG_GET_SS(self)->media.type != action->media.type && action->media.type != tmedia_none);
 	if (mediaType_changed){
 		if (self->msession_mgr) {
 			ret = tmedia_session_mgr_set_media_type(self->msession_mgr, action->media.type);
 		}
 		self->cseq_out_media_update = TSIP_DIALOG(self)->cseq_value + 1;
 	}
 	
 	/* Appy media params received from the user */
 	if(!TSK_LIST_IS_EMPTY(action->media.params)){
 		ret = tmedia_session_mgr_set_3(self->msession_mgr, action->media.params);
 	}
 	
 	/* send the request */
 	ret = send_INVITE(self, mediaType_changed);
 	
 	/* alert the user */
 	if(mediaType_changed){
 		TSIP_DIALOG_INVITE_SIGNAL(self, tsip_m_updating,
 							  tsip_event_code_dialog_request_outgoing, "Updating media type", self->last_oInvite);
 	}
 	
 	return ret;
 }
 
 /* Any -> (iPRACK) -> Any */
 int x0000_Any_2_Any_X_iPRACK(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_request_t *rPRACK = va_arg(*app, const tsip_request_t *);
 
 	const tsip_header_RAck_t* RAck;
 	
 	if((RAck = (const tsip_header_RAck_t*)tsip_message_get_header(rPRACK, tsip_htype_RAck))){
 		if((RAck->seq == self->rseq) &&
 			(tsk_striequals(RAck->method, self->last_o1xxrel->CSeq->method)) &&
 			(RAck->cseq == self->last_o1xxrel->CSeq->seq)){
 			
 			++self->rseq;
 			return send_RESPONSE(self, rPRACK, 200, "OK", tsk_false);
 		}
 	}
 	
 	/* Send 488 */
 	return send_ERROR(self, rPRACK, 488, "Failed to match PRACK request", "SIP; cause=488; text=\"Failed to match PRACK request\"");
 }
 
 /* Any -> (iOPTIONS) -> Any */
 int x0000_Any_2_Any_X_iOPTIONS(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_request_t *rOPTIONS = va_arg(*app, const tsip_request_t *);
 
 	/* Alert user */
 
 	/* Send 2xx */
 	send_RESPONSE(self, rOPTIONS, 200, "OK", tsk_false);
 
 	return 0;
 }
 
 
 /*	Any --> (i401/407 INVITE or UPDATE) --> Any */
 int x0000_Any_2_Any_X_i401_407_Challenge(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_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_INVITE_SIGNAL(self, tsip_ao_request,
 			TSIP_RESPONSE_CODE(response), TSIP_RESPONSE_PHRASE(response), response);
 		
 		return ret;
 	}
 	
 	if(TSIP_RESPONSE_IS_TO_INVITE(response) || TSIP_RESPONSE_IS_TO_UPDATE(response)){
 		
 		return send_INVITEorUPDATE(self, TSIP_RESPONSE_IS_TO_INVITE(response), tsk_false);
 	}
 	else if(TSIP_RESPONSE_IS_TO_BYE(response)){
 		return send_BYE(self);
 	}
 	else{
 		TSK_DEBUG_ERROR("Unexpected code called");
 		return 0;
 	}
 }
 
 /*	Any --> (i2xx INVITE or i2xx UPDATE) --> Any */
 int x0000_Any_2_Any_X_i2xxINVITEorUPDATE(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_response_t *r2xx = va_arg(*app, const tsip_response_t *);
 	int ret = 0;
 
 	/* Update the dialog state */
 	if((ret = tsip_dialog_update(TSIP_DIALOG(self), r2xx))){
 		return ret;
 	}
 
 	/* session timers */
 	if(self->stimers.timer.timeout){
 		tsip_dialog_invite_stimers_handle(self, r2xx);
 	}
 
 	/* Process remote offer */
 	if((ret = tsip_dialog_invite_process_ro(self, r2xx))){
 		send_BYE(self);
 		return ret;
 	}
 
 	
 	/* send ACK */
 	if(TSIP_RESPONSE_IS_TO_INVITE(r2xx)){
 		ret = send_ACK(self, r2xx);
 	}
 
 	// starts ICE timers now that both parties received the "candidates"
 	if(tsip_dialog_invite_ice_is_enabled(self)){
 		tsip_dialog_invite_ice_timers_set(self, (self->required.ice ? -1 : TSIP_DIALOG_INVITE_ICE_CONNCHECK_TIMEOUT));
 	}
 	
 	return ret;
 }
 
 
 /* Any -> (oBYE) -> Trying */
 int x0000_Any_2_Trying_X_oBYE(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	int ret;
 
 	/* Alert the user */
 	TSIP_DIALOG_SIGNAL(self, tsip_event_code_dialog_terminating, "Terminating dialog");
 
 	/* send BYE */
 	if((ret = send_BYE(self)) == 0){
 #if !TSIP_UNDER_APPLE // FIXME: hangs up on iOS (RTP transport runnable join never exits)
 		// stop session manager
 		if(self->msession_mgr && self->msession_mgr->started){
 			tmedia_session_mgr_stop(self->msession_mgr);
 		}
 #endif
 	}
 	return ret;
 }
 
 /* Any -> (iBYE) -> Terminated */
 int x0000_Any_2_Terminated_X_iBYE(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_request_t *rBYE = va_arg(*app, const tsip_request_t *);
 
 	/* set last error (or info) */
 	tsip_dialog_set_lasterror(TSIP_DIALOG(self), "Call Terminated", tsip_event_code_dialog_terminated);
 
 	/* send 200 OK */
 	return send_RESPONSE(self, rBYE, 200, "OK", tsk_false);
 }
 
 /* Any -> Shutdown -> Terminated */
 int x0000_Any_2_Trying_X_shutdown(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	
 	/* schedule shutdow timeout */
 	TSIP_DIALOG_INVITE_TIMER_SCHEDULE(shutdown);
 
 	/* alert user */
 	TSIP_DIALOG_SIGNAL(self, tsip_event_code_dialog_terminating, "Terminating dialog");
 	
 	if(TSIP_DIALOG(self)->state == tsip_established){
 		return send_BYE(self);
 	}
 	else if(TSIP_DIALOG(self)->state == tsip_early){
 		return send_CANCEL(self);
 	}
 	
 	return 0;
 }
 
 
 /* Any -> (i1xx) -> Any */
 int x0000_Any_2_Any_X_i1xx(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 	const tsip_response_t *r1xx = va_arg(*app, const tsip_response_t *);
 	int ret = 0;
 
 	/* Update the dialog state */
 	if((ret = tsip_dialog_update(TSIP_DIALOG(self), r1xx))){
 		return ret;
 	}
 
 	/* RFC 3262 - 4 UAC Behavior
 		If a provisional response is received for an initial request, and
 		that response contains a Require header field containing the option
 		tag 100rel, the response is to be sent reliably.  If the response is
 		a 100 (Trying) (as opposed to 101 to 199), this option tag MUST be
 		ignored, and the procedures below MUST NOT be used.
 
 		Assuming the response is to be transmitted reliably, the UAC MUST
 		create a new request with method PRACK.  This request is sent within
 		the dialog associated with the provisional response (indeed, the
 		provisional response may have created the dialog).  PRACK requests
 		MAY contain bodies, which are interpreted according to their type and
 		disposition.
 
 		Note that the PRACK is like any other non-INVITE request within a
 		dialog.  In particular, a UAC SHOULD NOT retransmit the PRACK request
 		when it receives a retransmission of the provisional response being
 		acknowledged, although doing so does not create a protocol error.
 	 
 		Additional information: We should only process the SDP from reliable responses (require:100rel)
 		but there was many problem with some clients sending SDP with this tag: tiscali, DTAG, samsung, ...
 	*/
 	if((TSIP_RESPONSE_CODE(r1xx) >= 101 && TSIP_RESPONSE_CODE(r1xx) <=199)){
 		/* Process Remote offer */
 		if(TSIP_MESSAGE_HAS_CONTENT(r1xx) && (ret = tsip_dialog_invite_process_ro(self, r1xx))){
 			/* Send Error */
 			return ret;
 		}
 		// don't send PRACK if 100rel is only inside "supported" header
 		if(tsip_message_required(r1xx, "100rel") && (ret = send_PRACK(self, r1xx))){
 			return ret;
 		}
 	}
 	
 	/* QoS Reservation */
 	if((self->qos.timer.id == TSK_INVALID_TIMER_ID) && tsip_message_required(r1xx, "precondition") && !tmedia_session_mgr_canresume(self->msession_mgr)){
 		tsip_dialog_invite_qos_timer_schedule(self);
 	}
 
 	/* alert the user */
 	ret = TSIP_DIALOG_INVITE_SIGNAL(self, tsip_ao_request,
 		TSIP_RESPONSE_CODE(r1xx), TSIP_RESPONSE_PHRASE(r1xx), r1xx);
 	if(self->is_transf){
 		ret = tsip_dialog_invite_notify_parent(self, r1xx);
 	}
 
 	return ret;
 }
 
 /* Any -> (oINFO) -> Any */
 int x0000_Any_2_Any_X_oINFO(va_list *app)
 {
 	tsip_dialog_invite_t *self;
 	const tsip_action_t* action;
 	tsip_request_t* rINFO;
 
 	self = va_arg(*app, tsip_dialog_invite_t *);
 	va_arg(*app, const tsip_message_t *);
 	action = va_arg(*app, const tsip_action_t *);
 	
 	if((rINFO = tsip_dialog_request_new(TSIP_DIALOG(self), "INFO"))){
 		int ret;
 		if(action){
 			ret = tsip_dialog_apply_action(TSIP_MESSAGE(rINFO), action);
 		}
 		ret = tsip_dialog_request_send(TSIP_DIALOG(self), rINFO);
 		TSK_OBJECT_SAFE_FREE(rINFO);
 		return ret;
 	}
 	else{
 		TSK_DEBUG_ERROR("Failed to create new INFO request");
 		return -1;
 	}
 }
 
 int x0000_Any_2_Any_X_iINFO(va_list *app)
 {
 	tsip_dialog_invite_t * self = va_arg(*app, tsip_dialog_invite_t *);
 	tsip_request_t* rINFO = (tsip_request_t*)va_arg(*app, const tsip_message_t *);
 	int ret = -1;
 
 	if (rINFO){
 		ret = send_RESPONSE(self, rINFO, 200, "Ok", tsk_false);
 		{
 			// int tmedia_session_mgr_recv_rtcp_event(tmedia_session_mgr_t* self, tmedia_type_t media_type, tmedia_rtcp_event_type_t event_type, uint32_t ssrc_media);
 			if (self->msession_mgr && TSIP_MESSAGE_HAS_CONTENT(rINFO)){
 				if (tsk_striequals("application/media_control+xml", TSIP_MESSAGE_CONTENT_TYPE(rINFO))){ /* rfc5168: XML Schema for Media Control */
 					static uint32_t __ssrc_media_fake = 0;
 					static tmedia_type_t __tmedia_type_video = tmedia_video; // TODO: add bfcpvideo?
 					const char* content_ptr = (const char*)TSIP_MESSAGE_CONTENT_DATA(rINFO);
 					tsk_size_t content_size = (tsk_size_t)TSIP_MESSAGE_CONTENT_DATA_LENGTH(rINFO);
 					tsk_bool_t is_fir = tsk_false;
 					uint64_t sessionId = 0;
 #if HAVE_LIBXML2
 					{
 						xmlDoc *pDoc;
 						xmlNode *pRootElement;
 						xmlXPathContext *pPathCtx;
 						xmlXPathObject *pPathObj;
 						static const xmlChar* __xpath_expr_picture_fast_update = (const xmlChar*)"/media_control/vc_primitive/to_encoder/picture_fast_update";
 						static const xmlChar* __xpath_expr_stream_id = (const xmlChar*)"/media_control/vc_primitive/stream_id";
 						
 						if (!(pDoc = xmlParseDoc(content_ptr))) {

 							TSK_DEBUG_ERROR("Failed to parse XML content");

 							return 0;
 						}
 						if (!(pRootElement = xmlDocGetRootElement(pDoc))) {

 							TSK_DEBUG_ERROR("Failed to get root element from XML content");

 							xmlFreeDoc(pDoc);
 							return 0;
 						}
 						if (!(pPathCtx = xmlXPathNewContext(pDoc))) {

 							TSK_DEBUG_ERROR("Failed to create path context from XML content");

 							xmlFreeDoc(pDoc);
 							return 0;
 						}
 						// picture_fast_update
 						if (!(pPathObj = xmlXPathEvalExpression(__xpath_expr_picture_fast_update, pPathCtx))) {

 							TSK_DEBUG_ERROR("Error: unable to evaluate xpath expression: picture_fast_update");

 							xmlXPathFreeContext(pPathCtx);
 							xmlFreeDoc(pDoc);
 							return 0;
 						}
 						is_fir = (pPathObj->type == XPATH_NODESET && pPathObj->nodesetval->nodeNr > 0);
 						xmlXPathFreeObject(pPathObj);
 						// stream_id
 						if (!(pPathObj = xmlXPathEvalExpression(__xpath_expr_stream_id, pPathCtx))) {

 							TSK_DEBUG_ERROR("Error: unable to evaluate xpath expression: stream_id");

 							xmlXPathFreeContext(pPathCtx);
 							xmlFreeDoc(pDoc);
 						}
 						else if (pPathObj->type == XPATH_NODESET && pPathObj->nodesetval->nodeNr > 0 && pPathObj->nodesetval->nodeTab[0]->children && pPathObj->nodesetval->nodeTab[0]->children->content) {
 							sessionId = tsk_atoi64((const char*)pPathObj->nodesetval->nodeTab[0]->children->content);
 						}
 						xmlXPathFreeObject(pPathObj);
 						
 						xmlXPathFreeContext(pPathCtx); 
 						xmlFreeDoc(pDoc);
 					}
 #else
 					is_fir = (tsk_strcontains(content_ptr, content_size, "to_encoder") && tsk_strcontains(content_ptr, content_size, "picture_fast_update"));
 #endif
 					if (is_fir) {
 						TSK_DEBUG_INFO("Incoming SIP INFO(picture_fast_update)");
 						ret = sessionId 
 							? tmedia_session_mgr_recv_rtcp_event_2(self->msession_mgr, tmedia_rtcp_event_type_fir, sessionId)
 							: tmedia_session_mgr_recv_rtcp_event(self->msession_mgr, __tmedia_type_video, tmedia_rtcp_event_type_fir, __ssrc_media_fake);
 					}
 					else {
 						TSK_DEBUG_INFO("Incoming SIP INFO(unknown)");
 					}
 				}
 				else if (tsk_striequals("application/sdp", TSIP_MESSAGE_CONTENT_TYPE(rINFO)))
 				{
 					//Process multicast INFO message 
 					const char* content_ptr = (const char*)TSIP_MESSAGE_CONTENT_DATA(rINFO);
 					tsk_size_t content_size = (tsk_size_t)TSIP_MESSAGE_CONTENT_DATA_LENGTH(rINFO);
 
 					if((ret = tsip_dialog_invite_process_ro(self, rINFO))){
 						return ret;
 					}
 					else{
 						tsdp_message_t* sdp = tsk_null;
 						const tsdp_header_M_t* multicast_media = tsk_null;
 						
 						const tsdp_header_A_t* mbms_attr = tsk_null;
 						
 						char* saveptr = tsk_null;
 						char* value = tsk_null; 
 						uint64_t tmgi_decimal = 0;
 						uint64_t tmgi_decimal_local = 0;
 						uint32_t tmgi_part = 0;
 
 						if(!(sdp = tsdp_message_parse(content_ptr, content_size)))
 							return -1;
 
 						if(!(multicast_media = tsdp_message_find_media_at_index(sdp, "audio", 1)))
 							return -1;
 						
 						if(!(mbms_attr = tsdp_header_M_findA(multicast_media, "mbms-mode")))
 							return -1;
 						
 						value = tsk_strtok_r((char*)mbms_attr->value, " ", &saveptr);
 						
 						if(!value)
 							return -1;
 						
 						value = tsk_strtok_r(tsk_null, " ", &saveptr);
 						if(!value)
 							return -1;
 						
 						sscanf(value, "%llu", &tmgi_decimal);
 						tmgi_part = (uint32_t)(tmgi_decimal & 0x00000000FFFFFFFFULL);
 						tmgi_decimal_local = ((uint64_t)tnet_ntohl_2(&tmgi_part)) << 32;
 						tmgi_part = (uint32_t)(((uint64_t)(tmgi_decimal & 0xFFFFFFFF00000000ULL)) >> 32);
 			            tmgi_decimal_local |= tnet_ntohl_2(&tmgi_part);
 						
 						
 					}
 					
 				}
 			}
 		}
 		TSIP_DIALOG_INVITE_SIGNAL(self, tsip_i_request, 
 				tsip_event_code_dialog_request_incoming, "Incoming Request", rINFO);
 	}
 
 	return ret;
 }
 
 int x9998_Any_2_Terminated_X_transportError(va_list *app)
 {
 	tsip_dialog_invite_t *self = va_arg(*app, tsip_dialog_invite_t *);
 
 	/* set last error (or info) */
 	tsip_dialog_set_lasterror(TSIP_DIALOG(self), "Transport error", tsip_event_code_dialog_terminated);
 
 	return 0;
 }
 
 int x9999_Any_2_Any_X_Error(va_list *app)
 {
 	return 0;
 }
 
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //				== STATE MACHINE END ==
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 int tsip_dialog_invite_msession_configure(tsip_dialog_invite_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_invite_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);
 }
 
 int tsip_dialog_invite_msession_start(tsip_dialog_invite_t *self)
 {
 	if(!self || !self->msession_mgr){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if(tsip_dialog_invite_ice_is_enabled(self) && !tsip_dialog_invite_ice_is_connected(self)){
 		if(self->msession_mgr->type != self->ice.media_type){
 			TSK_DEBUG_INFO("Media session type(%d)<>ICE media type(%d)", self->msession_mgr->type, self->ice.media_type);
 			// make sure to use the right media types
 			tsip_dialog_invite_ice_set_media_type(self, self->msession_mgr->type);
 		}
 		self->ice.start_smgr = tsk_true;
 	}
 	else{
 		self->ice.start_smgr = tsk_false;
 		return tmedia_session_mgr_start(self->msession_mgr);
 	}
 	return 0;
 }
 
 
 
 // send INVITE/UPDATE request

 int send_INVITEorUPDATE(tsip_dialog_invite_t *self, tsk_bool_t is_INVITE, tsk_bool_t force_sdp
 )

 {
 	int ret = -1;
 	tsip_request_t *request = tsk_null;
 	tsk_bool_t bodiless = tsk_false;
 	const tsip_header_t* hdr;
 	tsk_size_t i;
 	tsk_bool_t control_accept_contact;
 	char* x_Framed_IP_Address_Port_Header=tsk_null;
 	tsip_stack_t* sip_stack=tsk_null;
 //	tsk_size_t len;
 //	char* hdr_value;
 
 #if BODILESS_INVITE
 	if(TSIP_DIALOG(self)->state == tsip_initial){
 		bodiless = tsk_true;
 	}
 #endif
 
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}

 	//MCPTT

 	if(is_INVITE && ((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));
 	}
 

 	if((request = tsip_dialog_request_new(TSIP_DIALOG(self), is_INVITE ? "INVITE" : "UPDATE"))){
 		/* apply action params to the request (will add a content if the action contains one) */
 
 		char* type_Header_Answer="";
 		char* value_Header_Answer="";
 		if(TSIP_DIALOG(self)->curr_action){
 			tsip_dialog_apply_action(request, TSIP_DIALOG(self)->curr_action);
 		}
 
 
 		
 		if(!bodiless){
 			/* add our payload if current action does not have one */
 			if((force_sdp || is_INVITE) || ((self->msession_mgr && self->msession_mgr->state_changed) || (TSIP_DIALOG(self)->state == tsip_initial))){
 				if(!TSIP_DIALOG(self)->curr_action || !TSIP_DIALOG(self)->curr_action->payload){
 					const tsdp_message_t* sdp_lo;
 					char* sdp;
 					uint32_t speechNO = 0;
 					uint32_t speechYES = 1;

                     uint32_t floorControlNO = 0;
                     uint32_t floorControlYES = 1;
                     uint32_t withFloorControl=floorControlNO;

 					if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt){

 						//MCPTT
                         if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_floor_control) == tmedia_floor_control) {
                             withFloorControl=floorControlYES;
                         }
                             tmedia_session_mgr_set(self->msession_mgr,
                                                TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"with_floor_control",
                                                                         withFloorControl
                                                ),

 							TMEDIA_SESSION_SET_INT32(tmedia_audio,"speech",speechYES),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"implicit",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_implicit),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"priority",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_priority),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"granted",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_granted),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"type_session",(TSIP_DIALOG_GET_SS(self)->media.type)),
 							TMEDIA_SESSION_SET_POBJECT(tmedia_mcptt,"mcptt_id_local",(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_id)),

 							//Insert Timers that received from CMS MCPTT UE init Config

 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"t100",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.timer_s.timer_t100),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"t101",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.timer_s.timer_t101),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"t103",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.timer_s.timer_t103),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"t104",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.timer_s.timer_t104),
 							TMEDIA_SESSION_SET_INT32(tmedia_mcptt,"t132",TSIP_DIALOG_GET_STACK(self)->pttMCPTT.timer_s.timer_t132),
 							TMEDIA_SESSION_SET_NULL());

 
 
                     } else{
 						//MCPTT

 						tmedia_session_mgr_set(self->msession_mgr,
 							TMEDIA_SESSION_SET_INT32(tmedia_audio,"speech",speechNO),
 							TMEDIA_SESSION_SET_NULL());
 					}
 					
 

 					if((sdp_lo = tmedia_session_mgr_get_lo(self->msession_mgr)) && (sdp = tsdp_message_tostring(sdp_lo))){

 
 
 							// MCPTT IF IS INVITE AND MCPTT AUDIO

 							if(is_INVITE && ((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt)){//PTT call MCPTT
 							uint32_t local_ssrc = 0;
 							tmedia_session_t* audio_session;
 							tmedia_session_t* multicast_audio_session = tsk_null;
 							//Get from SDP local of ip and port for header "X-Framed-IP-Address-Port"
 							sip_stack=TSIP_DIALOG_GET_STACK(self);
 							if(sdp_lo && sip_stack->pttMCPTT.mcptt_insert_x_Framed_IP){
 								x_Framed_IP_Address_Port_Header=getAddrPortsFromSDP(sdp_lo);
 							}

 							if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt_group) != tmedia_mcptt_group){//IF is not MCPTT GROUP. It is private

 								
 								tmedia_multipart_body_t* body = tsk_null;
 								tmedia_content_multipart_t* sdp_content = tsk_null;
 								tmedia_content_multipart_t* recipient_list_content = tsk_null;
 								tmedia_content_multipart_t* mcptt_info_content = tsk_null;
 								tsk_buffer_t* resource_list;
 								tsk_buffer_t* mcptt_info;
 								char* content_type_hdr  = tsk_null;
 								char* body_string = tsk_null;
 
 								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);
 								}
 
 								resource_list = tsip_dialog_invite_create_resource_list(self);
 								mcptt_info = tsip_dialog_invite_create_mcpttinfo(self);
 
 								body = tmedia_content_multipart_body_create("multipart/mixed", tsk_null);
 								if(body)
 								{
 								  //SDP
 								  sdp_content = tmedia_content_multipart_create(sdp, tsk_strlen(sdp), "application/sdp", tsk_null);
 								  if(sdp_content)
 									tmedia_content_multipart_body_add_content(body, sdp_content);
 								  //resource-list
 								  recipient_list_content = tmedia_content_multipart_create(TSK_BUFFER_DATA(resource_list), TSK_BUFFER_SIZE(resource_list), "application/resource-lists+xml", "recipient-list");
 								  if(recipient_list_content)
 									tmedia_content_multipart_body_add_content(body, recipient_list_content);
 								  //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);
 								  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));							
 
 
 							}

 							// MCPTT

 							//this code generate the body of invite sip MCPTT. Call Group
 							else if(1)//IF call MCPTt  group is  and the members exist
 							{
 								tsk_buffer_t* resource_list = tsip_dialog_create_resource_list_group(TSIP_DIALOG(self), TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_group_members);
 								char* content_type_hdr  = tsk_null;
 								char* body_string = tsk_null;
 								tsk_buffer_t* mcptt_info;
 								
 								
 
 								tmedia_multipart_body_t* body = tsk_null;
 								tmedia_content_multipart_t* sdp_content = tsk_null;
 								tmedia_content_multipart_t* recipient_list_content = tsk_null;
 								tmedia_content_multipart_t* mcptt_info_content = tsk_null;
 
 								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_info = tsip_dialog_invite_create_mcpttinfo(self);
 								body = tmedia_content_multipart_body_create("multipart/mixed", tsk_null);
 								if(body)
 								{
 									/*
 								  sdp_content = tmedia_content_multipart_create(sdp, tsk_strlen(sdp), "application/sdp", tsk_null);
 								  if(sdp_content)
 									tmedia_content_multipart_body_add_content(body, sdp_content);
 								  recipient_list_content = tmedia_content_multipart_create(TSK_BUFFER_DATA(resource_list), TSK_BUFFER_SIZE(resource_list), "application/resource-lists+xml", "recipient-list");
 								  if(recipient_list_content)
 									tmedia_content_multipart_body_add_content(body, recipient_list_content);
 								  body_string = tmedia_content_multipart_body_tostring(body);
 								  content_type_hdr = tmedia_content_multipart_body_get_header(body);
 								  */
 								  //SDP
 								  sdp_content = tmedia_content_multipart_create(sdp, tsk_strlen(sdp), "application/sdp", tsk_null);
 								  if(sdp_content)
 									tmedia_content_multipart_body_add_content(body, sdp_content);
 								  
 								  //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);
 								  }
 									
 								  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{
 								tsip_message_add_content(request, "application/sdp", sdp, tsk_strlen(sdp));
 							}
 							local_ssrc = tmedia_session_mgr_audio_get_ssrc(self->msession_mgr);							
 							audio_session = tmedia_session_mgr_find(self->msession_mgr, tmedia_audio);
 							multicast_audio_session = tmedia_session_mgr_find_at_index(self->msession_mgr, tmedia_audio, 1);
 
 							if(multicast_audio_session != tsk_null)
 							{
 								tmedia_session_mgr_set(self->msession_mgr,
 									TMEDIA_SESSION_SET_POBJECT(tmedia_mcptt, "multicast_audio_session", multicast_audio_session),
 									TMEDIA_SESSION_SET_NULL());
 								multicast_audio_session->lo_held = tsk_false;
 								multicast_audio_session->ro_held = tsk_false;
 								
 							}
 							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->lo_held = tsk_true;
 						
 						}

 						// MCPTT

 						else if (!is_INVITE && (TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt)//IF it isn�t invite
 						{
 							tmedia_session_t* audio_session = tsk_null;
 							tmedia_session_t* multicast_audio_session = tsk_null;
 							tsip_message_add_content(request, "application/sdp", sdp, tsk_strlen(sdp));
 							
 							
 							audio_session = tmedia_session_mgr_find(self->msession_mgr, tmedia_audio);
 							multicast_audio_session = tmedia_session_mgr_find_at_index(self->msession_mgr, tmedia_audio, 1);
 							if(multicast_audio_session != tsk_null && audio_session != tsk_null)
 							{
 								tmedia_session_mgr_set(self->msession_mgr,
 									TMEDIA_SESSION_SET_POBJECT(tmedia_mcptt, "multicast_audio_session", multicast_audio_session),
 									TMEDIA_SESSION_SET_NULL());
 								multicast_audio_session->lo_held = tsk_true;
 								if(audio_session->lo_held == tsk_true)
 									multicast_audio_session->ro_held = tsk_false;
 								else
 									multicast_audio_session->ro_held = tsk_true;	
 							}
 							
 
 						}
 					    else
 						  tsip_message_add_content(request, "application/sdp", sdp, tsk_strlen(sdp));
 					    
 						if(tsip_dialog_invite_ice_is_enabled(self)){
 							ret = tsip_dialog_invite_ice_process_lo(self, sdp_lo);
 						}
 
 						TSK_FREE(sdp);
 					}
 				}
 			}
 		}
 
 		/* Session timers */
 		if(self->stimers.timer.timeout){
 			if(self->required.timer){
 				tsip_message_add_headers(request,
 						TSIP_HEADER_SESSION_EXPIRES_VA_ARGS(self->stimers.timer.timeout, !self->stimers.is_refresher),
 						TSIP_HEADER_REQUIRE_VA_ARGS("timer"),
 						tsk_null
 					);
 			}
 			else if(self->supported.timer){
 				tsip_message_add_headers(request,
 						TSIP_HEADER_SESSION_EXPIRES_VA_ARGS(self->stimers.timer.timeout, !self->stimers.is_refresher),
 						TSIP_HEADER_SUPPORTED_VA_ARGS("timer"),
 						tsk_null
 					);
 			}
 			
 		}
 
 		if(self->stimers.minse){
 			tsip_message_add_headers(request,
 					TSIP_HEADER_MIN_SE_VA_ARGS(self->stimers.minse),
 					tsk_null
 				);
 		}
 		
 		/* 100rel */
 		if(self->required._100rel){
 			tsip_message_add_headers(request,
 					TSIP_HEADER_REQUIRE_VA_ARGS("100rel"),
 					tsk_null
 				);
 		}
 		else if(self->supported._100rel){
 			tsip_message_add_headers(request,
 					TSIP_HEADER_SUPPORTED_VA_ARGS("100rel"),
 					tsk_null
 				);
 		}
 
 		/* QoS */
 		if(self->required.precondition){
 			tsip_message_add_headers(request,
 				TSIP_HEADER_REQUIRE_VA_ARGS("precondition"),
 				tsk_null
 			);
 		}
 		else if(self->supported.precondition){
 			tsip_message_add_headers(request,
 				TSIP_HEADER_SUPPORTED_VA_ARGS("precondition"),
 				tsk_null
 			);
 		}

 		/*Only audio or audio and Video*/
 		if((TSIP_DIALOG_GET_SS(self)->media.type) == tmedia_audio || (TSIP_DIALOG_GET_SS(self)->media.type & tmedia_video) == tmedia_video)
 		{
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("P-Preferred-Service", "urn:urn-7:3gpp-service.ims.icsi.mmtel"),
 				tsk_null);
 		}
 

 
 		//MCPTT Insert parameter in contact

 		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);
 			//Add new header
 			if(x_Framed_IP_Address_Port_Header!=tsk_null){
 				tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("X-Framed-IP-Address-Port", x_Framed_IP_Address_Port_Header),
 				tsk_null);
 			}
 			
 		}
 
 		/* MCPTT Headers*/
 		if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt)
 		{
 
 			control_accept_contact=tsk_false;
 			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)
 				{
 					//Answer-Mode 
 					control_accept_contact=tsk_true;
 					TSIP_HEADER_ADD_PARAM(dummy_hdr,"+g.3gpp.mcptt;require;explicit", tsk_null);
 					TSIP_HEADER_ADD_PARAM(dummy_hdr,"+g.3gpp.icsi-ref=\"urn%3Aurn-7%3A3gpp-service.ims.icsi.mcptt\";require;explicit", tsk_null);
 					break;
 				}
 	
 /*				else if(tsk_strcmp(dummy_hdr->name, "User-Agent") == 0)
 				{
 					len = tsk_strlen(dummy_hdr->value) + 19;
 					hdr_value = (char *)malloc(len * sizeof(char));
 					tsk_sprintf(&hdr_value, "PoC-client/OMA_PCPS_1.0 %s", dummy_hdr->value);
 					tsk_object_delete(dummy_hdr->value);
 	
 				}*/
 			}
 			if(control_accept_contact==tsk_false){
 				tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Accept-Contact", "*;+g.3gpp.mcptt;require;explicit"),
 				tsk_null
 				);
 				tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Accept-Contact", "*;+g.3gpp.icsi-ref=\"urn%3Aurn-7%3A3gpp-service.ims.icsi.mcptt\";require;explicit"),
 				tsk_null
 				);
 			}
 
 			//new param insert in headers ANSWER_MODE and PRIV_ANSWER_MODE

 			if(TSIP_DIALOG_GET_SS(self)->pttMCPTT.answer_mode_auto){
 				if(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_priv_answer_mode==tsk_true){
 					type_Header_Answer="Priv-Answer-Mode";
 					value_Header_Answer="Auto";
 				}else if(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_answer_mode==tsk_true){
 					type_Header_Answer="Answer-Mode";
 					value_Header_Answer="Auto";
 				}else{
 					type_Header_Answer="Answer-Mode";
 					value_Header_Answer="Manual";
 				}

 			}else{
 				type_Header_Answer="Answer-Mode";
 				value_Header_Answer="Manual";
 			}
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS(type_Header_Answer,value_Header_Answer),
 				tsk_null);
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("P-Preferred-Service", "urn:urn-7:3gpp-service.ims.icsi.mcptt"),
 				tsk_null);
 
 			tsip_message_get_header(request, tsip_htype_User_Agent);

 			//If this call is of emergency
 			if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_emergency) == tmedia_emergency ||
 				(TSIP_DIALOG_GET_SS(self)->media.type & tmedia_alert) == tmedia_alert ||
 				(TSIP_DIALOG_GET_SS(self)->media.type & tmedia_imminentperil) == tmedia_imminentperil)
 			{
 				char *resource_priority_all=tsk_null;
 				char *resource_priority_int=tsk_null;
 				tsip_ssession_t* session_sip;
 				int num_digit=0;
 				int num_priority=-1;
 				int len_priority_string=0;
 				int len_priotity_int=0;
 				session_sip=TSIP_DIALOG_GET_SS(self);
 				num_priority=session_sip->pttMCPTT.emergency.resource_priority_int;
 				//it is call emergency
 				//Now insert the header expecific:
 				if(session_sip->pttMCPTT.emergency.resource_priority_string!=tsk_null && 
 					session_sip->pttMCPTT.emergency.resource_priority_int>-1){
 					num_digit=(int)floor(log10(abs(session_sip->pttMCPTT.emergency.resource_priority_int))) + 1;
 					#if HAVE_CRT //Debug memory
 						resource_priority_int=(char*)malloc((num_digit+1)*sizeof(char));
 	
 					#else
 						resource_priority_int=(char*)tsk_malloc((num_digit+1)*sizeof(char));
 	
 					#endif //HAVE_CRT
 					sprintf(resource_priority_int, "%d",session_sip->pttMCPTT.emergency.resource_priority_int);
 					len_priority_string=tsk_strlen(session_sip->pttMCPTT.emergency.resource_priority_string);
 					len_priotity_int=tsk_strlen(resource_priority_int);
 					#if HAVE_CRT //Debug memory
 					resource_priority_all=(char*)malloc((tsk_strlen(session_sip->pttMCPTT.emergency.resource_priority_string)+tsk_strlen(resource_priority_int)+2)*sizeof(char));
 		
 					#else
 						resource_priority_all=(char*)tsk_malloc((tsk_strlen(session_sip->pttMCPTT.emergency.resource_priority_string)+tsk_strlen(resource_priority_int)+2)*sizeof(char));
 	
 					#endif //HAVE_CRT
 					sprintf(resource_priority_all, "%s.%s",session_sip->pttMCPTT.emergency.resource_priority_string,resource_priority_int);
 					tsip_message_add_headers(request,
 					TSIP_HEADER_DUMMY_VA_ARGS(tsip_header_get_name(tsip_htype_Resource_Priority), resource_priority_all),
 					tsk_null);
 				}
 				if(resource_priority_all && resource_priority_all!=tsk_null){
 					TSK_FREE(resource_priority_all);
 				}
 				if(resource_priority_int && resource_priority_int!=tsk_null){
 					TSK_FREE(resource_priority_int);
 				}
 				
 			}
 
 

 
 			
 
 
 			/*
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Reject-Contact", "*;sip.automata;sip.actor=msg-taker;require;explicit"),
 				tsk_null
 			);
 			//here it is adding new parameter in request, formate key and value
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Reject-Contact", "*;sip.automata;sip.actor=principal;sip.description=\"poc recording device\";require;explicit"),
 				tsk_null
 			);
 
 			
 			
 			tsip_message_add_headers(request,
 				TSIP_HEADER_DUMMY_VA_ARGS("Priv-Answer-Mode", "Auto"),
 				tsk_null
 			);
 			*/
 		}
 

 		/* Always added headers */
 		// Explicit Communication Transfer (3GPP TS 24.629)
 		/*tsip_message_add_headers(request,
 					TSIP_HEADER_SUPPORTED_VA_ARGS("norefersub,replaces"),
 					tsk_null
 				);*/
 
 		/* send the request */
 		ret = tsip_dialog_request_send(TSIP_DIALOG(self), request);
 		if(ret == 0){
 			/* update last INVITE */
 			TSK_OBJECT_SAFE_FREE(self->last_oInvite);
 			self->last_oInvite = request;
 		}
 		else{
 			TSK_OBJECT_SAFE_FREE(request);
 		}
 	}
 	if(x_Framed_IP_Address_Port_Header!=tsk_null){
 		TSK_FREE(x_Framed_IP_Address_Port_Header);
 	}
 
 bail:
 	return ret;
 }
 
 
 
 
 // Send PRACK
 int send_PRACK(tsip_dialog_invite_t *self, const tsip_response_t* r1xx)
 {
 	// "Require: 100rel\r\n" should be checked by the caller of this function
 	int ret = -1;
 	tsip_request_t *request = tsk_null;
 	const tsip_header_RSeq_t* RSeq;
 
 	if(!self || !r1xx || !r1xx->CSeq){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}
 
 
 	/*	RFC 3262 - 4 UAC Behavior
 	The UAC MUST maintain a sequence number that indicates the most recently
 	received in-order reliable provisional response for the initial request.
 	*/
 	if((RSeq = (const tsip_header_RSeq_t*)tsip_message_get_header(r1xx, tsip_htype_RSeq))){
 
 		/*	RFC 3262 - 4 UAC Behavior
 		If the UAC receives another reliable provisional
 		response to the same request, and its RSeq value is not one higher
 		than the value of the sequence number, that response MUST NOT be
 		acknowledged with a PRACK, and MUST NOT be processed further by the
 		UAC.  An implementation MAY discard the response, or MAY cache the
 		response in the hopes of receiving the missing responses.
 		*/
 		if(self->rseq && (RSeq->seq <= self->rseq)){
 			TSK_DEBUG_WARN("1xx.RSeq value is not one higher than lastINVITE.RSeq.");
 			ret = 0; /* Not error */
 			goto bail;
 		}
 		self->rseq = RSeq->seq;
 	}
 
 	/* RFC 3262 - 4 UAC Behavior
 	Assuming the response is to be transmitted reliably, the UAC MUST
 	create a new request with method PRACK.
 	*/
 	if(!(request = tsip_dialog_request_new(TSIP_DIALOG(self), "PRACK"))){
 		goto bail;
 	}
 
 	/* RFC 3262 - 7.2 RAck
 		The first number is the value from the RSeq header in the provisional
 		response that is being acknowledged.  The next number, and the
 		method, are copied from the CSeq in the response that is being
 		acknowledged.  The method name in the RAck header is case sensitive.
 	*/
 	TSIP_MESSAGE_ADD_HEADER(request, TSIP_HEADER_RACK_VA_ARGS(self->rseq, r1xx->CSeq->seq, r1xx->CSeq->method));
 	//TSIP_MESSAGE_ADD_HEADER(request, TSIP_HEADER_DUMMY_VA_ARGS("Test", "value"));
 
 	/*	Initial INVITE was a bodiless request and 100rel is supported (I'm Alice)
 		1. Alice sends an initial INVITE without offer
 		2. Bob's answer is sent in the first reliable provisional response, in this case it's a 1xx INVITE response
 		3. Alice's answer is sent in the PRACK response
 	*/
 	if(self->is_client && (self->last_oInvite && !TSIP_MESSAGE_HAS_CONTENT(self->last_oInvite))){
 		const tsdp_message_t* sdp_lo;
 		char* sdp;
 		if((sdp_lo = tmedia_session_mgr_get_lo(self->msession_mgr)) && (sdp = tsdp_message_tostring(sdp_lo))){
 			tsip_message_add_content(request, "application/sdp", sdp, tsk_strlen(sdp));
 			TSK_FREE(sdp);
 		}
 	}
 	
 	// Send request
 	ret = tsip_dialog_request_send(TSIP_DIALOG(self), request);
 	
 bail:
 	TSK_OBJECT_SAFE_FREE(request);
 	return ret;
 }
 
 // Send CANCEL
 int send_CANCEL(tsip_dialog_invite_t *self)
 {
 	int ret = -1;
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}
 	/* RFC 3261 - 9 Canceling a Request
 		If the request being cancelled contains a Route header field, the
 		CANCEL request MUST include that Route header field's values.
 		==> up to tsip_dialog_request_new()
 	*/
 
 	/*	RFC 3261 - 9 Canceling a Request
 		Once the CANCEL is constructed, the client SHOULD check whether it
 		has received any response (provisional or final) for the request
 		being cancelled (herein referred to as the "original request").
 
 		If no provisional response has been received, the CANCEL request MUST
 		NOT be sent; rather, the client MUST wait for the arrival of a
 		provisional response before sending the request.
 		==> up to the caller to check that we are not in the initial state and the FSM
 		is in Trying state.
    */
 
 	/*	RFC 3261 - 9 Canceling a Request
 		The following procedures are used to construct a CANCEL request.  The
 		Request-URI, Call-ID, To, the numeric part of CSeq, and From header
 		fields in the CANCEL request MUST be identical to those in the
 		request being cancelled, including tags.  A CANCEL constructed by a
 		client MUST have only a single Via header field value matching the
 		top Via value in the request being cancelled.  Using the same values
 		for these header fields allows the CANCEL to be matched with the
 		request it cancels (Section 9.2 indicates how such matching occurs).
 		However, the method part of the CSeq header field MUST have a value
 		of CANCEL.  This allows it to be identified and processed as a
 		transaction in its own right (See Section 17)
 	*/
 	if(self->last_oInvite){
 		/* to avoid concurrent access, take a reference to the request */
 		tsip_request_t* last_oInvite = tsk_object_ref(self->last_oInvite);
 		tsip_request_t* cancel;
 
 		if((cancel = tsip_request_create("CANCEL", last_oInvite->line.request.uri))){
 			const tsk_list_item_t* item;
 			const tsip_header_t* header;
 
 			tsip_message_add_headers(cancel,
 				TSIP_HEADER_CSEQ_VA_ARGS(last_oInvite->CSeq->seq, "CANCEL"),
 				TSIP_HEADER_MAX_FORWARDS_VA_ARGS(TSIP_HEADER_MAX_FORWARDS_DEFAULT),
 				TSIP_HEADER_CONTENT_LENGTH_VA_ARGS(0),
 				tsk_null);
 
 			cancel->Call_ID = tsk_object_ref(last_oInvite->Call_ID);
 			cancel->To = tsk_object_ref(last_oInvite->To);
 			cancel->From = tsk_object_ref(last_oInvite->From);
 			cancel->firstVia = tsk_object_ref(last_oInvite->firstVia);
 			cancel->sigcomp_id = tsk_strdup(TSIP_DIALOG_GET_SS(self)->sigcomp_id);
 
 			// Copy Authorizations, Routes and Proxy-Auth
 			tsk_list_foreach(item, last_oInvite->headers){
 				if(!(header = TSIP_HEADER(item->data))){
 					continue;
 				}
 
 				switch(header->type){
 					case tsip_htype_Route:
 					case tsip_htype_Proxy_Authorization:
 					case tsip_htype_Authorization:
 						header = tsk_object_ref((void*)header);
 						if(!cancel->headers){
 							cancel->headers = tsk_list_create();
 						}
 						tsk_list_push_back_data(cancel->headers, (void**)&header);
 						break;
                     default: break;
 				}
 			}
 			
 			ret = tsip_dialog_add_session_headers(TSIP_DIALOG(self), cancel);
 			ret = tsip_dialog_request_send(TSIP_DIALOG(self), cancel);
 			TSK_OBJECT_SAFE_FREE(cancel);
 		}
 		else{
 			TSK_DEBUG_ERROR("Failed to create CANCEL request");
 			ret = -2;
 		}
 
 		TSK_OBJECT_SAFE_FREE(last_oInvite);
 		return ret;
 	}
 	else{
 		TSK_DEBUG_WARN("There is no INVITE request to cancel");
 		return 0;
 	}
 
 bail:
 	return ret;
 }
 
 int tsip_dialog_invite_notify_parent(tsip_dialog_invite_t *self, const tsip_response_t* response)
 {
 	int ret = -1;
 	tsip_dialog_t* dlg_parent = tsip_dialog_layer_find_by_ssid(TSIP_DIALOG_GET_STACK(self)->layer_dialog, TSIP_DIALOG_GET_SS(self)->id_parent);
 	if(dlg_parent){
 		tsip_action_t* action = tsip_action_create(tsip_atype_ect_lnotify,
 			TSIP_ACTION_SET_NULL());
 		if(action){
 			ret = tsip_dialog_fsm_act(dlg_parent, action->type, response, action);
 			TSK_OBJECT_SAFE_FREE(action);
 		}
 		else{
 			TSK_DEBUG_ERROR("Failed to create action object");
 		}
 		TSK_OBJECT_SAFE_FREE(dlg_parent);
 	}
 	else{

 		TSK_DEBUG_ERROR("Failed to find parent with id");

 	}
 	return ret;
 }
 
 // Send BYE
 int send_BYE(tsip_dialog_invite_t *self)
 {
 
 	tsip_dialog_t* dialog=tsk_null;
 	int ret = -1;
 	tsip_request_t *bye = tsk_null;
 
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}
 	dialog=TSIP_DIALOG(self);
 	/* RFC 3261 - 15.1.1 UAC Behavior
 		A BYE request is constructed as would any other request within a
 		dialog, as described in Section 12.
 
 		Once the BYE is constructed, the UAC core creates a new non-INVITE
 		client transaction, and passes it the BYE request.  The UAC MUST
 		consider the session terminated (and therefore stop sending or
 		listening for media) as soon as the BYE request is passed to the
 		client transaction.  If the response for the BYE is a 481
 		(Call/Transaction Does Not Exist) or a 408 (Request Timeout) or no
 
 		response at all is received for the BYE (that is, a timeout is
 		returned by the client transaction), the UAC MUST consider the
 		session and the dialog terminated.
 	*/
 	TSK_DEBUG_INFO("Create BYE");
 	if((bye = tsip_dialog_request_new(TSIP_DIALOG(self), "BYE"))){
 		if(TSIP_DIALOG(self)->curr_action){
 			tsip_dialog_apply_action(bye, TSIP_DIALOG(self)->curr_action);
 		}
 		ret = tsip_dialog_request_send(TSIP_DIALOG(self), bye);
 		TSK_OBJECT_SAFE_FREE(bye);
 	}
 
 bail:
 	return ret;
 }
 
 // Send INFO
 int send_INFO(tsip_dialog_invite_t *self, const char* content_type, const void* content_ptr, tsk_size_t content_size)
 {
 	int ret = -1;
 	tsip_request_t *info = tsk_null;
 
 	if (!self) {
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}
 	if ((info = tsip_dialog_request_new(TSIP_DIALOG(self), "INFO"))) {
 		if (TSIP_DIALOG(self)->curr_action) {
 			ret = tsip_dialog_apply_action(info, TSIP_DIALOG(self)->curr_action);
 			if (ret) {
 				goto bail;
 			}
 		}
 		if (content_type && content_ptr && content_size) {
 			ret = tsip_message_add_content(info, content_type, content_ptr, content_size);
 			if (ret) {
 				goto bail;
 			}
 		}
 		ret = tsip_dialog_request_send(TSIP_DIALOG(self), info);
 		if (ret) {
 			goto bail;
 		}
 	}
 
 bail:
 	TSK_OBJECT_SAFE_FREE(info);
 	return ret;
 }
 
 // Send ACK
 int send_ACK(tsip_dialog_invite_t *self, const tsip_response_t* r2xxINVITE)
 {
 	int ret = -1;
 	tsip_dialog_t* dialog=tsk_null;
 	tsip_request_t *request = tsk_null;
 
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		goto bail;
 	}	
 	dialog=TSIP_DIALOG(self);
 	if((request = tsip_dialog_request_new(dialog, "ACK"))){
 		request->Contact=tsk_null;
 		/* The initial INVITE sent by us was a bodiless request and we don't support 100rel (We are Alice)
 		   1. Alice sends initial INVITE without offer
 		   2. Bob's offer is sent in the 2xx INVITE response
 		   3. Alice's answer is sent in the ACK request
 		*/
 		if(self->is_client && (self->last_oInvite && !TSIP_MESSAGE_HAS_CONTENT(self->last_oInvite))){
 			const tsdp_message_t* sdp_lo;
 			char* sdp;
 			if((sdp_lo = tmedia_session_mgr_get_lo(self->msession_mgr)) && (sdp = tsdp_message_tostring(sdp_lo))){
 				tsip_message_add_content(request, "application/sdp", sdp, tsk_strlen(sdp));
 				TSK_FREE(sdp);
 			}
 
 			// Start media session if not done
 			if(!self->msession_mgr->started && (self->msession_mgr->sdp.lo && self->msession_mgr->sdp.ro)){
 				/* Set MSRP Callback */
 				if((self->msession_mgr->type & tmedia_msrp) == tmedia_msrp){
 					tmedia_session_mgr_set_msrp_cb(self->msession_mgr, 
 						TSIP_DIALOG_GET_SS(self)->userdata, TSIP_DIALOG_GET_SS(self)->media.msrp.callback);
 				}
 				// starts session manager
 				ret = tsip_dialog_invite_msession_start(self);
 			}
 		}
 
 		/*	RFC 3261 - 13.2.2.4 2xx Responses
 		   The UAC core MUST generate an ACK request for each 2xx received from
 		   the transaction layer.  The header fields of the ACK are constructed
 		   in the same way as for any request sent within a dialog (see Section
 		   12) with the exception of the CSeq and the header fields related to
 		   authentication.  The sequence number of the CSeq header field MUST be
 		   the same as the INVITE being acknowledged, but the CSeq method MUST
 		   be ACK.  The ACK MUST contain the same credentials as the INVITE.  If
 		   the 2xx contains an offer (based on the rules above), the ACK MUST
 		   carry an answer in its body.  If the offer in the 2xx response is not
 		   acceptable, the UAC core MUST generate a valid answer in the ACK and
 		   then send a BYE immediately.
 		   ==> Credentials will be added by tsip_dialog_request_new() because they are
 		   associated to the dialog itself.
 		   ==> It's up to us to add/update the CSeq number.
 		   ==> ACK requests sent here will create new client transactions, which means that
 		   they will have there own branches. This is not the case for ACK requests sent from
 		   the transaction layer.
 		*/
 		request->CSeq->seq = r2xxINVITE->CSeq->seq; /* As the 2xx has the same CSeq than the INVITE */
 		
 		/*	RFC 3261 - 13.2.2.4 2xx Responses
 		   Once the ACK has been constructed, the procedures of [4] are used to
 		   determine the destination address, port and transport.  However, the
 		   request is passed to the transport layer directly for transmission,
 		   rather than a client transaction.  This is because the UAC core
 		   handles retransmissions of the ACK, not the transaction layer.  The
 		   ACK MUST be passed to the client transport every time a
 		   retransmission of the 2xx final response that triggered the ACK
 		   arrives.
 		*/
 		if(TSIP_DIALOG_GET_STACK(self)->layer_transport){
 			ret = tsip_transport_layer_send(TSIP_DIALOG_GET_STACK(self)->layer_transport, tsk_null, request);
 		}
 		else{
 			ret = -1;
 			TSK_DEBUG_ERROR("Not Transport layer associated to this stack");
 		}
 		TSK_OBJECT_SAFE_FREE(request);
 	}
 
 bail:
 	return ret;
 }
 
 // Send any response
 int send_RESPONSE(tsip_dialog_invite_t *self, const tsip_request_t* request, short code, const char* phrase, tsk_bool_t force_sdp)
 {
 
 	const tsdp_message_t* sdp_lo;
 	char* sdp = tsk_null;

 	tsk_buffer_t* m_info;

 	char* content_type_hdr  = tsk_null;
 	char* body_string = tsk_null;
 	tmedia_multipart_body_t* body = tsk_null;
 	tmedia_content_multipart_t* mcptt_info_content = tsk_null;
 	tmedia_content_multipart_t* sdp_content = tsk_null;
 	char* x_Framed_IP_Address_Port_Header=tsk_null;
 	tsip_response_t *response;
 	int ret = -1;
 
 	if((response = tsip_dialog_response_new(TSIP_DIALOG(self), code, phrase, request))){
 		if(TSIP_REQUEST_IS_INVITE(request) || TSIP_REQUEST_IS_UPDATE(request)){
 			/* Session timers (for 2xx to INVITE or UPDATE) */
 			if(self->required.timer){
 				tsip_message_add_headers(response,
 						TSIP_HEADER_REQUIRE_VA_ARGS("timer"),
 						TSIP_HEADER_SESSION_EXPIRES_VA_ARGS(self->stimers.timer.timeout, tsk_striequals(self->stimers.refresher, "uas")),
 						tsk_null
 					);
 			}
 			else if(self->supported.timer){
 				tsip_message_add_headers(response,
 						TSIP_HEADER_SUPPORTED_VA_ARGS("timer"),
 						TSIP_HEADER_SESSION_EXPIRES_VA_ARGS(self->stimers.timer.timeout, tsk_striequals(self->stimers.refresher, "uas")),
 						tsk_null
 					);
 			}
 			if(self->stimers.minse){
 				tsip_message_add_headers(response,
 						TSIP_HEADER_MIN_SE_VA_ARGS(self->stimers.minse),
 						tsk_null
 					);
 			}
 			if(code == 422){
 				tsip_message_add_headers(response,
 						TSIP_HEADER_DUMMY_VA_ARGS("Reason", "SIP; cause=422; text=\"Session Interval Too Small\""),
 						tsk_null
 					);
 			}
 			
 			/* 180 Ringing */
 			/* 183 Session in Progress */
 			if(code == 180 || code == 183){
 				if(self->required._100rel){
 					if(self->rseq == 0){
 						self->rseq = TSK_ABS((rand() ^ rand()) + 1);
 					}
 					tsip_message_add_headers(response,
 						TSIP_HEADER_REQUIRE_VA_ARGS("100rel"),
 						TSIP_HEADER_RSEQ_VA_ARGS(self->rseq),
 						tsk_null
 					);
 					TSK_OBJECT_SAFE_FREE(self->last_o1xxrel);
 					self->last_o1xxrel = tsk_object_ref(response);
 					
 					/* No-Initial reliable 1xx will use tsip_dialog_response_send() instead of this function
 					* ==> can reseset timeout value and make initial schedule */
 					TSIP_DIALOG_TIMER_CANCEL(100rel);
 					self->timer100rel.timeout = tsip_timers_getA();
 					TSIP_DIALOG_INVITE_TIMER_SCHEDULE(100rel);
 				}
 			}
 
 			/* Precondition */
 			if(code == 180 || code == 183){
 				if(self->required.precondition){
 					tsip_message_add_headers(response,
 						TSIP_HEADER_REQUIRE_VA_ARGS("precondition"),
 						tsk_null
 					);
 				}
 			}
 			
 			
 			/* SDP content */
 			if(self->msession_mgr && force_sdp){

 
 
 				    if(((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt) && ((sdp_lo = tmedia_session_mgr_get_lo(self->msession_mgr)) && (sdp = tsdp_message_tostring(sdp_lo)))){
 
 					m_info = tsip_dialog_200ok_create_mcpttinfo(self);
 

 					body = tmedia_content_multipart_body_create("multipart/mixed", tsk_null);
 
 					if(sdp_lo && TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_insert_x_Framed_IP){
 						x_Framed_IP_Address_Port_Header=getAddrPortsFromSDP(sdp_lo);
 					}
 
 					if(body)
 					{
 						//SDP
 						sdp_content = tmedia_content_multipart_create(sdp, tsk_strlen(sdp), "application/sdp", tsk_null);
 						if(sdp_content)
 						tmedia_content_multipart_body_add_content(body, sdp_content);

 						//mc-info
 						mcptt_info_content = tmedia_content_multipart_create(TSK_BUFFER_DATA(m_info), TSK_BUFFER_SIZE(m_info), "application/vnd.3gpp.mcptt-info+xml",tsk_null);

 						if(mcptt_info_content)
 						tmedia_content_multipart_body_add_content(body, mcptt_info_content);
 						body_string = tmedia_content_multipart_body_tostring(body);
 						content_type_hdr = tmedia_content_multipart_body_get_header(body);
 					}
 
 					ret = tsip_message_add_content(response, content_type_hdr, body_string, tsk_strlen(body_string));							
 
 					
 
 

 				TSK_FREE(m_info);

 				}else if((sdp_lo = tmedia_session_mgr_get_lo(self->msession_mgr)) && (sdp = tsdp_message_tostring(sdp_lo))){
 					ret = tsip_message_add_content(response, "application/sdp", sdp, tsk_strlen(sdp));
 					if(tsip_dialog_invite_ice_is_enabled(self)){
 						ret = tsip_dialog_invite_ice_process_lo(self, sdp_lo);
 					}
 				}
 
 				TSK_FREE(body_string);
 				
 				TSK_FREE(content_type_hdr);		
 				TSK_FREE(sdp);
 			}
 
 
 
 
 			/* Add Allow header */
 			tsip_message_add_headers(response,
 						TSIP_HEADER_DUMMY_VA_ARGS("Allow", TSIP_HEADER_ALLOW_DEFAULT),
 						tsk_null
 					);
 		}
 		else if(TSIP_REQUEST_IS_REFER(request)){
 			if(self->required.norefersub){
 					tsip_message_add_headers(response,
 						TSIP_HEADER_REQUIRE_VA_ARGS("norefersub"),
 						tsk_null
 					);
 			}
 			if(self->supported.norefersub){
 					tsip_message_add_headers(response,
 						TSIP_HEADER_SUPPORTED_VA_ARGS("norefersub"),
 						tsk_null
 					);
 			}
 		}
 

 		//MCPTT Insert parameter in contact

 		if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt) == tmedia_mcptt){
 			//Add new header
 			if(x_Framed_IP_Address_Port_Header!=tsk_null){
 				tsip_message_add_headers(response,
 				TSIP_HEADER_DUMMY_VA_ARGS("X-Framed-IP-Address-Port", x_Framed_IP_Address_Port_Header),
 				tsk_null);
 			}
 			
 		}
 			
 
 		ret = tsip_dialog_response_send(TSIP_DIALOG(self), response);
 		TSK_OBJECT_SAFE_FREE(response);
 		if(x_Framed_IP_Address_Port_Header!=tsk_null){
 			TSK_FREE(x_Framed_IP_Address_Port_Header);
 		}
 	}
 	return ret;
 }
 
 // Send error response
 int send_ERROR(tsip_dialog_invite_t* self, const tsip_request_t* request, short code, const char* phrase, const char* reason)
 {
 	tsip_response_t *response;
 
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if((response = tsip_dialog_response_new(TSIP_DIALOG(self), code, phrase, request))){
 		tsip_message_add_headers(response,
 			TSIP_HEADER_DUMMY_VA_ARGS("Reason", reason),
 			tsk_null
 			);
 
 		tsip_dialog_response_send(TSIP_DIALOG(self), response);
 		TSK_OBJECT_SAFE_FREE(response);
 	}
 	else{
 		TSK_DEBUG_ERROR("Failed to create new message");
 	}
 	return 0;
 }
 
 // FSM callback to signal that the dialog is in the terminated state
 int tsip_dialog_invite_OnTerminated(tsip_dialog_invite_t *self)
 {
 	TSK_DEBUG_INFO("=== INVITE Dialog terminated ===");
 
 	/* Cancel all transactions associated to this dialog (will also be done when the dialog is destroyed ) 
 		worth nothing to do it here in order to cancel in-dialog request (such as INFO, REFER...)
 	*/
 	tsip_transac_layer_cancel_by_dialog(TSIP_DIALOG_GET_STACK(self)->layer_transac, TSIP_DIALOG(self));
 
 	/* stop session manager */
 	if(self->msession_mgr && self->msession_mgr->started){
 		tmedia_session_mgr_stop(self->msession_mgr);
 	}
 	// because of C# and Java garbage collectors, the ICE context could
 	// be destroyed (then stoppped) very late
 	if(self->ice.ctx_audio){
 		tnet_ice_ctx_stop(self->ice.ctx_audio);
 	}
 	if(self->ice.ctx_video){
 		tnet_ice_ctx_stop(self->ice.ctx_video);
 	}
 
 	/* alert the user */
 	TSIP_DIALOG_SIGNAL_2(self, tsip_event_code_dialog_terminated,
 			TSIP_DIALOG(self)->last_error.phrase ? TSIP_DIALOG(self)->last_error.phrase : "Call Terminated",
 			TSIP_DIALOG(self)->last_error.message);
 
 	/* Remove from the dialog layer. */
 	return tsip_dialog_remove(TSIP_DIALOG(self));
 }
 
 // callback function called when media session error occures asynchronously
 static int tsip_dialog_invite_msession_onerror_cb(const void* usrdata, const struct tmedia_session_s* session, const char* reason, tsk_bool_t is_fatal)
 {
 	tsip_dialog_t *self = (tsip_dialog_t*)usrdata;
 
 	if(self && is_fatal){
 		char* str = tsk_null;
 		tsip_action_t* action;
 		tsk_sprintf(&str, "SIP; cause=488; text=\"%s\"", (reason ? reason : "Internal error"));
 		action = tsip_action_create(tsip_atype_hangup,
            TSIP_ACTION_SET_HEADER("Reason", str),
            TSIP_ACTION_SET_NULL());
 		TSK_FREE(str);
 		
 		tsip_dialog_hangup(self, action);
 		TSK_OBJECT_SAFE_FREE(action);
 	}
 
 	return 0;
 }
 
 // callback function called when media session events (related to rfc5168) occures asynchronously
 static int tsip_dialog_invite_msession_rfc5168_cb(const void* usrdata, const struct tmedia_session_s* session, const char* reason, enum tmedia_session_rfc5168_cmd_e command)
 {
 	tsip_dialog_invite_t *self = (tsip_dialog_invite_t*)usrdata;
 
 	if (self) {
 		if (command == tmedia_session_rfc5168_cmd_picture_fast_update) {
 			char* content_ptr = tsk_null;
 			static const char* __content_type = "application/media_control+xml";
 			static const void* __content_format = 
 				"<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"
 				" <media_control>\r\n"
 				"   <vc_primitive>\r\n"
 				"     <to_encoder>\r\n"
 				"       <picture_fast_update>\r\n"
 				"       </picture_fast_update>\r\n"
 				"     </to_encoder>\r\n"
 				"     <stream_id>%llu</stream_id>\r\n"
 				"   </vc_primitive>\r\n"
 				" </media_control>\r\n";
 			TSK_DEBUG_INFO("Media session is asking the sigaling layer to send SIP INFO('picture_fast_update')");
 			tsk_sprintf(&content_ptr, __content_format, session->id);
 			return send_INFO(self, __content_type, content_ptr, tsk_strlen(content_ptr));
 		}
 	}
 	return 0;
 }
 
 static tsk_buffer_t* tsip_dialog_invite_create_resource_list(const tsip_dialog_invite_t* self)
 {
 	//const tsk_list_item_t* item;
 	tsk_buffer_t* output = tsk_buffer_create_null();
 	char* ret = tsk_null;
 	int numMembers=0;
 	tsip_ssession_t* ptsip_ssession_t;
 	int con;
 /*
 #if HAVE_LIBXML2
 	ret = tsk_null;
 #else*/
 	const char* head  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 						"<resource-lists xmlns=\"urn:ietf:params:xml:ns:resource-lists\""
 						" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
 						" xmlns:cc=\"urn:ietf:params:xml:ns:copycontrol\">\r\n"
 						"  <list>\r\n";
 
 	const char* headout  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 						"<resource-lists>\r\n"
 						"  <list>\r\n";
 	const char* tail =  "  </list>\r\n"
 						"</resource-lists>\r\n";
 	ptsip_ssession_t=TSIP_SSESSION(self);
 	/*if(ptsip_ssession_t->stack->pttMCPTT.mcptt_namespace==tsk_true){*/
 		tsk_buffer_append_2(output, "%s", head);
 	/*}else{
 		tsk_buffer_append_2(output, "%s", headout);
 	}*/

 	if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_mcptt_group) == tmedia_mcptt_group){

 		//MCPTT GROUP
 		numMembers=tsip_ssession_get_ptt_mcptt_group_members(TSIP_DIALOG_GET_SS(self));
 		//
 		for(con=0;con<numMembers;con++){
 			tsk_buffer_append_2(output, "<entry uri=\"%s\" cc:copyControl=\"to\"/>\r\n",tsip_ssession_get_ptt_mcptt_group_member_at_position(TSIP_DIALOG_GET_SS(self),con));
 		}	

 	}else if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_mcptt) == tmedia_audio_ptt_mcptt) {

 		//MCPTT PRIVATE 

 		tsk_buffer_append_2(output, "<entry uri=\"%s\" cc:copyControl=\"to\"/>\r\n",
 							TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_caller_uri);
 
 

 	}else{
 		//OTHER
 		tsk_buffer_append_2(output, "<entry uri=\"%s\" cc:copyControl=\"to\"/>\r\n", tsip_uri_tostring(TSIP_DIALOG(self)->uri_remote, tsk_false, tsk_false));
 		
 	}
 
 	tsk_buffer_append_2(output, "%s", tail);
 		
 
 
 	
 	return output;
 }
 
 static tsk_buffer_t* tsip_dialog_invite_create_mcpttinfo(const tsip_dialog_invite_t* self)
 {
 	tsip_stack_t* ptsip_stack_t=TSIP_DIALOG_GET_STACK(self);
 	tsk_buffer_t* output = tsk_buffer_create_null();
 
 #if HAVE_LIBXML2
 	xmlNsPtr ns;
 	xmlNsPtr xsi;
 	xmlDocPtr doc = NULL;       /* document pointer */
     xmlNodePtr root_node = NULL;
 	xmlNodePtr mcptt_Params = NULL;/* node pointers */
 	xmlNodePtr session_type = NULL;
 	xmlNodePtr request_Uri=NULL;

     xmlNodePtr mcptt_client_id=NULL;
 	xmlNodePtr emergency_node = NULL;
 	xmlNodePtr alert_node = NULL;
 	xmlNodePtr imminentperil_node = NULL;

 	tsip_ssession_t* session_sip;
 	tsip_ssession_t* ptsip_ssession_t=TSIP_SSESSION(self);
 	char* dataOut=tsk_null;
 
 	
 	//create xml with libxml
 	/* 
      * Creates a new document, a node and set it as a root node
      */
 	session_sip=TSIP_DIALOG_GET_SS(self);
     doc = xmlNewDoc(BAD_CAST "1.0");
     root_node = xmlNewNode(NULL, BAD_CAST "mcpttinfo");
     ns = xmlNewNs(root_node, BAD_CAST"urn:3gpp:ns:mcpttInfo:1.0",NULL);
     xsi = xmlNewNs(root_node, BAD_CAST"http://www.w3.org/2001/XMLSchema-instance", BAD_CAST "xsi");
 	xmlDocSetRootElement(doc, root_node);
 	 /* 
      * xmlNewChild() creates a new node, which is "attached" as child node
      * of root_node node. 
      */
     mcptt_Params=xmlNewChild(root_node, NULL, BAD_CAST "mcptt-Params",
                 BAD_CAST"");

 
 	if((session_sip->media.type & tmedia_mcptt_chat) == tmedia_mcptt_chat){
 		//Chat group call
 		session_type=xmlNewChild(mcptt_Params, NULL, BAD_CAST "session-type",
 								 BAD_CAST"chat");
 			//New version
 			request_Uri=xmlNewChild(mcptt_Params, NULL, BAD_CAST "mcptt-request-uri",
 									BAD_CAST"");
 			xmlNewProp(request_Uri, BAD_CAST "type", BAD_CAST "Normal");
 			xmlNewChild(request_Uri, NULL, BAD_CAST "mcpttURI",
 						BAD_CAST session_sip->pttMCPTT.ptt_group_uri);
 
 		//Insert mcptt client id
 		mcptt_client_id=xmlNewChild(mcptt_Params, NULL, BAD_CAST "mcptt-client-id",
 										BAD_CAST"");
 		xmlNewProp(mcptt_client_id, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(mcptt_client_id, NULL, BAD_CAST "mcpttString",
 					BAD_CAST TSK_BUFFER_TO_STRING(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_client_id));
 
 
 	}else

 	if((session_sip->media.type & tmedia_audio_ptt_group_mcptt) != tmedia_audio_ptt_group_mcptt){
 		//Call private
 		session_type=xmlNewChild(mcptt_Params, NULL, BAD_CAST "session-type",
                 BAD_CAST"private");
 	}else{
 		//Call group
 		session_type=xmlNewChild(mcptt_Params, NULL, BAD_CAST "session-type",
                 BAD_CAST"prearranged");
 			//New version
 			request_Uri=xmlNewChild(mcptt_Params, NULL, BAD_CAST "mcptt-request-uri",
                 BAD_CAST"");
 			xmlNewProp(request_Uri, BAD_CAST "type", BAD_CAST "Normal");
 			xmlNewChild(request_Uri, NULL, BAD_CAST "mcpttURI",
                 BAD_CAST session_sip->pttMCPTT.ptt_group_uri);

         //Insert mcptt client id
         mcptt_client_id=xmlNewChild(mcptt_Params, NULL, BAD_CAST "mcptt-client-id",
                                     BAD_CAST"");
         xmlNewProp(mcptt_client_id, BAD_CAST "type", BAD_CAST "Normal");
         xmlNewChild(mcptt_client_id, NULL, BAD_CAST "mcpttString",
                     BAD_CAST TSK_BUFFER_TO_STRING(TSIP_DIALOG_GET_STACK(self)->pttMCPTT.mcptt_client_id));

 		
 			
 		
 	}

 	//Define logic for call emergence
 	if((session_sip->media.type & tmedia_imminentperil) == tmedia_imminentperil){
 		imminentperil_node=xmlNewChild(mcptt_Params, NULL, BAD_CAST "imminentperil-ind",
         BAD_CAST"");
 		xmlNewProp(imminentperil_node, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(imminentperil_node, NULL, BAD_CAST "mcpttBoolean",
         BAD_CAST"true");
 		/*
 		 * if the MCPTT user has not requested an MCPTT emergency alert to be sent, shall set the <alert-ind> element of the application/vnd.3gpp.mcptt-info+xml MIME body to "false"; and
 		 */
 		alert_node=xmlNewChild(mcptt_Params, NULL, BAD_CAST "alert-ind",
 							   BAD_CAST"");
 		xmlNewProp(alert_node, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(alert_node, NULL, BAD_CAST "mcpttBoolean",
 					BAD_CAST"false");
 	}
 	if((session_sip->media.type & tmedia_alert) == tmedia_alert){
 		/**
 		 * 	include in the application/vnd.3gpp.mcptt-info+xml MIME body the <alert-ind> element set to "true" and set the MCPTT emergency alert state to "MEA 2: emergency-alert-confirm-pending";
 		 */
 		alert_node=xmlNewChild(mcptt_Params, NULL, BAD_CAST "alert-ind",
         BAD_CAST"");
 		xmlNewProp(alert_node, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(alert_node, NULL, BAD_CAST "mcpttBoolean",
         BAD_CAST"true");
 	}else{
 		/*
 		 * if the MCPTT user has not requested an MCPTT emergency alert to be sent, shall set the <alert-ind> element of the application/vnd.3gpp.mcptt-info+xml MIME body to "false"; and
 		 */
 		alert_node=xmlNewChild(mcptt_Params, NULL, BAD_CAST "alert-ind",
 							   BAD_CAST"");
 		xmlNewProp(alert_node, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(alert_node, NULL, BAD_CAST "mcpttBoolean",
 					BAD_CAST"false");
 	}
 	if((session_sip->media.type & tmedia_emergency) == tmedia_emergency){
 		emergency_node=xmlNewChild(mcptt_Params, NULL, BAD_CAST "emergency-ind",
         BAD_CAST"");
 		xmlNewProp(emergency_node, BAD_CAST "type", BAD_CAST "Normal");
 		xmlNewChild(emergency_node, NULL, BAD_CAST "mcpttBoolean",
         BAD_CAST"true");
 
 
 	}

 	dataOut=xml_to_string(doc);
 	output=tsk_buffer_create(dataOut,tsk_strlen(dataOut));
 	/*if(doc)
 		xmlFreeDoc(doc);
 	if(root_node)
 		xmlFreeNode(root_node);
 	if(ns)
 		xmlFreeNs(ns);
 	if(xsi)
 		xmlFreeNs(xsi);*/
 	
 
 #else
 	
 	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>";//String
 	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* tabInitRequestUriOld =  "<mcptt-request-uri>";
 	const char* tabInitRequestUri =  "<mcptt-request-uri type=\"Normal\">";
 	const char* tabEndRequestUri =  "</mcptt-request-uri>\r\n";
 	const char* tail =  "</mcptt-Params>\r\n"
 						"</mcpttinfo>\r\n";
 	
 	if(ptsip_stack_t->pttMCPTT.mcptt_namespace!=tsk_false){
 		tsk_buffer_append_2(output, "%s", head);
 	}else{
 		tsk_buffer_append_2(output, "%s", headout);
 	}
 	if((TSIP_DIALOG_GET_SS(self)->media.type & tmedia_audio_ptt_group_mcptt) != tmedia_audio_ptt_group_mcptt){
 		//<session-type>
 		tsk_buffer_append_2(output, "%s", tabInitSessionType);
 		tsk_buffer_append_2(output, "%s", "private");
 		tsk_buffer_append_2(output, "%s", tabEndSessionType);
 		//<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);
 		*/
 		
 	}else{
 		//<session-type>
 		tsk_buffer_append_2(output, "%s", tabInitSessionType);
 		tsk_buffer_append_2(output, "%s", "prearranged");
 		tsk_buffer_append_2(output, "%s", tabEndSessionType);
 		//<mcptt-request-uri>
 
 			tsk_buffer_append_2(output, "%s", tabInitRequestUri);
 			tsk_buffer_append_2(output, "%s", tabInitMcpttURI);
 		tsk_buffer_append_2(output, "%s", TSIP_DIALOG_GET_SS(self)->pttMCPTT.ptt_group_uri);
 			tsk_buffer_append_2(output, "%s", tabEndMcpttURI);
 		tsk_buffer_append_2(output, "%s", tabEndRequestUri);
 		
 	}
 	tsk_buffer_append_2(output, "%s", tail);
 		
 	
 	
 #endif	
 	return output;
 }
 
 

 static char* xml_to_string(xmlDocPtr doc)
 {
 	char* out;
     xmlChar *s;
     int size;

 	xmlDocDumpFormatMemoryEnc(doc, &s, &size, "UTF-8", 1);
 	//xmlDocDumpMemory(doc, &s, &size);

 	#if HAVE_CRT //Debug memory

 		out = malloc(strlen((char *)s)+1);

 	#else

 		out = tsk_malloc(strlen((char *)s)+1);

 	#endif //HAVE_CRT

 	strcpy(out,(char *)s);
     xmlFree(s);
 	return out;
 }
 
 

 static tsk_buffer_t* tsip_dialog_200ok_create_mcpttinfo(const tsip_dialog_invite_t* self)
 {
 	tsip_stack_t* ptsip_stack_t;
 	tsk_buffer_t* output = tsk_buffer_create_null();
 	/*
 #if HAVE_LIBXML2
 	ret = tsk_null;
 #else*/
 	const char* tabInitMcpttURI= "<mcpttURI>";
 	const char* tabEndMcpttURI= "</mcpttURI>\r\n";
 	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-called-party-id type=\"Normal\">";
 	const char* tabInitMCPTTID_old =  "<mcptt-called-party-id>";
 	const char* tabEndMCPTTID =  "</mcptt-called-party-id>\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);
 	}
 	//<<mcptt-called-party-id>>
 		tsk_buffer_append_2(output, "%s", tabInitMCPTTID);
 		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", tabEndMCPTTID);
 	tsk_buffer_append_2(output, "%s", tail);
 		
 
 	
 	return output;
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 //========================================================
 //	SIP dialog INVITE object definition
 //
 static tsk_object_t* tsip_dialog_invite_ctor(tsk_object_t * self, va_list * app)
 {
 	tsip_dialog_invite_t *dialog = self;
 	if(dialog){
 		tsip_ssession_handle_t *ss = va_arg(*app, tsip_ssession_handle_t *);
 		const char* call_id = va_arg(*app, const char *);
 
 		/* Initialize base class */
 		tsip_dialog_init(TSIP_DIALOG(self), tsip_dialog_INVITE, call_id, ss, _fsm_state_Started, _fsm_state_Terminated);
 
 		/* FSM */
 		TSIP_DIALOG_GET_FSM(dialog)->debug = DEBUG_STATE_MACHINE;
 		tsk_fsm_set_callback_terminated(TSIP_DIALOG_GET_FSM(dialog), TSK_FSM_ONTERMINATED_F(tsip_dialog_invite_OnTerminated), (const void*)dialog);
 
 		/* default values */		
 		dialog->supported._100rel = ((tsip_ssession_t*)ss)->media.enable_100rel;
 		dialog->supported.norefersub = tsk_true;
 		dialog->required.ice = (((tsip_ssession_t*)ss)->media.profile == tmedia_profile_rtcweb);
 		dialog->supported.ice = (dialog->required.ice || ((tsip_ssession_t*)ss)->media.enable_ice);
 #if 0 /* This was a patch for chrome but no longer needed when using version 23.0.1271.64 or later */
 		dialog->ice.is_jingle = (((tsip_ssession_t*)ss)->media.profile == tmedia_profile_rtcweb);
 #else
 		dialog->ice.is_jingle = tsk_false;
 #endif
 		dialog->ice.last_sdp_ro_ver = -1;
 		dialog->use_rtcp = (((tsip_ssession_t*)ss)->media.profile == tmedia_profile_rtcweb) ? tsk_true : ((tsip_ssession_t*)ss)->media.enable_rtcp;
 		dialog->use_rtcpmux = (((tsip_ssession_t*)ss)->media.profile == tmedia_profile_rtcweb) ? tsk_true : ((tsip_ssession_t*)ss)->media.enable_rtcpmux;
 
 		dialog->ice.last_action_id = tsk_fsm_state_none;
 		dialog->refersub = tsk_true;
 		// ... do the same for preconditions, replaces, ....
 		
 		/* Initialize the class itself */
 		tsip_dialog_invite_init(self);
 	}
 	return self;
 }
 
 static tsk_object_t* tsip_dialog_invite_dtor(tsk_object_t * _self)
 { 
 	tsip_dialog_invite_t *self = _self;
 	if(self){
 		// Cancel all timers
 		tsip_dialog_invite_stimers_cancel(self);
 		tsip_dialog_invite_qos_timer_cancel(self);
 		TSIP_DIALOG_TIMER_CANCEL(shutdown);
 		TSIP_DIALOG_TIMER_CANCEL(100rel);
 
 		// DeInitialize base class
 		tsip_dialog_deinit(TSIP_DIALOG(self));
 		
 		// DeInitialize self
 		TSK_OBJECT_SAFE_FREE(self->ss_transf);
 		TSK_OBJECT_SAFE_FREE(self->msession_mgr);
 		
 		TSK_OBJECT_SAFE_FREE(self->last_oInvite);
 		TSK_OBJECT_SAFE_FREE(self->last_iInvite);
 		TSK_OBJECT_SAFE_FREE(self->last_o1xxrel);
 		TSK_OBJECT_SAFE_FREE(self->last_iRefer);
 		TSK_FREE(self->stimers.refresher);
 		
 		TSK_OBJECT_SAFE_FREE(self->ice.ctx_audio);
 		TSK_OBJECT_SAFE_FREE(self->ice.ctx_video);
 		TSK_OBJECT_SAFE_FREE(self->ice.last_action);
 		TSK_OBJECT_SAFE_FREE(self->ice.last_message);
 		//...
 
 		TSK_DEBUG_INFO("*** INVITE Dialog destroyed ***");
 	}
 	return self;
 }
 
 static int tsip_dialog_invite_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_invite_def_s = 
 {
 	sizeof(tsip_dialog_invite_t),
 	tsip_dialog_invite_ctor, 
 	tsip_dialog_invite_dtor,
 	tsip_dialog_invite_cmp, 
 };
 const tsk_object_def_t *tsip_dialog_invite_def_t = &tsip_dialog_invite_def_s;