src/cu_stub/cu_stub.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   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                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  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
  19 /* This functions contains main() for cu_app */
  20 #include "common_def.h"
  21 #include "cu_stub_sctp.h"
  22 #include "cu_stub_egtp.h"
  23 #include "OCTET_STRING.h"
  24 #include "cu_f1ap_msg_hdl.h"
  25 #include "cu_stub.h"
  26
  27 #ifdef O1_ENABLE
  28 #include "CmInterface.h"
  29 #endif
  30
  31
  32 #ifdef O1_ENABLE
  33 extern StartupConfig g_cfg;
  34 #endif
  35
  36 /*******************************************************************
  37  *
  38  * @brief Handles SCTP notification
  39  *
  40  * @details
  41  *
  42  *    Function : sctpNtfyInd
  43  *
  44  *    Functionality:
  45  *         Handles SCTP notification
  46  *
  47  * @params[in] sctp notification
  48  * @return void
  49  *
  50  ******************************************************************/
  51 void sctpNtfyInd(CmInetSctpNotification *ntfy)
  52 {
  53 //TODO
  54 }
  55
  56 void init_log()
  57 {
  58     openlog("CU_STUB",LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
  59 }
  60 /*******************************************************************
  61  *
  62  * @brief Main function of CU APP
  63  *
  64  * @details
  65  *
  66  *    Function : main
  67  *
  68  *    Functionality:
  69  *         - Reads CU related configurations
  70  *         - Initialize SCTP Parameters
  71  *         - Start SCTP receiver thread
  72  *
  73  * @params[in]
  74  * @return ROK     - success
  75  *         RFAILED - failure
  76  *
  77  * ****************************************************************/
  78
  79 uint8_t tst()
  80 {
  81    int retVal=0;
  82    pthread_t conThrdId;
  83    pthread_attr_t attr;
  84
  85    init_log();
  86    DU_LOG("\nINFO   -->  CU_STUB : Starting CU_STUB\n");
  87
  88    /* Start thread to receive console input */
  89    pthread_attr_init(&attr);
  90    pthread_attr_setstacksize(&attr, (size_t)NULLD);
  91    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
  92    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  93    retVal = pthread_create(&conThrdId, &attr, cuConsoleHandler, NULLP);
  94    if(retVal != 0)
  95    {
  96       DU_LOG("\nERROR  -->  CU_STUB :  Thread creation failed. Cause %d", retVal);
  97    }
  98    pthread_attr_destroy(&attr);
  99
 100    /* Read CU configurations */
 101    readCuCfg();
 102
 103    /* Start CU-EGTP */
 104    egtpActvInit();
 105    egtpInitReq();
 106
 107    /* Initializing SCTP global parameters */
 108    sctpActvInit();
 109
 110    /* Start CU-SCTP to listen on incoming connection */
 111    sctpCfgReq();
 112    sctpStartReq();
 113
 114    return ROK;
 115 }
 116
 117 /*******************************************************************
 118  *
 119  * @brief Read CU related configuration
 120  *
 121  * @details
 122  *
 123  *    Function : readCuCfg
 124  *
 125  *    Functionality:
 126  *            - RRead CU related configuration
 127  *
 128  * @params[in]
 129  * @return ROK     - success
 130  *         RFAILED - failure
 131  *
 132  * ****************************************************************/
 133
 134 void readCuCfg()
 135 {
 136    uint8_t  numDu, *numRemoteCu;
 137    uint32_t ipv4_du, ipv4_cu, ipv4_remote_cu;
 138
 139    DU_LOG("\nDEBUG  -->  CU_STUB : Reading CU configurations");
 140
 141    cuCb.cuCfgParams.cuId = CU_ID;
 142    strcpy(cuCb.cuCfgParams.cuName, CU_NAME);
 143
 144 #ifdef O1_ENABLE
 145    if( getStartupConfigForStub(&g_cfg) != ROK )
 146    {
 147       DU_LOG("\nError  -->  CU_STUB : Could not fetch startup "\
 148              "configurations from Netconf interface\n");
 149       exit(1);
 150    }
 151
 152    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
 153    cuCb.cuCfgParams.sctpParams.destCb[0].destIpAddr.ipV4Addr = ipv4_du;
 154    cuCb.cuCfgParams.sctpParams.destCb[0].destIpAddr.ipV6Pres = false;
 155
 156    cmInetAddr((S8*)g_cfg.CU_IPV4_Addr, &ipv4_cu);
 157    cuCb.cuCfgParams.sctpParams.localIpAddr.ipV4Addr = ipv4_cu;
 158    cuCb.cuCfgParams.sctpParams.localIpAddr.ipV6Pres = false;
 159
 160    cuCb.cuCfgParams.sctpParams.destCb[0].destPort = g_cfg.DU_Port;
 161    cuCb.cuCfgParams.sctpParams.f1SctpPort = g_cfg.CU_Port;
 162    cuCb.cuCfgParams.sctpParams.numDestNode = 1;
 163
 164    cuCb.cuCfgParams.egtpParams.localIp.ipV4Pres = TRUE;
 165    cuCb.cuCfgParams.egtpParams.localIp.ipV4Addr = ipv4_cu;
 166    cuCb.cuCfgParams.egtpParams.localPort = F1_EGTP_PORT;
 167    cuCb.cuCfgParams.egtpParams.dstCfg[0].dstIp.ipV4Pres = TRUE;
 168    cuCb.cuCfgParams.egtpParams.dstCfg[0].dstIp.ipV4Addr = ipv4_du;
 169    cuCb.cuCfgParams.egtpParams.dstCfg[0].dstPort = F1_EGTP_PORT;
 170    cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID;
 171    cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId;
 172    cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID;
 173    cuCb.cuCfgParams.egtpParams.numDu = 1;
 174
 175 #else
 176    /* CU IP Address and Port*/
 177    memset(&ipv4_du, 0, sizeof(uint32_t));
 178    cmInetAddr((S8*)LOCAL_IP_CU, &ipv4_cu);
 179
 180    cuCb.cuCfgParams.sctpParams.localIpAddr.ipV4Addr = ipv4_cu;
 181    cuCb.cuCfgParams.sctpParams.localIpAddr.ipV6Pres = false;
 182
 183    /* SCTP and EGTP configuration for F1 Interface */
 184    cuCb.cuCfgParams.sctpParams.f1SctpInfo.port = F1_SCTP_PORT;
 185
 186    cuCb.cuCfgParams.egtpParams.localIp.ipV4Pres = TRUE;
 187    cuCb.cuCfgParams.egtpParams.localIp.ipV4Addr = ipv4_cu;
 188    cuCb.cuCfgParams.egtpParams.localPort = F1_EGTP_PORT;
 189
 190    cuCb.cuCfgParams.sctpParams.f1SctpInfo.numDestNode = 0;
 191    cuCb.cuCfgParams.egtpParams.numDu = 0;
 192
 193    numDu = 0;
 194    while(numDu < NUM_F1_ASSOC)
 195    {
 196       /* DU IP Address */
 197       memset(&ipv4_du, 0, sizeof(uint32_t));
 198       cmInetAddr((S8*)REMOTE_IP_DU[numDu], &ipv4_du);
 199
 200       /* SCTP Parameters */
 201       cuCb.cuCfgParams.sctpParams.f1SctpInfo.destCb[numDu].destIpAddr.ipV4Addr = ipv4_du;
 202       cuCb.cuCfgParams.sctpParams.f1SctpInfo.destCb[numDu].destIpAddr.ipV6Pres = false;
 203       cuCb.cuCfgParams.sctpParams.f1SctpInfo.destCb[numDu].destPort = F1_SCTP_PORT;
 204
 205       /* EGTP Parameters */
 206       cuCb.cuCfgParams.egtpParams.dstCfg[numDu].dstIp.ipV4Pres = TRUE;
 207       cuCb.cuCfgParams.egtpParams.dstCfg[numDu].dstIp.ipV4Addr = ipv4_du;
 208       cuCb.cuCfgParams.egtpParams.dstCfg[numDu].dstPort = F1_EGTP_PORT;
 209
 210       (numDu)++;
 211    }
 212
 213    cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID;
 214    cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId;
 215    cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID;
 216    cuCb.cuCfgParams.egtpParams.numDu = numDu;
 217    cuCb.cuCfgParams.sctpParams.f1SctpInfo.numDestNode = numDu;
 218
 219    /* SCTP configuration for Xn interface */
 220    cuCb.cuCfgParams.sctpParams.xnSctpInfo.port = XN_SCTP_PORT;
 221    cuCb.cuCfgParams.sctpParams.xnSctpInfo.localNodeType = LOCAL_NODE_TYPE;
 222    numRemoteCu = &cuCb.cuCfgParams.sctpParams.xnSctpInfo.numDestNode;
 223    (*numRemoteCu) = 0;
 224    while((*numRemoteCu) < NUM_XN_ASSOC)
 225    {
 226       /* Remote CU IP address */
 227       memset(&ipv4_remote_cu, 0, sizeof(uint32_t));
 228       cmInetAddr((S8*)REMOTE_IP_CU[*numRemoteCu], &ipv4_remote_cu);
 229
 230       /* SCTP Parameters */
 231       cuCb.cuCfgParams.sctpParams.xnSctpInfo.destCb[*numRemoteCu].destIpAddr.ipV4Addr = ipv4_remote_cu;
 232       cuCb.cuCfgParams.sctpParams.xnSctpInfo.destCb[*numRemoteCu].destIpAddr.ipV6Pres = false;
 233       cuCb.cuCfgParams.sctpParams.xnSctpInfo.destCb[*numRemoteCu].destPort = XN_SCTP_PORT;
 234
 235       (*numRemoteCu)++;
 236    }
 237 #endif
 238
 239    /*PLMN*/
 240    cuCb.cuCfgParams.plmn.mcc[0] = PLMN_MCC0;
 241    cuCb.cuCfgParams.plmn.mcc[1] = PLMN_MCC1;
 242    cuCb.cuCfgParams.plmn.mcc[2] = PLMN_MCC2;
 243    cuCb.cuCfgParams.plmn.mnc[0] = PLMN_MNC0;
 244    cuCb.cuCfgParams.plmn.mnc[1] = PLMN_MNC1;
 245    cuCb.cuCfgParams.plmn.mnc[2] = PLMN_MNC2;
 246
 247    /*RRC Version*/
 248    cuCb.cuCfgParams.rrcVersion.rrcVer = RRC_VER;
 249    cuCb.cuCfgParams.rrcVersion.extRrcVer = EXT_RRC_VER;
 250
 251
 252
 253 } /* End of readCuCfg */
 254
 255 /*******************************************************************
 256  *
 257  * @brief Initiates inter DU handover
 258  *
 259  * @details
 260  *
 261  *    Function : initiateInterDuHandover
 262  *
 263  *    Functionality: Initiates the first procedure of inter-DU
 264  *    handover i.eG GNB-DU configuration query to source DU
 265  *
 266  * @params[in] Source DU Id
 267  *             Target DU Id
 268  *             UE Id to be handed off
 269  * @return ROK     - success
 270  *         RFAILED - failure
 271  *
 272  * ****************************************************************/
 273 void initiateInterDuHandover(uint32_t sourceDuId, uint32_t targetDuId, uint32_t duUeF1apId)
 274 {
 275    uint8_t duIdx = 0;
 276    DuDb *duDb = NULLP;
 277    CuUeCb *ueCb = NULLP;
 278
 279    DU_LOG("\nINFO  --> CU_STUB: Inter-DU Handover Started for ueId [%d] from DU ID [%d] to DU ID [%d]", \
 280          duUeF1apId, sourceDuId, targetDuId);
 281
 282    SEARCH_DU_DB(duIdx, sourceDuId, duDb);
 283    if(duDb)
 284       ueCb = &duDb->ueCb[duUeF1apId-1];
 285    if(ueCb)
 286    {
 287       ueCb->state = UE_HANDOVER_IN_PROGRESS;
 288       ueCb->hoInfo.HOType = Inter_DU_HO;
 289       ueCb->hoInfo.srcNodeId = sourceDuId;
 290       ueCb->hoInfo.tgtNodeId = targetDuId;
 291
 292       BuildAndSendUeContextModificationReq(sourceDuId, ueCb, QUERY_CONFIG);
 293    }
 294    else
 295    {
 296       DU_LOG("\nINFO  --> CU_STUB: DU UE F1AP ID [%d] not found", duUeF1apId);
 297    }
 298 }
 299
 300
 301 /*******************************************************************
 302  *
 303  * @brief Initiates inter CU handover
 304  *
 305  * @details
 306  *
 307  *    Function : initiateInterCuHandover
 308  *
 309  *    Functionality: Initiates the first procedure of inter-CU
 310  *    handover
 311  *
 312  * @params[in] Source CU Id
 313  *             Target CU Id
 314  *             UE Id to be handed off
 315  * @return ROK     - success
 316  *         RFAILED - failure
 317  *
 318  * ****************************************************************/
 319 void initiateInterCuHandover(uint32_t targetCuId, uint32_t cellId, uint32_t cuUeF1apId)
 320 {
 321     uint8_t  duIdx, ueIdx;
 322     CuUeCb   *ueCb = NULLP;
 323
 324     DU_LOG("\nINFO  --> CU_STUB: Inter-CU Handover Started for ueId [%d] to CU ID [%d]", \
 325           cuUeF1apId, targetCuId);
 326
 327     for(duIdx = 0; duIdx < cuCb.numDu; duIdx++)
 328     {
 329        for(ueIdx = 0; ueIdx < (MAX_NUM_CELL * MAX_NUM_UE); ueIdx++)
 330        {
 331           ueCb = &cuCb.duInfo[duIdx].ueCb[ueIdx];
 332           if(cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
 333           {
 334              ueCb = &cuCb.duInfo[duIdx].ueCb[ueIdx];
 335              break;
 336           }
 337        }
 338        if(ueCb)
 339           break;
 340     }
 341
 342     if(ueCb)
 343     {
 344        ueCb->state = UE_HANDOVER_IN_PROGRESS;
 345        ueCb->hoInfo.HOType = Xn_Based_Inter_CU_HO;
 346        ueCb->hoInfo.srcNodeId = cuCb.cuCfgParams.cuId;
 347        ueCb->hoInfo.tgtNodeId = targetCuId;
 348        ueCb->hoInfo.tgtCellId = cellId;
 349        ueCb->hoInfo.cuUeF1apIdSrc = ueCb->gnbCuUeF1apId;
 350
 351        BuildAndSendUeContextModificationReq(cuCb.duInfo[duIdx].duId, ueCb, QUERY_CONFIG);
 352     }
 353     else
 354     {
 355        DU_LOG("\nINFO  --> CU_STUB: CU UE F1AP ID [%d] not found", cuUeF1apId);
 356     }
 357 }
 358
 359 /*******************************************************************
 360  *
 361  * @brief start Dl data
 362  *
 363  * @details
 364  *
 365  *    Function : startDlData
 366  *
 367  *    Functionality: start the downlink data
 368  *
 369  * @params[in]
 370  * @return ROK     - success
 371  *         RFAILED - failure
 372  *
 373  * ****************************************************************/
 374
 375 uint8_t startDlData()
 376 {
 377    uint32_t teId = 0;
 378    uint32_t duId;
 379    uint8_t ret = ROK;
 380    uint8_t cnt = 0;
 381    int32_t totalNumOfTestFlow = 20;
 382    EgtpTeIdCb *teidCb = NULLP;
 383
 384    while(totalNumOfTestFlow)
 385    {
 386       for(duId = 1; duId <= cuCb.cuCfgParams.egtpParams.numDu; duId++)
 387       {
 388          for(teId = 1; teId <= NUM_TUNNEL_TO_PUMP_DATA; teId++)
 389          {
 390             teidCb = NULLP;
 391             cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
 392             if(teidCb)
 393             {
 394                cnt =0;
 395                DU_LOG("\nDEBUG  -->  EGTP: Sending DL User Data(duId %d, teId:%d)\n", duId, teId);
 396                while(cnt < NUM_DL_PACKETS)
 397                {
 398                   ret =  cuEgtpDatReq(duId, teId);
 399                   if(ret != ROK)
 400                   {
 401                      DU_LOG("\nERROR --> EGTP: Issue with teid=%d\n",teId);
 402                      break;
 403                   }
 404                   /* TODO : sleep(1) will be removed later once we will be able to
 405                    * support the continuous data pack transfer */
 406                   sleep(1);
 407                   cnt++;
 408                }
 409             }
 410             else
 411             {
 412                DU_LOG("\nDEBUG  -->  EGTP: TunnelId Not Found for (duId %d, teId:%d)\n", duId, teId);
 413             }
 414          }
 415       }
 416       totalNumOfTestFlow--;
 417    }
 418
 419    return ROK;
 420 }
 421
 422 /*******************************************************************
 423  *
 424  * @brief Handles Console input
 425  *
 426  * @details
 427  *
 428  *    Function : cuConsoleHandler
 429  *
 430  *    Functionality: Handles Console input
 431  *
 432  * @params[in]
 433  * @return ROK     - success
 434  *         RFAILED - failure
 435  *
 436  * ****************************************************************/
 437 void *cuConsoleHandler(void *args)
 438 {
 439    char ch;
 440
 441    while(true)
 442    {
 443       ch = getchar();
 444       /* Send DL user data to CU when user enters 'd' on console */
 445       if(ch == 'd')
 446       {
 447
 448          /* Change #if 0 to #if 1 to take input from user */
 449 #if 0
 450          DU_LOG("\n EGTP --> : Enter TEID id(1..10) where DL Data to be sent\n");
 451          scanf("%d",&teId);
 452
 453          if(teId > MAX_TEID || teId < MIN_TEID)
 454          {
 455             DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
 456             printf("\n");
 457             continue;
 458          }
 459          /* Start Pumping data from CU to DU */
 460          DU_LOG("\nDEBUG  -->  EGTP: Sending DL User Data(teId:%d)\n",teId);
 461
 462          cnt =0;
 463          while(cnt < NUM_DL_PACKETS)
 464          {
 465             ret =  cuEgtpDatReq(teId);
 466             if(ret != ROK)
 467             {
 468                DU_LOG("\nERROR --> EGTP: Issue with teid=%d\n",teId);
 469                break;
 470             }
 471             cnt++;
 472          }
 473 #else
 474
 475          /* This variable is taken for sending specific number of downlink data packet.
 476           * Presently the code is supporting total 4500 data packets trasfer for 3 UEs only with sleep(1).
 477           * If you wants to pump data for 3 UE change the following macro values
 478           * NUM_TUNNEL_TO_PUMP_DATA = 9, NUM_DL_PACKETS = 1.
 479           * totalDataPacket = totalNumOfTestFlow * NUM_TUNNEL_TO_PUMP_DATA * NUM_DL_PACKETS
 480           * totalDataPacket = [500*9*1] */
 481
 482          startDlData();
 483 #endif
 484          continue;
 485       }
 486
 487       /* Start Handover procedure towards DU when 'h' is received from console input */
 488       else if(ch == 'h')
 489       {
 490          HandoverType hoType;
 491          uint32_t srcNodeId, tgtNodeId, targetCellId, ueId;
 492
 493          DU_LOG("\n\nChoose the type of handover to initiate : \nEnter 1 for Inter-CU Handover over Xn interface\nEnter 2 for Inter-DU Handover\n");
 494          scanf("%d", &hoType);
 495
 496          if(hoType == Xn_Based_Inter_CU_HO)
 497          {
 498             DU_LOG("\nEnter Target CU ID for Inter-CU Handover : ");
 499             scanf("%d", &tgtNodeId);
 500             DU_LOG("\nEnter Target Physical Cell ID for Inter-CU Handover : ");
 501             scanf("%d", &targetCellId);
 502             DU_LOG("\nEnter CU UE F1AP ID to be handed over : ");
 503             scanf("%d", &ueId);
 504
 505             initiateInterCuHandover(tgtNodeId, targetCellId, ueId);
 506          }
 507          else if(hoType == Inter_DU_HO)
 508          {
 509             DU_LOG("\nEnter Source DU ID for Inter-DU Handover : ");
 510             scanf("%d", &srcNodeId);
 511             DU_LOG("\nEnter Target DU ID for Inter-DU Handover : ");
 512             scanf("%d", &tgtNodeId);
 513             DU_LOG("\nEnter DU UE F1AP ID to be handed over : ");
 514             scanf("%d", &ueId);
 515
 516             initiateInterDuHandover(srcNodeId, tgtNodeId, ueId);
 517          }
 518       }
 519       /* Start Idle mode paging when 'p' is received from console input */
 520       else if(ch == 'p')
 521       {
 522          uint64_t sTmsi = 0;
 523          uint8_t duId = 0;
 524
 525          DU_LOG("\nEnter DU ID on which this UE to be pagged");
 526          scanf("%d", &duId);
 527          DU_LOG("\nEnter 5g-S-TMSI");
 528          scanf("%lu", &sTmsi);
 529
 530          if(BuildAndSendPagingMsg(sTmsi, duId) != ROK)
 531          {
 532             DU_LOG("\nERROR --> EGTP: Failed to build and send paging message for 5gsTmsi[%lu]\n", sTmsi);
 533          }
 534          continue;
 535       }
 536       else if(ch == 'm')
 537       {
 538          uint8_t  ueId  = 1;
 539          uint8_t  duId  = 0;
 540          uint8_t  duIdx = 0;
 541          DuDb    *duDb  = NULLP;
 542          CuUeCb  *ueCb  = NULLP;
 543
 544          DU_LOG("\nEnter DU ID whose UE has to be modified");
 545          scanf("%d", &duId);
 546          DU_LOG("\nEnter UE ID to be modified");
 547          scanf("%d", &ueId);
 548
 549          DU_LOG("\nINFO  --> CU_STUB: UE Context Mod for ueId [%d] at DU ID [%d]", \
 550                   ueId, duId);
 551
 552          SEARCH_DU_DB(duIdx, duId, duDb);
 553          if(duDb)
 554          {
 555             ueCb = &duDb->ueCb[ueId-1];
 556             BuildAndSendUeContextModificationReq(duId, ueCb, MODIFY_UE);
 557          }
 558          else
 559          {
 560             DU_LOG("ERROR --> DuDb is NULLP");
 561          }
 562          continue;
 563
 564       }
 565       /*UE context release command from CU*/
 566       else if(ch == 'c')
 567       {
 568          uint32_t duId, cuUeF1apId, duUeF1apId;
 569          uint8_t  duIdx = 0;
 570          DuDb    *duDb  = NULLP;
 571
 572          DU_LOG("\nEnter DU ID on which UE has to be released");
 573          scanf("%d", &duId);
 574          DU_LOG("\nEnter UE ID to be released");
 575          scanf("%d", &duUeF1apId);
 576
 577          SEARCH_DU_DB(duIdx, duId, duDb);
 578          if(duDb)
 579          {
 580             if(duDb->ueCb[duUeF1apId-1].gnbDuUeF1apId == duUeF1apId)
 581             {
 582                cuUeF1apId = duDb->ueCb[duUeF1apId-1].gnbCuUeF1apId;
 583                DU_LOG("INFO   -->  CU_STUB: Cu UeId: %d Du UeId:%d",cuUeF1apId, duUeF1apId);
 584                BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId);
 585             }
 586             else
 587             {
 588                DU_LOG("ERROR  -->  CU_STUB: Du UeId:%d in UeCb mismatch",\
 589                         duDb->ueCb[duUeF1apId-1].gnbDuUeF1apId);
 590             }
 591          }
 592
 593          sleep(5);
 594          continue;
 595       }
 596    }
 597 }
 598 /**********************************************************************
 599          End of file
 600 **********************************************************************/