X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fcu_stub%2Fcu_stub_egtp.c;h=3729e45fcdb41df313176f46723cb8f07e92ad7d;hb=def50dc175cebc67238db5f1acd5ff322a2279bd;hp=e715736695e5ce58a4885b1fb756ad5c09fb9384;hpb=105199ef642ffe9736ea24a01d4546578fa25e60;p=o-du%2Fl2.git diff --git a/src/cu_stub/cu_stub_egtp.c b/src/cu_stub/cu_stub_egtp.c index e71573669..3729e45fc 100644 --- a/src/cu_stub/cu_stub_egtp.c +++ b/src/cu_stub/cu_stub_egtp.c @@ -19,7 +19,6 @@ /* This file contains all EGTP related functionality */ #include "common_def.h" -#include "odu_common_codec.h" #include "cu_stub_egtp.h" #include "du_log.h" @@ -49,9 +48,9 @@ EgtpGlobalCb egtpCb; S16 egtpActvInit() { DU_LOG("\n\nEGTP : Initializing"); - cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb)); + memset (&egtpCb, 0, sizeof(EgtpGlobalCb)); protType = CM_INET_PROTO_UDP; - RETVALUE(ROK); + return ROK; } @@ -74,23 +73,23 @@ S16 egtpActvInit() * RFAILED - failure * ***************************************************************************/ -S16 egtpInitReq() +uint8_t egtpInitReq() { - S16 ret = ROK; + uint8_t ret = ROK; EgtpTnlEvt tnlEvt; ret = cuEgtpCfgReq(); if(ret != ROK) { DU_LOG("\nEGTP : Configuration failed"); - RETVALUE(ret); + return (ret); } ret = cuEgtpSrvOpenReq(); if(ret != ROK) { DU_LOG("\nEGTP : Transport server open request failed"); - RETVALUE(ret); + return (ret); } tnlEvt.action = EGTP_TNL_MGMT_ADD; @@ -100,11 +99,10 @@ S16 egtpInitReq() if(ret != ROK) { DU_LOG("\n EGTP : Tunnel management request failed"); - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ret); - + return ret; } /* egtpInitReq */ /************************************************************************** @@ -123,32 +121,32 @@ S16 egtpInitReq() * ***********************************************************************/ S16 cuEgtpCfgReq() { - U8 ret; + uint8_t ret; - cmMemcpy((U8 *)&egtpCb.egtpCfg, (U8 *)&cuCfgParams.egtpParams, (PTR)sizeof(EgtpParams)); + memcpy(&egtpCb.egtpCfg, &cuCfgParams.egtpParams, sizeof(EgtpParams)); - egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr); + egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT; - egtpCb.dstCb.dstIp = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr); + egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr); egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort; - egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr); + egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort; egtpCb.dstCb.numTunn = 0; - ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_U32MOD, CU_APP_MEM_REG, CU_POOL); + ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL); if(ret != ROK) { DU_LOG("\nEGTP : TeId hash list initialization failed"); - RETVALUE(RFAILED); + return RFAILED; } else { DU_LOG("\nEGTP : Configuration successful"); } - RETVALUE(ROK); + return ROK; } /* cuEgtpCfgReq */ /************************************************************************** @@ -171,41 +169,41 @@ S16 cuEgtpCfgReq() S16 cuEgtpSrvOpenReq(Pst *pst) { - U8 ret; + uint8_t ret; DU_LOG("\nEGTP : Received open server request"); sockType = CM_INET_DGRAM; - if(ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType)) != ROK) + if((ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType))) != ROK) { DU_LOG("\nEGTP : Failed to open UDP socket"); - RETVALUE(RFAILED); + return RFAILED; } ret = cmInetBind(&(egtpCb.recvTptSrvr.sockFd), &(egtpCb.recvTptSrvr.addr)); if(ret != ROK) { DU_LOG("\nEGTP : Failed to bind socket"); - RETVALUE(RFAILED); + return RFAILED; } if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK) { DU_LOG("\nEGTP : Failed to open UDP socket"); - RETVALUE(RFAILED); + return RFAILED; } ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr)); if(ret != ROK) { DU_LOG("\nEGTP : Failed to bind socket"); - RETVALUE(RFAILED); + return RFAILED; } /* TODO: set socket options */ DU_LOG("\nEGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd, egtpCb.dstCb.sendTptSrvr.sockFd.fd); - RETVALUE(ROK); + return ROK; } /* cuEgtpSrvOpenReq */ @@ -255,7 +253,7 @@ S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt) } } - RETVALUE(ret); + return (ret); } /************************************************************************** @@ -282,40 +280,41 @@ S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt) DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid); - ret = SGetSBuf(CU_APP_MEM_REG, CU_POOL, (Data **)&teidCb, (Size)sizeof(EgtpTeIdCb)); - if(ret != ROK) + CU_ALLOC(teidCb, (Size)sizeof(EgtpTeIdCb)); + + if(teidCb == NULLP) { DU_LOG("\nEGTP : Memory allocation failed"); - RETVALUE(RFAILED); + return RFAILED; } - cmMemset((U8 *)teidCb, 0, sizeof(EgtpTeIdCb)); + memset(teidCb, 0, sizeof(EgtpTeIdCb)); teidCb->teId = tnlEvt.lclTeid; teidCb->remTeId = tnlEvt.remTeid; - ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (U8 *)&(teidCb->teId), sizeof(U32)); + ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t)); if(ret != ROK) { DU_LOG("\nEGTP : Failed to insert in hash list"); - SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb)); - RETVALUE(RFAILED); + CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb)); + return RFAILED; } egtpCb.dstCb.numTunn++; /* Encoding pre-defined header */ - cmMemset((U8*)&preDefHdr, 0, sizeof(EgtpMsgHdr)); + memset(&preDefHdr, 0, sizeof(EgtpMsgHdr)); preDefHdr.msgType = EGTPU_MSG_GPDU; preDefHdr.teId = teidCb->remTeId; preDefHdr.extHdr.pdcpNmb.pres = FALSE; preDefHdr.extHdr.udpPort.pres = FALSE; preDefHdr.nPdu.pres = FALSE; - cuEgtpEncodeHdr((U8 *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt)); + cuEgtpEncodeHdr((uint8_t *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt)); /* SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));*/ - RETVALUE(ROK); + return ROK; } /* cuEgtpTnlAdd */ /************************************************************************** @@ -341,17 +340,17 @@ S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt) printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid); - cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.teId), sizeof(U32), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { printf("\nTunnel id not found"); - RETVALUE(RFAILED); + return RFAILED; } teidCb->teId = tnlEvt.lclTeid; teidCb->remTeId = tnlEvt.remTeid; #endif - RETVALUE(ROK); + return ROK; } /************************************************************************** @@ -375,18 +374,18 @@ S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt) DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid); - cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.lclTeid), sizeof(U32), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid); - RETVALUE(RFAILED); + return RFAILED; } cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb); - SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb)); + CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb)); egtpCb.dstCb.numTunn--; - RETVALUE(ROK); + return ROK; } /* cuEgtpTnlDel */ /******************************************************************* @@ -406,12 +405,12 @@ S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt) * RFAILED - failure * * ****************************************************************/ -S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx) +S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx) { - U8 tmpByte = 0; /* Stores one byte of data for enc */ - U8 cnt = EGTP_MAX_HDR_LEN; /* Stores the position */ + uint8_t tmpByte = 0; /* Stores one byte of data for enc */ + uint8_t cnt = EGTP_MAX_HDR_LEN; /* Stores the position */ Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */ - U16 nwWord = 0; + uint16_t nwWord = 0; /* Encoding header */ tmpByte |= EGTP_MASK_BIT6; /* Setting 6th LSB of 1st byte as version */ @@ -442,12 +441,12 @@ S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx) /* Encode Tunnel endpoint */ preEncodedHdr[--cnt] = 0; preEncodedHdr[--cnt] = 0; - nwWord = (U16)(GetHiWord(preDefHdr->teId)); - preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord)); - preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord)); - nwWord = (U16)(GetLoWord(preDefHdr->teId)); - preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord)); - preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord)); + nwWord = (uint16_t)(GetHiWord(preDefHdr->teId)); + preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord)); + preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord)); + nwWord = (uint16_t)(GetLoWord(preDefHdr->teId)); + preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord)); + preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord)); /* Encode sequence number */ if(preDefHdr->seqNum.pres) @@ -496,7 +495,7 @@ S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx) } *hdrIdx = cnt; - RETVALUE(ROK); + return ROK; } /* egtpEncodeHdr */ @@ -506,41 +505,40 @@ S16 cuEgtpHdlRecvMsg(Buffer *mBuf) cuEgtpDecodeHdr(mBuf); /* Start Pumping data from CU to DU */ - RETVALUE(cuEgtpDatReq()); + return (cuEgtpDatReq()); } S16 cuEgtpDecodeHdr(Buffer *mBuf) { EgtpMsg egtpMsg; - S16 retVal = ROK; /* Holds the return value */ - U8 tmpByte[5]; /* Holds one byte of data after Dec */ - U8 version = 0; /* Holds the version type, decoded */ + uint8_t tmpByte[5]; /* Holds one byte of data after Dec */ + uint8_t version = 0; /* Holds the version type, decoded */ MsgLen msgLen = 0; /* Holds the msgLen from the Hdr */ MsgLen bufLen = 0; /* Holds the total buffer length */ - U8 extHdrType = 0; /* Holds the Extension hdr type */ - U8 extHdrLen = 0; /* Extension hdr length */ + uint8_t extHdrType = 0; /* Holds the Extension hdr type */ + uint8_t extHdrLen = 0; /* Extension hdr length */ Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */ - SFndLenMsg(mBuf, &bufLen); + ODU_GET_MSG_LEN(mBuf, &bufLen); /* Decode version */ - SRemPreMsg(&tmpByte[0], mBuf); + ODU_REM_PRE_MSG(&tmpByte[0], mBuf); version = tmpByte[0] >> 5; /* Decode message type */ - SRemPreMsg((Data*)&(egtpMsg.msgHdr.msgType), mBuf); + ODU_REM_PRE_MSG((Data*)&(egtpMsg.msgHdr.msgType), mBuf); /* Decode message length */ - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); msgLen = (tmpByte[1] << 8) | tmpByte[2]; /* Decode tunnel id */ - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); - SRemPreMsg(&tmpByte[3], mBuf); - SRemPreMsg(&tmpByte[4], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[3], mBuf); + ODU_REM_PRE_MSG(&tmpByte[4], mBuf); egtpMsg.msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4]; if((tmpByte[0] & EGTP_MASK_BIT1) || (tmpByte[0] & EGTP_MASK_BIT2)||(tmpByte[0] & EGTP_MASK_BIT3)) @@ -552,15 +550,15 @@ S16 cuEgtpDecodeHdr(Buffer *mBuf) if ( tmpByte[0] & EGTP_MASK_BIT2 ) { egtpMsg.msgHdr.seqNum.pres = TRUE; - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2]; } else if(extPres) { egtpMsg.msgHdr.seqNum.pres = 0; - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2]; } @@ -568,29 +566,29 @@ S16 cuEgtpDecodeHdr(Buffer *mBuf) if ( tmpByte[0] & EGTP_MASK_BIT1 ) { egtpMsg.msgHdr.nPdu.pres = TRUE; - SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf); + ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf); } else if(extPres) { egtpMsg.msgHdr.nPdu.pres = TRUE; - SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf); + ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf); } if(extPres & EGTP_MASK_BIT1) { - SRemPreMsg(&extHdrType, mBuf); + ODU_REM_PRE_MSG(&extHdrType, mBuf); while( 0 != extHdrType) { switch (extHdrType) { case EGTP_EXT_HDR_UDP_TYPE: { - SRemPreMsg(&extHdrLen, mBuf); + ODU_REM_PRE_MSG(&extHdrLen, mBuf); if(extHdrLen == 0x01) { egtpMsg.msgHdr.extHdr.udpPort.pres = TRUE; - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); egtpMsg.msgHdr.extHdr.udpPort.val = (tmpByte[1] << 8) | tmpByte[2]; } break; @@ -598,37 +596,37 @@ S16 cuEgtpDecodeHdr(Buffer *mBuf) case EGTP_EXT_HDR_PDCP_TYPE: { - SRemPreMsg(&extHdrLen, mBuf); + ODU_REM_PRE_MSG(&extHdrLen, mBuf); if(extHdrLen == 0x01) { egtpMsg.msgHdr.extHdr.pdcpNmb.pres = TRUE; - SRemPreMsg(&tmpByte[1], mBuf); - SRemPreMsg(&tmpByte[2], mBuf); + ODU_REM_PRE_MSG(&tmpByte[1], mBuf); + ODU_REM_PRE_MSG(&tmpByte[2], mBuf); egtpMsg.msgHdr.extHdr.pdcpNmb.val = (tmpByte[1] << 8) | tmpByte[2]; } break; } } /* End of switch */ - SRemPreMsg(&extHdrType, mBuf); + ODU_REM_PRE_MSG(&extHdrType, mBuf); } /* End of while */ } /* End of if(extPres & EGTP_MASK_BIT1) */ else if(extPres) { - SRemPreMsg(&extHdrType, mBuf); + ODU_REM_PRE_MSG(&extHdrType, mBuf); } DU_LOG("\nEGTP : Message Buffer after decoding header "); - SPrntMsg(mBuf, 0, 0); + ODU_PRINT_MSG(mBuf, 0, 0); - RETVALUE(ROK); + return ROK; } /* End of cuEgtpDecodeHdr */ S16 cuEgtpDatReq() { - U8 cnt = 0; + uint8_t cnt = 0; EgtpMsg egtpMsg; /* Build Application message that is supposed to come from app to egtp */ @@ -645,9 +643,9 @@ S16 cuEgtpDatReq() cnt++; } - SPutMsg(egtpMsg.msg); + ODU_PUT_MSG_BUF(egtpMsg.msg); - RETVALUE(ROK); + return ROK; } @@ -658,19 +656,19 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) Buffer *mBuf; - if(SGetMsg(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK) + if(ODU_GET_MSG_BUF(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK) { - if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK) + if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK) { - DU_LOG("\nEGTP : SAddPstMsgMult failed"); - SPutMsg(mBuf); - RETVALUE(RFAILED); + DU_LOG("\nEGTP : ODU_ADD_POST_MSG_MULT failed"); + ODU_PUT_MSG_BUF(mBuf); + return RFAILED; } } else { DU_LOG("\nEGTP : Failed to allocate memory"); - RETVALUE(RFAILED); + return RFAILED; } /* filling IPv4 header */ @@ -678,14 +676,14 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) MsgLen mLen; mLen = 0; - SFndLenMsg(mBuf, &mLen); + ODU_GET_MSG_LEN(mBuf, &mLen); - cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr)); + memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr)); ipv4Hdr.length = CM_IPV4_HDRLEN + mLen; ipv4Hdr.hdrVer = 0x45; ipv4Hdr.proto = 1; - ipv4Hdr.srcAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr); - ipv4Hdr.destAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr); + ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr); + ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr); /* Packing IPv4 header into buffer */ S16 ret, cnt, idx; @@ -694,8 +692,8 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) /* initialize locals */ cnt = 0; - cmMemset(revPkArray, 0, CM_IPV4_HDRLEN); - cmMemset(pkArray, 0, CM_IPV4_HDRLEN); + memset(revPkArray, 0, CM_IPV4_HDRLEN); + memset(pkArray, 0, CM_IPV4_HDRLEN); /* Pack Header Version */ pkArray[cnt++] = ipv4Hdr.hdrVer; @@ -740,7 +738,7 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1]; /* this function automatically reverses revPkArray */ - ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf); + ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf); egtpMsg->msgHdr.msgType = EGTPU_MSG_GPDU; egtpMsg->msgHdr.nPdu.pres = FALSE; @@ -750,7 +748,7 @@ S16 BuildAppMsg(EgtpMsg *egtpMsg) egtpMsg->msgHdr.teId = 10; egtpMsg->msg = mBuf; - RETVALUE(ROK); + return ret; } @@ -758,15 +756,15 @@ S16 BuildEgtpMsg(EgtpMsg *egtpMsg) { EgtpTeIdCb *teidCb = NULLP; MsgLen tPduSize; - U8 hdrLen; - U32 msgLen; + uint8_t hdrLen; + uint32_t msgLen; EgtpMsgHdr *msgHdr; - cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(egtpMsg->msgHdr.teId), sizeof(U32), 0, (PTR *)&teidCb); + cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb); if(teidCb == NULLP) { DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId); - RETVALUE(LCM_REASON_INVALID_PAR_VAL); + return (LCM_REASON_INVALID_PAR_VAL); } msgHdr = &(egtpMsg->msgHdr); @@ -787,7 +785,7 @@ S16 BuildEgtpMsg(EgtpMsg *egtpMsg) teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT3); } - SFndLenMsg(egtpMsg->msg, &tPduSize); + ODU_GET_MSG_LEN(egtpMsg->msg, &tPduSize); /*Adjust the header to fill the correct length*/ msgLen = tPduSize + (EGTP_MAX_HDR_LEN - hdrLen) - 0x08; @@ -795,27 +793,27 @@ S16 BuildEgtpMsg(EgtpMsg *egtpMsg) /*********************************************** * Fill the length field of the message header * ***********************************************/ - teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (U8)GetHiByte(msgLen); - teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (U8)GetLoByte(msgLen); + teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (uint8_t)GetHiByte(msgLen); + teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (uint8_t)GetLoByte(msgLen); /*Update the sequence number*/ if(egtpMsg->msgHdr.seqNum.pres) { teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= (EGTP_MASK_BIT2); - teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (U8)GetHiByte(egtpMsg->msgHdr.seqNum.val); - teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (U8)GetLoByte(egtpMsg->msgHdr.seqNum.val); + teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (uint8_t)GetHiByte(egtpMsg->msgHdr.seqNum.val); + teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (uint8_t)GetLoByte(egtpMsg->msgHdr.seqNum.val); } else { teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT2); } - SAddPreMsgMult(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg); + ODU_ADD_PRE_MSG_MULT(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg); DU_LOG("\nEGTP : Sending message buffer"); - SPrntMsg(egtpMsg->msg, 0, 0); + ODU_PRINT_MSG(egtpMsg->msg, 0, 0); - RETVALUE(ROK); + return ROK; } S16 cuEgtpSendMsg(Buffer *mBuf) @@ -835,10 +833,10 @@ S16 cuEgtpSendMsg(Buffer *mBuf) if(ret != ROK && ret != RWOULDBLOCK) { DU_LOG("\nEGTP : Message send failure"); - RETVALUE(RFAILED); + return RFAILED; } DU_LOG("\nEGTP : Message Sent"); - RETVALUE(ROK); + return ROK; }