X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_e2ap_mgr.c;h=99b36230da2e8d85038d987a08e5441242684d3b;hb=61f1d2eec53a339d27c720eee5ded1869ec72fbb;hp=0c4b0b3b840143d8fec0da20a337c825063ee3e1;hpb=5b669934530a541a73f027aff9be4269a5fd6b52;p=o-du%2Fl2.git

diff --git a/src/du_app/du_e2ap_mgr.c b/src/du_app/du_e2ap_mgr.c
index 0c4b0b3b8..99b36230d 100644
--- a/src/du_app/du_e2ap_mgr.c
+++ b/src/du_app/du_e2ap_mgr.c
@@ -201,22 +201,33 @@ MeasurementInfo *fetchMeasInfoFromMeasTypeName(char *e2MeasTypeName, CmLListCp *
  *
  * @params[in] Action ID 
  *             RIC Subscription DB
+ *             Ric Action Node
+ *             Config Type
  * @return Action Info DB
  *         NULL, in case of failure
  *
  * ****************************************************************/
-ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo)
+ActionInfo *fetchActionInfoFromActionId(uint8_t actionId, RicSubscription *ricSubscriptionInfo, CmLList ** actionNode, ConfigType cfgType)
 {
    ActionInfo *actionInfoDb = NULLP;
-   if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+
+   CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, *actionNode);
+   while(*actionNode)
    {
-      actionInfoDb = &ricSubscriptionInfo->actionSequence[actionId];
+      actionInfoDb = (ActionInfo*)((*actionNode)->node);
+      if(actionInfoDb && (actionInfoDb->actionId == actionId) && (actionInfoDb->action == cfgType))
+      {
+         break;
+      }
+      *actionNode= (*actionNode)->next;
+      actionInfoDb = NULLP;
    }
-   else
+   
+   if(!actionInfoDb) 
    {
       DU_LOG("\nERROR  -->  E2AP : fetchActionInfoFromActionId: Action Id [%d] not found in \
-         subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
-         ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
+            subscription info [Requestor id : %d] [Instance Id : %d]", actionId,\
+            ricSubscriptionInfo->requestId.requestorId, ricSubscriptionInfo->requestId.instanceId);
 
    }
    return actionInfoDb;
@@ -471,20 +482,22 @@ uint8_t ResetE2Request(E2ProcedureDirection dir, E2FailureCause resetCause)
  * ****************************************************************/
 uint8_t fillRicSubsInMacStatsReq(MacStatsReq *macStatsReq, RicSubscription* ricSubscriptionInfo)
 {
-   uint8_t    actionIdx = 0, grpIdx = 0, statsIdx = 0;
+   uint8_t    grpIdx = 0, statsIdx = 0;
    uint64_t   subscriptionId = 0;
    ActionInfo *actionDb = NULLP;
+   CmLList *actionNode = NULLP;
    ActionDefFormat1 *format1Action = NULLP;
 
    /* Generate subscription ID using RIC Request ID and RAN Function ID */
    encodeSubscriptionId(&subscriptionId, ricSubscriptionInfo->ranFuncId, ricSubscriptionInfo->requestId);
 
    macStatsReq->subscriptionId = subscriptionId;
-   for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+   CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, actionNode);
+   while(actionNode)
    {
-      if(ricSubscriptionInfo->actionSequence[actionIdx].action == CONFIG_ADD)
+      actionDb = (ActionInfo*)(actionNode->node);
+      if(actionDb->action == CONFIG_ADD)
       {
-         actionDb = &ricSubscriptionInfo->actionSequence[actionIdx];
          macStatsReq->statsGrpList[grpIdx].groupId = actionDb->actionId;
          switch(actionDb->definition.formatType)
          {
@@ -533,6 +546,7 @@ uint8_t fillRicSubsInMacStatsReq(MacStatsReq *macStatsReq, RicSubscription* ricS
          if(macStatsReq->statsGrpList[grpIdx].numStats)
             grpIdx++;
       }
+      actionNode = actionNode->next;
    }
 
    macStatsReq->numStatsGroup = grpIdx;
@@ -585,42 +599,153 @@ uint8_t rejectAllStatsGroup(RanFunction *ranFuncDb, CmLList *ricSubscriptionNode
 
 /*******************************************************************
  *
- * @brief Process statistics response from MAC
+ * @brief Process statistics response received for subscription 
+ * modification req and send the ric subscription response msg
  *
  * @details
  *
- *    Function : e2ProcStatsRsp
+ *    Function : procStatsRspForSubsModReq
  *
  *    Functionality: Processes statistics configuration response
- *       from MAC. If configuration is succsessful, DUAPP starts
- *       reporting period timer for this subscription request
- *       from RIC
+ *     received for subscription modification req. 
+ *     [Step 1] - Fetch pendingSubsModRsp list from ran func db 
+ *     based on RIC request info.
+ *     [Step 2] - Traverse each index of accepted list received in
+ *     stats response.
+ *          [Step 2.1] - Added each action related info in pending 
+ *          rsp's accepted list and mark action status CONFIG_UNKNOWN.
+ *     [Step 3] - Traverse each index of rejected list received in
+ *     stats response.
+ *          [Step 3.1] - Added each action related info in pending 
+ *          rsp's rejected list and delete the action info from Db.
+ *     [Step 4] - Set addActionCompleted true, and  process the Pending
+ *          Subscription modification rsp list.
  *
- * @params[in] Statistics response received from MAC
+ * @params[in]
+ *             Mac Stats Rsp
+ *             Ran Function info
+ *             Ric subscription info
  *
  * @return ROK     - success
  *         RFAILED - failure
  *
  * ****************************************************************/
-uint8_t e2ProcStatsRsp(MacStatsRsp *statsRsp)
+uint8_t procStatsRspForSubsModReq(MacStatsRsp *statsRsp, RanFunction *ranFuncDb, RicSubscription *ricSubscriptionInfo)
 {
    uint8_t idx = 0;
    uint8_t actionId = 0;
-   uint32_t reportingPeriod = 0;
-   RanFunction *ranFuncDb = NULLP;
-   CmLList *ricSubscriptionNode = NULLP;
-   RicSubscription *ricSubscriptionInfo = NULLP;
+   CmLList *actionNode = NULLP;
    ActionInfo *actionInfoDb = NULLP;
-   PendingSubsRspInfo *pendingSubsRsp = NULLP;
+   PendingSubsModRspInfo *pendingSubsModRsp = NULLP;
+   
+   /* Step - 1 */
+   for(idx=0; idx<ranFuncDb->numPendingSubsModRsp; idx++)
+   {
+      if((ranFuncDb->pendingSubsModRspInfo[idx].requestId.requestorId == ricSubscriptionInfo->requestId.requestorId) &&
+            (ricSubscriptionInfo->requestId.instanceId == ricSubscriptionInfo->requestId.instanceId))
+      {
+         pendingSubsModRsp = &ranFuncDb->pendingSubsModRspInfo[idx];
+         break;
+      }
+   }
+   
+   if(pendingSubsModRsp == NULLP)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
 
-   /* Fetch RAN Function and Subscription DB using subscription Id received in statistics response */
-   if(fetchSubsInfoFromSubsId(statsRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
+   /* Step - 2 */
+   for(idx=0; idx<statsRsp->numGrpAccepted; idx++)
+   {
+      actionInfoDb = NULLP;
+
+      actionId = statsRsp->statsGrpAcceptedList[idx];
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_ADD);
+      if(actionInfoDb)
+      {
+         /* Step - 2.1 */
+         actionInfoDb->action = CONFIG_UNKNOWN;
+         pendingSubsModRsp->addActionStatus.acceptedActionList[pendingSubsModRsp->addActionStatus.numOfAcceptedActions++] = actionId;
+      }
+   }
+
+   /* Step - 3 */
+   for(idx=0; idx<statsRsp->numGrpRejected; idx++)
    {
-      DU_LOG("\nERROR  -->  E2AP : DuProcMacStatsRsp: Failed to fetch subscriprtion details");
+      actionInfoDb = NULLP;
+      actionId = statsRsp->statsGrpRejectedList[idx].groupId;
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_ADD);
+      if(actionInfoDb)
+      {
+         /* Step - 3.1 */
+         cmLListDelFrm(&ricSubscriptionInfo->actionSequence, actionNode);
+         deleteActionSequence(actionNode);
+         pendingSubsModRsp->addActionStatus.rejectedActionList[pendingSubsModRsp->addActionStatus.numOfRejectedActions].id = actionId;
+         convertDuCauseToE2Cause(statsRsp->statsGrpRejectedList[idx].cause, \
+               &pendingSubsModRsp->addActionStatus.rejectedActionList[pendingSubsModRsp->addActionStatus.numOfRejectedActions].failureCause);
+         pendingSubsModRsp->addActionStatus.numOfRejectedActions++;
+      }
+   }
+   
+   /* Step - 4 */
+   pendingSubsModRsp->addActionCompleted =true; 
+   if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
       return RFAILED;
    }
+   return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Process statistics response for subscription req and 
+ * send the ric subscription response msg
+ *
+ * @details
+ *
+ *    Function : procStatsRspForSubsReq
+ *
+ *    Functionality: Processes statistics configuration response
+ *     received for subscription req.  
+ *     [Step 1] - Fetch PendingSubsRspInfo list from ran func db 
+ *     based on RIC request info.
+ *     [Step 2] - If all stats group got rejected then send delete
+ *     ric subs action info from db and send ric subscription delete
+ *     message to ric
+ *     [Step 3] - Store and start RIC Subscription reporting timer.
+ *     [Step 4] - Traverse each index of accepted list received in
+ *     stats response.
+ *          [Step 4.1] - Added each action related info in pending 
+ *          rsp's accepted list and mark action status CONFIG_UNKNOWN.
+ *     [Step 5] - Traverse each index of rejected list received in
+ *     stats response.
+ *          [Step 5.1] - Added each action related info in pending 
+ *          rsp's rejected list and delete the action info from Db.
+ *     [Step 6] - Send subscription response with accepted and rejected 
+ *     action lists to RIC.
+ *
+ * @params[in] 
+ *             Mac Stats Rsp
+ *             Ran Function info
+ *             Ric subscription node
+ *             Ric subscription info
+ *
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t procStatsRspForSubsReq(MacStatsRsp *statsRsp, RanFunction *ranFuncDb,  CmLList *ricSubscriptionNode, RicSubscription *ricSubscriptionInfo)
+{
+   uint8_t idx = 0;
+   uint8_t actionId = 0;
+   uint32_t reportingPeriod = 0;
+   CmLList *actionNode = NULLP;
+   ActionInfo *actionInfoDb = NULLP;
+   PendingSubsRspInfo *pendingSubsRsp = NULLP;
 
-   /* Fetch pre-stored statistics response info by DU APP */
+   /* [Step 1]  */
    for(idx=0; idx<ranFuncDb->numPendingSubsRsp; idx++)
    {
       if((ranFuncDb->pendingSubsRspInfo[idx].requestId.requestorId == ricSubscriptionInfo->requestId.requestorId) &&
@@ -630,35 +755,34 @@ uint8_t e2ProcStatsRsp(MacStatsRsp *statsRsp)
          break;
       }
    }
-
-   /* If no action is accepted
-    *  a. Remove subcription entry from RAN Function
-    *  b. Send RIC subscription failure */
+   
+   if(pendingSubsRsp == NULLP)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+   
    if(statsRsp->numGrpAccepted == 0)
    {
+      /* [Step 2 ]  */
       rejectAllStatsGroup(ranFuncDb, ricSubscriptionNode, statsRsp);
    }
    else
    {
-      /* Once RIC subscription is successful, mark the config action as unknown */
-      ricSubscriptionInfo->action = CONFIG_UNKNOWN;
-
-      /* Start RIC Subscription reporting timer */
+      /* [Step 3 ]  */
       switch(ricSubscriptionInfo->eventTriggerDefinition.formatType)
       {
          case 1:
             {
                reportingPeriod = ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod;
-
-               /* Save the start time of reporting period */
                storeReportStartTime(&ricSubscriptionInfo->eventTriggerDefinition.choice.format1.startTime);
                break;
             }
          default:
-         {
-            DU_LOG("\nERROR  -->  E2AP : Invalid event trigger format of RIC subscription");
-            return RFAILED;
-         }
+            {
+               DU_LOG("\nERROR  -->  E2AP : Invalid event trigger format of RIC subscription");
+               return RFAILED;
+            }
       }
       if(duChkTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) != true)
       {
@@ -666,42 +790,37 @@ uint8_t e2ProcStatsRsp(MacStatsRsp *statsRsp)
       }
       else
       {
-         DU_LOG("\nERROR  -->  E2AP : RIC Subscription reporting timer already running for RIC Subscription");  
+         DU_LOG("\nERROR  -->  E2AP : RIC Subscription reporting timer already running for RIC Subscription");
          return RFAILED;
       }
 
 
-      /* If even 1 action is accepted :
-       *
-       * For accepted groups:
-       *    Mark subscribed-action's -> action = CONFIG_UNKNOWN
-       *    Add to accepted-action-list of subscription response
-       */
+      /* [ Step 4 ]  */
       for(idx=0; idx<statsRsp->numGrpAccepted; idx++)
       {
          actionInfoDb = NULLP;
 
          actionId = statsRsp->statsGrpAcceptedList[idx];
-         actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo);
-         if(actionInfoDb && (actionInfoDb->action == CONFIG_ADD))
+         actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_ADD);
+         if(actionInfoDb)
          {
+            /* [ Step 4.1 ]  */
             actionInfoDb->action = CONFIG_UNKNOWN;
             pendingSubsRsp->acceptedActionList[pendingSubsRsp->numOfAcceptedActions++] = actionId;
          }
       }
 
-      /* For rejected groups:
-       *    Remove entry from DU's RAN Function->subscription->actionList
-       *    Add to rejected-action-list in subscription response
-       */
+      /* [ Step 5 ]  */
       for(idx=0; idx<statsRsp->numGrpRejected; idx++)
       {
+         actionInfoDb = NULLP;
          actionId = statsRsp->statsGrpRejectedList[idx].groupId;
-         if(ricSubscriptionInfo->actionSequence[actionId].actionId == actionId)
+         actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_ADD);
+         if(actionInfoDb)
          {
-            memset(&ricSubscriptionInfo->actionSequence[actionId], 0, sizeof(ActionInfo));
-            ricSubscriptionInfo->numOfActions--;
-
+            /* [ Step 5.1 ]  */
+            cmLListDelFrm(&ricSubscriptionInfo->actionSequence, actionNode);
+            deleteActionSequence(actionNode);
             pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].id = actionId;
             convertDuCauseToE2Cause(statsRsp->statsGrpRejectedList[idx].cause, \
                   &pendingSubsRsp->rejectedActionList[pendingSubsRsp->numOfRejectedActions].failureCause);
@@ -709,10 +828,77 @@ uint8_t e2ProcStatsRsp(MacStatsRsp *statsRsp)
          }
       }
 
-      /* Send subscription response with accepted and rejected action lists to RIC */
-      BuildAndSendRicSubscriptionRsp(pendingSubsRsp);
+      /* [ Step 6]  */
+      if(BuildAndSendRicSubscriptionRsp(pendingSubsRsp) != ROK)
+      {
+         DU_LOG("\nERROR  -->  E2AP : Failed to build and send RIC Subscription rsp");
+         return RFAILED;
+      }
    }
    memset(pendingSubsRsp, 0, sizeof(PendingSubsRspInfo));
+   ricSubscriptionInfo->action = CONFIG_UNKNOWN;
+   return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Process statistics response from MAC
+ *
+ * @details
+ *
+ *    Function : e2ProcStatsRsp
+ *
+ *    Functionality: Processes statistics configuration response
+ *       from MAC.
+ *       [Step -1]Fetch RAN Function and Subscription DB using 
+ *       subscription Id received in statistics response
+ *       [Step -2]check ricSubscriptionInfo's action
+ *          [Step 2.1]if action == CONFIG_ADD, if no group 
+ *          accepted then reject all stats group and send ric
+ *          subscription failure. Else process stats rsp for 
+ *          RIC subscription response.
+ *          [Step 2.1]if action == CONFIG_MOD, process stats rsp 
+ *          for RIC subscription modification response.
+ *
+ * @params[in] Statistics response received from MAC
+ *
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t e2ProcStatsRsp(MacStatsRsp *statsRsp)
+{
+   RanFunction *ranFuncDb = NULLP;
+   CmLList *ricSubscriptionNode = NULLP;
+   RicSubscription *ricSubscriptionInfo = NULLP;
+
+   /*  [Step -1] */
+   if(fetchSubsInfoFromSubsId(statsRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+   
+   /*  [Step -2] */
+   if(ricSubscriptionInfo->action == CONFIG_ADD)
+   {
+      /*  [Step -2.1] */
+      if(procStatsRspForSubsReq(statsRsp, ranFuncDb, ricSubscriptionNode, ricSubscriptionInfo) != ROK)
+      {
+         rejectAllStatsGroup(ranFuncDb, ricSubscriptionNode, statsRsp);
+         DU_LOG("\nERROR  -->  E2AP : Failed to build and send RIC Subscription rsp");
+         return RFAILED;
+      }
+   }
+   else if(ricSubscriptionInfo->action == CONFIG_MOD)
+   {
+      /*  [Step -2.2] */
+      if(procStatsRspForSubsModReq(statsRsp, ranFuncDb, ricSubscriptionInfo) != ROK)
+      {
+         DU_LOG("\nERROR  -->  E2AP : Failed to build and send RIC Subscription rsp");
+         return RFAILED;
+      }
+   }
    return ROK;
 }
 
@@ -738,6 +924,7 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
    uint8_t statsIdx = 0;
    RanFunction *ranFuncDb = NULLP;
    CmLList *ricSubscriptionNode = NULLP;
+   CmLList *actionNode = NULLP;
    RicSubscription *ricSubscriptionInfo = NULLP;
    ActionInfo *actionInfo = NULLP;
    ActionDefFormat1 *actionFormat = NULLP;
@@ -758,15 +945,15 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
     * in statistics response */
    if(fetchSubsInfoFromSubsId(statsInd->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
    {
-      DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Failed to fetch subscriprtion details");
+      DU_LOG("\nERROR  -->  E2AP : %s : Failed to fetch subscriprtion details",__func__);
       return RFAILED;
    }
 
    /* Fetch RIC subscription's action DB */
-   actionInfo = fetchActionInfoFromActionId(statsInd->groupId, ricSubscriptionInfo);
+   actionInfo = fetchActionInfoFromActionId(statsInd->groupId, ricSubscriptionInfo, &actionNode, CONFIG_UNKNOWN);
    if(actionInfo == NULLP)
    {
-      DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Failed to fetch action ID [%d]", statsInd->groupId);
+      DU_LOG("\nERROR  -->  E2AP : %s: Failed to fetch action ID [%d]",__func__, statsInd->groupId);
       return RFAILED;
    }
 
@@ -780,7 +967,7 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
          }
       default:
          {
-            DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Action Format [%d] is not supported", \
+            DU_LOG("\nERROR  -->  E2AP : %s: Action Format [%d] is not supported", __func__,\
                   actionInfo->definition.formatType);
             return RFAILED;
          }
@@ -796,8 +983,8 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
       /* Convert Measurement type from MAC-supported format to E2-supported format */
       if(convertMacMeasTypeToE2MeasType(statsInd->measuredStatsList[statsIdx].type, e2MeasTypeName) != ROK)
       {
-         DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Failed to convert measurement type from MAC-supported\
-            MAC-supported format to E2-supported format");
+         DU_LOG("\nERROR  -->  E2AP : %s: Failed to convert measurement type from MAC-supported\
+            MAC-supported format to E2-supported format",__func__);
          continue;
       }
       
@@ -805,7 +992,7 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
       measInfo = fetchMeasInfoFromMeasTypeName(e2MeasTypeName, &actionFormat->measurementInfoList, &measInfoNode); 
       if(measInfo == NULLP)
       {
-         DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Measurement Type Name [%s] not found", e2MeasTypeName); 
+         DU_LOG("\nERROR  -->  E2AP : %s: Measurement Type Name [%s] not found", __func__,e2MeasTypeName); 
          continue;
       }
       
@@ -813,7 +1000,7 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
       DU_ALLOC(measValue, sizeof(double));
       if(!measValue)
       {
-         DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Memory allocation failed at line [%d]", __LINE__);
+         DU_LOG("\nERROR  -->  E2AP : %s: Memory allocation failed at line [%d]",__func__, __LINE__);
          return RFAILED; 
       }
       *measValue = statsInd->measuredStatsList[statsIdx].value;
@@ -821,7 +1008,7 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
       DU_ALLOC(measValueNode, sizeof(CmLList));
       if(!measValueNode)
       {
-         DU_LOG("\nERROR  -->  E2AP : extractStatsMeasurement: Memory allocation failed at line [%d]", __LINE__);
+         DU_LOG("\nERROR  -->  E2AP : %s : Memory allocation failed at line [%d]",__func__, __LINE__);
          DU_FREE(measValue, sizeof(double));
          return RFAILED; 
       }
@@ -849,15 +1036,16 @@ uint8_t e2ProcStatsInd(MacStatsInd *statsInd)
  * ****************************************************************/
 void E2apHdlRicSubsReportTmrExp(RicSubscription *ricSubscription)
 {
-   uint8_t actionIdx = 0;
    uint32_t reportingPeriod = 0;
+   ActionInfo *action=NULLP;
+   CmLList *actionNode=NULLP;
 
-   for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
+   CM_LLIST_FIRST_NODE(&ricSubscription->actionSequence, actionNode);
+   while(actionNode)
    {
-      if(ricSubscription->actionSequence[actionIdx].actionId >= 0)
-      {
-         BuildAndSendRicIndication(ricSubscription, &ricSubscription->actionSequence[actionIdx]);  
-      }
+      action = (ActionInfo*)actionNode->node;
+      BuildAndSendRicIndication(ricSubscription, action);
+      actionNode = actionNode->next;
    }
 
    /* Start RIC Subscription reporting timer again */
@@ -1288,31 +1476,66 @@ void deleteMeasurementInfoList(CmLListCp *measInfoList)
  * @return void 
  *
  * ****************************************************************/
-void deleteActionSequence(ActionInfo *action)
+void deleteActionSequence(CmLList *actionNode)
 {
+   ActionInfo *action = NULLP;
    ActionDefinition *definition=NULLP;
-   definition= &action->definition;       
    
-   switch(definition->formatType)
+   if(actionNode)
    {
-      case 1:
-         {
-            deleteMeasurementInfoList(&definition->choice.format1.measurementInfoList);
-            break;
-         }
+      action = (ActionInfo*)actionNode->node;
+      definition= &action->definition;       
 
-      case 2:
-      case 3:
-      case 4:
-      case 5:
-      default:
+      switch(definition->formatType)
       {
-         DU_LOG("\nERROR  -->  E2AP : Format %d does not supported", definition->formatType);
-         break;
+         case 1:
+            {
+               deleteMeasurementInfoList(&definition->choice.format1.measurementInfoList);
+               break;
+            }
+
+         case 2:
+         case 3:
+         case 4:
+         case 5:
+         default:
+            {
+               DU_LOG("\nERROR  -->  E2AP : Format %d does not supported", definition->formatType);
+               break;
+            }
       }
+      memset(action, 0, sizeof(ActionInfo));
+      DU_FREE(actionNode->node, sizeof(ActionInfo));
+      DU_FREE(actionNode, sizeof(CmLList));
+   }
+}
+
+/******************************************************************
+ *
+ * @brief Delete Ric subscription action list
+ *
+ * @details
+ *
+ *    Function : deleteActionSequenceList
+ *
+ *    Functionality: Delete Ric subscription action list
+ *
+ * @params[in] Action info list
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void deleteActionSequenceList(CmLListCp *actionList)
+{
+   CmLList *actionNode=NULLP;
+
+   CM_LLIST_FIRST_NODE(actionList, actionNode);
+   while(actionNode)
+   {
+      cmLListDelFrm(actionList, actionNode);
+      deleteActionSequence(actionNode);
+      CM_LLIST_FIRST_NODE(actionList, actionNode);
    }
-   memset(action, 0, sizeof(ActionInfo));
-   action->actionId = -1;
 }
 
 /******************************************************************
@@ -1332,19 +1555,11 @@ void deleteActionSequence(ActionInfo *action)
  * ****************************************************************/
 void deleteRicSubscriptionNode(CmLList *subscriptionNode)
 {
-   uint8_t actionIdx=0;
    RicSubscription *ricSubscriptionInfo = NULLP;
 
    ricSubscriptionInfo = (RicSubscription*)subscriptionNode->node;    
 
-   for(actionIdx = 0; actionIdx < MAX_RIC_ACTION; actionIdx++)
-   {
-      if(ricSubscriptionInfo->actionSequence[actionIdx].actionId > -1)
-      {
-         deleteActionSequence(&ricSubscriptionInfo->actionSequence[actionIdx]);
-      }
-   }
-
+   deleteActionSequenceList(&ricSubscriptionInfo->actionSequence);
    if(duChkTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) == TRUE)
    {
       duStopTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR);
@@ -1463,9 +1678,502 @@ void removeE2NodeInformation()
    memset(&duCb.e2apDb.ricId, 0, sizeof(GlobalRicId));
    duCb.e2apDb.numOfTNLAssoc = 0;
    memset(&duCb.e2apDb.tnlAssoc, 0, MAX_TNL_ASSOCIATION*sizeof(TNLAssociation));
-   cmInetClose(&ricParams.sockFd);
    memset(&ricParams, 0, sizeof(DuSctpDestCb));
 }
+
+/*******************************************************************
+ *
+ * @brief Extract statistics received from DU layers and delete
+ * Ric subscription info
+ *
+ * @details
+ *
+ *    Function :e2ProcStatsDeleteRsp 
+ *
+ *    Functionality: Extract statistics received from DU layers
+ *       and delete ric subscription iformation form db
+ *
+ * @params[in] Statistics delete rsp from MAC
+ * @return ROK-success
+ *         RFAILED-failure
+ *
+ * ****************************************************************/
+uint8_t e2ProcStatsDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp)
+{
+   RicRequestId    requestId;
+   uint16_t        ranFuncId;
+   RanFunction *ranFuncDb = NULLP;
+   CmLList *ricSubscriptionNode = NULLP;
+   RicSubscription *ricSubscriptionInfo = NULLP;
+   E2FailureCause failureCause;
+
+   /* Fetch RAN Function and Subscription DB using subscription Id received
+    * in statistics delete response */
+   if(fetchSubsInfoFromSubsId(statsDeleteRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : e2ProcStatsDeleteRsp: Failed to fetch subscriprtion details");
+      return RFAILED;
+   }
+   ranFuncId = ricSubscriptionInfo->ranFuncId;
+   memcpy(&requestId, &ricSubscriptionInfo->requestId, sizeof(RicRequestId));
+
+   deleteRicSubscriptionNode(ricSubscriptionNode);
+   
+   if(statsDeleteRsp->subsDelRsp == MAC_DU_APP_RSP_NOK)
+   {
+      if(statsDeleteRsp->subsDelCause == STATS_ID_NOT_FOUND)
+      {
+         failureCause.causeType =E2_RIC_REQUEST;
+         failureCause.cause = E2_REQUEST_INFORMATION_UNAVAILABLE;
+      }
+      else
+      {
+         failureCause.causeType = E2_MISCELLANEOUS;
+         failureCause.cause = E2_MISCELLANEOUS_CAUSE_UNSPECIFIED;
+      }
+
+      if(BuildAndSendRicSubscriptionDeleteFailure(ranFuncId, requestId, failureCause) != ROK)
+      {
+         DU_LOG("\nERROR  -->  E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete failure");
+         return RFAILED;
+      }
+   }
+   else
+   {
+      if(BuildAndSendRicSubscriptionDeleteResponse(ranFuncId, requestId) != ROK)
+      {
+         DU_LOG("\nERROR  -->  E2AP : e2ProcStatsDeleteRsp: failed to build and send ric subs delete rsp");
+         return RFAILED;
+      }
+   }
+   
+   return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Extract statistics received from DU layers and delete
+ * Ric subscription's action info
+ *
+ * @details
+ *
+ *    Function : e2ProcActionDeleteRsp
+ *
+ *    Functionality: 
+ *       [Step-1] Fetch RAN Function and Subscription DB using 
+ *       subscription Id received in statistics delete response.
+ *       [Step-2] Fetch pending ric subs modification rsp info
+ *       from ran func db based on ric request information.
+ *       [Step 3] - Traverse each index of stats group delete list 
+ *       received in stats delete response.
+ *         [Step 3.1] - If action deleted successfully, delete the 
+ *         node from DB and fill the action info in the pending ric 
+ *         subs modification rsp's accepted list.
+ *         [Step 3.1] - Else fill the action info in the pending ric 
+ *         subs modification rsp's rejected list.
+ *       [Step 4] - Set removeActionCompleted true and process the 
+ *       Pending Subscription modification rsp list.
+ *
+ *
+ * @params[in] Statistics delete rsp 
+ * @return ROK-success
+ *         RFAILED-failure
+ *
+ * ****************************************************************/
+uint8_t e2ProcActionDeleteRsp(MacStatsDeleteRsp *statsDeleteRsp)
+{
+   uint8_t idx = 0;
+   uint8_t actionId = 0;
+   uint8_t tmpIndex = 0;
+   CmLList *actionNode = NULLP;
+   ActionInfo *actionInfoDb = NULLP;
+   PendingSubsModRspInfo *pendingSubsModRsp = NULLP;
+   RanFunction *ranFuncDb = NULLP;
+   CmLList *ricSubscriptionNode = NULLP;
+   RicSubscription *ricSubscriptionInfo = NULLP;
+
+   /* [Step-1]  */
+   if(fetchSubsInfoFromSubsId(statsDeleteRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+   
+   /* [Step-2]  */
+   for(idx=0; idx<ranFuncDb->numPendingSubsModRsp; idx++)
+   {
+      if((ranFuncDb->pendingSubsModRspInfo[idx].requestId.requestorId == ricSubscriptionInfo->requestId.requestorId) &&
+            (ricSubscriptionInfo->requestId.instanceId == ricSubscriptionInfo->requestId.instanceId))
+      {
+         pendingSubsModRsp = &ranFuncDb->pendingSubsModRspInfo[idx];
+         break;
+      }
+   }
+
+   if(pendingSubsModRsp == NULLP)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+
+   /* [Step-3]  */
+   for(idx=0; idx<statsDeleteRsp->numStatsGroupDeleted; idx++)
+   {
+      actionInfoDb = NULLP;
+      actionId = statsDeleteRsp->statsGrpDelInfo[idx].groupId;
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_DEL);
+      if(actionInfoDb)
+      {
+         if(statsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelRsp == MAC_DU_APP_RSP_OK)
+         {
+            /* [Step-3.1]  */
+            tmpIndex = pendingSubsModRsp->removeActionStatus.numOfAcceptedActions;
+            actionInfoDb->action = CONFIG_UNKNOWN;
+            cmLListDelFrm(&ricSubscriptionInfo->actionSequence, actionNode);
+            deleteActionSequence(actionNode);
+            pendingSubsModRsp->removeActionStatus.acceptedActionList[tmpIndex] = actionId;
+            pendingSubsModRsp->removeActionStatus.numOfAcceptedActions++;
+         }
+         else
+         {
+            /* [Step-3.2]  */
+            tmpIndex = pendingSubsModRsp->removeActionStatus.numOfRejectedActions;
+            pendingSubsModRsp->removeActionStatus.rejectedActionList[tmpIndex].id = actionId;
+            convertDuCauseToE2Cause(statsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause,\
+            &pendingSubsModRsp->removeActionStatus.rejectedActionList[tmpIndex].failureCause);
+            pendingSubsModRsp->removeActionStatus.numOfRejectedActions++;
+         }
+      }
+   }
+   
+   /* [Step-4]  */
+   pendingSubsModRsp->removeActionCompleted = true;
+   if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed to process subscription modification rsp");
+      return RFAILED;
+   }
+   return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief du process pending ric subscription modification rsp 
+ * recieved from the layers
+ *
+ * @details
+ *
+ *    Function : duProcPendingSubsModRsp 
+ *
+ *    Functionality: Process pending subscription modification response 
+ *                If processing of add, mod and remove action completes 
+ *                then send the ric sub modification rsp
+ *
+ * @params[in] 
+ *             Ric subscription info
+ *             Pending Subs modification rsp
+ *
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duProcPendingSubsModRsp(RicSubscription *ricSubscriptionInfo, PendingSubsModRspInfo *pendingSubsModRsp)
+{
+   uint8_t ret = RFAILED;
+   uint32_t reportingPeriod = 0;
+   
+   while(true)
+   {
+      if(pendingSubsModRsp->addActionCompleted && pendingSubsModRsp->removeActionCompleted && pendingSubsModRsp->modActionCompleted)
+      {
+         switch(ricSubscriptionInfo->eventTriggerDefinition.formatType)
+         {
+            case 1:
+               {
+                  reportingPeriod = ricSubscriptionInfo->eventTriggerDefinition.choice.format1.reportingPeriod;
+                  storeReportStartTime(&ricSubscriptionInfo->eventTriggerDefinition.choice.format1.startTime);
+                  break;
+               }
+            default:
+               {
+                  DU_LOG("\nERROR  -->  E2AP : Invalid event trigger format of RIC subscription");
+                  break;
+               }
+         }
+         if(reportingPeriod == 0)
+         {
+            DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+            break;
+         }
+
+         if(duChkTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR) != true)
+         {
+            duStartTmr((PTR)ricSubscriptionInfo, EVENT_RIC_SUBSCRIPTION_REPORTING_TMR, reportingPeriod);
+         }
+         else
+         {
+            DU_LOG("\nERROR  -->  E2AP : RIC Subscription reporting timer already running for RIC Subscription");
+            break;
+         }
+
+         if(BuildAndSendRicSubscriptionModificationResponse(pendingSubsModRsp) != ROK)
+         {
+            DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+            break;
+         }
+
+         memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo));
+         DU_LOG("\nProcessing of RIC subscription modification completed");
+         ret = ROK;
+         break;
+      }
+      else
+      {
+         ret = ROK;
+         break;
+      }
+   }
+   
+   if(ret == RFAILED)
+   {
+      memset(pendingSubsModRsp, 0, sizeof(PendingSubsModRspInfo));
+   }
+   return ret;
+}
+/*******************************************************************
+ *
+ * @brief Process statistics modification response from MAC
+ *
+ * @details
+ *
+ *    Function : e2ProcStatsModificationRsp
+ *
+ *    Functionality: Processes statistics modification configuration 
+ *     response from MAC.
+ *     [Step-1] Fetch RAN Function and Subscription DB using subs Id
+ *     received in statistics modification response.
+ *     [Step-2] Fetch pre-stored statistics mod response info by DUAPP.
+ *     [Step 3] - Traverse each index of accepted list received in
+ *     stats modification response.
+ *          [Step 3.1] - fetch action info from databse which is set
+ *          as CONFIG_UNKNOWN and then delete the node.
+ *          [Step 3.1] - Again fetch action info from databse which is 
+ *          set as CONFIG_MOD. Change the action status as CONFIG_UNKNOWN.
+ *          fill the action in pending subscription modification rsp's 
+ *          accepted list.
+ *     [Step 4] - Traverse each index of rejected list received in
+ *     stats modification response.
+ *          [Step 4.1] - fetch action info from databse and delete 
+ *          the action node which is set as CONFIG_MOD. and then 
+ *          fill the action in pending subscription modification rsp's 
+ *          rejected list.
+ *     [Step 5] - Send subscription response with accepted and rejected 
+ * @params[in] Statistics modification response received from MAC
+ *
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t e2ProcStatsModificationRsp(MacStatsModificationRsp *statsModificationRsp)
+{
+   uint8_t idx = 0;
+   uint8_t actionId = 0;
+   uint8_t tempCount = 0;
+   RanFunction *ranFuncDb = NULLP;
+   CmLList *actionNode = NULLP;
+   ActionInfo *actionInfoDb = NULLP;
+   CmLList *ricSubscriptionNode = NULLP;
+   RicSubscription *ricSubscriptionInfo = NULLP;
+   PendingSubsModRspInfo *pendingSubsModRsp = NULLP;
+
+
+   /* [Step-1] */
+   if(fetchSubsInfoFromSubsId(statsModificationRsp->subscriptionId, &ranFuncDb, &ricSubscriptionNode, &ricSubscriptionInfo) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+
+   /* [Step-2] */
+   for(idx=0; idx<ranFuncDb->numPendingSubsModRsp; idx++)
+   {
+      if((ranFuncDb->pendingSubsModRspInfo[idx].requestId.requestorId == ricSubscriptionInfo->requestId.requestorId) &&
+            (ricSubscriptionInfo->requestId.instanceId == ricSubscriptionInfo->requestId.instanceId))
+      {
+         pendingSubsModRsp = &ranFuncDb->pendingSubsModRspInfo[idx];
+         break;
+      }
+   }
+   if(pendingSubsModRsp == NULLP)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed in function %s at line %d",__func__,__LINE__);
+      return RFAILED;
+   }
+
+   /* [Step-3] */
+   for(idx=0; idx<statsModificationRsp->numGrpAccepted; idx++)
+   {
+      actionInfoDb = NULLP;
+      actionId = statsModificationRsp->statsGrpAcceptedList[idx];
+      
+      /* [Step-3.1] */
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode,CONFIG_UNKNOWN);
+      if(actionInfoDb)
+      {
+         cmLListDelFrm(&ricSubscriptionInfo->actionSequence, actionNode);
+         deleteActionSequence(actionNode);
+      }
+      
+      /* [Step-3.2] */
+      actionNode=NULLP;
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode,CONFIG_MOD);
+      if(actionInfoDb)
+      {
+         actionInfoDb->action = CONFIG_UNKNOWN;
+      }
+      pendingSubsModRsp->modActionStatus.acceptedActionList[pendingSubsModRsp->modActionStatus.numOfAcceptedActions++] = actionId;
+   }
+
+   /* [Step-4] */
+   for(idx=0; idx<statsModificationRsp->numGrpRejected; idx++)
+   {
+      actionInfoDb = NULLP;
+      actionId = statsModificationRsp->statsGrpRejectedList[idx].groupId;
+
+      /* [Step-4.1] */
+      actionInfoDb = fetchActionInfoFromActionId(actionId, ricSubscriptionInfo, &actionNode, CONFIG_MOD);
+      if(actionInfoDb)
+      {
+         cmLListDelFrm(&ricSubscriptionInfo->actionSequence, actionNode);
+         deleteActionSequence(actionNode);
+         tempCount = pendingSubsModRsp->modActionStatus.numOfRejectedActions;
+         pendingSubsModRsp->modActionStatus.rejectedActionList[tempCount].id = actionId;
+         convertDuCauseToE2Cause(statsModificationRsp->statsGrpRejectedList[idx].cause, \
+         &pendingSubsModRsp->modActionStatus.rejectedActionList[tempCount].failureCause);
+         pendingSubsModRsp->modActionStatus.numOfRejectedActions++;
+      }
+   }
+   
+   /* [Step-5] */
+   pendingSubsModRsp->modActionCompleted = true;
+   if(duProcPendingSubsModRsp(ricSubscriptionInfo, pendingSubsModRsp) != ROK)
+   {
+      DU_LOG("\nERROR  -->  E2AP : failed to process subscription modification rsp");
+      return RFAILED;
+   }
+   return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RIC Subscription datils in MAC Statistics 
+ * ModificationRequest
+ *
+ * @details
+ *
+ *    Function : fillRicSubsInMacStatsModificationReq
+ *
+ *    Functionality: Fill RIC Subscription datils in MAC 
+ *    Modification Statistics Request
+ *    [Step -1] Generate subscription ID using RIC Request ID and 
+ *    RAN Function ID
+ *    [Step -2] Check all the action staus of each action present
+ *    in the ric subscription. If action is CONFIG_MOD then fill
+ *    the information in stats group list.
+ *    [Step -3] Fill group related information in stats modification 
+ *    req's in stats group list
+ *    [Step -4] fill measurement information in stats group list
+ *    [Step -5] If the number of stats which needs to modify is 
+ *    greater then zero then return ROK else return RFAILED
+ *
+ * @params[in] MAC Statistics Modification Request to be filled
+ *             RIC Subscription Info
+ *
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRicSubsInMacStatsModificationReq(MacStatsModificationReq *macStatsModificationReq, RicSubscription* ricSubscriptionInfo)
+{
+   uint8_t    grpIdx = 0;
+   uint8_t statsModifyReqIdx = 0;
+   uint64_t   subscriptionId = 0;
+   CmLList *node = NULLP;
+   ActionInfo *actionDb = NULLP;
+   CmLList *actionNode = NULLP;
+   MeasurementInfo *measInfo = NULLP;
+   ActionDefFormat1 *format1Action = NULLP;
+
+   /* [Step -1] */
+   encodeSubscriptionId(&subscriptionId, ricSubscriptionInfo->ranFuncId, ricSubscriptionInfo->requestId);
+
+   macStatsModificationReq->subscriptionId = subscriptionId;
+   CM_LLIST_FIRST_NODE(&ricSubscriptionInfo->actionSequence, actionNode);
+   while(actionNode)
+   {
+      actionDb = (ActionInfo*)(actionNode->node);
+      /* [Step -2] */
+      if(actionDb->action == CONFIG_MOD)
+      {
+         /* [Step -3] */
+         macStatsModificationReq->statsGrpList[grpIdx].groupId = actionDb->actionId;
+         switch(actionDb->definition.formatType)
+         {
+            case 1:
+               {
+                  format1Action = &actionDb->definition.choice.format1;
+                  macStatsModificationReq->statsGrpList[grpIdx].periodicity = format1Action->granularityPeriod;
+
+                  statsModifyReqIdx = 0;
+                  node = cmLListFirst(&format1Action->measurementInfoList);
+                  while(node)
+                  {
+                     /* [Step -4] */
+                     measInfo = (MeasurementInfo *)(node->node);
+                     switch(measInfo->measurementTypeId)
+                     {
+                        case 1:
+                           {
+                              macStatsModificationReq->statsGrpList[grpIdx].statsList[statsModifyReqIdx++] = MAC_DL_TOTAL_PRB_USAGE;
+                              break;
+                           }
+                        case 2:
+                           {
+                              macStatsModificationReq->statsGrpList[grpIdx].statsList[statsModifyReqIdx++] = MAC_UL_TOTAL_PRB_USAGE;
+                              break;
+                           }
+                        default:
+                           {
+                              DU_LOG("\nERROR  -->  E2AP : Invalid measurement name");
+                              break;
+                           }
+                     }
+                     node = node->next;
+                  }
+                  macStatsModificationReq->statsGrpList[grpIdx].numStats = statsModifyReqIdx;
+                  break;
+               }
+            default:
+               {
+                  DU_LOG("\nERROR  -->  E2AP : fillRicSubsInMacStatsModificationReq: Only Action Definition Format 1 supported");
+                  break;
+               }
+         }
+         if(macStatsModificationReq->statsGrpList[grpIdx].numStats)
+            grpIdx++;
+      }
+      actionNode = actionNode->next;
+   }
+
+   /* [Step -5] */
+   macStatsModificationReq->numStatsGroup = grpIdx;
+   if(macStatsModificationReq->numStatsGroup)
+   {
+      return ROK;
+   }
+   return RFAILED;
+}
+
 /**********************************************************************
   End of file
  **********************************************************************/