b8616c067a24a1fb3d80f5960a244cb08f180d44
[o-du/l2.git] / src / cu_stub / cu_stub_egtp.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 file contains all EGTP related functionality */
20
21 #include "common_def.h"
22 #include "cu_stub_egtp.h"
23 #include "du_log.h"
24
25 /* Global variable declaration */
26 EgtpGlobalCb egtpCb;
27
28 /**************************************************************************
29  * @brief Task Initiation callback function. 
30  *
31  * @details
32  *
33  *     Function : egtpActvInit 
34  *    
35  *     Functionality:
36  *             This function is supplied as one of parameters during EGTP's 
37  *             task registration. SSI will invoke this function once, after
38  *             it creates and attaches this TAPA Task to a system task.
39  *     
40  * @param[in]  Ent entity, the entity ID of this task.     
41  * @param[in]  Inst inst, the instance ID of this task.
42  * @param[in]  Region region, the region ID registered for memory 
43  *              usage of this task.
44  * @param[in]  Reason reason.
45  * @return ROK     - success
46  *         RFAILED - failure
47  ***************************************************************************/
48 S16 egtpActvInit()
49 {
50   DU_LOG("\n\nEGTP : Initializing");
51   cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb));
52   protType = CM_INET_PROTO_UDP;
53   return ROK;
54 }
55
56
57 /**************************************************************************
58  * @brief Task Activation callback function. 
59  *
60  * @details
61  *
62  *      Function : egtpActvTsk 
63  * 
64  *      Functionality:
65  *           This function handles all EGTP messages received
66  *           This API is registered with SSI during the 
67  *           Task Registration of DU APP.
68  *     
69  * @param[in]  Pst     *pst, Post structure of the primitive.     
70  * @param[in]  Buffer *mBuf, Packed primitive parameters in the
71  *  buffer.
72  * @return ROK     - success
73  *         RFAILED - failure
74  *
75  ***************************************************************************/
76 S16 egtpInitReq()
77 {
78    S16 ret = ROK;
79    EgtpTnlEvt tnlEvt;
80
81    ret = cuEgtpCfgReq();
82    if(ret != ROK)
83    {
84       DU_LOG("\nEGTP : Configuration failed");
85       return (ret);
86    }
87
88    ret = cuEgtpSrvOpenReq();
89    if(ret != ROK)
90    {
91        DU_LOG("\nEGTP : Transport server open request failed");
92        return (ret);
93    }
94
95    tnlEvt.action = EGTP_TNL_MGMT_ADD;
96    tnlEvt.lclTeid = 10;
97    tnlEvt.remTeid = 1;
98    ret = cuEgtpTnlMgmtReq(tnlEvt);
99    if(ret != ROK)
100    {
101       DU_LOG("\n EGTP : Tunnel management request failed");
102       return RFAILED;
103    }
104
105    return (ret);
106
107 } /* egtpInitReq */
108
109 /**************************************************************************
110  * @brief EGTP server configuration 
111  *
112  * @details
113  *
114  *      Function : egtpCfgReq
115  * 
116  *      Functionality:
117  *           This function handles EGTP configuration request.
118  *     
119  * @return ROK     - success
120  *         RFAILED - failure
121  *
122  * ***********************************************************************/
123 S16 cuEgtpCfgReq()
124 {
125    U8 ret;
126
127    cmMemcpy((U8 *)&egtpCb.egtpCfg, (U8 *)&cuCfgParams.egtpParams, (PTR)sizeof(EgtpParams));
128
129    egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
130    egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
131
132    egtpCb.dstCb.dstIp = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
133    egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
134    egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
135    egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
136    egtpCb.dstCb.numTunn = 0;
137
138    ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_U32MOD, CU_APP_MEM_REG, CU_POOL);
139
140    if(ret != ROK)
141    {
142       DU_LOG("\nEGTP : TeId hash list initialization failed");
143       return RFAILED;
144    }
145    else
146    {
147       DU_LOG("\nEGTP : Configuration successful");
148    }
149
150    return ROK;
151 } /* cuEgtpCfgReq */
152
153 /**************************************************************************
154  * @brief EGTP server open request 
155  *
156  * @details
157  *
158  *      Function : egtpSrvOpenReq
159  * 
160  *      Functionality:
161  *           This function handles EGTP open server request.
162  *           It opens udp socket to receive/send msgs.
163  *     
164  * @param[in]  Pst *pst, post structure
165  * @return ROK     - success
166  *         RFAILED - failure
167  *
168  ***************************************************************************/
169
170 S16 cuEgtpSrvOpenReq(Pst *pst)
171 {
172
173    U8 ret;
174
175    DU_LOG("\nEGTP : Received open server request");
176  
177    sockType = CM_INET_DGRAM;
178    if(ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType)) != ROK)
179    {
180       DU_LOG("\nEGTP : Failed to open UDP socket");
181       return RFAILED;
182    }
183
184    ret = cmInetBind(&(egtpCb.recvTptSrvr.sockFd), &(egtpCb.recvTptSrvr.addr));
185    if(ret != ROK)
186    {
187       DU_LOG("\nEGTP : Failed to bind socket");
188       return RFAILED;
189    }
190
191    if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK)
192    {  
193       DU_LOG("\nEGTP : Failed to open UDP socket");
194       return RFAILED;
195    }
196       
197    ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr));
198    if(ret != ROK)
199    {  
200       DU_LOG("\nEGTP : Failed to bind socket");
201       return RFAILED;
202    }
203        
204    /* TODO: set socket options */
205
206    DU_LOG("\nEGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd, egtpCb.dstCb.sendTptSrvr.sockFd.fd);
207    return ROK;
208 } /* cuEgtpSrvOpenReq */
209
210
211 /**************************************************************************
212  * @brief EGTP tunnel management request
213  *
214  * @details
215  *
216  *      Function : cuEgtpTnlMgmtReq
217  * 
218  *      Functionality:
219  *           This function handles EGTP tunnel managament request
220  *     
221  * @param[in]  Pst *pst, post structure
222  *             Tunnel Eveny structure
223  * @return ROK     - success
224  *         RFAILED - failure
225  *
226  
227  * ***************************************************************************/
228 S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt)
229 {
230    S8 ret;
231
232    DU_LOG("\nEGTP : Received tunnel management request");
233    switch(tnlEvt.action)
234    {
235       case EGTP_TNL_MGMT_ADD:
236       {
237          ret = cuEgtpTnlAdd(tnlEvt);
238          break;
239       }
240       case EGTP_TNL_MGMT_MOD:
241       {
242          ret = cuEgtpTnlMod(tnlEvt);
243          break;
244       }
245       case EGTP_TNL_MGMT_DEL:
246       {
247          ret = cuEgtpTnlDel(tnlEvt);
248          break;
249       }
250       default:
251       {
252          DU_LOG("\nEGTP : Invalid tunnel management action[%d]", tnlEvt.action);
253          ret = RFAILED;
254       }
255    }
256
257    return (ret);
258 }
259
260 /**************************************************************************
261  * @brief EGTP tunnel addition
262  *
263  * @details
264  *
265  *      Function : cuEgtpTnlAdd
266  * 
267  *      Functionality:
268  *           This function handles EGTP tunnel addition
269  *     
270  * @param[in]  Tunnel Event structure
271  * @return ROK     - success
272  *         RFAILED - failure
273  *
274  * ***************************************************************************/
275 S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt)
276 {
277    S16   ret;
278    EgtpTeIdCb     *teidCb;
279    EgtpMsgHdr   preDefHdr; /* pre-define header for this tunnel */
280    
281
282    DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
283
284    CU_ALLOC(teidCb, (Size)sizeof(EgtpTeIdCb));
285
286    if(teidCb == NULLP)
287    {
288       DU_LOG("\nEGTP : Memory allocation failed");
289       return RFAILED;
290    }
291
292
293    cmMemset((U8 *)teidCb, 0, sizeof(EgtpTeIdCb));
294    teidCb->teId = tnlEvt.lclTeid;
295    teidCb->remTeId = tnlEvt.remTeid;
296
297    ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (U8 *)&(teidCb->teId), sizeof(U32));
298    if(ret != ROK)
299    {
300       DU_LOG("\nEGTP : Failed to insert in hash list");
301       CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
302       return RFAILED;
303    }
304    egtpCb.dstCb.numTunn++;
305
306    /* Encoding pre-defined header */
307    cmMemset((U8*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
308    preDefHdr.msgType = EGTPU_MSG_GPDU;
309    preDefHdr.teId = teidCb->remTeId;
310    preDefHdr.extHdr.pdcpNmb.pres = FALSE;
311    preDefHdr.extHdr.udpPort.pres = FALSE;
312    preDefHdr.nPdu.pres = FALSE;
313    
314    cuEgtpEncodeHdr((U8 *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
315
316 /*   SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));*/
317
318    return ROK;
319 } /* cuEgtpTnlAdd */
320
321 /**************************************************************************
322  * @brief EGTP tunnel modification
323  *
324  * @details
325  *
326  *      Function : cuEgtpTnlMod
327  * 
328  *      Functionality:
329  *           This function handles EGTP tunnel modification
330  *     
331  * @param[in]  Tunnel Event structure
332  * @return ROK     - success
333  *         RFAILED - failure
334  * 
335  * ***************************************************************************/
336 S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt)
337 {
338 #if 0
339    S16   ret;
340    EgtpTeIdCb     *teidCb = NULLP;
341
342    printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
343
344    cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.teId), sizeof(U32), 0, (PTR *)&teidCb);
345    if(teidCb == NULLP)
346    {
347       printf("\nTunnel id not found");
348       return RFAILED;
349    }  
350    
351    teidCb->teId = tnlEvt.lclTeid;
352    teidCb->remTeId = tnlEvt.remTeid;
353 #endif
354    return ROK;
355 }
356
357 /**************************************************************************
358  * @brief EGTP tunnel deletion
359  *
360  * @details
361  *
362  *     Function : cuEgtpTnlDel
363  * 
364  *     Functionality:
365  *         This function handles EGTP tunnel deletion
366  *    
367  * @param[in]  Tunnel Event structure
368  * @return ROK     - success
369  *         RFAILED - failure
370  * 
371  * ***************************************************************************/
372 S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt)
373 {
374    EgtpTeIdCb     *teidCb = NULLP;
375
376    DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
377    
378    cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.lclTeid), sizeof(U32), 0, (PTR *)&teidCb);
379    if(teidCb == NULLP)
380    {
381       DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
382       return RFAILED;
383    } 
384
385    cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb);
386    CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
387    egtpCb.dstCb.numTunn--;
388
389    return ROK;
390 } /* cuEgtpTnlDel */
391
392 /*******************************************************************
393  *
394  * @brief Encodes message header
395  *
396  * @details
397  *
398  *    Function : cuEgtpEncodeHdr
399  * 
400  *    Functionality:
401  *       Encodes EGTP message haeder
402  *
403  * @params[in] EGTP message
404  *             Message Buffer 
405  * @return ROK     - success
406  *         RFAILED - failure
407  *
408  * ****************************************************************/
409 S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx)
410 {
411    U8         tmpByte = 0;                 /* Stores one byte of data for enc */
412    U8         cnt     = EGTP_MAX_HDR_LEN;  /* Stores the position */
413    Bool       extPres = FALSE;             /* Flag for indication of S, E or P presense flag */
414    U16        nwWord = 0;
415
416    /* Encoding header */
417    tmpByte |= EGTP_MASK_BIT6;   /* Setting 6th LSB of 1st byte as version */
418    tmpByte |= EGTP_MASK_BIT5;   /* Setting 5th LSB of 1st byte as protocol type */
419    
420    if(preDefHdr->extHdr.udpPort.pres || preDefHdr->extHdr.pdcpNmb.pres)
421    {
422       tmpByte |= EGTP_MASK_BIT3;  /* Setting 3rd LSB of 1st byte if Extension heaeder is present */
423    }
424     
425    if(preDefHdr->seqNum.pres)
426    {
427       tmpByte |= EGTP_MASK_BIT2;
428    }
429    
430    if(preDefHdr->nPdu.pres)
431    {
432       tmpByte |= EGTP_MASK_BIT1;
433    }
434    
435    if((tmpByte & EGTP_MASK_BIT1) || (tmpByte & EGTP_MASK_BIT2)||(tmpByte & EGTP_MASK_BIT3))
436    {
437       extPres = TRUE;
438    }
439    preEncodedHdr[--cnt] = tmpByte;
440    preEncodedHdr[--cnt] = preDefHdr->msgType;
441     
442    /* Encode Tunnel endpoint */
443    preEncodedHdr[--cnt] = 0;
444    preEncodedHdr[--cnt] = 0;
445    nwWord = (U16)(GetHiWord(preDefHdr->teId));
446    preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
447    preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
448    nwWord = (U16)(GetLoWord(preDefHdr->teId));
449    preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
450    preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
451     
452    /* Encode sequence number */
453    if(preDefHdr->seqNum.pres)
454    {
455       preEncodedHdr[--cnt] = GetHiByte(preDefHdr->seqNum.val);
456       preEncodedHdr[--cnt] = GetLoByte(preDefHdr->seqNum.val);
457    }
458    else if(extPres)
459    {
460       preEncodedHdr[--cnt] = 0;
461       preEncodedHdr[--cnt] = 0;
462    }
463
464    if(preDefHdr->nPdu.pres)
465    {
466       preEncodedHdr[--cnt] = preDefHdr->nPdu.val;
467    }
468    else if(extPres)
469    {
470       preEncodedHdr[--cnt] = 0;
471    }
472     
473    if(preDefHdr->extHdr.udpPort.pres)
474    {
475       preEncodedHdr[--cnt] = EGTP_EXT_HDR_UDP_TYPE;
476       preEncodedHdr[--cnt] = 1;
477       preEncodedHdr[--cnt] = GetHiByte(preDefHdr->extHdr.udpPort.val);
478       preEncodedHdr[--cnt] = GetLoByte(preDefHdr->extHdr.udpPort.val);
479    }
480    
481    if(preDefHdr->extHdr.pdcpNmb.pres)
482    {
483       preEncodedHdr[--cnt] = EGTP_EXT_HDR_PDCP_TYPE;
484       preEncodedHdr[--cnt] = 1;
485       preEncodedHdr[--cnt] = GetHiByte(preDefHdr->extHdr.pdcpNmb.val);
486       preEncodedHdr[--cnt] = GetLoByte(preDefHdr->extHdr.pdcpNmb.val);
487    }
488     
489    if(tmpByte & EGTP_MASK_BIT3)
490    {
491       preEncodedHdr[--cnt] = 0;
492    }
493    else if(extPres)
494    {
495       preEncodedHdr[--cnt] = 0;
496    } 
497    
498    *hdrIdx = cnt;
499    return ROK;
500
501 } /* egtpEncodeHdr */
502
503 S16 cuEgtpHdlRecvMsg(Buffer *mBuf)
504 {
505    /*Decoding of EGTP message header */
506    cuEgtpDecodeHdr(mBuf);
507
508    /* Start Pumping data from CU to DU */
509    return (cuEgtpDatReq());
510
511 }
512
513 S16 cuEgtpDecodeHdr(Buffer *mBuf)
514 {
515    EgtpMsg  egtpMsg;
516    S16      retVal  = ROK;       /* Holds the return value */
517    U8       tmpByte[5];         /* Holds one byte of data after Dec */
518    U8       version = 0;         /* Holds the version type, decoded */
519    MsgLen   msgLen  = 0;         /* Holds the msgLen from the Hdr */
520    MsgLen   bufLen  = 0;         /* Holds the total buffer length */
521    U8       extHdrType = 0;       /* Holds the Extension hdr type */
522    U8       extHdrLen = 0;        /* Extension hdr length */
523    Bool     extPres = FALSE;      /* Flag for indication of S, E or P presense flag */
524
525    ODU_FIND_MSG_LEN(mBuf, &bufLen);
526
527    /* Decode version */
528    ODU_REM_PRE_MSG(&tmpByte[0], mBuf);
529    version = tmpByte[0] >> 5;
530
531    /* Decode message type */
532    ODU_REM_PRE_MSG((Data*)&(egtpMsg.msgHdr.msgType), mBuf);
533
534    /* Decode message length */
535    ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
536    ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
537    msgLen = (tmpByte[1] << 8) | tmpByte[2];
538
539    /* Decode tunnel id */
540    ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
541    ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
542    ODU_REM_PRE_MSG(&tmpByte[3], mBuf);
543    ODU_REM_PRE_MSG(&tmpByte[4], mBuf);
544    egtpMsg.msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4];
545
546    if((tmpByte[0] & EGTP_MASK_BIT1) || (tmpByte[0] & EGTP_MASK_BIT2)||(tmpByte[0] & EGTP_MASK_BIT3))
547    {
548       extPres = TRUE;
549    }
550
551    /* Decode sequence number */
552    if ( tmpByte[0] & EGTP_MASK_BIT2 )
553    {
554       egtpMsg.msgHdr.seqNum.pres = TRUE;
555       ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
556       ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
557       egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
558    }
559    else  if(extPres)
560    {
561       egtpMsg.msgHdr.seqNum.pres = 0;
562       ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
563       ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
564       egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
565    }
566
567    /* Decode N-PDU number */
568    if ( tmpByte[0] & EGTP_MASK_BIT1 )
569    {
570       egtpMsg.msgHdr.nPdu.pres = TRUE;
571       ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf);
572    }
573    else if(extPres)
574    {
575       egtpMsg.msgHdr.nPdu.pres = TRUE;
576       ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf);
577    }
578
579    if(extPres & EGTP_MASK_BIT1)
580    {
581       ODU_REM_PRE_MSG(&extHdrType, mBuf);
582       while( 0 != extHdrType)
583       {
584          switch (extHdrType)
585          {
586             case EGTP_EXT_HDR_UDP_TYPE:
587             {
588                ODU_REM_PRE_MSG(&extHdrLen, mBuf);
589                if(extHdrLen == 0x01)
590                {
591                   egtpMsg.msgHdr.extHdr.udpPort.pres = TRUE;
592                   ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
593                   ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
594                   egtpMsg.msgHdr.extHdr.udpPort.val = (tmpByte[1] << 8) | tmpByte[2];
595                }
596                break;
597             }
598
599             case EGTP_EXT_HDR_PDCP_TYPE:
600             {
601                ODU_REM_PRE_MSG(&extHdrLen, mBuf);
602                if(extHdrLen == 0x01)
603                {
604                   egtpMsg.msgHdr.extHdr.pdcpNmb.pres = TRUE;
605                   ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
606                   ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
607                   egtpMsg.msgHdr.extHdr.pdcpNmb.val = (tmpByte[1] << 8) | tmpByte[2];
608                }
609                break;
610             }
611          } /* End of switch */
612
613          ODU_REM_PRE_MSG(&extHdrType, mBuf);
614
615       } /* End of while */
616    } /* End of if(extPres & EGTP_MASK_BIT1) */
617    else if(extPres)
618    {
619       ODU_REM_PRE_MSG(&extHdrType, mBuf);
620    }
621
622    DU_LOG("\nEGTP : Message Buffer after decoding header ");
623    ODU_PRINT_MSG(mBuf, 0, 0);
624
625    return ROK;
626      
627 } /* End of cuEgtpDecodeHdr */
628
629 S16 cuEgtpDatReq()
630 {
631    U8 cnt = 0;
632    EgtpMsg  egtpMsg;
633
634    /* Build Application message that is supposed to come from app to egtp */
635    BuildAppMsg(&egtpMsg);
636
637    /* Encode EGTP header to build final EGTP message */
638    BuildEgtpMsg(&egtpMsg);
639
640    /* Send Message to peer */
641    while(cnt < 1)
642    {
643       DU_LOG("\nEGTP : Sending message[%d]", cnt+1);
644       cuEgtpSendMsg(egtpMsg.msg);
645       cnt++;
646    }
647
648    ODU_PUT_MSG(egtpMsg.msg);
649
650    return ROK;
651 }
652
653
654 S16 BuildAppMsg(EgtpMsg  *egtpMsg)
655 {
656    char data[30] = "This is EGTP data from CU";
657    int datSize = 30;
658  
659    Buffer   *mBuf;
660  
661    if(ODU_GET_MSG(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK)
662    {
663       if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
664       {
665          DU_LOG("\nEGTP : ODU_ADD_POST_MSG_MULT failed");
666          ODU_PUT_MSG(mBuf);
667          return RFAILED;
668       }
669    }
670    else
671    {
672        DU_LOG("\nEGTP : Failed to allocate memory");
673        return RFAILED;
674    }
675  
676    /* filling IPv4 header */
677    CmIpv4Hdr ipv4Hdr;
678    MsgLen    mLen;
679  
680    mLen = 0;
681    ODU_FIND_MSG_LEN(mBuf, &mLen);
682
683    cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
684    ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
685    ipv4Hdr.hdrVer = 0x45;
686    ipv4Hdr.proto = 1;
687    ipv4Hdr.srcAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
688    ipv4Hdr.destAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
689  
690    /* Packing IPv4 header into buffer */
691    S16          ret, cnt, idx;
692    Data         revPkArray[CM_IPV4_HDRLEN];
693    Data         pkArray[CM_IPV4_HDRLEN];
694  
695    /* initialize locals */
696    cnt = 0;
697    cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
698    cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
699
700    /* Pack Header Version */
701    pkArray[cnt++] = ipv4Hdr.hdrVer;
702  
703    /* Pack TOS */
704    pkArray[cnt++] = ipv4Hdr.tos;
705  
706    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
707    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
708  
709    /* Pack Id */
710    pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
711    pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
712  
713    /* Pack Offset */
714    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
715    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
716  
717    /* Pack TTL */
718    pkArray[cnt++] = ipv4Hdr.ttl;
719  
720    /* Pack Protocol */
721    pkArray[cnt++] = ipv4Hdr.proto;
722  
723    /* Pack Checksum */
724    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
725    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
726                                                         
727    /* Pack Source Address */
728    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
729    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
730    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
731    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
732  
733    /* Pack Destination Address */
734    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
735    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
736    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
737    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
738  
739    for (idx = 0;  idx < CM_IPV4_HDRLEN;  idx++)
740       revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
741  
742    /* this function automatically reverses revPkArray */
743    ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
744  
745    egtpMsg->msgHdr.msgType = EGTPU_MSG_GPDU;
746    egtpMsg->msgHdr.nPdu.pres = FALSE;
747    egtpMsg->msgHdr.seqNum.pres = FALSE;
748    egtpMsg->msgHdr.extHdr.udpPort.pres = FALSE;
749    egtpMsg->msgHdr.extHdr.pdcpNmb.pres = FALSE;
750    egtpMsg->msgHdr.teId = 10;
751    egtpMsg->msg = mBuf;
752
753    return ROK;
754 }
755
756
757 S16 BuildEgtpMsg(EgtpMsg *egtpMsg)
758 {
759    EgtpTeIdCb   *teidCb = NULLP;
760    MsgLen tPduSize;
761    U8     hdrLen;
762    U32    msgLen;
763    EgtpMsgHdr   *msgHdr;
764  
765    cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(egtpMsg->msgHdr.teId), sizeof(U32), 0, (PTR *)&teidCb);
766    if(teidCb == NULLP)
767    {
768       DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
769       return (LCM_REASON_INVALID_PAR_VAL);
770    }
771
772    msgHdr = &(egtpMsg->msgHdr);
773
774    hdrLen = teidCb->preEncodedHdr.cnt;
775
776    if(msgHdr->extHdr.pdcpNmb.pres)
777    {
778       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= EGTP_MASK_BIT3;
779       teidCb->preEncodedHdr.hdr[hdrLen] = EGTP_EXT_HDR_PDCP_TYPE;
780       teidCb->preEncodedHdr.hdr[--hdrLen] = 1;
781       teidCb->preEncodedHdr.hdr[--hdrLen] = GetHiByte(msgHdr->extHdr.pdcpNmb.val);
782       teidCb->preEncodedHdr.hdr[--hdrLen] = GetLoByte(msgHdr->extHdr.pdcpNmb.val);
783       teidCb->preEncodedHdr.hdr[--hdrLen] = 0;
784    }
785    else
786    {
787       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT3);
788    }
789  
790    ODU_FIND_MSG_LEN(egtpMsg->msg, &tPduSize);
791
792    /*Adjust the header to fill the correct length*/
793    msgLen = tPduSize +  (EGTP_MAX_HDR_LEN - hdrLen) - 0x08;
794
795    /***********************************************
796     * Fill the length field of the message header *
797     ***********************************************/
798    teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (U8)GetHiByte(msgLen);
799    teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (U8)GetLoByte(msgLen);
800
801    /*Update the sequence number*/
802    if(egtpMsg->msgHdr.seqNum.pres)
803    {
804       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= (EGTP_MASK_BIT2);
805       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (U8)GetHiByte(egtpMsg->msgHdr.seqNum.val);
806       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (U8)GetLoByte(egtpMsg->msgHdr.seqNum.val);
807    }
808    else
809    {
810       teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT2);
811    }
812
813    ODU_ADD_PRE_MSG_MULT(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg);
814
815    DU_LOG("\nEGTP : Sending message buffer");
816    ODU_PRINT_MSG(egtpMsg->msg, 0, 0);
817
818    return ROK;
819 }
820
821 S16 cuEgtpSendMsg(Buffer *mBuf)
822 {
823    S16            ret;
824    MsgLen         txLen;
825    CmInetMemInfo  info;
826    CmInetAddr     dstAddr;
827
828    info.region = CU_APP_MEM_REG;
829    info.pool = CU_POOL;
830  
831    dstAddr.port = EGTP_DFLT_PORT;
832    dstAddr.address = egtpCb.dstCb.dstIp;
833  
834    ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
835    if(ret != ROK && ret != RWOULDBLOCK)
836    {
837       DU_LOG("\nEGTP : Message send failure");
838       return RFAILED;
839    }
840    
841    DU_LOG("\nEGTP : Message Sent");
842  
843    return ROK;
844 }