1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /* This file contains all EGTP related functionality */
22 #include "cu_stub_egtp.h"
24 /* Global variable declaration */
27 /**************************************************************************
28 * @brief Task Initiation callback function.
32 * Function : egtpActvInit
35 * This function is supplied as one of parameters during EGTP's
36 * task registration. SSI will invoke this function once, after
37 * it creates and attaches this TAPA Task to a system task.
39 * @param[in] Ent entity, the entity ID of this task.
40 * @param[in] Inst inst, the instance ID of this task.
41 * @param[in] Region region, the region ID registered for memory
43 * @param[in] Reason reason.
44 * @return ROK - success
46 ***************************************************************************/
49 DU_LOG("\n\nEGTP : Initializing");
50 cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb));
51 protType = CM_INET_PROTO_UDP;
56 /**************************************************************************
57 * @brief Task Activation callback function.
61 * Function : egtpActvTsk
64 * This function handles all EGTP messages received
65 * This API is registered with SSI during the
66 * Task Registration of DU APP.
68 * @param[in] Pst *pst, Post structure of the primitive.
69 * @param[in] Buffer *mBuf, Packed primitive parameters in the
71 * @return ROK - success
74 ***************************************************************************/
83 DU_LOG("\nEGTP : Configuration failed");
87 ret = cuEgtpSrvOpenReq();
90 DU_LOG("\nEGTP : Transport server open request failed");
94 tnlEvt.action = EGTP_TNL_MGMT_ADD;
97 ret = cuEgtpTnlMgmtReq(tnlEvt);
100 DU_LOG("\n EGTP : Tunnel management request failed");
108 /**************************************************************************
109 * @brief EGTP server configuration
113 * Function : egtpCfgReq
116 * This function handles EGTP configuration request.
118 * @return ROK - success
121 * ***********************************************************************/
126 cmMemcpy((U8 *)&egtpCb.egtpCfg, (U8 *)&cuCfgParams.egtpParams, (PTR)sizeof(EgtpParams));
128 egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
129 egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
131 egtpCb.dstCb.dstIp = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
132 egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
133 egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
134 egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
135 egtpCb.dstCb.numTunn = 0;
137 ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_U32MOD, CU_APP_MEM_REG, CU_POOL);
141 DU_LOG("\nEGTP : TeId hash list initialization failed");
146 DU_LOG("\nEGTP : Configuration successful");
152 /**************************************************************************
153 * @brief EGTP server open request
157 * Function : egtpSrvOpenReq
160 * This function handles EGTP open server request.
161 * It opens udp socket to receive/send msgs.
163 * @param[in] Pst *pst, post structure
164 * @return ROK - success
167 ***************************************************************************/
169 S16 cuEgtpSrvOpenReq(Pst *pst)
174 DU_LOG("\nEGTP : Received open server request");
176 sockType = CM_INET_DGRAM;
177 if(ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType)) != ROK)
179 DU_LOG("\nEGTP : Failed to open UDP socket");
183 ret = cmInetBind(&(egtpCb.recvTptSrvr.sockFd), &(egtpCb.recvTptSrvr.addr));
186 DU_LOG("\nEGTP : Failed to bind socket");
190 if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK)
192 DU_LOG("\nEGTP : Failed to open UDP socket");
196 ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr));
199 DU_LOG("\nEGTP : Failed to bind socket");
203 /* TODO: set socket options */
205 DU_LOG("\nEGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd, egtpCb.dstCb.sendTptSrvr.sockFd.fd);
207 } /* cuEgtpSrvOpenReq */
210 /**************************************************************************
211 * @brief EGTP tunnel management request
215 * Function : cuEgtpTnlMgmtReq
218 * This function handles EGTP tunnel managament request
220 * @param[in] Pst *pst, post structure
221 * Tunnel Eveny structure
222 * @return ROK - success
226 * ***************************************************************************/
227 S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt)
231 DU_LOG("\nEGTP : Received tunnel management request");
232 switch(tnlEvt.action)
234 case EGTP_TNL_MGMT_ADD:
236 ret = cuEgtpTnlAdd(tnlEvt);
239 case EGTP_TNL_MGMT_MOD:
241 ret = cuEgtpTnlMod(tnlEvt);
244 case EGTP_TNL_MGMT_DEL:
246 ret = cuEgtpTnlDel(tnlEvt);
251 DU_LOG("\nEGTP : Invalid tunnel management action[%d]", tnlEvt.action);
259 /**************************************************************************
260 * @brief EGTP tunnel addition
264 * Function : cuEgtpTnlAdd
267 * This function handles EGTP tunnel addition
269 * @param[in] Tunnel Event structure
270 * @return ROK - success
273 * ***************************************************************************/
274 S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt)
278 EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
281 DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
283 ret = SGetSBuf(CU_APP_MEM_REG, CU_POOL, (Data **)&teidCb, (Size)sizeof(EgtpTeIdCb));
286 DU_LOG("\nEGTP : Memory allocation failed");
291 cmMemset((U8 *)teidCb, 0, sizeof(EgtpTeIdCb));
292 teidCb->teId = tnlEvt.lclTeid;
293 teidCb->remTeId = tnlEvt.remTeid;
295 ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (U8 *)&(teidCb->teId), sizeof(U32));
298 DU_LOG("\nEGTP : Failed to insert in hash list");
299 SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));
302 egtpCb.dstCb.numTunn++;
304 /* Encoding pre-defined header */
305 cmMemset((U8*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
306 preDefHdr.msgType = EGTPU_MSG_GPDU;
307 preDefHdr.teId = teidCb->remTeId;
308 preDefHdr.extHdr.pdcpNmb.pres = FALSE;
309 preDefHdr.extHdr.udpPort.pres = FALSE;
310 preDefHdr.nPdu.pres = FALSE;
312 cuEgtpEncodeHdr((U8 *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
314 /* SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));*/
319 /**************************************************************************
320 * @brief EGTP tunnel modification
324 * Function : cuEgtpTnlMod
327 * This function handles EGTP tunnel modification
329 * @param[in] Tunnel Event structure
330 * @return ROK - success
333 * ***************************************************************************/
334 S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt)
338 EgtpTeIdCb *teidCb = NULLP;
340 printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
342 cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.teId), sizeof(U32), 0, (PTR *)&teidCb);
345 printf("\nTunnel id not found");
349 teidCb->teId = tnlEvt.lclTeid;
350 teidCb->remTeId = tnlEvt.remTeid;
355 /**************************************************************************
356 * @brief EGTP tunnel deletion
360 * Function : cuEgtpTnlDel
363 * This function handles EGTP tunnel deletion
365 * @param[in] Tunnel Event structure
366 * @return ROK - success
369 * ***************************************************************************/
370 S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt)
372 EgtpTeIdCb *teidCb = NULLP;
374 DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
376 cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.lclTeid), sizeof(U32), 0, (PTR *)&teidCb);
379 DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
383 cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb);
384 SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));
385 egtpCb.dstCb.numTunn--;
390 /*******************************************************************
392 * @brief Encodes message header
396 * Function : cuEgtpEncodeHdr
399 * Encodes EGTP message haeder
401 * @params[in] EGTP message
403 * @return ROK - success
406 * ****************************************************************/
407 S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx)
409 U8 tmpByte = 0; /* Stores one byte of data for enc */
410 U8 cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
411 Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
414 /* Encoding header */
415 tmpByte |= EGTP_MASK_BIT6; /* Setting 6th LSB of 1st byte as version */
416 tmpByte |= EGTP_MASK_BIT5; /* Setting 5th LSB of 1st byte as protocol type */
418 if(preDefHdr->extHdr.udpPort.pres || preDefHdr->extHdr.pdcpNmb.pres)
420 tmpByte |= EGTP_MASK_BIT3; /* Setting 3rd LSB of 1st byte if Extension heaeder is present */
423 if(preDefHdr->seqNum.pres)
425 tmpByte |= EGTP_MASK_BIT2;
428 if(preDefHdr->nPdu.pres)
430 tmpByte |= EGTP_MASK_BIT1;
433 if((tmpByte & EGTP_MASK_BIT1) || (tmpByte & EGTP_MASK_BIT2)||(tmpByte & EGTP_MASK_BIT3))
437 preEncodedHdr[--cnt] = tmpByte;
438 preEncodedHdr[--cnt] = preDefHdr->msgType;
440 /* Encode Tunnel endpoint */
441 preEncodedHdr[--cnt] = 0;
442 preEncodedHdr[--cnt] = 0;
443 nwWord = (U16)(GetHiWord(preDefHdr->teId));
444 preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
445 preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
446 nwWord = (U16)(GetLoWord(preDefHdr->teId));
447 preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
448 preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
450 /* Encode sequence number */
451 if(preDefHdr->seqNum.pres)
453 preEncodedHdr[--cnt] = GetHiByte(preDefHdr->seqNum.val);
454 preEncodedHdr[--cnt] = GetLoByte(preDefHdr->seqNum.val);
458 preEncodedHdr[--cnt] = 0;
459 preEncodedHdr[--cnt] = 0;
462 if(preDefHdr->nPdu.pres)
464 preEncodedHdr[--cnt] = preDefHdr->nPdu.val;
468 preEncodedHdr[--cnt] = 0;
471 if(preDefHdr->extHdr.udpPort.pres)
473 preEncodedHdr[--cnt] = EGTP_EXT_HDR_UDP_TYPE;
474 preEncodedHdr[--cnt] = 1;
475 preEncodedHdr[--cnt] = GetHiByte(preDefHdr->extHdr.udpPort.val);
476 preEncodedHdr[--cnt] = GetLoByte(preDefHdr->extHdr.udpPort.val);
479 if(preDefHdr->extHdr.pdcpNmb.pres)
481 preEncodedHdr[--cnt] = EGTP_EXT_HDR_PDCP_TYPE;
482 preEncodedHdr[--cnt] = 1;
483 preEncodedHdr[--cnt] = GetHiByte(preDefHdr->extHdr.pdcpNmb.val);
484 preEncodedHdr[--cnt] = GetLoByte(preDefHdr->extHdr.pdcpNmb.val);
487 if(tmpByte & EGTP_MASK_BIT3)
489 preEncodedHdr[--cnt] = 0;
493 preEncodedHdr[--cnt] = 0;
499 } /* egtpEncodeHdr */
501 S16 cuEgtpHdlRecvMsg(Buffer *mBuf)
503 /*Decoding of EGTP message header */
504 cuEgtpDecodeHdr(mBuf);
506 /* Start Pumping data from CU to DU */
507 RETVALUE(cuEgtpDatReq());
511 S16 cuEgtpDecodeHdr(Buffer *mBuf)
514 S16 retVal = ROK; /* Holds the return value */
515 U8 tmpByte[5]; /* Holds one byte of data after Dec */
516 U8 version = 0; /* Holds the version type, decoded */
517 MsgLen msgLen = 0; /* Holds the msgLen from the Hdr */
518 MsgLen bufLen = 0; /* Holds the total buffer length */
519 U8 extHdrType = 0; /* Holds the Extension hdr type */
520 U8 extHdrLen = 0; /* Extension hdr length */
521 Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
523 SFndLenMsg(mBuf, &bufLen);
526 SRemPreMsg(&tmpByte[0], mBuf);
527 version = tmpByte[0] >> 5;
529 /* Decode message type */
530 SRemPreMsg((Data*)&(egtpMsg.msgHdr.msgType), mBuf);
532 /* Decode message length */
533 SRemPreMsg(&tmpByte[1], mBuf);
534 SRemPreMsg(&tmpByte[2], mBuf);
535 msgLen = (tmpByte[1] << 8) | tmpByte[2];
537 /* Decode tunnel id */
538 SRemPreMsg(&tmpByte[1], mBuf);
539 SRemPreMsg(&tmpByte[2], mBuf);
540 SRemPreMsg(&tmpByte[3], mBuf);
541 SRemPreMsg(&tmpByte[4], mBuf);
542 egtpMsg.msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4];
544 if((tmpByte[0] & EGTP_MASK_BIT1) || (tmpByte[0] & EGTP_MASK_BIT2)||(tmpByte[0] & EGTP_MASK_BIT3))
549 /* Decode sequence number */
550 if ( tmpByte[0] & EGTP_MASK_BIT2 )
552 egtpMsg.msgHdr.seqNum.pres = TRUE;
553 SRemPreMsg(&tmpByte[1], mBuf);
554 SRemPreMsg(&tmpByte[2], mBuf);
555 egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
559 egtpMsg.msgHdr.seqNum.pres = 0;
560 SRemPreMsg(&tmpByte[1], mBuf);
561 SRemPreMsg(&tmpByte[2], mBuf);
562 egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
565 /* Decode N-PDU number */
566 if ( tmpByte[0] & EGTP_MASK_BIT1 )
568 egtpMsg.msgHdr.nPdu.pres = TRUE;
569 SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf);
573 egtpMsg.msgHdr.nPdu.pres = TRUE;
574 SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf);
577 if(extPres & EGTP_MASK_BIT1)
579 SRemPreMsg(&extHdrType, mBuf);
580 while( 0 != extHdrType)
584 case EGTP_EXT_HDR_UDP_TYPE:
586 SRemPreMsg(&extHdrLen, mBuf);
587 if(extHdrLen == 0x01)
589 egtpMsg.msgHdr.extHdr.udpPort.pres = TRUE;
590 SRemPreMsg(&tmpByte[1], mBuf);
591 SRemPreMsg(&tmpByte[2], mBuf);
592 egtpMsg.msgHdr.extHdr.udpPort.val = (tmpByte[1] << 8) | tmpByte[2];
597 case EGTP_EXT_HDR_PDCP_TYPE:
599 SRemPreMsg(&extHdrLen, mBuf);
600 if(extHdrLen == 0x01)
602 egtpMsg.msgHdr.extHdr.pdcpNmb.pres = TRUE;
603 SRemPreMsg(&tmpByte[1], mBuf);
604 SRemPreMsg(&tmpByte[2], mBuf);
605 egtpMsg.msgHdr.extHdr.pdcpNmb.val = (tmpByte[1] << 8) | tmpByte[2];
609 } /* End of switch */
611 SRemPreMsg(&extHdrType, mBuf);
614 } /* End of if(extPres & EGTP_MASK_BIT1) */
617 SRemPreMsg(&extHdrType, mBuf);
620 DU_LOG("\nEGTP : Message Buffer after decoding header ");
621 SPrntMsg(mBuf, 0, 0);
625 } /* End of cuEgtpDecodeHdr */
632 /* Build Application message that is supposed to come from app to egtp */
633 BuildAppMsg(&egtpMsg);
635 /* Encode EGTP header to build final EGTP message */
636 BuildEgtpMsg(&egtpMsg);
638 /* Send Message to peer */
641 DU_LOG("\nEGTP : Sending message[%d]", cnt+1);
642 cuEgtpSendMsg(egtpMsg.msg);
646 SPutMsg(egtpMsg.msg);
652 S16 BuildAppMsg(EgtpMsg *egtpMsg)
654 char data[30] = "This is EGTP data from CU";
659 if(SGetMsg(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK)
661 if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK)
663 DU_LOG("\nEGTP : SAddPstMsgMult failed");
670 DU_LOG("\nEGTP : Failed to allocate memory");
674 /* filling IPv4 header */
679 SFndLenMsg(mBuf, &mLen);
681 cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
682 ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
683 ipv4Hdr.hdrVer = 0x45;
685 ipv4Hdr.srcAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
686 ipv4Hdr.destAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
688 /* Packing IPv4 header into buffer */
690 Data revPkArray[CM_IPV4_HDRLEN];
691 Data pkArray[CM_IPV4_HDRLEN];
693 /* initialize locals */
695 cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
696 cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
698 /* Pack Header Version */
699 pkArray[cnt++] = ipv4Hdr.hdrVer;
702 pkArray[cnt++] = ipv4Hdr.tos;
704 pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
705 pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
708 pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
709 pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
712 pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
713 pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
716 pkArray[cnt++] = ipv4Hdr.ttl;
719 pkArray[cnt++] = ipv4Hdr.proto;
722 pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
723 pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
725 /* Pack Source Address */
726 pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
727 pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
728 pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
729 pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
731 /* Pack Destination Address */
732 pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
733 pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
734 pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
735 pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
737 for (idx = 0; idx < CM_IPV4_HDRLEN; idx++)
738 revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
740 /* this function automatically reverses revPkArray */
741 ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
743 egtpMsg->msgHdr.msgType = EGTPU_MSG_GPDU;
744 egtpMsg->msgHdr.nPdu.pres = FALSE;
745 egtpMsg->msgHdr.seqNum.pres = FALSE;
746 egtpMsg->msgHdr.extHdr.udpPort.pres = FALSE;
747 egtpMsg->msgHdr.extHdr.pdcpNmb.pres = FALSE;
748 egtpMsg->msgHdr.teId = 10;
755 S16 BuildEgtpMsg(EgtpMsg *egtpMsg)
757 EgtpTeIdCb *teidCb = NULLP;
763 cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(egtpMsg->msgHdr.teId), sizeof(U32), 0, (PTR *)&teidCb);
766 DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
767 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
770 msgHdr = &(egtpMsg->msgHdr);
772 hdrLen = teidCb->preEncodedHdr.cnt;
774 if(msgHdr->extHdr.pdcpNmb.pres)
776 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= EGTP_MASK_BIT3;
777 teidCb->preEncodedHdr.hdr[hdrLen] = EGTP_EXT_HDR_PDCP_TYPE;
778 teidCb->preEncodedHdr.hdr[--hdrLen] = 1;
779 teidCb->preEncodedHdr.hdr[--hdrLen] = GetHiByte(msgHdr->extHdr.pdcpNmb.val);
780 teidCb->preEncodedHdr.hdr[--hdrLen] = GetLoByte(msgHdr->extHdr.pdcpNmb.val);
781 teidCb->preEncodedHdr.hdr[--hdrLen] = 0;
785 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT3);
788 SFndLenMsg(egtpMsg->msg, &tPduSize);
790 /*Adjust the header to fill the correct length*/
791 msgLen = tPduSize + (EGTP_MAX_HDR_LEN - hdrLen) - 0x08;
793 /***********************************************
794 * Fill the length field of the message header *
795 ***********************************************/
796 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (U8)GetHiByte(msgLen);
797 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (U8)GetLoByte(msgLen);
799 /*Update the sequence number*/
800 if(egtpMsg->msgHdr.seqNum.pres)
802 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= (EGTP_MASK_BIT2);
803 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (U8)GetHiByte(egtpMsg->msgHdr.seqNum.val);
804 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (U8)GetLoByte(egtpMsg->msgHdr.seqNum.val);
808 teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT2);
811 SAddPreMsgMult(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg);
813 DU_LOG("\nEGTP : Sending message buffer");
814 SPrntMsg(egtpMsg->msg, 0, 0);
819 S16 cuEgtpSendMsg(Buffer *mBuf)
826 info.region = CU_APP_MEM_REG;
829 dstAddr.port = EGTP_DFLT_PORT;
830 dstAddr.address = egtpCb.dstCb.dstIp;
832 ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
833 if(ret != ROK && ret != RWOULDBLOCK)
835 DU_LOG("\nEGTP : Message send failure");
839 DU_LOG("\nEGTP : Message Sent");