X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fcu_stub%2Fcu_stub_sctp.c;h=c74290a22b4a31fcfc98cc80f97ffb2255bf09ec;hb=0ba7b600f85b2975e1d60e5b8ad1523349b5f396;hp=c7a3eeb1cb778180f0658633554de6d298b3fd8d;hpb=d349ae65e1495488772f87e5cfa1ae71d9eab075;p=o-du%2Fl2.git diff --git a/src/cu_stub/cu_stub_sctp.c b/src/cu_stub/cu_stub_sctp.c index c7a3eeb1c..c74290a22 100644 --- a/src/cu_stub/cu_stub_sctp.c +++ b/src/cu_stub/cu_stub_sctp.c @@ -18,22 +18,18 @@ /* This file contains all SCTP related functionality */ -#include -#include "f1ap_msg_hdl.h" +#include "common_def.h" +#include "OCTET_STRING.h" +#include "cu_f1ap_msg_hdl.h" #include "cu_stub_sctp.h" +#include "cu_stub_egtp.h" +#include "cu_stub.h" +#include "cm_inet.h" +#include "cm_tpt.h" -/* Global variable declaration */ -CmInetFd lstnSockFd; /* Listening Socket file descriptor */ -CmInetFd sockFd; /* Socket File descriptor */ -U8 socket_type; /* Socket type */ -Bool nonblocking; /* Blocking/Non-blocking socket */ -Bool connUp; /* Is connection up */ -int assocId; /* Assoc Id of connected assoc */ +#include "cm_inet.x" +#include "cm_tpt.x" -CmInetNetAddrLst localAddrLst; -CmInetNetAddrLst remoteAddrLst; - -SctpParams *sctpCfg; /* SCTP configurations at DU */ /************************************************************************** * @brief Task Initiation callback function. @@ -55,14 +51,12 @@ SctpParams *sctpCfg; /* SCTP configurations at DU */ * @return ROK - success * RFAILED - failure ***************************************************************************/ -S16 sctpActvInit(Ent entity, Inst inst, Region region, Reason reason) +uint8_t sctpActvInit() { - connUp = FALSE; - assocId = 0; - nonblocking = FALSE; - sctpCfg = &(cuCfgParams.sctpParams); + DU_LOG("\n\nDEBUG --> SCTP : Initializing"); + memset(&sctpCb, 0, sizeof(SctpGlobalCb)); + sctpCb.sctpCfg = cuCb.cuCfgParams.sctpParams; return ROK; - } /************************************************************************** @@ -84,132 +78,144 @@ S16 sctpActvInit(Ent entity, Inst inst, Region region, Reason reason) * RFAILED - failure * ***************************************************************************/ -S16 sctpActvTsk(Pst *pst, Buffer *mBuf) +uint8_t sctpActvTsk(Pst *pst, Buffer *mBuf) { //TODO: TBD return ROK; } +/************************************************************************** + * @brief Function to configure the Sctp Params during config Request + * + * @details + * + * Function : duSctpCfgReq + * + * Functionality: + * This function configures SCTP Params during the config Request + * + * @return ROK - success + * RFAILED - failure + * + ***************************************************************************/ + +uint8_t sctpCfgReq() +{ + int destIdx; + + for(destIdx=0; destIdx < sctpCb.sctpCfg.numDu; destIdx++) + { + sctpCb.destCb[destIdx].destPort = sctpCb.sctpCfg.sctpAssoc[destIdx].duPort; + sctpCb.destCb[destIdx].srcPort = sctpCb.sctpCfg.sctpAssoc[destIdx].cuPort; + sctpCb.destCb[destIdx].bReadFdSet = ROK; + memset(&sctpCb.destCb[destIdx].sockFd, -1, sizeof(CmInetFd)); + memset(&sctpCb.destCb[destIdx].lstnSockFd, -1, sizeof(CmInetFd)); + fillDestNetAddr(&sctpCb.destCb[destIdx].destIpNetAddr, &sctpCb.sctpCfg.sctpAssoc[destIdx].duIpAddr); + fillAddrLst(&sctpCb.destCb[destIdx].localAddrLst, &sctpCb.sctpCfg.sctpAssoc[destIdx].cuIpAddr); + } + sctpCb.numDu = sctpCb.sctpCfg.numDu; + return ROK; +} + + /******************************************************************* * - * @brief Opens a non-blocking socket and binds to local address + * @brief Fills the address List of the source Ip Address * * @details * - * Function : openSctpEndp + * Function : fillAddrLst * * Functionality: - * Opens a non-blocking socket and binds to local address + * Fills the address List of source Ip Address * - * @params[in] + * @params[in] CmInetNetAddrLst *addrLstPtr, Address List pointer + * @params[in] F1IpAddr *srcIpAddr, src Ip Adrress to be filled in the Address List * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -S16 openSctpEndp() -{ - U8 ret; - U8 numRetry = 0; - - /* Opening a non-blocking SCTP socket */ - socket_type = CM_INET_STREAM; - - do{ - ret = cmInetSocket(socket_type, &lstnSockFd, IPPROTO_SCTP,(sctpCfg->cuIpAddr.ipV4Pres ? AF_INET : AF_INET6)); - if (ret != ROK) - { - numRetry++; - if(numRetry >= MAX_RETRY) - { - printf("\nAll attempts to open socket failed."); - /* Send indication to du_app */ - RETVALUE(RFAILED); - } - else - { - printf("\nRetrying socket opening"); - } - } - else - { - printf("\nSocket[%d] opened successfully",lstnSockFd.fd); - break; - } - }while(numRetry < MAX_RETRY); - - RETVALUE(ROK); -} /* End of openSctpEndp */ + ******************************************************************/ +uint8_t fillAddrLst(CmInetNetAddrLst *addrLstPtr, SctpIpAddr *ipAddr) +{ + addrLstPtr->addrs[addrLstPtr->count].type = CM_INET_IPV4ADDR_TYPE; + addrLstPtr->addrs[addrLstPtr->count].u.ipv4NetAddr = CM_INET_NTOH_UINT32(ipAddr->ipV4Addr); + addrLstPtr->count++; + return ROK; +} -/******************************************************************* +/****************************************************************************** * - * @brief Bind socket to local Ip address and port + * @brief Fills the address List of the source Ip Address * * @details * - * Function : bindSctpEndp + * Function : fillDestNetAddr * * Functionality: - * -Bind socket to local Ip address and port + * Fills the address List of destinatoion Ip Address * - * @params[in] + * @params[in] CmInetNetAddr *destAddrPtr, Address List pointer + * @params[in] F1IpAddr *dstIpAddr, destIp Address to be filled in the Address List * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -S16 bindSctpEndp() + *******************************************************************************/ +uint8_t fillDestNetAddr(CmInetNetAddr *destAddrPtr, SctpIpAddr *dstIpPtr) { + /* Filling destination address */ + destAddrPtr->type = CM_INET_IPV4ADDR_TYPE; + destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr); + return ROK; +} - U8 ret; - U8 numRetry = 0; +/****************************************************************************** + * + * @brief Eastablishes the Assoc Req for the received interface type + * + * @details + * + * Function : sctpStartReq + * + * Functionality: + * Eastablishes the Assoc Req for the received interface type + * + * @params[in] DuSctpDestCb *paramPtr + * @return ROK - success + * RFAILED - failure + * + *******************************************************************************/ - /* Binding the socket with local address */ - localAddrLst.count = 1; - if(sctpCfg->cuIpAddr.ipV4Pres) - { - localAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - localAddrLst.addrs[0].u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg->cuIpAddr.ipV4Addr); - } - else if(sctpCfg->cuIpAddr.ipV6Pres) - { - localAddrLst.addrs[0].type = CM_INET_IPV6ADDR_TYPE; - // CM_INET_COPY_IPV6ADDR(&(localAddrLst.addrs[0].u.ipv6NetAddr),&(sctpCfg->cuIpAddr.ipV6Addr); - } - else - { - localAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - localAddrLst.addrs[0].u.ipv4NetAddr = 0; - } +uint8_t sctpStartReq() +{ + uint8_t destIdx; + uint8_t ret = ROK; - do{ - ret = cmInetSctpBindx(&lstnSockFd, &localAddrLst, sctpCfg->cuPort); - if (ret != ROK) + socket_type = CM_INET_STREAM; + for(destIdx=0; destIdx < sctpCb.numDu; destIdx++) + { + if((ret = cmInetSocket(socket_type, &sctpCb.destCb[destIdx].lstnSockFd, IPPROTO_SCTP) != ROK)) { - numRetry++; - if(numRetry >= MAX_RETRY) - { - printf("\nAll attempts to bind socket failed."); - cmInetClose(&lstnSockFd); - /* Send indication to du_app */ - RETVALUE(RFAILED); - } - else - { - printf("\nRetrying socket binding"); - } + DU_LOG("\nERROR --> SCTP : Socket[%d] coudnt open for listening", sctpCb.destCb[destIdx].lstnSockFd.fd); + } + else if((ret = cmInetSctpBindx(&sctpCb.destCb[destIdx].lstnSockFd, &sctpCb.destCb[destIdx].localAddrLst, \ + sctpCb.destCb[destIdx].srcPort)) != ROK) + { + DU_LOG("\nERROR --> SCTP: Binding failed at CU"); } - else + else if((ret = sctpAccept(&sctpCb.destCb[destIdx])) != ROK) { - printf("\nSocket bind successful"); - break; + DU_LOG("\nERROR --> SCTP: Unable to accept the connection at CU"); } - }while(numRetry < MAX_RETRY); - - RETVALUE(ROK); - -} /* End of bindSctpEndp() */ + } + if(sctpSockPoll() != ROK) + { + DU_LOG("\nERROR --> SCTP: Polling failed to start at CU"); + } + return (ret); +} /******************************************************************* * * @brief Sets socket options as per requirement @@ -226,8 +232,9 @@ S16 bindSctpEndp() * RFAILED - failure * * ****************************************************************/ -S16 sctpSetSockOpts() +uint8_t sctpSetSockOpts(CmInetFd *sock_Fd) { + S16 ret = ROK; CmSctpEvent sctpEvent; sctpEvent.dataIoEvent = TRUE; @@ -239,8 +246,12 @@ S16 sctpSetSockOpts() sctpEvent.partialDeliveryEvent = TRUE; sctpEvent.adaptationLayerEvent = TRUE; - cmInetSetOpt(&sockFd, CM_SOCKOPT_LEVEL_SCTP, CM_SOCKOPT_OPT_SCTP_EVENTS, &sctpEvent); - RETVALUE(ROK); + if((ret = cmInetSetOpt(sock_Fd, CM_SOCKOPT_LEVEL_SCTP, CM_SOCKOPT_OPT_SCTP_EVENTS, &sctpEvent)) != ROK) + { + ret = RFAILED; + } + + return (ret); } /******************************************************************* @@ -260,42 +271,43 @@ S16 sctpSetSockOpts() * RFAILED - failure * * ****************************************************************/ -S16 sctpAccept() +uint8_t sctpAccept(CuSctpDestCb *destCb) { - U8 ret; - CmInetAddr peerAddr; + uint8_t ret; - ret = cmInetListen(&lstnSockFd, 1);; + ret = cmInetListen(&destCb->lstnSockFd, 1); if (ret != ROK) { - printf("\nListening on socket failed"); - cmInetClose(&lstnSockFd); - RETVALUE(RFAILED); + DU_LOG("\nERROR --> SCTP : Listening on socket failed"); + cmInetClose(&destCb->lstnSockFd); + return RFAILED; } + + DU_LOG("\nINFO --> SCTP : Connecting"); - while(!connUp) + while(!destCb->connUp) { - ret = cmInetAccept(&lstnSockFd, &peerAddr, &sockFd); + ret = cmInetAccept(&destCb->lstnSockFd, &destCb->peerAddr, &destCb->sockFd); if (ret == ROKDNA) { continue; } else if(ret != ROK) { - printf("\nFailed to accept connection"); - RETVALUE(RFAILED); + DU_LOG("\nERROR --> SCTP : Failed to accept connection"); + return RFAILED; } else { - connUp = TRUE; - sctpSetSockOpts(); - printf("\nAccepted incoming connection"); + destCb->connUp = TRUE; + sctpSetSockOpts(&destCb->sockFd); break; } } + DU_LOG("\nINFO --> SCTP : Connection established"); - RETVALUE(ROK); -}/* End of sctpAccept() */ + return ROK; +} /******************************************************************* * @@ -314,65 +326,67 @@ S16 sctpAccept() * RFAILED - failure * * ****************************************************************/ -S16 sctpNtfyHdlr(CmInetSctpNotification *ntfy) +uint8_t sctpNtfyHdlr(CuSctpDestCb *destCb, CmInetSctpNotification *ntfy) { switch(ntfy->header.nType) { case CM_INET_SCTP_ASSOC_CHANGE : + DU_LOG("\nINFO --> SCTP : Assoc change notification received"); switch(ntfy->u.assocChange.state) { case CM_INET_SCTP_COMM_UP: - printf("\nSCTP notify assocchange(comm up) received"); - connUp = TRUE; + DU_LOG("DEBUG --> Event : COMMUNICATION UP"); + destCb->connUp = TRUE; break; case CM_INET_SCTP_COMM_LOST: - printf("\nSCTP notify assocchange(comm lost) received"); - connUp = FALSE; + DU_LOG("DEBUG --> Event : COMMUNICATION LOST"); + destCb->connUp = FALSE; break; case CM_INET_SCTP_RESTART: - printf("\nSCTP notify assocchange(sctp restart) received"); - connUp = FALSE; + DU_LOG("DEBUG --> Event : SCTP RESTART"); + destCb->connUp = FALSE; break; case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */ - printf("\nSCTP notify assocchange(shutdown complete) received\n"); - connUp = FALSE; + DU_LOG("DEBUG --> Event : SHUTDOWN COMPLETE"); + destCb->connUp = FALSE; break; case CM_INET_SCTP_CANT_STR_ASSOC: - printf("\nSCTP notify assocchange(cant str assoc) received\n"); - connUp = FALSE; + DU_LOG("DEBUG --> Event : CANT START ASSOC"); + destCb->connUp = FALSE; break; default: - printf("\nInvalid event"); + DU_LOG("\nERROR --> Invalid event"); break; } break; case CM_INET_SCTP_PEER_ADDR_CHANGE : - printf("\nSCTP notify peer addr change received"); + DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received"); /* Need to add handler */ break; case CM_INET_SCTP_REMOTE_ERROR : - printf("\nSCTP notify remote error received"); + DU_LOG("\nINFO --> SCTP : Remote Error notification received"); break; case CM_INET_SCTP_SEND_FAILED : - printf("\nSCTP notify send failed received\n"); + DU_LOG("\nINFO --> SCTP : Send Failed notification received\n"); break; case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */ - printf("\nSCTP notify shutdown event received\n"); - connUp = FALSE; + DU_LOG("\nINFO --> SCTP : Shutdown Event notification received\n"); + destCb->connUp = FALSE; + exit(0); break; case CM_INET_SCTP_ADAPTATION_INDICATION : - printf("\nSCTP notify adaptation indication received\n"); + DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n"); break; case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT: - printf("\nSCTP notify partial delivery received\n"); + DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n"); break; default: - printf("\nInvalid sctp notification type\n"); + DU_LOG("\nERROR --> SCTP : Invalid notification type\n"); break; } sctpNtfyInd(ntfy); - RETVALUE(ROK); + return ROK; }/* End of sctpNtfyHdlr */ /******************************************************************* @@ -391,165 +405,167 @@ S16 sctpNtfyHdlr(CmInetSctpNotification *ntfy) * RFAILED - failure * * ****************************************************************/ -S16 sctpSockPoll() +uint8_t sctpSockPoll() { - U8 ret; - S16 numFds; - CmInetFdSet readFd; - U16 port; - U32 timeout; /* timeout for cmInetSelect() */ - U32 *timeoutPtr; /* pointer to timeout */ - U32 flag; - Buffer *mBuf; - MsgLen bufLen; - CmInetMemInfo memInfo; /* buffer allocation info */ - CmInetNetAddr addr; - CmInetSctpSndRcvInfo info; - CmInetSctpNotification ntfy; - - if (sockFd.blocking) - { - /* blocking */ - timeoutPtr = NULLP; - } - else - { - /* non-blocking */ - timeout = 0; - timeoutPtr = &timeout; - } + uint8_t destIdx; + uint16_t ret = ROK; + uint32_t timeout; + uint32_t *timeoutPtr; + Buffer *egtpBuf; + MsgLen egtpBufLen; + CmInetAddr egtpFromAddr; + CmInetMemInfo memInfo; + sctpSockPollParams f1PollParams; + uint64_t numMsgRcvd = 0; + + memset(&f1PollParams, 0, sizeof(sctpSockPollParams)); + + + /* All sockets are non-blocking */ + timeout = 0; + timeoutPtr = &timeout; memInfo.region = CU_APP_MEM_REG; memInfo.pool = CU_POOL; - CM_INET_FD_ZERO(&readFd); + + CM_INET_FD_ZERO(&f1PollParams.readFd); while(1) { - CM_INET_FD_SET(&sockFd, &readFd); - ret = cmInetSelect(&readFd, NULLP, timeoutPtr, &numFds); - if (CM_INET_FD_ISSET(&sockFd, &readFd)) + /* Receiving SCTP data */ + for(destIdx = 0; destIdx < sctpCb.numDu; destIdx++) { - CM_INET_FD_CLR(&sockFd, &readFd); - ret = cmInetSctpRecvMsg(&sockFd, &addr, &port, &memInfo, &mBuf, &bufLen, &info, &flag, &ntfy); - if (ret != ROK) + if((ret = processPolling(&f1PollParams, &sctpCb.destCb[destIdx], timeoutPtr, &memInfo)) != ROK) { - printf("\nFailed to receive sctp msg\n"); + DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1 at CU\n"); } - else + } + + /* Receiving EGTP data */ + for(destIdx = 0; destIdx < egtpCb.numDu; destIdx++) + { + + egtpFromAddr.port = egtpCb.dstCb[destIdx].dstPort; + egtpFromAddr.address = egtpCb.dstCb[destIdx].dstIp; + egtpBufLen = -1; + ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG); + if(ret == ROK && egtpBuf != NULLP) { - if ((flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0) - { - ret = sctpNtfyHdlr(&ntfy); - if(ret != ROK) - { - printf("\nFailed to process sctp notify msg\n"); - } - } - else if(connUp) /* If data received */ - { - F1InmsgHdlr(mBuf); - SPutMsg(mBuf); - } - else - { - SPutMsg(mBuf); - } + DU_LOG("\nINFO --> EGTP : Received UL Message [%ld] from DUid %d\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId); + numMsgRcvd++; + //ODU_PRINT_MSG(egtpBuf, 0 ,0); + cuEgtpHdlRecvMsg(egtpBuf); + } } }; - - RETVALUE(ROK); + return (ret); }/* End of sctpSockPoll() */ /******************************************************************* * - * @brief Send message on SCTP socket + * @brief checks for valid readFd and process the InetSctpRecvMsg + * during polling * * @details * - * Function : sctpOutMsgSend + * Function : processPolling * * Functionality: - * Send message on SCTP socket + * checks for valid readFd and process the InetSctpRecvMsg + * during polling + * + * @params[in] Params required for polling + * @params[in] SockFd for file descriptor + * @params[in] timeoutPtr indicates the timeout value + * @params[in] MemInfo indicates memory region * - * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 sctpOutMsgSend(Buffer *mBuf) -{ - U8 ret; - MsgLen len; /* number of actually sent octets */ - CmInetNetAddr peerAddr; /* destination port address */ - CmInetNetAddr *dstAddr; - CmInetMemInfo memInfo; - - memInfo.region = CU_APP_MEM_REG; - memInfo.pool = CU_POOL; - - - if(sctpCfg->duIpAddr.ipV4Pres) - { - peerAddr.type = CM_INET_IPV4ADDR_TYPE; - peerAddr.u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg->duIpAddr.ipV4Addr); - dstAddr = &peerAddr; - } - else if(sctpCfg->duIpAddr.ipV6Pres) - { - peerAddr.type = CM_INET_IPV6ADDR_TYPE; - //CM_INET_COPY_IPV6ADDR(&(primDstAddr.u.ipv6NetAddr),&(sctpCfg->duIpAddr.ipV6Addr); - dstAddr = &peerAddr; - } - else - { - dstAddr = NULLP; - } - ret = cmInetSctpSendMsg(&sockFd, dstAddr, sctpCfg->duPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK); - if(ret != ROK && ret != RWOULDBLOCK) +uint8_t processPolling(sctpSockPollParams *pollParams, CuSctpDestCb *destCb, uint32_t *timeoutPtr, CmInetMemInfo *memInfo) +{ + uint16_t ret = ROK; + CM_INET_FD_SET(&destCb->sockFd, &pollParams->readFd); + ret = cmInetSelect(&pollParams->readFd, NULLP, timeoutPtr, &pollParams->numFd); + if(CM_INET_FD_ISSET(&destCb->sockFd, &pollParams->readFd)) { - printf("\nFailed sending the message"); - RETVALUE(RFAILED); - } - - RETVALUE(ROK); -} /* End of sctpOutMsgSend */ + CM_INET_FD_CLR(&destCb->sockFd, &pollParams->readFd); + ret = cmInetSctpRecvMsg(&destCb->sockFd, &pollParams->addr, &pollParams->port, memInfo, &pollParams->mBuf, \ + &pollParams->bufLen, &pollParams->info, &pollParams->flag, &pollParams->ntfy); + if(destCb->connUp & (ret != ROK)) + { + destCb->bReadFdSet = RFAILED; + } + else + { + if(((pollParams->flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0) && (ret == ROK)) + { + ret = sctpNtfyHdlr(destCb, &pollParams->ntfy); + if(ret != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n"); + } + } + else if(destCb->connUp & (pollParams->port == destCb->destPort)) + { + F1APMsgHdlr(&destCb->duId, pollParams->mBuf); + ODU_PUT_MSG_BUF(pollParams->mBuf); + } + else + { + ODU_PUT_MSG_BUF(pollParams->mBuf); + } + } + } + return ROK; +}/* End of sctpSockPoll() */ /******************************************************************* * - * @brief Start SCTP at CU + * @brief Send message on SCTP socket * * @details * - * Function : sctpStartReq + * Function : sctpSend * * Functionality: - * Start SCTP at CU + * Send message on SCTP socket * - * @params[in] + * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -void sctpStartReq() +uint8_t sctpSend(uint32_t duId, Buffer *mBuf) { - if(openSctpEndp() != ROK) - { - printf("\nFailed while opening socket"); - } - else if(bindSctpEndp() != ROK) - { - printf("\nFailed while binding socket"); - } - else if(sctpAccept() != ROK) - { - printf("\nFailed while accepting connection"); - } - else if(sctpSockPoll() != ROK) + uint8_t ret = ROK, destIdx = 0; + MsgLen len = 0; /* number of actually sent octets */ + CmInetMemInfo memInfo; + + memset(&memInfo , 0, sizeof(CmInetMemInfo)); + memInfo.region = CU_APP_MEM_REG; + memInfo.pool = CU_POOL; + + for(destIdx=0; destIdx < sctpCb.numDu; destIdx++) { - printf("\nFailed while polling"); + if(sctpCb.destCb[destIdx].duId == duId) + { + ret = cmInetSctpSendMsg(&sctpCb.destCb[destIdx].sockFd, &sctpCb.destCb[destIdx].destIpNetAddr, \ + sctpCb.destCb[destIdx].destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK); + + if(ret != ROK && ret != RWOULDBLOCK) + { + DU_LOG("\nERROR --> SCTP : Send message failed"); + return RFAILED; + } + return ROK; + } } -} /* End of sctpAssocReq */ + DU_LOG("\nERROR --> SCTP : DU ID [%d] not found in SCTP DestCb list. Failed to send message", duId); + return RFAILED; +} /* End of sctpSend */ /********************************************************************** End of file