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

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

 *
 * Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
 *       
 * This file is part of MCOP MCPTT Client
 *
 * This 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.
 *       
 * This is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU General Public License for more details.
 *       
 * You should have received a copy of the GNU General Public License along 
 * with this program; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 /**@file tnet_mbms.c
  * @brief 3GPP MBMS
  */
 
 #include "tnet_mbms.h"
 
 #include "../tnet_endianness.h"
 
 #include "tsk_string.h"
 #include "tsk_memory.h"
 #include "tsk_debug.h"
 
 #include <string.h>
 
 tnet_mbms_ctx_t* tnet_mbms_ctx_create()
 {
 	return tsk_object_new(tnet_mbms_ctx_def_t);
 }
 
 
 tsk_bool_t tnet_mbms_check_network_tmgi(tnet_mbms_ctx_t* ctx)
 {
 	if(ctx == tsk_null)
 		return tsk_false;
 
 	if (ctx->mbms_service_id == tsk_null || 
 		ctx->mcc == tsk_null || 
 		ctx->mnc == tsk_null ||
 	    ctx->mbms_service_id_length != TNET_MBMS_SERVICE_ID_SIZE || 
 		ctx->mcc_length != TNET_MBMS_MCC_SIZE || 
 		ctx->mnc_length < 2 ||
 		ctx->mnc_length > 3)
 	{
 		return tsk_false;
 	}
 
 	//TODO: Need to check MBMS Service ID and MCC/MNC values in MBSFNAreaConfiguration and SystemInformationBlockType1 messages (LTE)
 	return tsk_true;
 }
 
 tsk_bool_t tnet_mbms_parse_tmgi(tnet_mbms_ctx_t* ctx, uint8_t* tmgi, tsk_size_t tmgi_size)
 {
 	tsk_bool_t ret = tsk_false;
 	uint8_t* p;
 
 	if(ctx == tsk_null)
 		return tsk_false;
 
 	if(tmgi_size != TNET_MBMS_TMGI_SIZE)
 		return tsk_false;
 
 	if(tmgi == tsk_null)
 		return tsk_false;
 
 	#if HAVE_CRT //Debug memory
 	ctx->tmgi = (uint8_t*)calloc(TNET_MBMS_TMGI_SIZE, sizeof(uint8_t));
 		
 	#else
 		
 	ctx->tmgi = (uint8_t*)tsk_calloc(TNET_MBMS_TMGI_SIZE, sizeof(uint8_t));
 	#endif //HAVE_CRT
 	if(ctx->tmgi == tsk_null)
 		goto bail;
 	memcpy(ctx->tmgi, tmgi, tmgi_size);
 	ctx->tmgi_size = TNET_MBMS_TMGI_SIZE;
 	p = ctx->tmgi;
 	#if HAVE_CRT //Debug memory
 	ctx->mbms_service_id = (uint8_t*)calloc(TNET_MBMS_SERVICE_ID_SIZE, sizeof(uint8_t));
 		
 	#else
 	ctx->mbms_service_id = (uint8_t*)tsk_calloc(TNET_MBMS_SERVICE_ID_SIZE, sizeof(uint8_t));
 		
 	#endif //HAVE_CRT
 	if(ctx->mbms_service_id == tsk_null)
 	{
 		TSK_FREE(ctx->tmgi);
 		ctx->tmgi_size = 0;
 		goto bail;
 	}
 	memcpy(ctx->mbms_service_id, p, TNET_MBMS_SERVICE_ID_SIZE);
 	ctx->mbms_service_id_length = TNET_MBMS_SERVICE_ID_SIZE;
 	p += TNET_MBMS_SERVICE_ID_SIZE;
 	#if HAVE_CRT //Debug memory
 	ctx->mcc = (uint8_t*)calloc(TNET_MBMS_MCC_SIZE, sizeof(uint8_t));
 		
 	#else
 	ctx->mcc = (uint8_t*)tsk_calloc(TNET_MBMS_MCC_SIZE, sizeof(uint8_t));
 		
 	#endif //HAVE_CRT
 	if(ctx->mcc == tsk_null)
 	{
 		TSK_FREE(ctx->tmgi);
 		ctx->tmgi_size = 0;
 		TSK_FREE(ctx->mbms_service_id);
 		ctx->mbms_service_id_length = 0;
 		goto bail;
 	}
 	ctx->mcc[0] = p[0] & 0x0F;
 	ctx->mcc[1] = (p[0] & 0xF0) >> 4;
 	ctx->mcc[2] = p[1] & 0x0F; 
 	ctx->mcc_length = TNET_MBMS_MCC_SIZE;
 	
 	if(((p[1] & 0xF0) >> 4) == 0x0F)
 	{
 		ctx->mnc_length = 2;
 		#if HAVE_CRT //Debug memory
 		ctx->mnc = (uint8_t*)calloc(ctx->mnc_length, sizeof(uint8_t));
 		
 		#else
 		ctx->mnc = (uint8_t*)tsk_calloc(ctx->mnc_length, sizeof(uint8_t));
 		
 		#endif //HAVE_CRT
 		if(ctx->mnc == tsk_null)
 		{
 			TSK_FREE(ctx->tmgi);
 			ctx->tmgi_size = 0;
 			TSK_FREE(ctx->mbms_service_id);
 			ctx->mbms_service_id_length = 0;
 			TSK_FREE(ctx->mcc);
 			ctx->mcc_length = 0;
 			ctx->mnc_length = 0;
 			goto bail;
 		}
 		ctx->mnc[0] = p[2] & 0x0F;
 		ctx->mnc[1] = (p[2] & 0xF0) >> 4;
 	}
 	else
 	{
 		ctx->mnc_length = 3;
 		#if HAVE_CRT //Debug memory
 		ctx->mnc = (uint8_t*)calloc(ctx->mnc_length, sizeof(uint8_t));
 		
 	#else
 		ctx->mnc = (uint8_t*)tsk_calloc(ctx->mnc_length, sizeof(uint8_t));
 		
 	#endif //HAVE_CRT
 		if(ctx->mnc == tsk_null)
 			goto bail;
 		ctx->mnc[0] = p[2] & 0x0F;
 		ctx->mnc[1] = (p[2] & 0xF0) >> 4;
 		ctx->mnc[2] = (p[1] & 0xF0) >> 4;
 	}
 
 	ret = tsk_true;
 
 bail:
 	return ret;
 }
 
 
 //=================================================================================================
 //	[[MBMS CONTEXT]] object definition
 //
 static tsk_object_t* tnet_mbms_ctx_ctor(tsk_object_t * self, va_list * app)
 {
 	tnet_mbms_ctx_t *ctx = self;
 	if (ctx){
 
 		ctx->tmgi = tsk_null;
 		ctx->tmgi_size = 0;
 		ctx->mbms_service_id = tsk_null;
 		ctx->mbms_service_id_length = 0;
 		ctx->mcc = tsk_null;
 		ctx->mcc_length = 0;
 		ctx->mnc = tsk_null;
 		ctx->mnc_length = 0;
 
 		tsk_safeobj_init(ctx);
 	}
 	return self;
 }
 
 static tsk_object_t* tnet_mbms_ctx_dtor(tsk_object_t * self)
 {
 	tnet_mbms_ctx_t *ctx = self;
 	if (ctx){
 		tsk_safeobj_deinit(ctx);
 
 		TSK_FREE(ctx->tmgi);
 		TSK_FREE(ctx->mbms_service_id);
 		TSK_FREE(ctx->mcc);
 		TSK_FREE(ctx->mnc);
 
 	}
 	return self;
 }
 
 static const tsk_object_def_t tnet_mbms_ctx_def_s =
 {
 	sizeof(tnet_mbms_ctx_t),
 	tnet_mbms_ctx_ctor,
 	tnet_mbms_ctx_dtor,
 	tsk_null,
 };
 const tsk_object_def_t *tnet_mbms_ctx_def_t = &tnet_mbms_ctx_def_s;