/* This file contains all SCTP related functionality */
#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 "du_log.h"
+#include "cu_stub.h"
+#include "cm_inet.h"
+#include "cm_tpt.h"
+
+#include "cm_inet.x"
+#include "cm_tpt.x"
+
-CuSctpDestCb f1Params;
/**************************************************************************
* @brief Task Initiation callback function.
*
* @return ROK - success
* RFAILED - failure
***************************************************************************/
-S16 sctpActvInit()
+uint8_t sctpActvInit()
{
- DU_LOG("\n\nSCTP : Initializing");
- 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;
-
}
/**************************************************************************
* RFAILED - failure
*
***************************************************************************/
-S16 sctpActvTsk(Pst *pst, Buffer *mBuf)
+uint8_t sctpActvTsk(Pst *pst, Buffer *mBuf)
{
//TODO: TBD
*
***************************************************************************/
-S16 sctpCfgReq()
+uint8_t sctpCfgReq()
{
-
-/* Fill F1 Params */
- f1Params.destPort = sctpCfg.duPort;
- f1Params.srcPort = sctpCfg.cuPort;
- f1Params.bReadFdSet = ROK;
- memset(&f1Params.sockFd, -1, sizeof(CmInetFd));
- memset(&f1Params.lstnSockFd, -1, sizeof(CmInetFd));
- fillDestNetAddr(&f1Params.destIpNetAddr, &sctpCfg.duIpAddr);
-
+ 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;
}
*
******************************************************************/
-S16 fillAddrLst(CmInetNetAddrLst *addrLstPtr, SctpIpAddr *ipAddr)
+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++;
- addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
- addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
-
return ROK;
}
* RFAILED - failure
*
*******************************************************************************/
-S16 fillDestNetAddr(CmInetNetAddr *destAddrPtr, SctpIpAddr *dstIpPtr)
+uint8_t fillDestNetAddr(CmInetNetAddr *destAddrPtr, SctpIpAddr *dstIpPtr)
{
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
- destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
+ destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr);
return ROK;
}
*
*******************************************************************************/
-S16 sctpStartReq()
+uint8_t sctpStartReq()
{
- S16 ret = ROK;
- socket_type = CM_INET_STREAM;
- fillAddrLst(&f1Params.localAddrLst, &sctpCfg.cuIpAddr);
+ uint8_t destIdx;
+ uint8_t ret = ROK;
- if((ret = cmInetSocket(socket_type, &f1Params.lstnSockFd, IPPROTO_SCTP) != ROK))
- {
- DU_LOG("\nSCTP : Socket[%d] coudnt open for listening", f1Params.lstnSockFd.fd);
- }
- else if((ret = cmInetSctpBindx(&f1Params.lstnSockFd, &f1Params.localAddrLst, f1Params.srcPort)) != ROK)
- {
- DU_LOG("\nSCTP: Binding failed at CU");
- }
- else if((ret = sctpAccept(&f1Params.lstnSockFd, &f1Params.peerAddr, &f1Params.sockFd)) != ROK)
+ socket_type = CM_INET_STREAM;
+ for(destIdx=0; destIdx < sctpCb.numDu; destIdx++)
{
- DU_LOG("\nSCTP: Unable to accept the connection at CU");
+ if((ret = cmInetSocket(socket_type, &sctpCb.destCb[destIdx].lstnSockFd, IPPROTO_SCTP) != ROK))
+ {
+ 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 if((ret = sctpAccept(&sctpCb.destCb[destIdx])) != ROK)
+ {
+ DU_LOG("\nERROR --> SCTP: Unable to accept the connection at CU");
+ }
}
- else if(sctpSockPoll() != ROK)
+
+ if(sctpSockPoll() != ROK)
{
- DU_LOG("\nSCTP: Polling failed to start at CU");
+ DU_LOG("\nERROR --> SCTP: Polling failed to start at CU");
}
return (ret);
}
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSetSockOpts(CmInetFd *sock_Fd)
+uint8_t sctpSetSockOpts(CmInetFd *sock_Fd)
{
S16 ret = ROK;
CmSctpEvent sctpEvent;
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpAccept(CmInetFd *lstnSock_Fd, CmInetAddr *peerAddr, CmInetFd *sock_Fd)
+uint8_t sctpAccept(CuSctpDestCb *destCb)
{
- U8 ret;
+ uint8_t ret;
- ret = cmInetListen(lstnSock_Fd, 1);
+ ret = cmInetListen(&destCb->lstnSockFd, 1);
if (ret != ROK)
{
- DU_LOG("\nSCTP : Listening on socket failed");
- cmInetClose(lstnSock_Fd);
+ DU_LOG("\nERROR --> SCTP : Listening on socket failed");
+ cmInetClose(&destCb->lstnSockFd);
return RFAILED;
}
- DU_LOG("\nSCTP : Connecting");
+ DU_LOG("\nINFO --> SCTP : Connecting");
- while(!connUp)
+ while(!destCb->connUp)
{
- ret = cmInetAccept(lstnSock_Fd, peerAddr, sock_Fd);
+ ret = cmInetAccept(&destCb->lstnSockFd, &destCb->peerAddr, &destCb->sockFd);
if (ret == ROKDNA)
{
continue;
}
else if(ret != ROK)
{
- DU_LOG("\nSCTP : Failed to accept connection");
+ DU_LOG("\nERROR --> SCTP : Failed to accept connection");
return RFAILED;
}
else
{
- connUp = TRUE;
- sctpSetSockOpts(sock_Fd);
+ destCb->connUp = TRUE;
+ sctpSetSockOpts(&destCb->sockFd);
break;
}
}
- DU_LOG("\nSCTP : Connection established");
+ DU_LOG("\nINFO --> SCTP : Connection established");
return ROK;
}
* 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("\nSCTP : Assoc change notification received");
+ DU_LOG("\nINFO --> SCTP : Assoc change notification received");
switch(ntfy->u.assocChange.state)
{
case CM_INET_SCTP_COMM_UP:
- DU_LOG("Event : COMMUNICATION UP");
- connUp = TRUE;
+ DU_LOG("DEBUG --> Event : COMMUNICATION UP");
+ destCb->connUp = TRUE;
break;
case CM_INET_SCTP_COMM_LOST:
- DU_LOG("Event : COMMUNICATION LOST");
- connUp = FALSE;
+ DU_LOG("DEBUG --> Event : COMMUNICATION LOST");
+ destCb->connUp = FALSE;
break;
case CM_INET_SCTP_RESTART:
- DU_LOG("Event : SCTP RESTART");
- connUp = FALSE;
+ DU_LOG("DEBUG --> Event : SCTP RESTART");
+ destCb->connUp = FALSE;
break;
case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */
- DU_LOG("Event : SHUTDOWN COMPLETE");
- connUp = FALSE;
+ DU_LOG("DEBUG --> Event : SHUTDOWN COMPLETE");
+ destCb->connUp = FALSE;
break;
case CM_INET_SCTP_CANT_STR_ASSOC:
- DU_LOG("Event : CANT START ASSOC");
- connUp = FALSE;
+ DU_LOG("DEBUG --> Event : CANT START ASSOC");
+ destCb->connUp = FALSE;
break;
default:
- DU_LOG("\nInvalid event");
+ DU_LOG("\nERROR --> Invalid event");
break;
}
break;
case CM_INET_SCTP_PEER_ADDR_CHANGE :
- DU_LOG("\nSCTP : Peer Address Change notificarion received");
+ DU_LOG("\nINFO --> SCTP : Peer Address Change notificarion received");
/* Need to add handler */
break;
case CM_INET_SCTP_REMOTE_ERROR :
- DU_LOG("\nSCTP : Remote Error notification received");
+ DU_LOG("\nINFO --> SCTP : Remote Error notification received");
break;
case CM_INET_SCTP_SEND_FAILED :
- DU_LOG("\nSCTP : Send Failed notification received\n");
+ DU_LOG("\nINFO --> SCTP : Send Failed notification received\n");
break;
case CM_INET_SCTP_SHUTDOWN_EVENT : /* peer socket gracefully closed */
- DU_LOG("\nSCTP : Shutdown Event notification 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 :
- DU_LOG("\nSCTP : Adaptation Indication received\n");
+ DU_LOG("\nINFO --> SCTP : Adaptation Indication received\n");
break;
case CM_INET_SCTP_PARTIAL_DELIVERY_EVENT:
- DU_LOG("\nSCTP : Partial Delivery Event received\n");
+ DU_LOG("\nINFO --> SCTP : Partial Delivery Event received\n");
break;
default:
- DU_LOG("\nSCTP : Invalid notification type\n");
+ DU_LOG("\nERROR --> SCTP : Invalid notification type\n");
break;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSockPoll()
+uint8_t sctpSockPoll()
{
- U16 ret = ROK;
- U32 timeout;
- U32 *timeoutPtr;
+ 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));
egtpFromAddr.port = egtpCb.dstCb.dstPort;
egtpFromAddr.address = egtpCb.dstCb.dstIp;
- if(f1Params.sockFd.blocking)
- {
- /* blocking */
- timeoutPtr = NULLP;
- }
- else
- {
- /* non-blocking */
- timeout = 0;
- timeoutPtr = &timeout;
- }
+ /* All sockets are non-blocking */
+ timeout = 0;
+ timeoutPtr = &timeout;
memInfo.region = CU_APP_MEM_REG;
memInfo.pool = CU_POOL;
while(1)
{
- if((ret = processPolling(&f1PollParams, &f1Params.sockFd, timeoutPtr, &memInfo)) != ROK)
+ /* Receiving SCTP data */
+ for(destIdx = 0; destIdx < sctpCb.numDu; destIdx++)
{
- DU_LOG("\nSCTP : Failed to RecvMsg for F1 at CU\n");
+ if((ret = processPolling(&f1PollParams, &sctpCb.destCb[destIdx], timeoutPtr, &memInfo)) != ROK)
+ {
+ DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1 at CU\n");
+ }
}
/* Receiving EGTP data */
ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG);
if(ret == ROK && egtpBuf != NULLP)
{
- DU_LOG("\nEGTP : Received message \n");
- ODU_PRINT_MSG(egtpBuf, 0 ,0);
+ DU_LOG("\nINFO --> EGTP : Received UL Message [%ld]\n", numMsgRcvd+1);
+ numMsgRcvd++;
+ //ODU_PRINT_MSG(egtpBuf, 0 ,0);
cuEgtpHdlRecvMsg(egtpBuf);
}
*
* ****************************************************************/
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo)
+uint8_t processPolling(sctpSockPollParams *pollParams, CuSctpDestCb *destCb, uint32_t *timeoutPtr, CmInetMemInfo *memInfo)
{
- U16 ret = ROK;
- CM_INET_FD_SET(sockFd, &pollParams->readFd);
+ 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(sockFd, &pollParams->readFd))
+ if(CM_INET_FD_ISSET(&destCb->sockFd, &pollParams->readFd))
{
- CM_INET_FD_CLR(sockFd, &pollParams->readFd);
- ret = cmInetSctpRecvMsg(sockFd, &pollParams->addr, &pollParams->port, memInfo, &pollParams->mBuf, &pollParams->bufLen, &pollParams->info, &pollParams->flag, &pollParams->ntfy);
- if(connUp & (ret != ROK))
+ 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))
{
- f1Params.bReadFdSet = RFAILED;
+ destCb->bReadFdSet = RFAILED;
}
else
{
if(((pollParams->flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0) && (ret == ROK))
{
- ret = sctpNtfyHdlr(&pollParams->ntfy);
+ ret = sctpNtfyHdlr(destCb, &pollParams->ntfy);
if(ret != ROK)
{
- DU_LOG("\nSCTP : Failed to process sctp notify msg\n");
+ DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n");
}
}
- else if(connUp & (pollParams->port == f1Params.destPort))
+ else if(destCb->connUp & (pollParams->port == destCb->destPort))
{
- F1APMsgHdlr(pollParams->mBuf);
- ODU_PUT_MSG(pollParams->mBuf);
+ F1APMsgHdlr(&destCb->duId, pollParams->mBuf);
+ ODU_PUT_MSG_BUF(pollParams->mBuf);
}
else
{
- ODU_PUT_MSG(pollParams->mBuf);
+ ODU_PUT_MSG_BUF(pollParams->mBuf);
}
}
}
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSend(Buffer *mBuf)
+uint8_t sctpSend(uint32_t duId, Buffer *mBuf)
{
- U8 ret;
- MsgLen len; /* number of actually sent octets */
+ 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;
- ret = cmInetSctpSendMsg(&f1Params.sockFd, &f1Params.destIpNetAddr, f1Params.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
-
- if(ret != ROK && ret != RWOULDBLOCK)
+ for(destIdx=0; destIdx < sctpCb.numDu; destIdx++)
{
- DU_LOG("\nSCTP : Send message failed");
- return RFAILED;
- }
+ 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);
- return ROK;
+ if(ret != ROK && ret != RWOULDBLOCK)
+ {
+ DU_LOG("\nERROR --> SCTP : Send message failed");
+ return RFAILED;
+ }
+ return ROK;
+ }
+ }
+ DU_LOG("\nERROR --> SCTP : DU ID [%d] not found in SCTP DestCb list. Failed to send message", duId);
+ return RFAILED;
} /* End of sctpSend */
/**********************************************************************
Code Review / o-du / l2.git / blobdiff