Epic-ID: ODUHIGH-463][Task-ID: ODUHIGH-504]Dummy Handover Request/Response and UE...
[o-du/l2.git] / 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 **********************************************************************/