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"
23 #include "du_app_mac_inf.h"
24 #include "du_app_rlc_inf.h"
25 #include "du_e2ap_mgr.h"
26 #include "du_e2ap_msg_hdl.h"
29 #include "du_mgr_main.h"
31 #include "GlobalE2node-gNB-ID.h"
32 #include "ProtocolIE-FieldE2.h"
33 #include "E2setupRequest.h"
34 #include "InitiatingMessageE2.h"
35 #include "SuccessfulOutcomeE2.h"
37 #include "odu_common_codec.h"
38 #include "E2nodeComponentInterfaceF1.h"
39 #include "E2setupRequest.h"
41 /*******************************************************************
43 * @brief Builds Global gNodeB Params
47 * Function : BuildGlobalgNBId
49 * Functionality: Building the Plmn and gNB id
51 * @params[in] GlobalE2node_gNB_ID_t *gNbId
52 * @return ROK - success
55 ******************************************************************/
57 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
64 /* Allocate Buffer size */
65 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
66 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
67 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
68 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
70 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
75 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
76 gNbId->global_gNB_ID.plmn_id.buf);
78 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
79 /* Allocate Buffer size */
80 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
81 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
82 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
83 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
84 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
86 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
91 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
97 /*******************************************************************
99 * @brief Builds E2 node config addition list
103 * Function : BuildE2NodeConfigAddList
105 * Functionality: Building E2 node config addition list
107 * @params[in] E2nodeComponentConfigAddition_List_t *e2NodeAddList
108 * @return ROK - success
111 ******************************************************************/
113 uint8_t BuildE2NodeConfigAddList(E2nodeComponentConfigAddition_List_t *e2NodeAddList)
116 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItemIe;
117 E2nodeComponentConfigAddition_Item_t *e2NodeAddItem;
119 e2NodeAddList->list.count = 1;
120 e2NodeAddList->list.size = e2NodeAddList->list.count * sizeof(E2nodeComponentConfigAddition_ItemIEs_t *);
121 DU_ALLOC(e2NodeAddList->list.array, e2NodeAddList->list.size);
122 if(e2NodeAddList->list.array == NULLP)
124 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
128 for(arrIdx = 0; arrIdx< e2NodeAddList->list.count; arrIdx++)
130 DU_ALLOC(e2NodeAddList->list.array[arrIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
131 if(e2NodeAddList->list.array[arrIdx] == NULLP)
133 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
139 e2NodeAddItemIe = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[arrIdx];
140 e2NodeAddItemIe->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition_Item;
141 e2NodeAddItemIe->criticality = CriticalityE2_reject;
142 e2NodeAddItemIe->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
143 e2NodeAddItem = &e2NodeAddItemIe->value.choice.E2nodeComponentConfigAddition_Item;
145 /* E2nodeComponentInterfaceType */
146 e2NodeAddItem->e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
148 /* E2 Node Component Request Part */
149 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size = duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize;
150 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
151 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
152 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf == NULLP)
154 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
158 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
159 duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, e2NodeAddItem->e2nodeComponentConfiguration.\
160 e2nodeComponentRequestPart.size);
161 DU_FREE(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf,duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
163 /* E2 Node Component Response Part */
164 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size = duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize;
165 DU_ALLOC(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
166 e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
167 if(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf == NULLP)
169 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
172 memcpy(e2NodeAddItem->e2nodeComponentConfiguration.e2nodeComponentResponsePart.buf, \
173 duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, e2NodeAddItem->e2nodeComponentConfiguration.\
174 e2nodeComponentResponsePart.size);
175 DU_FREE(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
177 /* E2 Node Component ID */
178 e2NodeAddItem->e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
179 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
180 sizeof(E2nodeComponentInterfaceF1_t));
181 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
183 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
186 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
187 DU_ALLOC(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
188 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
190 if(e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
192 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2NodeConfigAddList %d",__LINE__);
195 e2NodeAddItem->e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[arrIdx] = duCfgParam.duId;
200 /*******************************************************************
202 * @brief Fills the initiating IE for E2 Setup Request
206 * Function : fillE2SetupReq
208 * Functionality:Fills the Initiating message for
211 * @params[in] E2setupRequest_t *e2SetupReq,
213 * @return ROK - success
216 ******************************************************************/
218 uint8_t fillE2SetupReq(E2setupRequest_t **e2SetupReq, uint8_t *idx)
220 uint8_t elementCnt = 0;
224 if(*e2SetupReq != NULLP)
227 (*e2SetupReq)->protocolIEs.list.count = elementCnt;
228 (*e2SetupReq)->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t*);
230 /* Initialize the E2Setup members */
231 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array, \
232 (*e2SetupReq)->protocolIEs.list.size);
233 if((*e2SetupReq)->protocolIEs.list.array == NULLP)
235 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
238 for(*idx = 0; *idx < elementCnt; (*idx)++)
240 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[*idx],\
241 sizeof(E2setupRequestIEs_t));
242 if((*e2SetupReq)->protocolIEs.list.array[*idx] == NULLP)
244 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayidx [%d]", *idx);
251 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
252 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
253 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_TransactionID;
254 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
257 /* GlobalE2node_gNB_ID */
258 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
259 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
260 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
261 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
263 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.choice.\
264 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
265 if((*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.choice.\
266 GlobalE2node_ID.choice.gNB == NULLP)
268 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
273 ret = BuildGlobalgNBId((*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.\
274 choice.GlobalE2node_ID.choice.gNB);
277 DU_LOG("\nERROR --> E2AP : Failed to build Global Gnb Id");
283 /* E2 Node Component Configuration Addition List */
284 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAddition;
285 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
286 (*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
287 if(BuildE2NodeConfigAddList(&((*e2SetupReq)->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List))!=ROK)
289 DU_LOG("\nERROR --> E2AP : Failed to E2 Node config addition list");
296 DU_LOG("\nERROR --> E2AP : received e2SetupReq is NULL");
303 /*******************************************************************
305 * @brief De Allocate E2 Setup Request Message
309 * Function : FreeE2SetupReq
311 * Functionality: De-Allocating E2 Setup request Message
313 * @params[in] E2AP_PDU_t *e2apMsg
317 * ****************************************************************/
319 void FreeE2SetupReq(E2AP_PDU_t *e2apMsg)
322 uint8_t e2NodeAddListIdx =0;
323 E2setupRequest_t *e2SetupReq;
324 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
325 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
327 /* De-allocating Memory */
330 if(e2apMsg->choice.initiatingMessage != NULLP)
332 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
333 if(e2SetupReq->protocolIEs.list.array != NULLP)
335 for(arrIdx = 0; arrIdx < e2SetupReq->protocolIEs.list.count; arrIdx++)
337 if(e2SetupReq->protocolIEs.list.array[arrIdx] != NULLP)
339 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
341 case ProtocolIE_IDE2_id_TransactionID:
343 case ProtocolIE_IDE2_id_GlobalE2node_ID:
345 if(e2SetupReq->protocolIEs.list.array[arrIdx]->\
346 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
348 GlobalE2node_gNB_ID_t *gNbId = NULLP;
349 gNbId = e2SetupReq->protocolIEs.list.array[arrIdx]->\
350 value.choice.GlobalE2node_ID.choice.gNB;
351 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
353 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
354 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
355 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
356 gNbId->global_gNB_ID.plmn_id.size);
358 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx]->value.\
359 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
363 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
365 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
366 if(e2NodeAddList->list.array)
368 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
370 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
372 /* Free E2 Node Component Request Part */
373 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.buf,\
374 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart.size);
376 /* Free E2 Node Component Response Part */
377 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.\
378 e2nodeComponentResponsePart.buf, \
379 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart.size);
381 /* Free E2 Node Component ID */
382 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1)
384 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
385 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
386 e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
387 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
388 DU_FREE(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
389 sizeof(E2nodeComponentInterfaceF1_t));
391 DU_FREE(e2NodeAddList->list.array[e2NodeAddListIdx], sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
393 DU_FREE(e2NodeAddList->list.array, e2NodeAddList->list.size);
398 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
399 (e2SetupReq->protocolIEs.list.array[arrIdx]->id));
402 DU_FREE(e2SetupReq->protocolIEs.list.array[arrIdx], sizeof(E2setupRequestIEs_t));
405 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
407 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
409 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
413 /*******************************************************************
415 * @brief Builds and Send the E2SetupRequest
419 * Function : BuildAndSendE2SetupReq
421 * Functionality:Fills the E2SetupRequest
423 * @return ROK - success
426 ******************************************************************/
428 uint8_t BuildAndSendE2SetupReq()
432 E2AP_PDU_t *e2apMsg = NULLP;
433 E2setupRequest_t *e2SetupReq = NULLP;
434 asn_enc_rval_t encRetVal; /* Encoder return value */
436 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
439 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
442 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
445 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
446 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
447 if(e2apMsg->choice.initiatingMessage == NULLP)
449 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
450 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
453 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
454 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
455 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
456 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
458 ret = fillE2SetupReq(&e2SetupReq, &idx);
461 DU_LOG("\nERROR --> E2AP : fillE2SetupReq() failed");
464 /* Prints the Msg formed */
465 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
467 memset(encBuf, 0, ENC_BUF_MAX_LEN);
469 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
471 if(encRetVal.encoded == ENCODE_FAIL)
473 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
474 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
479 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
480 #ifdef DEBUG_ASN_PRINT
481 for(int i=0; i< encBufSize; i++)
483 printf("%x",encBuf[i]);
487 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
489 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
495 FreeE2SetupReq(e2apMsg);
497 }/* End of BuildAndSendE2SetupReq */
499 /*******************************************************************
501 * @brief Builds Ric Request Id
505 * Function : BuildRicRequestId
507 * Functionality: Building the Ric Request Id
509 * @params[in] RICrequestID_t *ricReqId
510 * @return ROK - success
513 * ****************************************************************/
515 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
517 if(ricReqId == NULLP)
522 ricReqId->ricRequestorID = 1;
523 ricReqId->ricInstanceID = 1;
527 /*******************************************************************
529 * @brief Fills the mandatory RicAdmitted List Items
533 * Function : fillRicAdmitList
535 * Functionality: Fills the mandatory Ric Admitted List Items
537 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
538 * @return ROK - success
541 * ****************************************************************/
543 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
546 if(ricAdmitItems != NULLP)
548 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
549 ricAdmitItems->criticality = CriticalityE2_reject;
550 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
551 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
559 /*******************************************************************
561 * @brief Builds the mandatory RicAdmitted List Params
565 * Function : BuildRicAdmitList
567 * Functionality: Builds the mandatory Ric Admitted List Params
569 * @params[in] RICaction_Admitted_List_t *admitListPtr
570 * @return ROK - success
573 * ****************************************************************/
575 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
582 if(admitListPtr == NULLP)
584 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
589 admitListPtr->list.count = elementCnt;
590 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
591 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
592 if(admitListPtr->list.array == NULLP)
594 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
599 for(idx=0 ; idx<elementCnt ; idx++ )
601 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
602 if(admitListPtr->list.array[idx] == NULLP)
610 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
616 /*******************************************************************
618 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
622 * Function : FreeRicSubscriptionRsp
624 * Functionality:Free the RicSubscriptionRsp
626 * @param[in] E2AP_PDU_t *e2apRicMsg
631 ******************************************************************/
632 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
634 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
637 RICaction_Admitted_List_t *admitListPtr;
639 if(e2apRicMsg != NULLP)
641 if(e2apRicMsg->choice.successfulOutcome != NULLP)
643 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
644 if(ricSubscriptionRsp)
646 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
648 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
650 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
652 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
654 case ProtocolIE_IDE2_id_RICrequestID:
657 case ProtocolIE_IDE2_id_RANfunctionID:
660 case ProtocolIE_IDE2_id_RICactions_Admitted:
662 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
663 array[idx]->value.choice.RICaction_Admitted_List;
664 if(admitListPtr->list.array != NULLP)
666 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
668 if(admitListPtr->list.array[idx1] != NULLP)
670 DU_FREE(admitListPtr->list.array[idx1],
671 sizeof(RICaction_Admitted_ItemIEs_t));
674 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
681 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
682 sizeof(RICsubscriptionResponse_IEs_t));
685 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
686 ricSubscriptionRsp->protocolIEs.list.size);
689 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
691 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
694 /*******************************************************************
696 * @brief Builds and Send the RicSubscriptionRsp
700 * Function : BuildAndSendRicSubscriptionRsp
702 * functionality:Fills the RicSubscriptionRsp
704 * @return ROK - success
707 ******************************************************************/
708 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
712 uint8_t elementCnt = 0;
713 uint8_t BuildRicRequestIdret=ROK;
714 uint8_t BuildRicAdmitListret=ROK;
717 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
718 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
719 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
720 ricSubscriptionRsp->protocolIEs.list.size);
721 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
723 DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
728 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
730 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
731 sizeof(RICsubscriptionResponse_IEs_t));
732 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
741 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
742 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
743 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
744 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
745 BuildRicRequestIdret =
746 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
747 if(BuildRicRequestIdret != ROK)
754 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
755 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
756 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
757 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
758 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
761 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
762 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
763 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
764 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
765 BuildRicAdmitListret =
766 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
767 if(BuildRicAdmitListret != ROK)
776 /*******************************************************************
778 * @brief Builds and Send the RicSubscriptionRsp
782 * Function : BuildAndSendRicSubscriptionRsp
784 * Functionality:Fills the RicSubscriptionRsp
786 * @return ROK - success
789 ******************************************************************/
791 uint8_t BuildAndSendRicSubscriptionRsp()
794 E2AP_PDU_t *e2apRicMsg = NULLP;
795 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
796 asn_enc_rval_t encRetVal;
797 uint8_t ret = RFAILED;
798 uint8_t FillRicricSubscriptionRspret;
802 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
804 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
805 if(e2apRicMsg == NULLP)
807 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
810 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
811 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
812 if(e2apRicMsg->choice.successfulOutcome == NULLP)
814 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
818 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
819 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
820 e2apRicMsg->choice.successfulOutcome->value.present = \
821 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
822 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
824 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
825 if(FillRicricSubscriptionRspret != ROK)
827 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
831 /* Prints the Msg formed */
832 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
834 memset(encBuf, 0, ENC_BUF_MAX_LEN);
836 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
838 if(encRetVal.encoded == ENCODE_FAIL)
840 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
841 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
846 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
847 #ifdef DEBUG_ASN_PRINT
848 for(int i=0; i< encBufSize; i++)
850 printf("%x",encBuf[i]);
855 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
857 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
865 FreeRicSubscriptionRsp(e2apRicMsg);
870 /******************************************************************
872 * @brief Deallocation of memory allocated bu aper decoder for e2 setup response
876 * Function : freeAperDecodingOfE2SetupRsp
878 * Functionality: Deallocation of memory allocated bu aper decoder for e2
881 * @params[in] E2setupResponse_t *e2SetRspMsg;
884 * ****************************************************************/
885 void freeAperDecodingOfE2SetupRsp(E2setupResponse_t *e2SetRspMsg)
887 uint8_t arrIdx, e2NodeConfigAddAckListIdx;
888 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
889 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAddAckList;
893 if(e2SetRspMsg->protocolIEs.list.array)
895 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
897 if(e2SetRspMsg->protocolIEs.list.array[arrIdx])
899 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
901 case ProtocolIE_IDE2_id_TransactionID:
904 case ProtocolIE_IDE2_id_GlobalRIC_ID:
906 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.pLMN_Identity.buf);
907 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID.buf);
911 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
913 e2NodeConfigAddAckList = &e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
914 if(e2NodeConfigAddAckList->list.array )
916 for(e2NodeConfigAddAckListIdx = 0; e2NodeConfigAddAckListIdx< e2NodeConfigAddAckList->list.count; e2NodeConfigAddAckListIdx++)
918 if(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx])
920 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx];
921 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
922 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf);
923 free(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.\
924 e2nodeComponentInterfaceTypeF1);
925 free(e2NodeConfigAddAckList->list.array[e2NodeConfigAddAckListIdx]);
928 free(e2NodeConfigAddAckList->list.array);
933 free(e2SetRspMsg->protocolIEs.list.array[arrIdx]);
936 free(e2SetRspMsg->protocolIEs.list.array);
940 /******************************************************************
942 * @brief Processes E2 Setup Response sent by RIC
946 * Function : procE2SetupRsp
948 * Functionality: Processes E2 Setup Response sent by RIC
950 * @params[in] E2AP_PDU_t ASN decoded E2AP message
951 * @return ROK - success
954 * ****************************************************************/
955 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
959 E2setupResponse_t *e2SetRspMsg;
961 DU_LOG("\nINFO --> E2AP : E2 Setup Response received");
962 duCb.e2Status = TRUE; //Set E2 status as true
963 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
965 for(arrIdx=0; arrIdx<e2SetRspMsg->protocolIEs.list.count; arrIdx++)
967 switch(e2SetRspMsg->protocolIEs.list.array[arrIdx]->id)
969 case ProtocolIE_IDE2_id_TransactionID:
972 case ProtocolIE_IDE2_id_GlobalRIC_ID:
974 /* To store the Ric Id Params */
975 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[arrIdx]->value\
976 .choice.GlobalRIC_ID.pLMN_Identity.size);
977 duCb.e2apDb.plmn = NULLP;
978 DU_ALLOC(duCb.e2apDb.plmn, recvBufLen);
981 memcpy(duCb.e2apDb.plmn, e2SetRspMsg->protocolIEs.list.array[arrIdx]\
982 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
984 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[arrIdx]->value.choice.GlobalRIC_ID.ric_ID, &duCb.e2apDb.ricId);
985 /*TODO : duCb.e2apDb.plmn memory to be deallocated after the usage */
989 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
993 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
994 e2SetRspMsg->protocolIEs.list.array[arrIdx]->id);
998 freeAperDecodingOfE2SetupRsp(e2SetRspMsg);
999 BuildAndSendE2NodeConfigUpdate();
1003 /******************************************************************
1005 * @brief Processes RIC Subscription Req sent by RIC
1009 * Function : procRicSubsReq
1011 * Functionality: Processes E2 Setup Response sent by CU
1013 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1014 * @return ROK - success
1017 * ****************************************************************/
1019 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
1024 uint32_t recvBufLen;
1025 RICsubscriptionRequest_t *ricSubsReq;
1026 RICaction_ToBeSetup_ItemIEs_t *actionItem;
1028 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
1029 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
1031 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
1033 if(ricSubsReq->protocolIEs.list.array[idx])
1035 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
1037 case ProtocolIE_IDE2_id_RICrequestID:
1039 duCb.e2apDb.ricReqId = ricSubsReq->protocolIEs.list.array[idx]->\
1040 value.choice.RICrequestID.ricRequestorID;
1041 duCb.e2apDb.ricInstanceId = ricSubsReq->protocolIEs.list.array[idx]-> \
1042 value.choice.RICrequestID.ricInstanceID;
1045 case ProtocolIE_IDE2_id_RANfunctionID:
1047 duCb.e2apDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
1048 value.choice.RANfunctionID;
1051 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
1053 recvBufLen = sizeof(ricSubsReq->protocolIEs.list.array[idx]->value\
1054 .choice.RICsubscriptionDetails.ricEventTriggerDefinition.size);
1055 duCb.e2apDb.ricEventTrigger = NULLP;
1056 DU_ALLOC(duCb.e2apDb.ricEventTrigger, recvBufLen);
1057 /*TODO : duCb.e2apDb.ricEventTrigger memory to be deallocated after the usage */
1058 if(duCb.e2apDb.ricEventTrigger)
1060 memcpy(duCb.e2apDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
1061 ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
1063 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
1064 RICsubscriptionDetails.ricEventTriggerDefinition.buf);
1066 if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1069 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
1070 .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
1073 for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
1074 RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
1076 switch(actionItem->id)
1078 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
1080 duCb.e2apDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1081 duCb.e2apDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
1085 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
1090 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
1097 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
1098 ricSubsReq->protocolIEs.list.array[idx]->id);
1101 free(ricSubsReq->protocolIEs.list.array[idx]);
1104 free(ricSubsReq->protocolIEs.list.array);
1105 ret = BuildAndSendRicSubscriptionRsp();
1110 /*******************************************************************
1112 * @brief Free the RicIndication Message
1116 * Function : FreeRicIndication
1118 * Functionality: Free the RicIndication Message
1123 ******************************************************************/
1124 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
1127 RICindication_t *ricIndicationMsg= NULLP;
1130 if(e2apMsg != NULLP)
1132 if(e2apMsg->choice.initiatingMessage != NULLP)
1134 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1135 if(ricIndicationMsg!= NULLP)
1137 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
1139 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
1141 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
1143 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
1145 case ProtocolIE_IDE2_id_RICrequestID:
1148 case ProtocolIE_IDE2_id_RANfunctionID:
1151 case ProtocolIE_IDE2_id_RICactionID:
1154 case ProtocolIE_IDE2_id_RICindicationType:
1157 case ProtocolIE_IDE2_id_RICindicationHeader:
1159 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
1160 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1163 case ProtocolIE_IDE2_id_RICindicationMessage:
1165 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
1166 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1172 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
1175 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
1178 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1180 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1183 /*******************************************************************
1185 * brief Fill the RicIndication Message
1189 * Function : FillRicIndication
1191 * Functionality:Fills the RicIndication Message
1193 * @return ROK - success
1196 ******************************************************************/
1197 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
1199 uint8_t elementCnt=0;
1204 ricIndicationMsg->protocolIEs.list.count = elementCnt;
1205 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
1206 /* Initialize the Ric Indication members */
1207 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
1208 ricIndicationMsg->protocolIEs.list.size);
1209 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
1211 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1216 for(idx=0; idx<elementCnt; idx++)
1218 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
1219 sizeof(RICindication_IEs_t));
1220 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
1222 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1230 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1231 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1232 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1233 RICindication_IEs__value_PR_RICrequestID;
1234 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =\
1235 duCb.e2apDb.ricReqId;
1236 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
1237 duCb.e2apDb.ricInstanceId;
1240 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1241 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1242 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1243 RICindication_IEs__value_PR_RANfunctionID;
1244 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID =
1245 duCb.e2apDb.ranFuncId;
1248 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
1249 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1250 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1251 RICindication_IEs__value_PR_RICactionID;
1252 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID =
1253 duCb.e2apDb.ricActionId;
1256 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
1257 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1258 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1259 RICindication_IEs__value_PR_RICindicationType;
1260 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType =
1261 duCb.e2apDb.ricActionType;
1264 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1265 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1266 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1267 RICindication_IEs__value_PR_RICindicationHeader;
1268 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1270 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1271 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1272 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1274 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1279 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1280 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
1282 /* TO BE CHANGED: RIC INDICATION DATA */
1283 /* For now filling a dummy octect data, need to tested with PRBs*/
1284 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1285 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1286 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1287 RICindication_IEs__value_PR_RICindicationMessage;
1288 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1290 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1291 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1292 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1294 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1299 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1300 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
1308 /*******************************************************************
1310 * @brief Builds and Send the RicIndication Message
1314 * Function : BuildAndSendRicIndication
1316 * Functionality:Fills the RicIndication Message
1318 * @return ROK - success
1321 ******************************************************************/
1323 uint8_t BuildAndSendRicIndication()
1325 E2AP_PDU_t *e2apMsg = NULLP;
1326 RICindication_t *ricIndicationMsg=NULLP;
1327 asn_enc_rval_t encRetVal; /* Encoder return value */
1328 uint8_t ret = RFAILED;
1329 uint8_t FillRicIndicationret = ROK;
1333 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
1335 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1336 if(e2apMsg == NULLP)
1338 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1342 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1343 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1344 if(e2apMsg->choice.initiatingMessage == NULLP)
1346 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1349 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1350 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1351 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1353 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1355 FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1356 if(FillRicIndicationret != ROK)
1360 /* Prints the Msg formed */
1361 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1362 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1364 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1366 if(encRetVal.encoded == ENCODE_FAIL)
1368 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
1369 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1374 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
1375 #ifdef DEBUG_ASN_PRINT
1376 for(int i=0; i< encBufSize; i++)
1378 printf("%x",encBuf[i]);
1383 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1385 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
1391 FreeRicIndication(e2apMsg);
1395 /*******************************************************************
1397 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1401 * Function : FreeE2NodeConfigUpdate
1404 * - freeing the memory allocated for E2nodeConfigurationUpdate
1406 * @params[in] E2AP_PDU_t *e2apMsg
1407 * @return ROK - success
1410 * ****************************************************************/
1411 void FreeE2NodeConfigUpdate(E2AP_PDU_t *e2apMsg)
1414 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate;
1416 if(e2apMsg != NULLP)
1418 if(e2apMsg->choice.initiatingMessage != NULLP)
1420 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
1421 if(e2NodeConfigUpdate->protocolIEs.list.array != NULLP)
1423 for(arrIdx = 0; arrIdx < e2NodeConfigUpdate->protocolIEs.list.count; arrIdx++)
1425 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
1427 DU_FREE(e2NodeConfigUpdate->protocolIEs.list.array, e2NodeConfigUpdate->protocolIEs.list.size);
1429 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1431 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1435 /*******************************************************************
1437 * @brief Buld and send the E2 node config update msg
1441 * Function : BuildAndSendE2NodeConfigUpdate
1444 * - Buld and send the E2 node config update msg
1447 * @return ROK - success
1450 * ****************************************************************/
1452 uint8_t BuildAndSendE2NodeConfigUpdate()
1454 uint8_t arrIdx = 0,elementCnt = 1;
1456 E2AP_PDU_t *e2apMsg = NULLP;
1457 E2nodeConfigurationUpdate_t *e2NodeConfigUpdate = NULLP;
1458 asn_enc_rval_t encRetVal; /* Encoder return value */
1460 DU_LOG("\nINFO --> E2AP : Building E2 Node config update\n");
1463 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1464 if(e2apMsg == NULLP)
1466 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1469 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1470 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1471 if(e2apMsg->choice.initiatingMessage == NULLP)
1473 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1474 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1477 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1478 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1479 e2apMsg->choice.initiatingMessage->value.present = \
1480 InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate;
1481 e2NodeConfigUpdate = &e2apMsg->choice.initiatingMessage->value.choice.E2nodeConfigurationUpdate;
1483 e2NodeConfigUpdate->protocolIEs.list.count = elementCnt;
1484 e2NodeConfigUpdate->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdate_IEs_t*);
1485 /* Initialize the Ric Indication members */
1486 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array, \
1487 e2NodeConfigUpdate->protocolIEs.list.size);
1488 if(e2NodeConfigUpdate->protocolIEs.list.array == NULLP)
1490 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
1494 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1496 DU_ALLOC(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_IEs_t));
1497 if(e2NodeConfigUpdate->protocolIEs.list.array[arrIdx] == NULLP)
1500 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdate failed");
1507 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1508 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1509 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
1510 e2NodeConfigUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1513 /* Prints the Msg formed */
1514 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1516 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1518 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1520 if(encRetVal.encoded == ENCODE_FAIL)
1522 DU_LOG("\nERROR --> E2AP : Could not encode E2nodeConfigurationUpdate structure (at %s)\n",\
1523 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1528 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2nodeConfigurationUpdate\n");
1529 #ifdef DEBUG_ASN_PRINT
1530 for(int i=0; i< encBufSize; i++)
1532 printf("%x",encBuf[i]);
1536 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize))
1538 DU_LOG("\nERROR --> E2AP : Sending E2 node config update failed");
1545 FreeE2NodeConfigUpdate(e2apMsg);
1549 /*******************************************************************
1551 * @brief Deallocate the memory allocated for E2ResetRequest msg
1555 * Function : FreeE2ResetRequest
1558 * - freeing the memory allocated for E2ResetRequest
1560 * @params[in] E2AP_PDU_t *e2apMsg
1561 * @return ROK - success
1564 * ****************************************************************/
1565 void FreeE2ResetRequest(E2AP_PDU_t *e2apMsg)
1568 ResetRequestE2_t *resetReq = NULLP;
1570 if(e2apMsg != NULLP)
1572 if(e2apMsg->choice.initiatingMessage != NULLP)
1574 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
1575 if(resetReq->protocolIEs.list.array)
1577 for(ieIdx = 0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1579 DU_FREE(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
1581 DU_FREE(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
1583 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1585 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1589 /*******************************************************************
1591 * @brief Build and send the E2 reset request msg
1595 * Function : BuildAndSendE2ResetRequest
1598 * - Buld and send the E2 reset request msg to RIC
1601 * @return ROK - success
1604 * ****************************************************************/
1605 uint8_t BuildAndSendE2ResetRequest(E2CauseType failureType, E2Cause failureCause)
1607 uint8_t ieIdx = 0, elementCnt = 0, transId = 0;
1608 uint8_t ret = RFAILED;
1609 E2AP_PDU_t *e2apMsg = NULLP;
1610 ResetRequestE2_t *resetReq = NULLP;
1611 asn_enc_rval_t encRetVal; /* Encoder return value */
1613 DU_LOG("\nINFO --> E2AP : Building E2 Reset Request\n");
1617 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1618 if(e2apMsg == NULLP)
1620 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for E2AP-PDU failed");
1624 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1625 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1626 if(e2apMsg->choice.initiatingMessage == NULLP)
1628 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation for initiatingMessage");
1632 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_Reset;
1633 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1634 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_ResetRequestE2;
1635 resetReq = &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2;
1638 resetReq->protocolIEs.list.count = elementCnt;
1639 resetReq->protocolIEs.list.size = elementCnt * sizeof(ResetRequestIEs_t *);
1641 DU_ALLOC(resetReq->protocolIEs.list.array, resetReq->protocolIEs.list.size);
1642 if(!resetReq->protocolIEs.list.array)
1644 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
1645 Reset Request IE array");
1649 for(ieIdx = 0; ieIdx < elementCnt; ieIdx++)
1651 DU_ALLOC(resetReq->protocolIEs.list.array[ieIdx], sizeof(ResetRequestIEs_t));
1652 if(!resetReq->protocolIEs.list.array[ieIdx])
1654 DU_LOG("\nERROR --> E2AP : BuildAndSendE2ResetRequest(): Memory allocation failed for \
1655 Reset Request IE array element");
1660 /* In case of failure */
1661 if(ieIdx < elementCnt)
1665 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1666 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1667 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_TransactionID;
1668 transId = assignTransactionId();
1669 resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1672 resetReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1673 resetReq->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_ignore;
1674 resetReq->protocolIEs.list.array[ieIdx]->value.present = ResetRequestIEs__value_PR_CauseE2;
1675 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present = failureType;
1676 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1678 case CauseE2_PR_NOTHING:
1680 case CauseE2_PR_ricRequest:
1681 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest = failureCause;
1683 case CauseE2_PR_ricService:
1684 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService = failureCause;
1686 case CauseE2_PR_e2Node:
1687 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node = failureCause;
1689 case CauseE2_PR_transport:
1690 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport = failureCause;
1692 case CauseE2_PR_protocol:
1693 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol = failureCause;
1695 case CauseE2_PR_misc:
1696 resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc = failureCause;
1700 /* Prints the Msg formed */
1701 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1703 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1705 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1707 if(encRetVal.encoded == ENCODE_FAIL)
1709 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
1710 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1715 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
1716 #ifdef DEBUG_ASN_PRINT
1717 for(int i=0; i< encBufSize; i++)
1719 printf("%x",encBuf[i]);
1723 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL, encBuf, encBufSize) != ROK)
1725 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
1729 /* In case the message is sent successfully, store the transaction info to
1730 * be used when response is received */
1731 duCb.e2apDb.onGoingTransaction[transId].transactionId = transId;
1732 duCb.e2apDb.onGoingTransaction[transId].procedureCode = e2apMsg->choice.initiatingMessage->procedureCode;
1738 /* Free all memory */
1739 FreeE2ResetRequest(e2apMsg);
1743 /*******************************************************************
1745 * @brief Deallocate the memory allocated for Reset Response msg
1749 * Function : freeAperDecodingOfE2ResetRsp
1752 * - freeing the memory allocated for Reset response
1754 * @params[in] ResetResponseE2_t *resetResponse
1757 * ****************************************************************/
1758 void freeAperDecodingOfE2ResetRsp(ResetResponseE2_t *resetResponse)
1764 if(resetResponse->protocolIEs.list.array)
1766 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1768 if(resetResponse->protocolIEs.list.array[ieIdx])
1770 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
1772 case ProtocolIE_IDE2_id_TransactionID:
1775 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
1778 free(resetResponse->protocolIEs.list.array[ieIdx]);
1781 free(resetResponse->protocolIEs.list.array);
1786 /******************************************************************
1788 * @brief Processes E2 Reset Response sent by RIC
1792 * Function : procResetResponse
1794 * Functionality: Processes E2 Reset Response sent by RIC
1796 * @params[in] E2AP_PDU_t ASN decoded E2AP message
1797 * @return ROK - success
1800 * ****************************************************************/
1801 uint8_t procResetResponse(E2AP_PDU_t *e2apMsg)
1803 uint8_t ieIdx =0, transId;
1804 ResetResponseE2_t *resetResponse;
1806 DU_LOG("\nINFO --> E2AP : E2 Reset Response received");
1807 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;;
1809 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1811 switch(resetResponse->protocolIEs.list.array[ieIdx]->id)
1813 case ProtocolIE_IDE2_id_TransactionID:
1814 transId = resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1815 if(duCb.e2apDb.onGoingTransaction[transId].transactionId == transId)
1816 memset(&duCb.e2apDb.onGoingTransaction[transId], 0, sizeof(E2TransInfo));
1819 DU_LOG("\nERROR --> E2AP : Invalid transaction id [%d]", transId);
1823 case ProtocolIE_IDE2_id_CriticalityDiagnosticsE2:
1824 /* As per ORAN WG3 E2AP spec v3.0, section 9.2.2
1825 Criticality Diagnostics IE is sent by Near-RT RIC when parts of a received message i.e.
1826 Reset Request in this case, have not been comprehended or were missing, or if the message
1827 contained logical errors.
1829 Processing of this ID should be implemented when negative call flows are to be supported.
1833 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2 Reset Response : %ld",
1834 resetResponse->protocolIEs.list.array[ieIdx]->id);
1839 freeAperDecodingOfE2ResetRsp(resetResponse);
1843 /*******************************************************************
1845 * @brief Handles received E2AP message and sends back response
1849 * Function : E2APMsgHdlr
1852 * - Decodes received E2AP control message
1853 * - Prepares response message, encodes and sends to SCTP
1856 * @return ROK - success
1859 * ****************************************************************/
1860 void E2APMsgHdlr(Buffer *mBuf)
1863 char *recvBuf = NULLP;
1865 MsgLen recvBufLen =0;
1866 E2AP_PDU_t *e2apMsg = NULLP;
1867 asn_dec_rval_t rval ={0}; /* Decoder return value */
1868 E2AP_PDU_t e2apasnmsg={0} ;
1870 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
1871 ODU_PRINT_MSG(mBuf, 0,0);
1873 /* Copy mBuf into char array to decode it */
1874 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1875 DU_ALLOC(recvBuf, (Size)recvBufLen);
1877 if(recvBuf == NULLP)
1879 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
1882 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1884 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
1888 #ifdef DEBUG_ASN_PRINT
1889 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
1890 for(i=0; i< recvBufLen; i++)
1892 printf("%x",recvBuf[i]);
1896 /* Decoding flat buffer into E2AP messsage */
1897 e2apMsg = &e2apasnmsg;
1898 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1900 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1901 DU_FREE(recvBuf, (Size)recvBufLen);
1903 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1905 DU_LOG("\nERROR --> E2AP : ASN decode failed");
1909 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1911 switch(e2apMsg->present)
1913 case E2AP_PDU_PR_successfulOutcome:
1915 switch(e2apMsg->choice.successfulOutcome->value.present)
1917 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
1921 procE2SetupRsp(e2apMsg);
1925 case SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge:
1927 DU_LOG("\nDEBUG --> E2AP : E2 node Config update ack message recevied");
1930 case SuccessfulOutcomeE2__value_PR_ResetResponseE2:
1932 procResetResponse(e2apMsg);
1937 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
1938 e2apMsg->choice.successfulOutcome->value.present);
1941 }/* End of switch(successfulOutcome) */
1942 free(e2apMsg->choice.successfulOutcome);
1946 case E2AP_PDU_PR_initiatingMessage:
1948 switch(e2apMsg->choice.initiatingMessage->value.present)
1950 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
1952 if(procRicSubsReq(e2apMsg) == ROK)
1954 BuildAndSendRicIndication();
1960 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
1961 e2apMsg->choice.initiatingMessage->value.present);
1964 }/* End of switch(initiatingMessage) */
1965 free(e2apMsg->choice.initiatingMessage);
1970 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
1975 }/* End of switch(e2apMsg->present) */
1977 } /* End of E2APMsgHdlr */
1979 /**********************************************************************
1981 **********************************************************************/