X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_sctp.c;h=93cd7dc6b47a5a53b505c4f0460a67aa2f53ea0c;hb=a14bf79bbc001990f96e01ada0dd291bcc9ddcad;hp=0fbee10b51d15ddbf6fa5f8453aab209dd8f0c46;hpb=3235ecfc7414aa0b72d0ad50db63ae8b5626045b;p=o-du%2Fl2.git diff --git a/src/du_app/du_sctp.c b/src/du_app/du_sctp.c index 0fbee10b5..93cd7dc6b 100644 --- a/src/du_app/du_sctp.c +++ b/src/du_app/du_sctp.c @@ -17,13 +17,22 @@ *******************************************************************************/ /* This file contains all SCTP related functionality */ - -#include +#include "common_def.h" +#include "du_tmr.h" +#include "lrg.h" +#include "legtp.h" +#include "lrg.x" +#include "lkw.x" +#include "cm_inet.h" +#include "cm_inet.x" +#include "du_app_mac_inf.h" +#include "du_e2ap_mgr.h" +#include "du_cfg.h" #include "du_sctp.h" #include "lsctp.h" - -/* Global variable declaration */ -F1SctpParams sctpCfg; /* SCTP configurations at DU */ +#include "du_app_rlc_inf.h" +#include "du_mgr.h" +#include "du_utils.h" /************************************************************************** * @brief Task Initiation callback function. @@ -45,17 +54,59 @@ F1SctpParams sctpCfg; /* SCTP configurations at DU */ * @return ROK - success * RFAILED - failure ***************************************************************************/ -S16 sctpActvInit(Ent entity, Inst inst, Region region, Reason reason) +uint8_t sctpActvInit(Ent entity, Inst inst, Region region, Reason reason) { - DU_LOG("\n\nSCTP : Initializing"); - SSetProcId(DU_PROC); + DU_LOG("\n\nDEBUG --> SCTP : Initializing"); + ODU_SET_PROC_ID(DU_PROC); connUp = FALSE; - assocId = 0; + + memset(&f1Params, 0, sizeof(DuSctpDestCb)); + f1Params.assocId = -1; + memset(&ricParams, 0, sizeof(DuSctpDestCb)); + ricParams.assocId = -1; nonblocking = FALSE; return ROK; } +/************************************************************************** +* @brief Function prints src, dest, msg infor about all the msgs that received. +* +* @details +* +* Function : callFlowSctpActvTsk +* +* Function prints src, dest, msg infor about all the msgs that received +* +* @param[in] Pst *pst, Post structure of the primitive. +* +* @return void +***************************************************************************/ +void callFlowSctpActvTsk(Pst *pst) +{ + char sourceTask[50]; + char destTask[50]="ENTSCTP"; + char message[100]; + + switch(pst->srcEnt) + { + case ENTDUAPP: + { + strcpy(sourceTask,"ENTDUAPP"); + switch(pst->event) + { + case EVTSTARTPOLL: + { + strcpy(message,"EVTSTARTPOLL"); + break; + } + } + break; + } + } + DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message); +} + /************************************************************************** * @brief Task Activation callback function. * @@ -75,259 +126,391 @@ 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) { + +#ifdef CALL_FLOW_DEBUG_LOG + callFlowSctpActvTsk(pst); +#endif + + switch(pst->srcEnt) { case ENTDUAPP: { switch(pst->event) { - case EVTSCTPSTRT: + case EVTSTARTPOLL: { - cmUnpkSctpAssocReq(mBuf); - SPutMsg(mBuf); - sctpAssocReq(); + sctpSockPoll(); break; - } + } } break; } } - SExitTsk(); + ODU_EXIT_TASK(); return ROK; } +/******************************************************************* + * + * @brief Checks the status of the received information + * + * @details + * + * Function : duCheckReqStatus + * + * Functionality: + * Checks the status of the received information + * + * @params[in] Confirm status + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint8_t duCheckReqStatus(CmStatus *cfm) +{ + uint8_t ret = ROK; + if(cfm->status != LCM_PRIM_OK) + { + DU_LOG("\nERROR --> DU_APP : Failed to process the request successfully"); + ret = RFAILED; + } + return (ret); +} + +/************************************************************************** + * @brief Function to configure the Sctp Params during config Request + * + * @details + * + * Function : duSctpCfgReq + * + * Functionality: + * This function configures SCTP Params during the config Request + * + * @param[in] SctpParams sctpCfg, common structure which has all the configuration + * @param[in] CmStatus cfm, Builds the cfm status and reason + * buffer. + * + * @return ROK - success + * RFAILED - failure + * + ***************************************************************************/ + +uint8_t duSctpCfgReq(SctpParams sctpCfg) +{ + uint8_t ret = ROK; + CmStatus cfm; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_CFG_REQ_TO_SCTP\n"); +#endif +/* Fill F1 Params */ + f1Params.destIpAddr.ipV4Pres = sctpCfg.cuIpAddr.ipV4Pres; + f1Params.destIpAddr.ipV4Addr = sctpCfg.cuIpAddr.ipV4Addr; + f1Params.destPort = sctpCfg.cuPort; + f1Params.itfState = DU_SCTP_DOWN; + f1Params.srcPort = sctpCfg.duPort[F1_INTERFACE]; + f1Params.recvMsgSet = ROK; + memset (&f1Params.sockFd, -1, sizeof(CmInetFd)); + fillDestNetAddr(&f1Params.destIpNetAddr, &f1Params.destIpAddr); + fillAddrLst(&f1Params.destAddrLst, &f1Params.destIpAddr); + +/* Fill RIC Params */ + ricParams.destIpAddr.ipV4Pres = sctpCfg.ricIpAddr.ipV4Pres; + ricParams.destIpAddr.ipV4Addr = sctpCfg.ricIpAddr.ipV4Addr; + ricParams.destPort = sctpCfg.ricPort; + ricParams.itfState = DU_SCTP_DOWN; + ricParams.srcPort = sctpCfg.duPort[E2_INTERFACE]; + ricParams.recvMsgSet = ROK; + memset (&ricParams.sockFd, -1, sizeof(CmInetFd)); + fillDestNetAddr(&ricParams.destIpNetAddr, &ricParams.destIpAddr); + fillAddrLst(&ricParams.destAddrLst, &ricParams.destIpAddr); + +/* Fill AddressList */ + fillAddrLst(&localAddrLst, &sctpCfg.duIpAddr); + +/* Set polling to FALSE */ + pollingState = FALSE; + +/* Fill Cfm Status */ + cfm.status = LCM_PRIM_OK; + cfm.reason = LCM_REASON_NOT_APPL; + + ret = duCheckReqStatus(&cfm); + + return (ret); +} /******************************************************************* * - * @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] CmInetNetAddrLst *addrLstPtr, Address List pointer + * @params[in] F1IpAddr *srcIpAddr, src Ip Adrress to be filled in the Address List * - * @params[in] * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -S16 openSctpEndp() + ******************************************************************/ + +uint8_t fillAddrLst(CmInetNetAddrLst *addrLstPtr, F1IpAddr *ipAddr) +{ + addrLstPtr->count++; + addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE; + addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_UINT32(ipAddr->ipV4Addr); + + return ROK; +} + +/****************************************************************************** + * + * @brief Fills the address List of the source Ip Address + * + * @details + * + * Function : fillDestNetAddr + * + * Functionality: + * Fills the address List of destinatoion Ip Address + * + * @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 + * + *******************************************************************************/ +uint8_t fillDestNetAddr(CmInetNetAddr *destAddrPtr, F1IpAddr *dstIpPtr) { - U8 ret; - U8 numRetry = 0; + /* Filling destination address */ + destAddrPtr->type = CM_INET_IPV4ADDR_TYPE; + destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr); + return ROK; +} + +/****************************************************************************** + * + * @brief Establishes the Assoc Req for the received interface type + * + * @details + * + * Function : establishAssocReq + * + * Functionality: + * Eastablishes the Assoc Req for the received interface type + * + * @params[in] DuSctpDestCb *paramPtr + * + * @return ROK - success + * RFAILED - failure + * + *******************************************************************************/ - /* Opening a non-blocking SCTP socket */ +uint8_t establishReq(DuSctpDestCb *paramPtr) +{ + Pst pst; + uint8_t ret = ROK; socket_type = CM_INET_STREAM; - do{ - ret = cmInetSocket(socket_type, &sockFd, IPPROTO_SCTP); - if (ret != ROK) + if((ret = cmInetSocket(socket_type, ¶mPtr->sockFd, IPPROTO_SCTP)) != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed while opening a socket in ODU"); + } + else if((ret = cmInetSctpBindx(¶mPtr->sockFd, &localAddrLst, paramPtr->srcPort)) != ROK) + { + DU_LOG("\nERROR --> SCTP: Failed during Binding in ODU"); + } + else if((ret = sctpSetSockOpts(¶mPtr->sockFd)) != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed to set Socket Opt in ODU"); + } + else + { + if(ret != ROK) { - numRetry++; - if(numRetry >= MAX_RETRY) - { - DU_LOG("\nSCTP : All attempts to open socket failed."); - /* Send indication to du_app */ - RETVALUE(RFAILED); - } - else - { - DU_LOG("\nSCTP : Retrying socket opening"); - } + DU_LOG("\nERROR --> SCTP : Failed while establishing Req at DU"); + ret = RFAILED; } - else + else { - DU_LOG("\nSCTP : Socket[%d] open",sockFd.fd); - break; + ret = cmInetSctpConnectx(¶mPtr->sockFd, ¶mPtr->destIpNetAddr, ¶mPtr->destAddrLst, paramPtr->destPort); + /* 115 error_code indicates that Operation is in progress and hence ignored if SctpConnect failed due to this */ + if(ret == 18) + { + ret = ROK; + } } - }while(numRetry < MAX_RETRY); - - RETVALUE(ROK); -} /* End of openSctpEndp */ + } + if((ret == ROK) & (paramPtr->itfState == DU_SCTP_DOWN)) + { + paramPtr->itfState = DU_SCTP_CONNECTING; + } + /* Post the EVTSTARTPOLL Msg */ + if(!pollingState) + { + pollingState = TRUE; + duFillSctpPst(&pst, EVTSTARTPOLL); + } + + return (ret); +} -/******************************************************************* +/****************************************************************************** * - * @brief Bind socket to local Ip address and port + * @brief Processes the assoc Req for the received interface type * * @details * - * Function : bindSctpEndp + * Function : duSctpAssocReq * * Functionality: - * -Bind socket to local Ip address and port + * Processes the Assoc Req for the received interface type * - * @params[in] + * @params[in] itfType interface Type, + * @params[in] cfm , represents the status of request + * * @return ROK - success * RFAILED - failure * - * ****************************************************************/ -S16 bindSctpEndp() -{ - - U8 ret; - U8 numRetry = 0; + *******************************************************************************/ - /* Binding the socket with local address */ - localAddrLst.count = 1; - if(sctpCfg.duIpAddr.ipV4Pres) +uint8_t duSctpAssocReq(uint8_t itfType) +{ + uint8_t ret = ROK; + CmStatus cfm; + DuSctpDestCb *paramPtr = NULLP; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_ASSOC_REQ_TO_SCTP\n"); +#endif + + DU_ALLOC(paramPtr, sizeof(DuSctpDestCb)); + if(paramPtr == NULLP) { - localAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - localAddrLst.addrs[0].u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg.duIpAddr.ipV4Addr); + DU_LOG("\nERROR --> DU_APP : Failed to allocate memory"); + return RFAILED; } - else + switch(itfType) { - localAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - localAddrLst.addrs[0].u.ipv4NetAddr = 0; - } - - do{ - ret = cmInetSctpBindx(&sockFd, &localAddrLst, sctpCfg.duPort); - if (ret != ROK) + case F1_INTERFACE: { - numRetry++; - if(numRetry >= MAX_RETRY) - { - DU_LOG("\nSCTP : All attempts to bind socket failed."); - cmInetClose(&sockFd); - /* Send indication to du_app */ - RETVALUE(RFAILED); - } - else - { - DU_LOG("\nSCTP : Retrying socket binding"); - } + paramPtr = &f1Params; + ret = establishReq(paramPtr); + break; } - else + case E2_INTERFACE: { - DU_LOG("\nSCTP : Socket bind successful"); + paramPtr = &ricParams; + ret = establishReq(paramPtr); break; } - }while(numRetry < MAX_RETRY); - - RETVALUE(ROK); - -} /* End of bindSctpEndp() */ + default: + { + DU_LOG("\nERROR --> SCTP : Invalid Interface Type %d", itfType); + break; + } + } + if(ret != ROK) + { + DU_LOG("\nERROR --> SCTP : ASSOC Req Failed."); + cfm.status = LCM_PRIM_NOK; + cfm.reason = LCM_REASON_NOT_APPL; + } + else + { + cfm.status = LCM_PRIM_OK; + cfm.reason = LCM_REASON_NOT_APPL; + } + ret = duCheckReqStatus(&cfm); + return (ret); +} /******************************************************************* * - * @brief Sets socket options as per requirement + * @brief Fills Pst struct for ENTSCTP * * @details * - * Function : sctpSetSockOpts + * Function : duFillSctpPst * - * Functionality: - * Sets socket options as per requirement + * Functionality: + * Fills Pst struct for ENTSCTP * * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 sctpSetSockOpts() +uint8_t duFillSctpPst(Pst *pst, Event event) { - CmSctpEvent sctpEvent; - - sctpEvent.dataIoEvent = TRUE; - sctpEvent.associationEvent = TRUE; - sctpEvent.addressEvent = TRUE; - sctpEvent.sendFailureEvent = TRUE; - sctpEvent.peerErrorEvent = TRUE; - sctpEvent.shutdownEvent = TRUE; - sctpEvent.partialDeliveryEvent = TRUE; - sctpEvent.adaptationLayerEvent = TRUE; - - cmInetSetOpt(&sockFd, CM_SOCKOPT_LEVEL_SCTP, CM_SOCKOPT_OPT_SCTP_EVENTS, &sctpEvent); - RETVALUE(ROK); + Buffer *mBuf; + if(ODU_GET_MSG_BUF(DFLT_REGION, DU_POOL, &mBuf) != ROK) + { + DU_LOG("\nERROR --> DU_APP : Failed to allocate memory"); + return RFAILED; + } + memset(pst, 0, sizeof(Pst)); + pst->srcEnt = (Ent)ENTDUAPP; + pst->srcInst = (Inst)DU_INST; + pst->srcProcId = DU_PROC; + pst->dstEnt = (Ent)ENTSCTP; + pst->dstInst = (Inst)SCTP_INST; + pst->dstProcId = pst->srcProcId; + pst->event = event; + pst->selector = ODU_SELECTOR_LC; + pst->pool= DU_POOL; + ODU_POST_TASK(pst, mBuf); - RETVALUE(ROK); + return ROK; } /******************************************************************* * - * @brief Initiates connection with peer SCTP + * @brief Sets socket options as per requirement * * @details * - * Function : sctpConnect + * Function : sctpSetSockOpts * - * Functionality: - * Establishes SCTP connection with peer. - * Here, DU-SCTP will initate connection towards CU-SCTP + * Functionality: + * Sets socket options as per requirement * - * @params[in] + * @params[in] sock_Fd determines the sockFd to be set * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 sctpConnect() +uint8_t sctpSetSockOpts(CmInetFd *sock_Fd) { - U8 ret; - U8 numRetry = 0; - CmInetNetAddr primDstAddr; /* primary destination address */ + uint8_t ret = ROK; + CmSctpEvent sctpEvent; - /* Filling primary destination address */ - if(sctpCfg.cuIpAddr.ipV4Pres) - { - primDstAddr.type = CM_INET_IPV4ADDR_TYPE; - primDstAddr.u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg.cuIpAddr.ipV4Addr); - } - else - { - primDstAddr.type = CM_INET_IPV4ADDR_TYPE; - primDstAddr.u.ipv4NetAddr = 0; - } + sctpEvent.dataIoEvent = TRUE; + sctpEvent.associationEvent = TRUE; + sctpEvent.addressEvent = TRUE; + sctpEvent.sendFailureEvent = TRUE; + sctpEvent.peerErrorEvent = TRUE; + sctpEvent.shutdownEvent = TRUE; + sctpEvent.partialDeliveryEvent = TRUE; + sctpEvent.adaptationLayerEvent = TRUE; - /* Filling destination address list */ - remoteAddrLst.count = 1; - if(sctpCfg.cuIpAddr.ipV4Pres) + if((ret = cmInetSetOpt(sock_Fd, CM_SOCKOPT_LEVEL_SCTP, CM_SOCKOPT_OPT_SCTP_EVENTS, &sctpEvent) != ROK)) { - remoteAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - remoteAddrLst.addrs[0].u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg.cuIpAddr.ipV4Addr); + ret = RFAILED; } - else - { - remoteAddrLst.addrs[0].type = CM_INET_IPV4ADDR_TYPE; - remoteAddrLst.addrs[0].u.ipv4NetAddr = 0; - } - - /* Sending connect request to remote */ - do{ - ret = cmInetSctpConnectx(&sockFd, &primDstAddr, &remoteAddrLst, sctpCfg.cuPort); - if (ret == RFAILED || ret == ROKDNA || ret == RCLOSED) - { - numRetry++; - if(numRetry >= MAX_RETRY) - { - DU_LOG("\nSCTP : All attempts to connect failed."); - cmInetClose(&sockFd); - /* Send indication to du_app */ - RETVALUE(RFAILED); - } - else - { - DU_LOG("\nSCTP : Retrying connection"); - } - } - else if(ret == RINPROGRESS) - { - DU_LOG("\nSCTP : Connection in progess"); - break; - } - else - { - connUp = TRUE; - DU_LOG("\nSCTP : Connect successful"); - break; - } - }while(numRetry < MAX_RETRY); - RETVALUE(ROK); -}/* End of sctpConnect() */ + return (ret); +} /******************************************************************* * @@ -350,11 +533,11 @@ S16 sctpConnect() void sendToDuApp(Buffer *mBuf, Event event) { Pst pst; - DU_LOG("\nSCTP : Forwarding received message to duApp"); - SPrntMsg(mBuf, 0, 0); + DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp"); + ODU_PRINT_MSG(mBuf, 0, 0); - cmMemset((U8 *)&(pst), 0, sizeof(Pst)); + memset(&(pst), 0, sizeof(Pst)); pst.srcEnt = (Ent)ENTSCTP; pst.srcInst = (Inst)SCTP_INST; pst.srcProcId = DU_PROC; @@ -362,13 +545,13 @@ void sendToDuApp(Buffer *mBuf, Event event) pst.dstInst = (Inst)DU_INST; pst.dstProcId = pst.srcProcId; pst.event = event; - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.pool= DU_POOL; pst.region = DFLT_REGION; - if (SPstTsk(&pst, mBuf) != ROK) + if (ODU_POST_TASK(&pst, mBuf) != ROK) { - DU_LOG("\nSCTP : SPstTsk failed in duReadCfg"); + DU_LOG("\nERROR --> SCTP : ODU_POST_TASK failed in duReadCfg"); } } @@ -388,263 +571,304 @@ void sendToDuApp(Buffer *mBuf, Event event) * RFAILED - failure * * ****************************************************************/ -S16 sctpNtfyHdlr(CmInetSctpNotification *ntfy) +uint8_t sctpNtfyHdlr(CmInetSctpNotification *ntfy, uint8_t *itfState) { Pst pst; switch(ntfy->header.nType) { case CM_INET_SCTP_ASSOC_CHANGE : - DU_LOG("\nSCTP : Assoc change notification received"); + DU_LOG("\nDEBUG --> 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("INFO --> Event : COMMUNICATION UP"); + *itfState = DU_SCTP_UP; break; case CM_INET_SCTP_COMM_LOST: - DU_LOG("Event : COMMUNICATION LOST"); - connUp = FALSE; + DU_LOG("INFO --> Event : COMMUNICATION LOST"); + *itfState = DU_SCTP_DOWN; break; case CM_INET_SCTP_RESTART: - DU_LOG("Event : SCTP RESTART"); - connUp = FALSE; + DU_LOG("INFO --> Event : SCTP RESTART"); + *itfState = DU_SCTP_DOWN; break; case CM_INET_SCTP_SHUTDOWN_COMP: /* association gracefully shutdown */ - DU_LOG("Event : SHUTDOWN COMPLETE"); - connUp = FALSE; + DU_LOG("INFO --> Event : SHUTDOWN COMPLETE"); + *itfState = DU_SCTP_DOWN; break; case CM_INET_SCTP_CANT_STR_ASSOC: - DU_LOG("Event : CANT START ASSOC"); - connUp = FALSE; + DU_LOG("INFO --> Event : CANT START ASSOC"); + *itfState = DU_SCTP_DOWN; break; default: - DU_LOG("\nInvalid event"); + DU_LOG("\nERROR --> Invalid event %d", ntfy->u.assocChange.state); 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"); + *itfState = DU_SCTP_DOWN; + 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 sctp notification type\n"); + DU_LOG("\nERROR --> SCTP : Invalid sctp notification type %d", ntfy->header.nType); break; } /* Pack notification and send to APP */ - DU_LOG("\nSCTP : Forwarding received message to duApp"); + DU_LOG("\nDEBUG --> SCTP : Forwarding received message to duApp"); - cmMemset((U8 *)&(pst), 0, sizeof(Pst)); + memset(&(pst), 0, sizeof(Pst)); pst.srcEnt = (Ent)ENTSCTP; pst.srcInst = (Inst)SCTP_INST; pst.srcProcId = DU_PROC; pst.dstEnt = (Ent)ENTDUAPP; pst.dstInst = (Inst)DU_INST; pst.dstProcId = pst.srcProcId; - pst.event = EVTSCTPNTFY; - pst.selector = DU_SELECTOR_LC; + pst.event = EVENT_SCTP_NTFY; + pst.selector = ODU_SELECTOR_LC; pst.pool= DU_POOL; - pst.region = DFLT_REGION; - + pst.region = DU_APP_MEM_REGION; + if(cmPkSctpNtfy(&pst, ntfy) != ROK) { - DU_LOG("\nSCTP : Failed to pack SCTP notification"); - RETVALUE(RFAILED); + DU_LOG("\nERROR --> SCTP : Failed to pack SCTP notification"); + return RFAILED; } - RETVALUE(ROK); + return ROK; } /******************************************************************* * - * @brief Receives message on the socket + * @brief checks for valid readFd and process the InetSctpRecvMsg + * during polling * * @details * - * Function : sctpSockPoll + * Function : processPolling * * Functionality: - * Receives message on the 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, recvMsgSet * - * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 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; - } - memInfo.region = DU_APP_MEM_REGION; - memInfo.pool = DU_POOL; - CM_INET_FD_ZERO(&readFd); - while(1) +uint8_t processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo, bool recvMsgSet) +{ + uint8_t ret = ROK; + CM_INET_FD_SET(sockFd, &pollParams->readFd); + ret = cmInetSelect(&pollParams->readFd, NULLP, timeoutPtr, (int16_t *)&pollParams->numFd); + if(CM_INET_FD_ISSET(sockFd, &pollParams->readFd)) { - CM_INET_FD_SET(&sockFd, &readFd); - ret = cmInetSelect(&readFd, NULLP, timeoutPtr, &numFds); - if (CM_INET_FD_ISSET(&sockFd, &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(ret != ROK) { - CM_INET_FD_CLR(&sockFd, &readFd); - ret = cmInetSctpRecvMsg(&sockFd, &addr, &port, &memInfo, &mBuf, &bufLen, &info, &flag, &ntfy); - if (connUp && ret != ROK) - { - DU_LOG("\nFailed to receive sctp msg\n"); - } + DU_LOG("\nERROR --> SCTP: Failed to receive sctp msg for sockFd[%d]\n", sockFd->fd); + recvMsgSet = RFAILED; + } + else + { +#ifdef CALL_FLOW_DEBUG_LOG + if(pollParams->port == f1Params.destPort) + DU_LOG("\nCall Flow: CU -> ENTSCTP : EVENT_SCTP_MSG\n"); else + DU_LOG("\nCall Flow: RIC -> ENTSCTP : EVENT_SCTP_MSG\n"); +#endif + if((((pollParams->flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0)) && ret == ROK) { - /* If SCTP notification received */ - if ((flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0) + if(pollParams->port == f1Params.destPort) { - ret = sctpNtfyHdlr(&ntfy); - if(ret != ROK) - { - DU_LOG("\nSCTP : Failed to process sctp notify msg\n"); - } + f1Params.assocId = pollParams->ntfy.u.assocChange.assocId; + DU_LOG("\nDEBUG --> SCTP : AssocId assigned to F1Params from PollParams [%d]\n", f1Params.assocId); + ret = sctpNtfyHdlr(&pollParams->ntfy, &f1Params.itfState); } - else if(connUp) /* If data received */ + else if(pollParams->port == ricParams.destPort) { - sendToDuApp(mBuf, EVTSCTPDATA); + ricParams.assocId = pollParams->ntfy.u.assocChange.assocId; + DU_LOG("\nDEBUG --> SCTP : AssocId assigned to ricParams from PollParams [%d]\n", ricParams.assocId); + ret = sctpNtfyHdlr(&pollParams->ntfy, &ricParams.itfState); } else { - SPutMsg(mBuf); + DU_LOG("\nERROR --> SCTP : Failed to fill AssocId\n"); + return RFAILED; + } + if(ret != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed to process sctp notify msg\n"); } } - } - }; - - RETVALUE(ROK); -}/* End of sctpSockPoll() */ + else if(f1Params.itfState & (pollParams->port == f1Params.destPort)) + { + sendToDuApp(pollParams->mBuf, EVENT_CU_DATA); + } + else if(ricParams.itfState & (pollParams->port == ricParams.destPort)) + { + sendToDuApp(pollParams->mBuf, EVENT_RIC_DATA); + } + else + { + ODU_PUT_MSG_BUF(pollParams->mBuf); + } + } + } + return ROK; +} /******************************************************************* * - * @brief Send message on SCTP socket + * @brief Receives message on the socket * * @details * - * Function : sctpSend + * Function : sctpSockPoll * * Functionality: - * Send message on SCTP socket + * Receives message on the socket * * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 sctpSend(Buffer *mBuf) +uint8_t sctpSockPoll() { - U8 ret; - MsgLen len; /* number of actually sent octets */ - CmInetNetAddr peerAddr; /* destination port address */ - CmInetNetAddr *dstAddr; - CmInetMemInfo memInfo; - - memInfo.region = DU_APP_MEM_REGION; - memInfo.pool = DU_POOL; + uint8_t ret = ROK; + uint32_t timeout; + uint32_t *timeout_Ptr; + CmInetMemInfo memInfo; + sctpSockPollParams f1PollParams, e2PollParams; + memset(&f1PollParams, 0, sizeof(sctpSockPollParams)); + memset(&e2PollParams, 0, sizeof(sctpSockPollParams)); - if(sctpCfg.cuIpAddr.ipV4Pres) + if (f1Params.sockFd.blocking & ricParams.sockFd.blocking) { - peerAddr.type = CM_INET_IPV4ADDR_TYPE; - peerAddr.u.ipv4NetAddr = CM_INET_NTOH_U32(sctpCfg.cuIpAddr.ipV4Addr); - dstAddr = &peerAddr; + /* blocking */ + timeout_Ptr = NULLP; } else { - dstAddr = NULLP; + /* non-blocking */ + timeout = 0; + timeout_Ptr = &timeout; } + memInfo.region = DU_APP_MEM_REGION; + memInfo.pool = DU_POOL; - ret = cmInetSctpSendMsg(&sockFd, dstAddr, sctpCfg.cuPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK); - if(ret != ROK && ret != RWOULDBLOCK) - { - DU_LOG("\nSCTP : Failed sending the message"); - RETVALUE(RFAILED); - } + CM_INET_FD_ZERO(&f1PollParams.readFd); + CM_INET_FD_ZERO(&e2PollParams.readFd); - RETVALUE(ROK); -} /* End of sctpSend */ + DU_LOG("\nINFO --> SCTP : Polling started at DU\n"); + while(true) + { + if(f1Params.itfState) + { + if((ret = processPolling(&f1PollParams, &f1Params.sockFd, timeout_Ptr, &memInfo, f1Params.recvMsgSet)) != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for F1\n"); + } + } + if(ricParams.itfState) + { + if((ret = processPolling(&e2PollParams, &ricParams.sockFd, timeout_Ptr, &memInfo, ricParams.recvMsgSet)) != ROK) + { + DU_LOG("\nERROR --> SCTP : Failed to RecvMsg for E2\n"); + } + } + }; + return (ret); +}/* End of sctpSockPoll() */ /******************************************************************* * - * @brief SCTP Assoc establishment request from DU + * @brief Send message on SCTP socket * * @details * - * Function : sctpAssocReq + * Function : sctpSend * * Functionality: - * This function opens a socket at DU and - * intiates SCTP connection. + * Send message on SCTP socket * - * @params[in] + * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -void sctpAssocReq() +uint8_t sctpSend(Buffer *mBuf, uint8_t itfType) { - if(openSctpEndp() != ROK) + uint8_t ret =0; + MsgLen len =0; /* number of actually sent octets */ + CmInetMemInfo memInfo; + + memInfo.region = DU_APP_MEM_REGION; + memInfo.pool = DU_POOL; + +#ifdef CALL_FLOW_DEBUG_LOG + if(itfType == F1_INTERFACE) { - DU_LOG("\nSCTP : Failed while opening socket"); + DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_F1AP_MSG_TO_SCTP\n"); } - else if(bindSctpEndp() != ROK) + else { - DU_LOG("\nSCTP : Failed while binding socket"); + DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_E2AP_MSG_TO_SCTP\n"); } - else if(sctpSetSockOpts() != ROK) +#endif + + if(itfType == F1_INTERFACE) { - DU_LOG("\nSCTP : Failed while setting socket options"); + DU_LOG("\nDEBUG --> SCTP : sending the message to CU"); +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCTP -> CU : EVENT_F1AP_MSG_TO_CU\n"); +#endif + ret = cmInetSctpSendMsg(&f1Params.sockFd, &f1Params.destIpNetAddr, f1Params.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK); } - else if(sctpConnect() != ROK) + + if(itfType == E2_INTERFACE) { - DU_LOG("\nSCTP : Failed while connecting to peer"); + DU_LOG("\nDEBUG --> SCTP : sending the message to ric"); +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCTP -> RIC : EVENT_E2AP_MSG_TO_RIC\n"); +#endif + ret = cmInetSctpSendMsg(&ricParams.sockFd, &ricParams.destIpNetAddr, ricParams.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK); } - else if(sctpSockPoll() != ROK) + + if(ret != ROK && ret != RWOULDBLOCK) { - DU_LOG("\nSCTP : Failed while polling"); + DU_LOG("\nERROR --> SCTP : Failed sending the message"); + return RFAILED; } -} /* End of sctpAssocReq */ + + return ROK; +} /* End of sctpSend */ /********************************************************************** End of file