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 *******************************************************************************/
19 /* This file contains E2AP message handler functions */
20 #include "common_def.h"
21 #include "OCTET_STRING.h"
22 #include "BIT_STRING.h"
23 #include "odu_common_codec.h"
24 #include "ric_stub_sctp.h"
26 #include "ric_e2ap_msg_hdl.h"
27 #include "GlobalE2node-gNB-ID.h"
28 #include "ProtocolIE-FieldE2.h"
29 #include "InitiatingMessageE2.h"
30 #include "SuccessfulOutcomeE2.h"
33 #include "E2nodeComponentInterfaceF1.h"
36 /*******************************************************************
38 * @brief Sends E2 msg over SCTP
42 * Function : SendE2APMsg
44 * Functionality: Sends E2 msg over SCTP
46 * @params[in] Region region
48 * @return ROK - success
51 * ****************************************************************/
53 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
57 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
59 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
61 ODU_PRINT_MSG(mBuf, 0,0);
63 if(sctpSend(duId, mBuf) != ROK)
65 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
66 ODU_PUT_MSG_BUF(mBuf);
72 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
73 ODU_PUT_MSG_BUF(mBuf);
76 ODU_PUT_MSG_BUF(mBuf);
80 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
87 /*******************************************************************
89 * @brief Builds Global RIC Id Params
93 * Function : BuildGlobalRicId
95 * Functionality: Building the Plmn and ric id
97 * @params[in] GlobalRIC_ID_t *ricId
98 * @return ROK - success
101 * ****************************************************************/
103 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
106 uint8_t byteSize = 3;
110 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
111 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
112 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
114 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
115 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
116 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
121 /*******************************************************************
123 * @brief deallocate the memory allocated in E2SetupResponse
127 * Function : FreeE2SetupRsp
129 * Functionality: deallocate the memory allocated in E2SetupResponse
131 * @params[in] E2AP_PDU_t *e2apMsg
134 * ****************************************************************/
135 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
138 E2setupResponse_t *e2SetupRsp;
142 if(e2apMsg->choice.successfulOutcome)
144 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
145 if(e2SetupRsp->protocolIEs.list.array)
147 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
149 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
151 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
153 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
155 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
159 /*******************************************************************
161 * @brief Build E2node Component config addition ack list
165 * Function : BuildE2nodeComponentConfigAdditionAck
167 * Functionality: deallocate the memory allocated in E2SetupResponse
169 * @params[in] E2nodeComponentConfigAdditionAck_List_t
170 * *e2NodeConfigAdditionAckList
172 * @return ROK - success
174 * ****************************************************************/
175 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, uint8_t duId)
178 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
180 e2NodeConfigAdditionAckList->list.count = 1;
181 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
182 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
183 if(e2NodeConfigAdditionAckList->list.array == NULLP)
185 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
189 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
191 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
192 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
194 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
198 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
199 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
200 e2NodeAddAckItem->criticality = CriticalityE2_reject;
201 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
202 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
204 /* >E2 Node Component ID */
205 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
206 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
207 sizeof(E2nodeComponentInterfaceF1_t));
208 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
210 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
213 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
214 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
215 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
217 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
219 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
222 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duId;
224 /* >E2 Node Component Configuration Acknowledge*/
225 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
226 E2nodeComponentConfigurationAck__updateOutcome_success;
230 /*******************************************************************
232 * @brief Builds and sends the E2SetupResponse
236 * Function : BuildAndSendE2SetupRsp
238 * Functionality: Constructs the F1SetupResponse message and sends
239 * it back to the DU through SCTP.
241 * @params[in] void **buf,Buffer to which encoded pattern is written into
242 * @params[in] int *size,size of buffer
244 * @return ROK - success
247 * ****************************************************************/
248 uint8_t BuildAndSendE2SetupRsp(uint32_t duId)
250 E2AP_PDU_t *e2apMsg = NULL;
251 E2setupResponse_t *e2SetupRsp;
252 asn_enc_rval_t encRetVal;
255 bool memAllocFailed = false;
257 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
260 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
263 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
266 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
267 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
268 if(e2apMsg->choice.successfulOutcome == NULLP)
270 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
274 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
275 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
276 e2apMsg->choice.successfulOutcome->value.present = \
277 SuccessfulOutcomeE2__value_PR_E2setupResponse;
278 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
281 e2SetupRsp->protocolIEs.list.count = elementCnt;
282 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t);
284 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
285 if(e2SetupRsp->protocolIEs.list.array == NULLP)
287 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
291 for(idx=0; idx<elementCnt; idx++)
293 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
294 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
296 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
297 memAllocFailed = true;
302 if(memAllocFailed == true)
304 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
309 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
310 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
311 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
312 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
316 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
317 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
318 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
319 E2setupResponseIEs__value_PR_GlobalRIC_ID;
321 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
323 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
327 /* E2 Node Component Configuration Addition Acknowledge List*/
329 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
330 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
331 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
332 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
333 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duId)!=ROK)
335 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
339 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
340 memset(encBuf, 0, ENC_BUF_MAX_LEN);
342 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
344 /* Check encode results */
345 if(encRetVal.encoded == ENCODE_FAIL)
347 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
348 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
353 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
354 for(int i=0; i< encBufSize; i++)
356 DU_LOG("%x",encBuf[i]);
360 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
362 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
368 FreeE2SetupRsp(e2apMsg);
369 BuildAndSendRicSubscriptionReq(duId);
373 /*******************************************************************
375 * @brief Builds Ric Request Id
379 * Function : BuildRicRequestId
381 * Functionality: Building the Ric Request Id
383 * @params[in] RICrequestID_t *ricReqId
384 * @return ROK - success
387 * ****************************************************************/
389 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
392 if(ricReqId != NULLP)
394 ricReqId->ricRequestorID = 1;
395 ricReqId->ricInstanceID = 1;
400 /*******************************************************************
402 * @brief Fills Ric Action To be Setup Item
406 * Function : fillSetupItems
408 * Functionality: Filling ricAction Id, RicActionType
410 * @params[in] RICaction_ToBeSetup_Item_t *setupItems
411 * @return pointer of type RICaction_ToBeSetup_Item_t
413 * ****************************************************************/
415 RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems)
417 if(setupItems != NULLP)
419 setupItems->ricActionID = 0;
420 setupItems->ricActionType = RICactionType_report;
426 /*******************************************************************
428 * @brief Fills RIC Subscription Details Item List
432 * Function : fillSubsDetails
434 * Functionality: Fill the RIC Subscription Details Items List
436 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
437 * @return ROK - success
440 * ****************************************************************/
442 uint8_t fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items)
446 items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
447 items->criticality = CriticalityE2_ignore;
448 items->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
449 fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item));
454 /*******************************************************************
456 * @brief builds RIC Subscription Details
460 * Function : BuildsRicSubsDetails
462 * Functionality: Builds the RIC Subscription Details
464 * @params[in] RICsubscriptionDetails_t *subsDetails
465 * @return ROK - success
468 * ****************************************************************/
470 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
475 if(subsDetails != NULLP)
477 /* Octet string to be build here */
478 /* Sending PLMN as Octect string */
479 uint8_t byteSize = 3;
480 subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
481 RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
482 buildPlmnId(ricCb.ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
484 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
485 subsDetails->ricAction_ToBeSetup_List.list.size = \
486 elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t);
487 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \
488 subsDetails->ricAction_ToBeSetup_List.list.size);
489 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
491 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
494 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\
495 sizeof(RICaction_ToBeSetup_ItemIEs_t));
496 fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]);
501 /*******************************************************************
503 * @brief Builds and Send the RicSubscriptionReq
507 * Function : BuildAndSendRicSubscriptionReq
509 * Functionality:Fills the RicSubscriptionReq
511 * @return ROK - success
514 ******************************************************************/
516 uint8_t BuildAndSendRicSubscriptionReq(uint32_t duId)
519 E2AP_PDU_t *e2apRicMsg = NULL;
520 RICsubscriptionRequest_t *ricSubscriptionReq;
525 asn_enc_rval_t encRetVal; /* Encoder return value */
527 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
529 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
530 if(e2apRicMsg == NULLP)
532 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
536 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
537 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
538 if(e2apRicMsg->choice.initiatingMessage == NULLP)
540 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
541 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
544 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
545 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
546 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
548 RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t));
549 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
552 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
553 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
555 /* Initialize the subscription members */
556 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \
557 ricSubscriptionReq->protocolIEs.list.size);
558 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
560 DU_LOG("\nERROR --> E2AP : Memory allocation for RICSubscriptionRequestIEs failed");
561 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
562 RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t));
566 for(idx=0; idx<elementCnt; idx++)
568 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx],\
569 sizeof(RICsubscriptionRequest_IEs_t));
570 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
572 for(ieId=0; ieId<idx; ieId++)
574 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\
575 sizeof(RICsubscriptionRequest_IEs_t));
577 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\
578 ricSubscriptionReq->protocolIEs.list.size);
579 RIC_FREE(e2apRicMsg->choice.initiatingMessage, \
580 sizeof(InitiatingMessageE2_t));
581 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
586 /* Filling RIC Request Id */
588 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
589 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
590 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
591 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
593 BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID);
596 /* Filling RAN Function Id */
598 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
599 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
600 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
601 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
602 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
605 /* Filling RIC Subscription Details */
607 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
608 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
609 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
610 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
612 BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
615 /* Prints the Msg formed */
616 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
618 memset(encBuf, 0, ENC_BUF_MAX_LEN);
620 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
622 if(encRetVal.encoded == ENCODE_FAIL)
624 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
625 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
630 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
631 for(int i=0; i< encBufSize; i++)
633 DU_LOG("%x",encBuf[i]);
639 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
641 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
648 /*******************************************************************
650 * @brief Process RicSubscriptionResponse
654 * Function : ProcRicSubscriptionRsp
656 * Functionality: Processes RicSubscriptionRsp
660 ******************************************************************/
662 void ProcRicSubscriptionResponse(uint32_t duId)
667 DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged");
669 SEARCH_DU_DB(duIdx, duId, duDb);
671 duDb->ricSubscribedToDu = true;
674 /*******************************************************************
676 * @brief process the e2setup request
680 * Function : ProcE2SetupReq
682 * Functionality: process the e2setup request
684 * @return ROK - success
687 ******************************************************************/
689 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
691 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0;
693 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
694 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
698 if(e2SetupReq->protocolIEs.list.array)
700 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
702 if(e2SetupReq->protocolIEs.list.array[arrIdx])
704 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
706 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
708 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
709 if(e2NodeAddList->list.array)
711 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
713 if(e2NodeAddList->list.array[e2NodeAddListIdx])
715 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
716 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
717 e2nodeComponentInterfaceTypeF1)
719 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
720 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf)
722 *duId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
723 choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
724 SEARCH_DU_DB(duIdx, duId, duDb);
727 duDb = &ricCb.duInfo[ricCb.numDu];
730 memset(duDb, 0, sizeof(DuDb));
733 if(BuildAndSendE2SetupRsp(*duId) !=ROK)
735 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
755 /*******************************************************************
757 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
761 * Function : FreeE2NodeConfigUpdate
764 * - freeing the memory allocated for E2nodeConfigurationUpdate
766 * @params[in] E2AP_PDU_t *e2apMsg
767 * @return ROK - success
770 * ****************************************************************/
771 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
774 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
778 if(e2apMsg->choice.successfulOutcome != NULLP)
780 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
781 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
783 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
785 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
787 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
789 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
791 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
795 /*******************************************************************
797 * @brief Buld and send the E2 node config update msg
801 * Function : BuildAndSendE2NodeConfigUpdate
804 * - Buld and send the E2 node config update msg
805 * @return ROK - success
808 * ****************************************************************/
810 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
812 uint8_t arrIdx = 0,elementCnt = 1;
814 E2AP_PDU_t *e2apMsg = NULLP;
815 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
816 asn_enc_rval_t encRetVal; /* Encoder return value */
818 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
821 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
824 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
827 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
828 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
829 if(e2apMsg->choice.successfulOutcome == NULLP)
831 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
832 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
836 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
837 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
838 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
839 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
841 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
842 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
843 /* Initialize the Ric Indication members */
844 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
845 e2NodeConfigUpdateAck->protocolIEs.list.size);
846 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
848 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
852 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
854 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
855 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
858 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
865 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
866 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
867 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
868 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
871 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
873 memset(encBuf, 0, ENC_BUF_MAX_LEN);
875 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
877 if(encRetVal.encoded == ENCODE_FAIL)
879 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
880 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
885 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
886 for(int i=0; i< encBufSize; i++)
888 DU_LOG("%x",encBuf[i]);
894 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
896 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
903 FreeE2NodeConfigUpdateAck(e2apMsg);
907 /*******************************************************************
909 * @brief Handles received E2AP message and sends back response
913 * Function : E2APMsgHdlr
916 * - Decodes received E2AP control message
917 * - Prepares response message, encodes and sends to SCTP
920 * @return ROK - success
923 * ****************************************************************/
924 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
931 asn_dec_rval_t rval; /* Decoder return value */
932 E2AP_PDU_t e2apasnmsg ;
934 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
935 ODU_PRINT_MSG(mBuf, 0,0);
937 /* Copy mBuf into char array to decode it */
938 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
939 RIC_ALLOC(recvBuf, (Size)recvBufLen);
943 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
946 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
948 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
952 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
953 for(i=0; i< recvBufLen; i++)
955 DU_LOG("%x",recvBuf[i]);
958 /* Decoding flat buffer into E2AP messsage */
959 e2apMsg = &e2apasnmsg;
960 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
962 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
963 RIC_FREE(recvBuf, (Size)recvBufLen);
965 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
967 DU_LOG("\nERROR --> E2AP : ASN decode failed");
971 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
973 switch(e2apMsg->present)
975 case E2AP_PDU_PR_initiatingMessage:
977 switch(e2apMsg->choice.initiatingMessage->value.present)
979 case InitiatingMessageE2__value_PR_E2setupRequest:
981 DU_LOG("\nINFO --> E2AP : E2 setup request received");
982 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
985 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
987 DU_LOG("\nINFO --> E2AP : E2 node config update received");
988 BuildAndSendE2NodeConfigUpdateAck(*duId);
991 case InitiatingMessageE2__value_PR_RICindication:
993 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
998 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
1001 }/* End of switch(initiatingMessage) */
1004 case E2AP_PDU_PR_successfulOutcome:
1006 switch(e2apMsg->choice.successfulOutcome->value.present)
1008 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
1010 ProcRicSubscriptionResponse(*duId);
1015 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
1024 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
1028 }/* End of switch(e2apMsg->present) */
1029 } /* End of E2APMsgHdlr */
1032 /**********************************************************************
1034 **********************************************************************/