1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
18 #include "common_def.h"
24 #include "du_app_mac_inf.h"
25 #include "du_app_rlc_inf.h"
26 #include "du_e2ap_mgr.h"
27 #include "du_e2ap_msg_hdl.h"
30 #include "du_mgr_main.h"
32 #include "GlobalE2node-gNB-ID.h"
33 #include "ProtocolIE-FieldE2.h"
34 #include "E2setupRequest.h"
35 #include "InitiatingMessageE2.h"
36 #include "SuccessfulOutcomeE2.h"
37 #include "UnsuccessfulOutcomeE2.h"
39 #include "odu_common_codec.h"
40 #include "E2nodeComponentInterfaceF1.h"
41 #include "E2setupRequest.h"
42 #include "du_e2_conversions.h"
44 /*******************************************************************
46 * @brief Builds Global gNodeB Params
50 * Function : BuildGlobalgNBId
52 * Functionality: Building the Plmn and gNB id
54 * @params[in] GlobalE2node_gNB_ID_t *gNbId
55 * @return ROK - success
58 ******************************************************************/
60 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
67 /* Allocate Buffer size */
68 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
69 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
70 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
71 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
73 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
78 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
79 gNbId->global_gNB_ID.plmn_id.buf);
81 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
82 /* Allocate Buffer size */
83 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
84 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
85 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
86 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
87 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
89 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
94 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
100 /*******************************************************************
102 * @brief Builds E2 node config addition list
106 * Function : BuildE2NodeConfigAddList
108 * Functionality: Building E2 node config addition list
110 * @params[in] E2nodeComponentConfigAddition_List_t *e2NodeAddList
111 * @return ROK - success
114 ******************************************************************/
116 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList)
119 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe;
120 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem;
122 e2NodeAddList->list.count = 1;
123 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
124 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
125 if(e2NodeAddList->list.array == NULLP)
127 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
131 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
133 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
134 if(e2NodeAddList->list.array[arrIdx] == NULLP)
136 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
142 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
143 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
144 e2NodeAddItemIe->criticality = CriticalityE2_reject;
145 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
146 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
148 /* E2nodeComponentInterfaceType */
149 e2NodeAddItem->e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
151 /* E2 Node Component Request Part */
152 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size = duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize;
153 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
154 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
155 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf == NULLP)
157 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
161 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
162 duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, e2NodeAddItem->e2nodeComponentConfiguration.\
163 e2nodeComponentRequestPart.size);
165 /* E2 Node Component Response Part */
166 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size = duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize;
167 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
168 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
169 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf == NULLP)
171 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
174 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
175 duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, e2NodeAddItem->e2nodeComponentConfiguration.\
176 e2nodeComponentResponsePart.size);
178 /* E2 Node Component ID */
179 e2NodeAddItem->e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
180 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
181 sizeof(E2nodeComponentInterfaceF1_t));
182 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
184 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
187 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
188 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
189 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
191 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
193 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
196 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[arrIdx] = duCfgParam.duId;
201 /*******************************************************************
203 * @brief De Allocate E2 Setup Request Message
207 * Function : FreeE2SetupReq
209 * Functionality: De-Allocating E2 Setup request Message
211 * @params[in] E2AP_PDU_t *e2apMsg
215 * ****************************************************************/
217 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
220 uint8_t e2NodeAddListIdx =0;
221 E2setupRequest_t *e2SetupReq;
222 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
223 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
225 /* De-allocating Memory */
228 if(e2apMsg->choice.initiatingMessage != NULLP)
230 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
231 if(e2SetupReq->protocolIEs.list.array != NULLP)
233 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
235 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
237 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
239 case ProtocolIE_IDE2_id_TransactionID:
241 case ProtocolIE_IDE2_id_GlobalE2node_ID:
243 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
244 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
246 GlobalE2node_gNB_ID_t *gNbId = NULLP;
247 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
248 value.choice.GlobalE2node_ID.choice.gNB;
249 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
251 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
252 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
253 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
254 gNbId->global_gNB_ID.plmn_id.size);
256 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
257 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
261 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
263 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
264 if(e2NodeAddList->list.array)
266 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
268 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
270 /* Free E2 Node Component Request Part */
271 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
272 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
274 /* Free E2 Node Component Response Part */
275 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
276 e2nodeComponentResponsePart.buf, \
277 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
279 /* Free E2 Node Component ID */
280 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
282 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
283 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
284 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
285 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
286 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
287 sizeof(E2nodeComponentInterfaceF1_t));
289 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
291 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
296 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
297 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
300 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
303 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
305 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
307 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
311 /*******************************************************************
313 * @brief Builds and Send the E2SetupRequest
317 * Function : BuildAndSendE2SetupReq
319 * Functionality:Fills the E2SetupRequest
321 * @return ROK - success
324 ******************************************************************/
326 uint8_t BuildAndSendE2SetupReq()
328 uint8_t arrIdx = 0, elementCnt=0;
329 uint8_t transId = 0, ret = ROK;
331 E2AP_PDU_t *e2apMsg = NULLP;
332 E2setupRequest_t *e2SetupReq = NULLP;
333 asn_enc_rval_t encRetVal; /* Encoder return value */
335 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
338 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
341 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
344 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
345 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
346 if(e2apMsg->choice.initiatingMessage == NULLP)
348 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
351 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
352 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
353 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
354 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
357 e2SetupReq->protocolIEs.list.count = elementCnt;
358 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
360 /* Initialize the E2Setup members */
361 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
362 e2SetupReq->protocolIEs.list.size);
363 if(e2SetupReq->protocolIEs.list.array == NULLP)
365 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
368 for(arrIdx = 0; arrIdx < elementCnt; (arrIdx)++)
370 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx],\
371 sizeof(E2setupRequestIEs_t));
372 if(e2SetupReq->protocolIEs.list.array[arrIdx] == NULLP)
374 memAllocFailed = true;
375 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayarrIdx [%d]", arrIdx);
379 if(memAllocFailed == true)
385 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
386 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
387 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
388 transId = assignTransactionId();
389 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
392 /* GlobalE2node_gNB_ID */
393 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
394 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
395 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
396 e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
398 DU_ALLOC(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
399 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
400 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.\
401 GlobalE2node_ID.choice.gNB == NULLP)
403 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
408 ret = BuildGlobalgNBId(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
409 choice.GlobalE2node_ID.choice.gNB);
412 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
418 /* E2 Node Component Configuration Addition List */
419 e2SetupReq->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
420 e2SetupReq->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
421 e2SetupReq->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
422 if(BuildE2NodeConfigAddList(&(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List))!=ROK)
424 DU_LOG("\nERROR --> E2AP : Failed to E2 Node config addition list");
430 /* Prints the Msg formed */
431 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
433 memset(encBuf, 0, ENC_BUF_MAX_LEN);
435 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
437 if(encRetVal.encoded == ENCODE_FAIL)
439 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
440 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
445 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
446 #ifdef DEBUG_ASN_PRINT
447 for(int i=0; i< encBufSize; i++)
449 printf("%x",encBuf[i]);
453 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
455 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
460 duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId;
461 duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
463 FreeE2SetupReq(e2apMsg);
465 }/* End of BuildAndSendE2SetupReq */
467 /*******************************************************************
469 * @brief Builds Ric Request Id
473 * Function : BuildRicRequestId
475 * Functionality: Building the Ric Request Id
477 * @params[in] RICrequestID_t *ricReqId
478 * @return ROK - success
481 * ****************************************************************/
483 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
485 if(ricReqId == NULLP)
490 ricReqId->ricRequestorID = 1;
491 ricReqId->ricInstanceID = 1;
495 /*******************************************************************
497 * @brief Fills the mandatory RicAdmitted List Items
501 * Function : fillRicAdmitList
503 * Functionality: Fills the mandatory Ric Admitted List Items
505 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
506 * @return ROK - success
509 * ****************************************************************/
511 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
514 if(ricAdmitItems != NULLP)
516 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
517 ricAdmitItems->criticality = CriticalityE2_reject;
518 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
519 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
527 /*******************************************************************
529 * @brief Builds the mandatory RicAdmitted List Params
533 * Function : BuildRicAdmitList
535 * Functionality: Builds the mandatory Ric Admitted List Params
537 * @params[in] RICaction_Admitted_List_t *admitListPtr
538 * @return ROK - success
541 * ****************************************************************/
543 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
550 if(admitListPtr == NULLP)
552 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
557 admitListPtr->list.count = elementCnt;
558 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
559 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
560 if(admitListPtr->list.array == NULLP)
562 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
567 for(idx=0 ; idx<elementCnt ; idx++ )
569 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
570 if(admitListPtr->list.array[idx] == NULLP)
578 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
584 /*******************************************************************
586 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
590 * Function : FreeRicSubscriptionRsp
592 * Functionality:Free the RicSubscriptionRsp
594 * @param[in] E2AP_PDU_t *e2apRicMsg
599 ******************************************************************/
600 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
602 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
605 RICaction_Admitted_List_t *admitListPtr;
607 if(e2apRicMsg != NULLP)
609 if(e2apRicMsg->choice.successfulOutcome != NULLP)
611 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
612 if(ricSubscriptionRsp)
614 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
616 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
618 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
620 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
622 case ProtocolIE_IDE2_id_RICrequestID:
625 case ProtocolIE_IDE2_id_RANfunctionID:
628 case ProtocolIE_IDE2_id_RICactions_Admitted:
630 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
631 array[idx]->value.choice.RICaction_Admitted_List;
632 if(admitListPtr->list.array != NULLP)
634 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
636 if(admitListPtr->list.array[idx1] != NULLP)
638 DU_FREE(admitListPtr->list.array[idx1],
639 sizeof(RICaction_Admitted_ItemIEs_t));
642 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
649 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
650 sizeof(RICsubscriptionResponse_IEs_t));
653 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
654 ricSubscriptionRsp->protocolIEs.list.size);
657 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
659 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
662 /*******************************************************************
664 * @brief Builds and Send the RicSubscriptionRsp
668 * Function : BuildAndSendRicSubscriptionRsp
670 * functionality:Fills the RicSubscriptionRsp
672 * @return ROK - success
675 ******************************************************************/
676 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
680 uint8_t elementCnt = 0;
681 uint8_t BuildRicRequestIdret=ROK;
682 uint8_t BuildRicAdmitListret=ROK;
685 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
686 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
687 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
688 ricSubscriptionRsp->protocolIEs.list.size);
689 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
691 DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
696 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
698 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
699 sizeof(RICsubscriptionResponse_IEs_t));
700 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
709 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
710 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
711 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
712 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
713 BuildRicRequestIdret =
714 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
715 if(BuildRicRequestIdret != ROK)
722 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
723 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
724 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
725 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
726 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
729 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
730 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
731 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
732 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
733 BuildRicAdmitListret =
734 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
735 if(BuildRicAdmitListret != ROK)
744 /*******************************************************************
746 * @brief Builds and Send the RicSubscriptionRsp
750 * Function : BuildAndSendRicSubscriptionRsp
752 * Functionality:Fills the RicSubscriptionRsp
754 * @return ROK - success
757 ******************************************************************/
759 uint8_t BuildAndSendRicSubscriptionRsp()
762 E2AP_PDU_t *e2apRicMsg = NULLP;
763 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
764 asn_enc_rval_t encRetVal;
765 uint8_t ret = RFAILED;
766 uint8_t FillRicricSubscriptionRspret;
770 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
772 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
773 if(e2apRicMsg == NULLP)
775 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
778 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
779 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
780 if(e2apRicMsg->choice.successfulOutcome == NULLP)
782 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
786 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
787 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
788 e2apRicMsg->choice.successfulOutcome->value.present = \
789 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
790 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
792 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
793 if(FillRicricSubscriptionRspret != ROK)
795 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
799 /* Prints the Msg formed */
800 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
802 memset(encBuf, 0, ENC_BUF_MAX_LEN);
804 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
806 if(encRetVal.encoded == ENCODE_FAIL)
808 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
809 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
814 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
815 #ifdef DEBUG_ASN_PRINT
816 for(int i=0; i< encBufSize; i++)
818 printf("%x",encBuf[i]);
823 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
825 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
833 FreeRicSubscriptionRsp(e2apRicMsg);
838 /******************************************************************
840 * @brief Deallocation of memory allocated bu aper decoder for e2 setup response
844 * Function : freeAperDecodingOfE2SetupRsp
846 * Functionality: Deallocation of memory allocated bu aper decoder for e2
849 * @params[in] E2setupResponse_t *e2SetRspMsg;
852 * ****************************************************************/
853 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
855 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
856 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
857 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
861 if(e2SetRspMsg->protocolIEs.list.array)
863 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
865 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
867 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
869 case ProtocolIE_IDE2_id_TransactionID:
872 case ProtocolIE_IDE2_id_GlobalRIC_ID:
874 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
875 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
879 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
881 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
882 if(e2NodeConfigAddAckList->list.array )
884 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
886 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
888 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
889 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
890 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
891 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
892 e2nodeComponentInterfaceTypeF1);
893 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
896 free(e2NodeConfigAddAckList->list.array);
901 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
904 free(e2SetRspMsg->protocolIEs.list.array);
908 /******************************************************************
910 * @brief Processes E2 Setup Response sent by RIC
914 * Function : procE2SetupRsp
916 * Functionality: Processes E2 Setup Response sent by RIC
918 * @params[in] E2AP_PDU_t ASN decoded E2AP message
919 * @return ROK - success
922 * ****************************************************************/
923 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
925 uint8_t arrIdx =0, transId=0;
927 E2setupResponse_t *e2SetRspMsg;
929 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
930 duCb.e2Status = TRUE; //Set E2 status as true
931 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
933 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
935 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
937 case ProtocolIE_IDE2_id_TransactionID:
939 transId = e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
940 if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\
941 (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
942 memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
945 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
951 case ProtocolIE_IDE2_id_GlobalRIC_ID:
953 /* To store the Ric Id Params */
954 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
955 .choice.GlobalRIC_ID.pLMN_Identity.size);
956 duCb.e2apDb.plmn = NULLP;
957 DU_ALLOC(duCb.e2apDb.plmn, recvBufLen);
960 memcpy(duCb.e2apDb.plmn, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
961 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
963 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
964 /*TODO : duCb.e2apDb.plmn memory to be deallocated after the usage */
968 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
972 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
973 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
977 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
979 DU_FREE(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf,duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
980 DU_FREE(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
982 BuildAndSendE2NodeConfigUpdate();
986 /******************************************************************
988 * @brief Processes RIC Subscription Req sent by RIC
992 * Function : procRicSubsReq
994 * Functionality: Processes E2 Setup Response sent by CU
996 * @params[in] E2AP_PDU_t ASN decoded E2AP message
997 * @return ROK - success
1000 * ****************************************************************/
1002 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
1007 uint32_t recvBufLen;
1008 RICsubscriptionRequest_t *ricSubsReq;
1009 RICaction_ToBeSetup_ItemIEs_t *actionItem;
1011 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
1012 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1014 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
1016 if(ricSubsReq->protocolIEs.list.array[idx])
1018 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
1020 case ProtocolIE_IDE2_id_RICrequestID:
1022 duCb.e2apDb.ricReqId = ricSubsReq->protocolIEs.list.array[idx]->\
1023 value.choice.RICrequestID.ricRequestorID;
1024 duCb.e2apDb.ricInstanceId = ricSubsReq->protocolIEs.list.array[idx]-> \
1025 value.choice.RICrequestID.ricInstanceID;
1028 case ProtocolIE_IDE2_id_RANfunctionID:
1030 duCb.e2apDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
1031 value.choice.RANfunctionID;
1034 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1036 recvBufLen = sizeof(ricSubsReq->protocolIEs.list.array[idx]->value\
1037 .choice.RICsubscriptionDetails.ricEventTriggerDefinition.size);
1038 duCb.e2apDb.ricEventTrigger = NULLP;
1039 DU_ALLOC(duCb.e2apDb.ricEventTrigger, recvBufLen);
1040 /*TODO : duCb.e2apDb.ricEventTrigger memory to be deallocated after the usage */
1041 if(duCb.e2apDb.ricEventTrigger)
1043 memcpy(duCb.e2apDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
1044 ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
1046 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
1047 RICsubscriptionDetails.ricEventTriggerDefinition.buf);
1049 if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1052 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
1053 .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
1056 for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
1057 RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
1059 switch(actionItem->id)
1061 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
1063 duCb.e2apDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1064 duCb.e2apDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
1068 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
1073 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1080 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
1081 ricSubsReq->protocolIEs.list.array[idx]->id);
1084 free(ricSubsReq->protocolIEs.list.array[idx]);
1087 free(ricSubsReq->protocolIEs.list.array);
1088 ret = BuildAndSendRicSubscriptionRsp();
1093 /*******************************************************************
1095 * @brief Free the RicIndication Message
1099 * Function : FreeRicIndication
1101 * Functionality: Free the RicIndication Message
1106 ******************************************************************/
1107 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
1110 RICindication_t *ricIndicationMsg= NULLP;
1113 if(e2apMsg != NULLP)
1115 if(e2apMsg->choice.initiatingMessage != NULLP)
1117 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1118 if(ricIndicationMsg!= NULLP)
1120 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
1122 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
1124 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
1126 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
1128 case ProtocolIE_IDE2_id_RICrequestID:
1131 case ProtocolIE_IDE2_id_RANfunctionID:
1134 case ProtocolIE_IDE2_id_RICactionID:
1137 case ProtocolIE_IDE2_id_RICindicationType:
1140 case ProtocolIE_IDE2_id_RICindicationHeader:
1142 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
1143 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1146 case ProtocolIE_IDE2_id_RICindicationMessage:
1148 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
1149 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1155 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
1158 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
1161 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1163 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1166 /*******************************************************************
1168 * brief Fill the RicIndication Message
1172 * Function : FillRicIndication
1174 * Functionality:Fills the RicIndication Message
1176 * @return ROK - success
1179 ******************************************************************/
1180 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
1182 uint8_t elementCnt=0;
1187 ricIndicationMsg->protocolIEs.list.count = elementCnt;
1188 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
1189 /* Initialize the Ric Indication members */
1190 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
1191 ricIndicationMsg->protocolIEs.list.size);
1192 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
1194 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1199 for(idx=0; idx<elementCnt; idx++)
1201 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
1202 sizeof(RICindication_IEs_t));
1203 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
1205 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1213 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1214 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1215 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1216 RICindication_IEs__value_PR_RICrequestID;
1217 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =\
1218 duCb.e2apDb.ricReqId;
1219 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
1220 duCb.e2apDb.ricInstanceId;
1223 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1224 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1225 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1226 RICindication_IEs__value_PR_RANfunctionID;
1227 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID =
1228 duCb.e2apDb.ranFuncId;
1231 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
1232 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1233 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1234 RICindication_IEs__value_PR_RICactionID;
1235 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID =
1236 duCb.e2apDb.ricActionId;
1239 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
1240 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1241 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1242 RICindication_IEs__value_PR_RICindicationType;
1243 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType =
1244 duCb.e2apDb.ricActionType;
1247 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1248 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1249 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1250 RICindication_IEs__value_PR_RICindicationHeader;
1251 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1253 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1254 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1255 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1257 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1262 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1263 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
1265 /* TO BE CHANGED: RIC INDICATION DATA */
1266 /* For now filling a dummy octect data, need to tested with PRBs*/
1267 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1268 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1269 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1270 RICindication_IEs__value_PR_RICindicationMessage;
1271 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1273 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1274 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1275 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1277 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1282 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1283 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
1291 /*******************************************************************
1293 * @brief Builds and Send the RicIndication Message
1297 * Function : BuildAndSendRicIndication
1299 * Functionality:Fills the RicIndication Message
1301 * @return ROK - success
1304 ******************************************************************/
1306 uint8_t BuildAndSendRicIndication()
1308 E2AP_PDU_t *e2apMsg = NULLP;
1309 RICindication_t *ricIndicationMsg=NULLP;
1310 asn_enc_rval_t encRetVal; /* Encoder return value */
1311 uint8_t ret = RFAILED;
1312 uint8_t FillRicIndicationret = ROK;
1316 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
1318 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1319 if(e2apMsg == NULLP)
1321 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1325 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1326 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1327 if(e2apMsg->choice.initiatingMessage == NULLP)
1329 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1332 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1333 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1334 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1336 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1338 FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1339 if(FillRicIndicationret != ROK)
1343 /* Prints the Msg formed */
1344 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1345 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1347 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1349 if(encRetVal.encoded == ENCODE_FAIL)
1351 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
1352 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1357 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
1358 #ifdef DEBUG_ASN_PRINT
1359 for(int i=0; i< encBufSize; i++)
1361 printf("%x",encBuf[i]);
1366 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1368 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
1374 FreeRicIndication(e2apMsg);
1378 /*******************************************************************
1380 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1384 * Function : FreeE2NodeConfigUpdate
1387 * - freeing the memory allocated for E2nodeConfigurationUpdate
1389 * @params[in] E2AP_PDU_t *e2apMsg
1390 * @return ROK - success
1393 * ****************************************************************/
1394 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
1397 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate;
1399 if(e2apMsg != NULLP)
1401 if(e2apMsg->choice.initiatingMessage != NULLP)
1403 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
1404 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
1406 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
1408 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
1410 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
1412 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1414 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1418 /*******************************************************************
1420 * @brief Buld and send the E2 node config update msg
1424 * Function : BuildAndSendE2NodeConfigUpdate
1427 * - Buld and send the E2 node config update msg
1430 * @return ROK - success
1433 * ****************************************************************/
1435 uint8_t BuildAndSendE2NodeConfigUpdate()
1437 uint8_t arrIdx = 0,elementCnt = 1;
1439 E2AP_PDU_t *e2apMsg = NULLP;
1440 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
1441 asn_enc_rval_t encRetVal; /* Encoder return value */
1443 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
1446 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1447 if(e2apMsg == NULLP)
1449 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1452 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1453 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1454 if(e2apMsg->choice.initiatingMessage == NULLP)
1456 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1457 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1460 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1461 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1462 e2apMsg->choice.initiatingMessage->value.present = \
1463 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
1464 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
1466 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
1467 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
1468 /* Initialize the Ric Indication members */
1469 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \
1470 e2NodeConfigUpdate->protocolIEs.list.size);
1471 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
1473 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
1477 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1479 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
1480 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
1483 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
1490 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1491 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1492 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
1493 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1496 /* Prints the Msg formed */
1497 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1499 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1501 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1503 if(encRetVal.encoded == ENCODE_FAIL)
1505 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
1506 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1511 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
1512 #ifdef DEBUG_ASN_PRINT
1513 for(int i=0; i< encBufSize; i++)
1515 printf("%x",encBuf[i]);
1519 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
1521 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
1528 FreeE2NodeConfigUpdate(e2apMsg);
1532 /*******************************************************************
1534 * @brief Deallocate the memory allocated for E2ResetRequest msg
1538 * Function : FreeE2ResetRequest
1541 * - freeing the memory allocated for E2ResetRequest
1543 * @params[in] E2AP_PDU_t *e2apMsg
1544 * @return ROK - success
1547 * ****************************************************************/
1548 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
1551 ResetRequestE2_t *resetReq = NULLP;
1553 if(e2apMsg != NULLP)
1555 if(e2apMsg->choice.initiatingMessage != NULLP)
1557 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
1558 if(resetReq->protocolIEs.list.array)
1560 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1562 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
1564 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
1566 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1568 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1572 /*******************************************************************
1574 * @brief Build and send the E2 reset request msg
1578 * Function : BuildAndSendE2ResetRequest
1581 * - Buld and send the E2 reset request msg to RIC
1584 * @return ROK - success
1587 * ****************************************************************/
1588 uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause)
1590 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
1591 uint8_t ret = RFAILED;
1592 E2AP_PDU_t *e2apMsg = NULLP;
1593 ResetRequestE2_t *resetReq = NULLP;
1594 asn_enc_rval_t encRetVal; /* Encoder return value */
1596 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
1600 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1601 if(e2apMsg == NULLP)
1603 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
1607 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1608 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1609 if(e2apMsg->choice.initiatingMessage == NULLP)
1611 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
1615 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
1616 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1617 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
1618 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
1621 resetReq->protocolIEs.list.count = elementCnt;
1622 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
1624 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
1625 if(!resetReq->protocolIEs.list.array)
1627 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
1628 Reset Request IE array");
1632 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
1634 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
1635 if(!resetReq->protocolIEs.list.array[ieIdx])
1637 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
1638 Reset Request IE array element");
1643 /* In case of failure */
1644 if(ieIdx < elementCnt)
1648 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1649 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1650 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
1651 transId = assignTransactionId();
1652 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1655 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1656 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
1657 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
1658 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present = failureType;
1659 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1661 case CauseE2_PR_NOTHING:
1663 case CauseE2_PR_ricRequest:
1664 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest = failureCause;
1666 case CauseE2_PR_ricService:
1667 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService = failureCause;
1669 case CauseE2_PR_e2Node:
1670 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node = failureCause;
1672 case CauseE2_PR_transport:
1673 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport = failureCause;
1675 case CauseE2_PR_protocol:
1676 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol = failureCause;
1678 case CauseE2_PR_misc:
1679 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc = failureCause;
1683 /* Prints the Msg formed */
1684 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1686 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1688 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1690 if(encRetVal.encoded == ENCODE_FAIL)
1692 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
1693 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1698 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
1699 #ifdef DEBUG_ASN_PRINT
1700 for(int i=0; i< encBufSize; i++)
1702 printf("%x",encBuf[i]);
1706 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1708 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
1712 /* In case the message is sent successfully, store the transaction info to
1713 * be used when response is received */
1714 duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId = transId;
1715 duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
1721 /* Free all memory */
1722 FreeE2ResetRequest(e2apMsg);
1726 /*******************************************************************
1728 * @brief Deallocate the memory allocated for Reset Response msg
1732 * Function : freeAperDecodingOfE2ResetRsp
1735 * - freeing the memory allocated for Reset response
1737 * @params[in] ResetResponseE2_t *resetResponse
1740 * ****************************************************************/
1741 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
1747 if(resetResponse->protocolIEs.list.array)
1749 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1751 if(resetResponse->protocolIEs.list.array[ieIdx])
1753 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
1755 case ProtocolIE_IDE2_id_TransactionID:
1758 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
1761 free(resetResponse->protocolIEs.list.array[ieIdx]);
1764 free(resetResponse->protocolIEs.list.array);
1769 /******************************************************************
1771 * @brief Processes E2 Reset Response sent by RIC
1775 * Function : procResetResponse
1777 * Functionality: Processes E2 Reset Response sent by RIC
1779 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1780 * @return ROK - success
1783 * ****************************************************************/
1784 uint8_t procResetResponse(E2AP_PDU_t *e2apMsg)
1786 uint8_t ieIdx =0, transId;
1787 ResetResponseE2_t *resetResponse;
1789 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
1790 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
1792 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1794 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
1796 case ProtocolIE_IDE2_id_TransactionID:
1797 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1798 if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) && \
1799 (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.successfulOutcome->procedureCode))
1800 memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
1803 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
1807 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
1808 /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2
1809 Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e.
1810 Reset Request in this case, have not been comprehended or were missing, or if the message
1811 contained logical errors.
1813 Processing of this ID should be implemented when negative call flows are to be supported.
1817 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
1818 resetResponse->protocolIEs.list.array[ieIdx]->id);
1823 freeAperDecodingOfE2ResetRsp(resetResponse);
1827 /******************************************************************
1829 * @brief Deallocation of memory allocated bu aper decoder for e2 setup Failure
1833 * Function : freeAperDecodingOfE2SetupFailure
1835 * Functionality: Deallocation of memory allocated bu aper decoder for e2
1838 * @params[in] E2setupFailure_t *e2SetupFailure;
1841 * ****************************************************************/
1842 void freeAperDecodingOfE2SetupFailure(E2setupFailure_t *e2SetupFailure)
1848 if(e2SetupFailure->protocolIEs.list.array)
1850 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
1852 if(e2SetupFailure->protocolIEs.list.array[arrIdx])
1854 free(e2SetupFailure->protocolIEs.list.array[arrIdx]);
1857 free(e2SetupFailure->protocolIEs.list.array);
1861 /******************************************************************
1863 * @brief Processes E2 Setup Failure sent by RIC
1867 * Function : procE2SetupFailure
1869 * Functionality: Processes E2 Setup failure sent by RIC
1871 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1872 * @return ROK - success
1875 * ****************************************************************/
1876 void procE2SetupFailure(E2AP_PDU_t *e2apMsg)
1878 uint8_t arrIdx =0, transId =0, timerValue=0;
1879 E2setupFailure_t *e2SetupFailure;
1881 DU_LOG("\nINFO --> E2AP : E2 Setup failure received");
1882 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
1884 for(arrIdx=0; arrIdx<e2SetupFailure->protocolIEs.list.count; arrIdx++)
1886 switch(e2SetupFailure->protocolIEs.list.array[arrIdx]->id)
1888 case ProtocolIE_IDE2_id_TransactionID:
1890 transId = e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1891 if((duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].transactionId == transId) &&\
1892 (duCb.e2apDb.e2TransInfo.onGoingTransaction[transId].procedureCode == e2apMsg->choice.unsuccessfulOutcome->procedureCode))
1893 memset(&duCb.e2apDb.e2TransInfo.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
1896 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
1901 case ProtocolIE_IDE2_id_TimeToWaitE2:
1903 timerValue = covertE2WaitTimerEnumToValue(e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2);
1904 if((duChkTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR)) == FALSE)
1906 duStartTmr((PTR)&(duCb.e2apDb), EVENT_E2_SETUP_TMR, timerValue);
1910 DU_LOG("\nERROR --> E2AP : EVENT_E2_SETUP_TMR timer is already running");
1918 freeAperDecodingOfE2SetupFailure(e2SetupFailure);
1920 /*******************************************************************
1922 * @brief Handles received E2AP message and sends back response
1926 * Function : E2APMsgHdlr
1929 * - Decodes received E2AP control message
1930 * - Prepares response message, encodes and sends to SCTP
1933 * @return ROK - success
1936 * ****************************************************************/
1937 void E2APMsgHdlr(Buffer *mBuf)
1940 char *recvBuf = NULLP;
1942 MsgLen recvBufLen =0;
1943 E2AP_PDU_t *e2apMsg = NULLP;
1944 asn_dec_rval_t rval ={0}; /* Decoder return value */
1945 E2AP_PDU_t e2apasnmsg={0} ;
1947 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
1948 ODU_PRINT_MSG(mBuf, 0,0);
1950 /* Copy mBuf into char array to decode it */
1951 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1952 DU_ALLOC(recvBuf, (Size)recvBufLen);
1954 if(recvBuf == NULLP)
1956 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
1959 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1961 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
1965 #ifdef DEBUG_ASN_PRINT
1966 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
1967 for(i=0; i< recvBufLen; i++)
1969 printf("%x",recvBuf[i]);
1973 /* Decoding flat buffer into E2AP messsage */
1974 e2apMsg = &e2apasnmsg;
1975 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1977 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1978 DU_FREE(recvBuf, (Size)recvBufLen);
1980 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1982 DU_LOG("\nERROR --> E2AP : ASN decode failed");
1986 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1988 switch(e2apMsg->present)
1990 case E2AP_PDU_PR_unsuccessfulOutcome:
1992 switch(e2apMsg->choice.unsuccessfulOutcome->value.present)
1994 case UnsuccessfulOutcomeE2__value_PR_E2setupFailure:
1996 procE2SetupFailure(e2apMsg);
2001 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_unsuccessfulOutcome [%d]",\
2002 e2apMsg->choice.unsuccessfulOutcome->value.present);
2008 case E2AP_PDU_PR_successfulOutcome:
2010 switch(e2apMsg->choice.successfulOutcome->value.present)
2012 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
2016 procE2SetupRsp(e2apMsg);
2020 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
2022 DU_LOG("\nDEBUG --> E2AP : E2 node Config update ack message recevied");
2025 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
2027 procResetResponse(e2apMsg);
2032 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
2033 e2apMsg->choice.successfulOutcome->value.present);
2036 }/* End of switch(successfulOutcome) */
2037 free(e2apMsg->choice.successfulOutcome);
2041 case E2AP_PDU_PR_initiatingMessage:
2043 switch(e2apMsg->choice.initiatingMessage->value.present)
2045 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
2047 if(procRicSubsReq(e2apMsg) == ROK)
2049 BuildAndSendRicIndication();
2055 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
2056 e2apMsg->choice.initiatingMessage->value.present);
2059 }/* End of switch(initiatingMessage) */
2060 free(e2apMsg->choice.initiatingMessage);
2065 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
2070 }/* End of switch(e2apMsg->present) */
2072 } /* End of E2APMsgHdlr */
2074 /**********************************************************************
2076 **********************************************************************/