LTE_NR.c

Go to the documentation of this file.

/************************************************************************************
* Copyright (C) 2021                                                                *
* TETCOS, Bangalore. India                                                          *
*                                                                                   *
* Tetcos owns the intellectual property rights in the Product and its content.      *
* The copying, redistribution, reselling or publication of any or all of the        *
* Product or its content without express prior written consent of Tetcos is         *
* prohibited. Ownership and / or any other right relating to the software and all   *
* intellectual property rights therein shall remain at all times with Tetcos.       *
*                                                                                   *
* This source code is licensed per the NetSim license agreement.                    *
*                                                                                   *
* No portion of this source code may be used as the basis for a derivative work,    *
* or used, for any purpose other than its intended use per the NetSim license       *
* agreement.                                                                        *
*                                                                                   *
* This source code and the algorithms contained within it are confidential trade    *
* secrets of TETCOS and may not be used as the basis for any other software,        *
* hardware, product or service.                                                     *
*                                                                                   *
* Author:    Shashi Kant Suman                                                      *
*                                                                                   *
* ----------------------------------------------------------------------------------*/
 
#pragma region HEADER_FILES
#include "stdafx.h"
#include "LTENR_SDAP.h"
#include "LTENR_NSA.h"
#include "LTENR_Multiplexing.h"
#pragma endregion
 
#pragma region VARIABLE_AND_FUN_DEF
static bool isLTENRConfigured = false;
static bool isLTENRTraceConfigured = false;
static bool isCalledOnce = false;
static bool isMetricsCalled = false;
//Function prototype
int fn_NetSim_LTE_NR_Init_F();
int fn_NetSim_LTE_NR_Configure_F(void** var);
int fn_NetSim_LTE_NR_Finish_F();
#pragma endregion
 
#pragma region LTENR_INIT
_declspec(dllexport) int fn_NetSim_LTE_NR_Init()
{
    if (!isCalledOnce)
    {
        LTENR_fn_InterferenceInit();
        fn_NetSim_LTENR_HARQ_Init();
        LTENR_RadioMeasurements_Init();
        fn_NetSim_LTE_MAC_PRBLOG();
        isCalledOnce = true;
    }
    return fn_NetSim_LTE_NR_Init_F();
}
#pragma endregion
 
#pragma region LTENR_RUN
_declspec(dllexport) int fn_NetSim_LTE_NR_Run()
{
    if (pstruEventDetails->nSubEventType)
    {
        LTENR_SUBEVENT_CALL();
        return 0;
    }
    
    switch (pstruEventDetails->nEventType)
    {
        case APPLICATION_IN_EVENT: 
        {
            NetSim_PACKET* packet = pstruEventDetails->pPacket;
            switch (packet->nControlDataType)
            {
                case LTENR_MSG_CORE_INITIAL_UE_MESSAGE:
                case LTENR_MSG_CORE_CREATE_SESSION_RESPONSE:
                case LTENR_MSG_CORE_INITIAL_CONTEXT_SETUP_RESPONSE:
                case LTENR_MSG_CORE_REGISTRATION_COMPLETE:
                case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
                case LTENR_MSG_CORE_MODIFY_BEARER_RESPONSE:
                    fn_NetSim_LTENR_AMF_PACKET_HANDLER();
                    break;
                case LTENR_MSG_CORE_CREATE_SESSION_REQUEST:
                case LTENR_MSG_CORE_PFCP_SESSION_REQUSET:
                case LTENR_MSG_CORE_PFCP_SESSION_RESPONSE:
                case LTENR_MSG_CORE_MODIFY_BEARER_REQUEST:
                    fn_NetSim_LTENR_SMF_UPF_PACKET_HANDLER();
                    break;
                case LTENR_MSG_CORE_INITIAL_CONTEXT_SETUP_REQUEST:
                case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
                    fn_NetSim_LTENR_GNB_CORE_PACKET_HANDLER();
                    break;
            }
        }
        break;
        case NETWORK_OUT_EVENT:
        {
            NETSIM_ID d = pstruEventDetails->nDeviceId;
            NETSIM_ID in = pstruEventDetails->nInterfaceId;
            ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
            if (data->deviceType == LTENR_DEVICETYPE_EPC) {
                LTENR_CallEPCOut();
                break;
            }
 
            NetSim_PACKET* packet = pstruEventDetails->pPacket;
            NETSIM_ID dest = get_first_dest_from_packet(packet);
 
            if (isGNB(d, in))
            {
                if (data->IFType == nGC_INTERFACE_XN)
                {
                    gNB_N3_Forward_packet_to_MAC(d, in, packet);
                    pstruEventDetails->pPacket = NULL;
                    break;
                }
            }
 
            if (dest == d) break;
 
            if (isGNB(d, in))
            {
                if (data->IFType == nGC_INTERFACE_N3 || data->IFType == nGC_INTERFACE_LTE_S1)
                {
                    gNB_N3_Forward_packet_to_MAC(d, in, packet);
                    pstruEventDetails->pPacket = NULL;
                    break;
                }
            }
 
            if (isUPF(d)) {
                if (data->isDCEnable && fn_NetSim_LTENR_NSA_IS_CORE_SPLIT_EXISTS(d, in)) {
                    NETSIM_ID splitID = fn_NetSim_LTENR_NSA_Splitting_Alogrithm_For_EPC(dest);
 
                    if (!splitID)
                    {
                        //Drop the Packet
                        packet->nPacketStatus = PacketStatus_Buffer_Dropped;
                        packet->nReceiverId = get_first_dest_from_packet(packet);
                        fn_NetSim_WritePacketTrace(packet);
                        fn_NetSim_Packet_FreePacket(packet);
                        pstruEventDetails->pPacket = NULL;
                        break;
                    }
 
                    NETSIM_ID splitIF = fn_NetSim_LTENR_CORE_INTERFACE(splitID, nGC_INTERFACE_N3);
                    packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(splitID, splitIF));
                    packet->nReceiverId = splitID;
                }
                gNB_N3_Forward_packet_to_MAC(d, in, packet);
                pstruEventDetails->pPacket = NULL;
                break;
            }
        }
        break;
        case NETWORK_IN_EVENT:
        {
            NETSIM_ID d = pstruEventDetails->nDeviceId;
            NETSIM_ID in = pstruEventDetails->nInterfaceId;
            NetSim_PACKET* packet = pstruEventDetails->pPacket;
 
            if (isLTENRControlPacket(packet) == false &&
                !fn_NetSim_LTENR_NSA_IS_CORE_SPLIT_EXISTS(d, in)) 
            {
                ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
                if (data->IFType == nGC_INTERFACE_XN && isGNB(d,in))
                {
                    ptrLTENR_XN_HDR hdr = packet->pstruNetworkData->Packet_NetworkProtocol;
                    if (hdr->flag) 
                    {
                        packet->pstruNetworkData->Packet_NetworkProtocol = NULL;
                        packet->pstruMacData->Packet_MACProtocol = hdr->msg;
                        NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
                        packet->nTransmitterId = d;
                        packet->nReceiverId = hdr->UEID;
                        if (fn_NetSim_isDeviceLTENR(d, in))
                            packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE_NR;
                        else
                            packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE;
                        packet->pstruNetworkData->szGatewayIP = STR_TO_IP4(hdr->gateway);
                        packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(hdr->UEID, hdr->UEIF));
                        LTENR_NSA_XN_INTERFACE_TO_RAN(d, RANIF, packet);
                    }
                    else 
                    {
                        NETSIM_ID RANIF;
                        if (fn_NetSim_LTENR_IS_S1_INTERFACE_EXISTS(d)) 
                        {
                            RANIF = fn_NetSim_LTENR_CORE_INTERFACE(d, nGC_INTERFACE_LTE_S1);
                            NETSIM_ID r, rin;
                            fn_NetSim_Stack_GetConnectedDevice(d, RANIF, &r, &rin);
                            packet->pstruNetworkData->szGatewayIP = IP_COPY(DEVICE_NWADDRESS(hdr->UEID, hdr->UEIF));
                            packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(r, rin));
                            packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE;
                        }
                        else 
                        {
                            packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE_NR;
                            RANIF = fn_NetSim_LTENR_CORE_INTERFACE(d, nGC_INTERFACE_N3);
                            ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(d, 
                                fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d));
                            packet->pstruNetworkData->szGatewayIP = IP_COPY(DEVICE_NWADDRESS(d, in));
                            NETSIM_ID r = fn_NetSim_Stack_GetDeviceId_asName(pd->connectedUPFName);
                            NETSIM_ID rin = fn_NetSim_LTENR_CORE_INTERFACE(r, nGC_INTERFACE_N3);
                            packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(r, rin));
                        }
                        gNB_N3_Forward_packet_to_MAC(d, RANIF, packet);
                    }
                    free(hdr);
                    pstruEventDetails->pPacket = NULL;
                    break;
                }
            }
 
            if (isGNB(d, in))
            {
                ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
                if (data->IFType == nGC_INTERFACE_N3 && isLTENRControlPacket(packet) == false)
                {
                    NETSIM_ID RANIF = 0;
                    if (fn_NetSim_isDeviceLTENR(d, in))
                        RANIF = fn_NetSim_FIND_LTENR_INTERFACE(d);
                    else
                        RANIF = fn_NetSim_FIND_LTE_INTERFACE(d);
                    gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
                    pstruEventDetails->pPacket = NULL;
                    break;
                }
                if (data->IFType == nGC_INTERFACE_LTE_S1 && isLTENRControlPacket(packet) == false)
                {
                    NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
                    gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
                    pstruEventDetails->pPacket = NULL;
                    break;
                }
            }
 
            switch (pstruEventDetails->pPacket->nControlDataType)
            {
                case LTENR_MSG_NAS_HANDOVER_REQUEST:
                case LTENR_MSG_NAS_HANDOVER_REQUEST_ACK:
                case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE:
                case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK:
                    if (!isEPC(d,in)) {
                        ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
                        if (data->IFType == nGC_INTERFACE_LTE_S1) {
                            NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
                            fn_NetSim_LTENR_LTE_S1_CONTROL_PACKET_TO_RAN(d, RANIF, packet);
                        }
                        else {
                            fn_NetSim_LTENR_Handover_RECV();
                        }
                        pstruEventDetails->pPacket = NULL;
                    }
                    else
                        fn_NetSim_LTENR_EPC_RouteHOPacket();
                    break;
                case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
                case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
                    LTENR_CallNASIn();
                    pstruEventDetails->pPacket = NULL;
                    break;
                case LTENR_MSG_DC_SEC_CELL_ADDITION_REQUEST:
                case LTENR_MSG_DC_SEC_CELL_ADDITION_RESPONSE:
                    if (!isEPC(d,in)) {
                        fn_NetSim_LTENR_NSA_RECV();
                        pstruEventDetails->pPacket = NULL;
                    }
                    else
                        fn_NetSim_LTENR_EPC_RouteHOPacket();
                    break;
                case LTENR_MSG_DC_HO_SEC_CELL_ADDITION_REQUEST:
                case LTENR_MSG_DC_HO_SEC_CELL_ADDITION_REQUEST_ACK:
                case LTENR_MSG_DC_HO_SEC_CELL_RELEASE_REQUEST:
                case LTENR_MSG_DC_HO_SEC_CELL_RELEASE_REQUEST_ACK:
                case LTENR_MSG_DC_HO_SEC_CELL_UE_CONTEXT_RELEASE:
                case LTENR_MSG_DC_HO_SEC_CELL_UE_CONTEXT_RELEASE_ACK:
                    if (!isEPC(d, in)) {
                        fn_NetSim_SN_HANDOVER_PACKET_HANDLER();
                        pstruEventDetails->pPacket = NULL;
                    }
                    else
                        fn_NetSim_LTENR_EPC_RouteHOPacket();
                    break;
                default:
                {
                    if (isGNB(d, in)) {
                        NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
                        gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
                        pstruEventDetails->pPacket = NULL;
                    }
                }
                    break;
            }
        }
        break;
        case MAC_OUT_EVENT:
        {
            bool isMore = true;
            NetSim_BUFFER* buffer = DEVICE_ACCESSBUFFER(pstruEventDetails->nDeviceId,pstruEventDetails->nInterfaceId);
            NetSim_PACKET* packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 0);
            switch (packet->nControlDataType)
            {
            case LTENR_MSG_NAS_HANDOVER_REQUEST:
            case LTENR_MSG_NAS_HANDOVER_REQUEST_ACK:
            case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
            case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE:
            case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK:
                packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 1);
                pstruEventDetails->pPacket = packet;
                LTENR_CallNASIn();
                break;
            case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
                packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 1);
                break;
            default:
                while (isMore)
                {
                    isMore = LTENR_GET_PACKET_FROM_ACCESS_BUFFER();
                    LTENR_CallSDAPOut();
                }
                break;
            }
        }
        break;
        case MAC_IN_EVENT:
            LTENR_CallMACIn();
            break;
        case PHYSICAL_OUT_EVENT:
            fn_NetSim_LTENR_HandlePhyOut();
            break;
        case PHYSICAL_IN_EVENT:
        {
            if (!isLTENRControlPacket(pstruEventDetails->pPacket))
            {
                fn_NetSim_Metrics_Add(pstruEventDetails->pPacket);
            }
            fn_NetSim_WritePacketTrace(pstruEventDetails->pPacket);
 
            pstruEventDetails->nEventType = MAC_IN_EVENT;
            fnpAddEvent(pstruEventDetails);
        }
            break;
        default:
            fnNetSimError("LTE-NR, Unknown event type %d.\n",
                          pstruEventDetails->nEventType);
            break;
    }
    return 0;
}
#pragma endregion
 
#pragma region LTENR_TRACE
_declspec(dllexport) char* fn_NetSim_LTE_NR_Trace(NETSIM_ID id)
{
    return LTENR_SUBEVNET_NAME(id);
}
#pragma endregion
 
#pragma region FREE_PACKET
_declspec(dllexport) int fn_NetSim_LTE_NR_FreePacket(NetSim_PACKET* packet)
{
    LTENR_MSG_FREE(packet);
    return 0;
}
#pragma endregion
 
#pragma region COPY_PACKET
_declspec(dllexport) int fn_NetSim_LTE_NR_CopyPacket(NetSim_PACKET* destPacket, const NetSim_PACKET* srcPacket)
{
    if (srcPacket->pstruMacData->nMACProtocol == MAC_PROTOCOL_LTE ||
        srcPacket->pstruMacData->nMACProtocol == MAC_PROTOCOL_LTE_NR)
    {
        ptrLTENR_MSG smsg = srcPacket->pstruMacData->Packet_MACProtocol;
        ptrLTENR_MSG dmsg = LTENR_MSG_COPY(srcPacket);
        destPacket->pstruMacData->Packet_MACProtocol = dmsg;
 
    }
    if (srcPacket->pstruAppData) {
        if (srcPacket->pstruAppData->nApplicationProtocol == MAC_PROTOCOL_LTE_NR) {
            destPacket->pstruAppData->Packet_AppProtocol = LTENR_MSG_APP_COPY(srcPacket);
            return 0;
        }
    }
    return 0;
}
#pragma endregion
 
#pragma region LTENR_MATRICS
_declspec(dllexport) int fn_NetSim_LTE_NR_Metrics(PMETRICSWRITER file)
{
    if (!isMetricsCalled)
    {
        fn_NetSim_LTENR_Cell_Metrics_F(file);
        //fn_NetSim_LTENR_SDAP_Metrics_F(file);
        // return fn_NetSim_LTE_Metrics_F(file);
        isMetricsCalled = true;
    }
    return 0;
}
#pragma endregion
 
#pragma region LTENR_CONFIG
_declspec(dllexport) int fn_NetSim_LTE_NR_Configure(void** var)
{
    isLTENRConfigured = true;
    return fn_NetSim_LTE_NR_Configure_F(var);
}
#pragma endregion
 
#pragma region CONFIG_PACKET_TRACE
_declspec(dllexport) char* fn_NetSim_LTE_NR_ConfigPacketTrace(void* xmlNetSimNode)
{
    if (isLTENRConfigured)
    {
        string szStatus;
        szStatus = fn_NetSim_xmlConfigPacketTraceField(xmlNetSimNode, "LTENR_PACKET_INFO");
        if (!_stricmp(szStatus, "ENABLE"))
        {
            isLTENRTraceConfigured = true;
            free(szStatus);
            return "LTENR_PACKET_INFO,";
        }
        free(szStatus);
        return "";
    }
    else
        return "";
}
#pragma endregion
 
#pragma region LTENR_FINISH
#include "NetSim_utility.h"
_declspec(dllexport) int fn_NetSim_LTE_NR_Finish()
{
    netsim_matlab_interface_close();
    fn_NetSim_LTENR_HARQ_Finish();
    LTENR_FreeBLERTable();
    LTENR_RadioMeasurements_Finish();
    close_ltenr_PRB_log();
    return fn_NetSim_LTE_NR_Finish_F();
}
#pragma endregion
 
#pragma region WRITE_PACKET_TRACE
_declspec(dllexport) int fn_NetSim_LTE_NR_WritePacketTrace(NetSim_PACKET* pstruPacket, char** ppszTrace)
{
    if (!isLTENRTraceConfigured)
        return -1;
 
 
    char* s = calloc(2*BUFSIZ, sizeof * s);
    *ppszTrace = s;
 
    if (pstruPacket->pstruAppData) {
        if (pstruPacket->pstruAppData->nApplicationProtocol == MAC_PROTOCOL_LTE_NR) {
            LTENR_MSG_WriteTrace_APP(pstruPacket, s);
            return 0;
        }
    }
 
    if (pstruPacket->pstruMacData->nMACProtocol != MAC_PROTOCOL_LTE_NR && 
        pstruPacket->pstruMacData->nMACProtocol != MAC_PROTOCOL_LTE)
    {
        strcpy(s, "N/A,");
        return -2;
    }
 
    LTENR_MSG_WriteTrace(pstruPacket, s);
    return 0;
}
#pragma endregion
 
#pragma region LOG_TRIGGER_FUN
bool get_ltenr_log_status()
{
#ifdef LTENR_LOG_DEV
    return true;
#else
    return false;
#endif
}
 
 
#pragma region SET_FAST_PERFORMANCE
void set_fast_performance()
{
    for (NETSIM_ID i = 0; i < NETWORK->nDeviceCount; i++)
    {
        for (NETSIM_ID j = 0; j < DEVICE(i + 1)->nNumOfInterface; j++)
        {
            if (!isLTE_NRInterface(i + 1, j + 1)) continue;
 
            ptrLTENR_SDAPVAR sdap = LTENR_SDAP_GET(i + 1, j + 1);
            if(sdap) sdap->isSDAPDisabled = true;
        }
    }
}
#pragma endregion
 
int LTENR_ConvertStrToEnumWithErrorMsg(const char** enumstr, const char* str, int length, char* name)
{
    int i;
    for (i = 0; i < length; i++)
    {
        if (!_stricmp(enumstr[i], str))
            return i;
    }
 
    fnNetSimError("Unknown value %s for %s. The value must be in following.\n",
        str, name);
    for (i = 0; i < length; i++)
        fprintf(stderr, "\t%d. %s\n", i + 1, enumstr[i]);
    fprintf(stderr, "\n");
    return 0;
}