42 #include <ti/drivers/net/wifi/simplelink.h> 43 #include <ti/drivers/net/wifi/source/protocol.h> 44 #include <ti/drivers/net/wifi/source/driver.h> 47 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf);
48 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf);
52 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf);
53 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf);
54 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 55 static _i16 _SlDrvClearCtrlSocket(
void);
56 static _i8 _SlDrvGetNextTimeoutValue(
void);
77 pCmd->IpV4.FamilyAndFlags = (_u8)((addr->sa_family << 4) & 0xF0);
80 if(SL_AF_INET == addr->sa_family)
84 #ifdef SL_SUPPORT_IPV6 87 sl_Memcpy(pCmd->IpV6.Address, ((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, 16 );
103 addr->sa_family = pRsp->IpV4.Family;
108 if(SL_AF_INET == addr->sa_family)
112 #ifdef SL_SUPPORT_IPV6 115 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, pRsp->IpV6.Address, 16);
134 #if _SL_INCLUDE_FUNC(sl_Socket) 138 SL_OPCODE_SOCKET_SOCKET,
145 _SlSockSocketMsg_u Msg;
147 Msg.Cmd.Domain = (_u8)Domain;
148 Msg.Cmd.Type = (_u8)Type;
149 Msg.Cmd.Protocol = (_u8)Protocol;
153 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
155 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockSocketCmdCtrl, &Msg, NULL));
157 if( Msg.Rsp.StatusOrLen < 0 )
159 return ( Msg.Rsp.StatusOrLen);
163 return (_i16)((_u8)Msg.Rsp.Sd);
178 #if _SL_INCLUDE_FUNC(sl_Close) 182 SL_OPCODE_SOCKET_CLOSE,
189 _SlSockCloseMsg_u Msg;
190 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
192 _SlReturnVal_t RetVal;
193 _u8 bSocketInAction = FALSE;
197 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
199 Msg.Cmd.Sd = (_u8)sd;
203 bSocketInAction = !!(g_pCB->ActiveActionsBitmap & (1<<sd));
205 if (bSocketInAction == FALSE)
207 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CLOSE_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
209 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
211 return SL_POOL_IS_EMPTY;
215 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
217 RetVal = Msg.Rsp.StatusOrLen;
219 if (bSocketInAction == FALSE)
221 if( SL_RET_CODE_OK == RetVal)
223 SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
224 SL_DRIVER_TIMEOUT_LONG,
225 SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT
227 RetVal = AsyncRsp.StatusOrLen;
230 _SlDrvReleasePoolObj(ObjIdx);
246 #if _SL_INCLUDE_FUNC(sl_Bind) 249 _SlSockBindMsg_u Msg;
254 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
256 switch(addr->sa_family)
259 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
263 #ifdef SL_SUPPORT_IPV6 265 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
273 return SL_RET_CODE_INVALID_INPUT;
276 Msg.Cmd.IpV4.LenOrPadding = 0;
277 Msg.Cmd.IpV4.Sd = (_u8)sd;
279 _SlSocketBuildAddress(addr, &Msg.Cmd);
280 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
282 return Msg.Rsp.StatusOrLen;
295 #if _SL_INCLUDE_FUNC(sl_SendTo) 305 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
307 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
309 return SL_ERROR_BSD_SOC_ERROR;
320 _SlDrvResetCmdExt(&CmdExt);
321 CmdExt.TxPayload1Len = (_u16)Len;
322 CmdExt.pTxPayload1 = (_u8 *)pBuf;
324 switch(to->sa_family)
327 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
331 #ifdef SL_SUPPORT_IPV6 333 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_V6;
340 return SL_RET_CODE_INVALID_INPUT;
343 Msg.Cmd.IpV4.LenOrPadding = Len;
344 Msg.Cmd.IpV4.Sd = (_u8)sd;
345 _SlSocketBuildAddress(to, &Msg.Cmd);
346 Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
348 RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
349 if(SL_OS_RET_CODE_OK != RetVal)
369 SL_OPCODE_SOCKET_RECVFROM,
374 #if _SL_INCLUDE_FUNC(sl_RecvFrom) 377 _SlRecvfromMsg_u Msg;
383 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
386 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
388 return SL_ERROR_BSD_SOC_ERROR;
391 _SlDrvResetCmdExt(&CmdExt);
392 CmdExt.RxPayloadLen = Len;
393 CmdExt.pRxPayload = (_u8 *)buf;
395 Msg.Cmd.Sd = (_u8)sd;
396 Msg.Cmd.StatusOrLen = (_u16)Len;
399 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
401 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
405 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
409 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
413 return SL_RET_CODE_INVALID_INPUT;
416 RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
417 if( RetVal != SL_OS_RET_CODE_OK )
422 RetVal = Msg.Rsp.IpV4.StatusOrLen;
426 VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.Sd);
428 _SlSocketParseAddress(&Msg.Rsp, from, fromlen);
430 from->sa_family = Msg.Rsp.IpV4.Family;
431 if(SL_AF_INET == from->sa_family)
437 #ifdef SL_SUPPORT_IPV6 438 else if(SL_AF_INET6 == from->sa_family)
443 sl_Memcpy(((
SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.Address, 16);
461 }_SlSockConnectMsg_u;
463 #if _SL_INCLUDE_FUNC(sl_Connect) 466 _SlSockConnectMsg_u Msg;
467 _SlReturnVal_t RetVal;
470 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
474 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
477 switch(addr->sa_family)
480 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
484 #ifdef SL_SUPPORT_IPV6 486 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
492 return SL_RET_CODE_INVALID_INPUT;
495 Msg.Cmd.IpV4.LenOrPadding = 0;
496 Msg.Cmd.IpV4.Sd = (_u8)sd;
498 _SlSocketBuildAddress(addr, &Msg.Cmd);
500 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
502 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
504 return SL_POOL_IS_EMPTY;
508 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
509 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
511 RetVal = Msg.Rsp.StatusOrLen;
513 if(SL_RET_CODE_OK == RetVal)
517 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
519 SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
520 SL_DRIVER_TIMEOUT_SHORT,
521 SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE
529 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
532 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
533 RetVal = AsyncRsp.StatusOrLen;
536 _SlDrvReleasePoolObj(ObjIdx);
546 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf)
550 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
552 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
553 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
556 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
557 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
560 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
561 SL_DRV_PROTECTION_OBJ_UNLOCK();
563 return SL_OS_RET_CODE_OK;
569 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf)
573 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
575 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
576 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
579 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
580 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
583 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
584 SL_DRV_PROTECTION_OBJ_UNLOCK();
586 return SL_OS_RET_CODE_OK;
600 SL_OPCODE_SOCKET_SEND,
605 #if _SL_INCLUDE_FUNC(sl_Send) 606 _i16
sl_Send(_i16 sd,
const void *pBuf, _i16 Len, _i16 flags)
615 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
617 _SlDrvResetCmdExt(&CmdExt);
618 CmdExt.TxPayload1Len = (_u16)Len;
619 CmdExt.pTxPayload1 = (_u8 *)pBuf;
622 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
624 tempVal = (_u32)flags;
625 CmdExt.pRxPayload = (_u8 *)&tempVal;
626 CmdExt.RxPayloadLen = -4;
630 CmdExt.pRxPayload = NULL;
638 Msg.Cmd.StatusOrLen = Len;
639 Msg.Cmd.Sd = (_u8)sd;
640 Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
642 RetVal = _SlDrvDataWriteOp((_u8)sd, (
_SlCmdCtrl_t *)&_SlSendCmdCtrl, &Msg, &CmdExt);
643 if(SL_OS_RET_CODE_OK != RetVal)
663 #if _SL_INCLUDE_FUNC(sl_Listen) 667 SL_OPCODE_SOCKET_LISTEN,
678 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
680 Msg.Cmd.Sd = (_u8)sd;
681 Msg.Cmd.Backlog = (_u8)backlog;
683 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
684 return (_i16)Msg.Rsp.status;
699 #if _SL_INCLUDE_FUNC(sl_Accept) 703 SL_OPCODE_SOCKET_ACCEPT,
710 _SlSockAcceptMsg_u Msg;
711 _SlReturnVal_t RetVal;
714 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
718 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
720 Msg.Cmd.Sd = (_u8)sd;
722 if((addr != NULL) && (addrlen != NULL))
725 Msg.Cmd.Family = (_u8)((
sizeof(
SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6);
730 Msg.Cmd.Family = (_u8)0;
733 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID, (_u8)sd & SL_BSD_SOCKET_ID_MASK);
735 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
737 return SL_POOL_IS_EMPTY;
741 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
742 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
744 RetVal = Msg.Rsp.StatusOrLen;
746 if(SL_OS_RET_CODE_OK == RetVal)
750 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
752 SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
753 SL_DRIVER_TIMEOUT_SHORT,
754 SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE
761 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
764 VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
766 RetVal = AsyncRsp.IpV4.StatusOrLen;
768 _SlSocketParseAddress(&AsyncRsp, addr, addrlen);
770 if((addr != NULL) && (addrlen != NULL))
772 addr->sa_family = AsyncRsp.IpV4.Family;
774 if(SL_AF_INET == addr->sa_family)
779 ((
SlSockAddrIn_t *)addr)->sin_addr.s_addr = AsyncRsp.IpV4.Address;
786 #ifdef SL_SUPPORT_IPV6 787 else if(SL_AF_INET6 == addr->sa_family)
792 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.Address, 16);
804 _SlDrvReleasePoolObj(ObjIdx);
819 p[0] = ((_i8* )&val)[3];
820 p[1] = ((_i8* )&val)[2];
821 p[2] = ((_i8* )&val)[1];
822 p[3] = ((_i8* )&val)[0];
840 p[0] = ((_i8* )&val)[1];
841 p[1] = ((_i8* )&val)[0];
854 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf)
858 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
860 VERIFY_PROTOCOL(( pMsgArgs->IpV4.Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
861 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
863 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSocketAddrResponse_u));
864 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
866 SL_DRV_PROTECTION_OBJ_UNLOCK();
868 return SL_OS_RET_CODE_OK;
882 #if _SL_INCLUDE_FUNC(sl_Recv) 886 SL_OPCODE_SOCKET_RECV,
892 _i16
sl_Recv(_i16 sd,
void *pBuf, _i16 Len, _i16 flags)
896 _SlReturnVal_t status;
900 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
902 _SlDrvResetCmdExt(&CmdExt);
903 CmdExt.RxPayloadLen = Len;
904 CmdExt.pRxPayload = (_u8 *)pBuf;
906 Msg.Cmd.Sd = (_u8)sd;
907 Msg.Cmd.StatusOrLen = (_u16)Len;
910 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
912 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
914 status = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvCmdCtrl, &Msg, &CmdExt);
915 if( status != SL_OS_RET_CODE_OK )
922 return (_i16)Msg.Rsp.StatusOrLen;
937 SL_OPCODE_SOCKET_SETSOCKOPT,
942 #if _SL_INCLUDE_FUNC(sl_SetSockOpt) 943 _i16
sl_SetSockOpt(_i16 sd, _i16 level, _i16 optname,
const void *optval, SlSocklen_t optlen)
945 _SlSetSockOptMsg_u Msg;
950 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
952 _SlDrvResetCmdExt(&CmdExt);
953 CmdExt.TxPayload1Len = optlen;
954 CmdExt.pTxPayload1 = (_u8 *)optval;
956 Msg.Cmd.Sd = (_u8)sd;
957 Msg.Cmd.Level = (_u8)level;
958 Msg.Cmd.OptionLen = (_u8)optlen;
959 Msg.Cmd.OptionName = (_u8)optname;
961 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
963 return (_i16)Msg.Rsp.StatusOrLen;
977 #if _SL_INCLUDE_FUNC(sl_GetSockOpt) 981 SL_OPCODE_SOCKET_GETSOCKOPT,
986 _i16
sl_GetSockOpt(_i16 sd, _i16 level, _i16 optname,
void *optval, SlSocklen_t *optlen)
988 _SlGetSockOptMsg_u Msg;
993 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
999 _SlDrvResetCmdExt(&CmdExt);
1000 CmdExt.RxPayloadLen = (_i16)(*optlen);
1001 CmdExt.pRxPayload = optval;
1003 Msg.Cmd.Sd = (_u8)sd;
1004 Msg.Cmd.Level = (_u8)level;
1005 Msg.Cmd.OptionLen = (_u8)(*optlen);
1006 Msg.Cmd.OptionName = (_u8)optname;
1008 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
1010 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
1012 *optlen = Msg.Rsp.OptionLen;
1013 return SL_ESMALLBUF;
1017 *optlen = (_u8)CmdExt.ActualRxPayloadLen;
1019 return (_i16)Msg.Rsp.Status;
1027 #if _SL_INCLUDE_FUNC(sl_Select) 1037 SL_OPCODE_SOCKET_SELECT,
1045 void SL_SOCKET_FD_SET(_i16 fd,
SlFdSet_t *fdset)
1047 fdset->fd_array[0] |= (1<< (fd & SL_BSD_SOCKET_ID_MASK));
1053 void SL_SOCKET_FD_CLR(_i16 fd,
SlFdSet_t *fdset)
1055 fdset->fd_array[0] &= ~(1<< (fd & SL_BSD_SOCKET_ID_MASK));
1061 _i16 SL_SOCKET_FD_ISSET(_i16 fd,
SlFdSet_t *fdset)
1063 if( fdset->fd_array[0] & (1<< (fd & SL_BSD_SOCKET_ID_MASK)) )
1073 void SL_SOCKET_FD_ZERO(
SlFdSet_t *fdset)
1075 fdset->fd_array[0] = 0;
1078 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 1085 #define LOCAL_CTRL_PORT (3632) 1086 #define SL_LOOPBACK_ADDR (0x0100007F) 1087 #define DUMMY_BUF_SIZE (4) 1088 #define CTRL_SOCK_FD (((_u16)(1)) << g_pCB->MultiSelectCB.CtrlSockFD) 1089 #define SELECT_TIMEOUT ((_u16)0) 1090 #define SELECT_NO_TIMEOUT (0xFFFFFFFF) 1116 static inline _u8 CountSetBits(_u16 fdList)
1122 Count += (fdList & ((_u16)1));
1123 fdList = fdList >> 1;
1132 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1134 _SlReturnVal_t RetVal;
1138 _u8 TimeoutEvent = 0;
1139 _u16 SelectEvent = 0;
1141 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1143 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1145 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1149 if((CTRL_SOCK_FD == pMsgArgs->ReadFds) && (pMsgArgs->Status != SELECT_TIMEOUT))
1151 RetVal = _SlDrvClearCtrlSocket();
1152 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1153 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1154 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1155 Msg.Cmd.tv_sec = 0xFFFF;
1156 Msg.Cmd.tv_usec = 0xFFFF;
1158 RegIdx = _SlDrvGetNextTimeoutValue();
1160 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rAdded caller: call Select with: Write:%x Sec:%d uSec:%d\n\r",
1161 Msg.Cmd.WriteFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1163 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1165 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1167 SL_DRV_PROTECTION_OBJ_UNLOCK();
1173 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1176 for(RegIdx = 0 ; RegIdx < MAX_CONCURRENT_ACTIONS ; RegIdx++)
1178 if(g_pCB->MultiSelectCB.SelectEntry[RegIdx] != NULL)
1183 TimeoutEvent = ((time_now + 100) >= g_pCB->MultiSelectCB.SelectEntry[RegIdx]->TimeStamp);
1185 if(pMsgArgs->Status != SELECT_TIMEOUT)
1187 SelectEvent = ((g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist & pMsgArgs->ReadFds) ||
1188 (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist & pMsgArgs->WriteFds));
1191 if(SelectEvent || TimeoutEvent)
1193 SL_TRACE4(DBG_MSG, MSG_312,
"\n\rg: %x, sl:%d, run:%d, idx:%d\n\r", g_pCB->MultiSelectCB.writesds, SelectEvent , times, RegIdx);
1196 g_pCB->MultiSelectCB.readsds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1197 g_pCB->MultiSelectCB.writesds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1202 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds = (pMsgArgs->ReadFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1203 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFds = (pMsgArgs->WriteFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1204 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1205 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1206 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount +
1207 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount);
1211 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = SELECT_TIMEOUT;
1214 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds &= ~(CTRL_SOCK_FD);
1217 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->MultiSelectCB.SelectEntry[RegIdx]->ObjIdx].SyncObj);
1220 g_pCB->MultiSelectCB.SelectEntry[RegIdx] = NULL;
1227 if((pMsgArgs->ReadFds & CTRL_SOCK_FD) && (pMsgArgs->Status != SELECT_TIMEOUT))
1229 RetVal = _SlDrvClearCtrlSocket();
1233 if((0 != g_pCB->MultiSelectCB.readsds) || (0 != g_pCB->MultiSelectCB.writesds))
1235 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1236 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1237 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1240 Msg.Cmd.tv_sec = 0xFFFF;
1241 Msg.Cmd.tv_usec = 0xFFFF;
1244 RegIdx = _SlDrvGetNextTimeoutValue();
1246 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRelease Partial: call Select with: Read:%x Sec:%d uSec:%d\n\r",
1247 Msg.Cmd.ReadFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1249 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1253 while(g_pCB->MultiSelectCB.ActiveWaiters)
1255 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1256 g_pCB->MultiSelectCB.ActiveWaiters--;
1259 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1261 SL_TRACE1(DBG_MSG, MSG_312,
"\n\rSelect isn't Active: %d\n\r", g_pCB->MultiSelectCB.ActiveSelect);
1264 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1266 SL_DRV_PROTECTION_OBJ_UNLOCK();
1268 return SL_OS_RET_CODE_OK;
1274 static _i8 _SlDrvGetNextTimeoutValue(
void)
1281 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1284 for(idx = 0 ; idx < MAX_CONCURRENT_ACTIONS ; idx++)
1286 if(NULL != g_pCB->MultiSelectCB.SelectEntry[idx])
1289 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp >= time_now)
1297 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp <= g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp)
1307 if(g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp != SELECT_NO_TIMEOUT)
1309 _i32 delta = (g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp - time_now);
1313 Msg.Cmd.tv_sec = (delta / 1000);
1314 Msg.Cmd.tv_usec = (((delta % 1000) * 1000) >> 10);
1320 Msg.Cmd.tv_usec = 0;
1330 static _i16 _SlDrvClearCtrlSocket(
void)
1332 _SlRecvfromMsg_u Msg;
1334 _u8 dummyBuf[DUMMY_BUF_SIZE];
1335 _SlReturnVal_t RetVal;
1338 _SlDrvResetCmdExt(&CmdExt);
1339 _SlDrvMemZero(&Msg,
sizeof(_SlRecvfromMsg_u));
1341 CmdExt.RxPayloadLen = DUMMY_BUF_SIZE;
1342 CmdExt.pRxPayload = (_u8 *)&dummyBuf;
1344 Msg.Cmd.Sd = (_u8)g_pCB->MultiSelectCB.CtrlSockFD;
1345 Msg.Cmd.StatusOrLen = (_u16)DUMMY_BUF_SIZE;
1346 Msg.Cmd.FamilyAndFlags = (SL_AF_INET << 4);
1348 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
1356 static _i16 _SlDrvOpenCtrlSocket(
void)
1361 if(g_pCB->MultiSelectCB.CtrlSockFD != 0xFF)
1367 retVal =
sl_Socket(SL_AF_INET, SL_SOCK_DGRAM, 0);
1369 if(retVal == SL_ERROR_BSD_ENSOCK)
1379 g_pCB->MultiSelectCB.CtrlSockFD = retVal;
1391 static _i16 _SlDrvCloseCtrlSocket(
void)
1397 sockfd = g_pCB->MultiSelectCB.CtrlSockFD;
1405 g_pCB->MultiSelectCB.CtrlSockFD = 0xFF;
1409 return SL_ERROR_BSD_SOC_ERROR;
1418 static inline _u32 to_mSec(
struct SlTimeval_t* timeout)
1420 return (((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10) + (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000));
1426 static _i16 _SlDrvUnRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _u8 SelectInProgress)
1428 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1431 g_pCB->MultiSelectCB.readsds &= ~(pEntry->readlist);
1432 g_pCB->MultiSelectCB.writesds &= ~(pEntry->writelist);
1435 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = NULL;
1437 if(g_pCB->MultiSelectCB.ActiveSelect == FALSE)
1439 _SlDrvCloseCtrlSocket();
1442 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1445 _SlDrvReleasePoolObj(pEntry->ObjIdx);
1447 return SL_ERROR_BSD_SOC_ERROR;
1453 static _i16 _SlDrvRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _SlSelectMsg_u* pMsg,
struct SlTimeval_t *timeout, _u8 SelectInProgress)
1455 _SlReturnVal_t _RetVal = 0;
1456 _u8 dummyBuf[4] = {0};
1459 pEntry->readlist = pMsg->Cmd.ReadFds;
1460 pEntry->writelist = pMsg->Cmd.WriteFds;
1462 if((pMsg->Cmd.tv_sec != 0xFFFF) && (timeout != NULL))
1464 pEntry->TimeStamp = to_mSec(timeout);
1468 pEntry->TimeStamp = SELECT_NO_TIMEOUT;
1471 g_pCB->MultiSelectCB.readsds |= pMsg->Cmd.ReadFds;
1472 g_pCB->MultiSelectCB.writesds |= pMsg->Cmd.WriteFds;
1473 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = pEntry;
1475 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRegistered: Objidx:%d, sec:%d, usec%d\n\r",
1476 pEntry->ObjIdx, pMsg->Cmd.tv_sec, pMsg->Cmd.tv_usec);
1478 if((!SelectInProgress) || (g_pCB->MultiSelectCB.ActiveSelect == FALSE))
1481 pMsg->Cmd.ReadFds |= CTRL_SOCK_FD;
1483 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1485 _RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, pMsg, NULL);
1487 if((_RetVal == SL_RET_CODE_OK) && (g_pCB->MultiSelectCB.CtrlSockFD != 0xFF))
1490 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1495 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1498 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1500 _RetVal =
sl_SendTo(g_pCB->MultiSelectCB.CtrlSockFD,
1517 _u8 isCaller = FALSE;
1520 _u8 SelectInProgress = FALSE;
1524 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1525 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1528 Msg.Cmd.Nfds = (_u8)nfds;
1532 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1537 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1542 Msg.Cmd.tv_sec = 0xffff;
1543 Msg.Cmd.tv_usec = 0xffff;
1547 if(0xffff <= timeout->tv_sec)
1549 Msg.Cmd.tv_sec = 0xffff;
1553 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1558 timeout->tv_usec = (timeout->tv_usec >> 10);
1560 if(0xffff <= timeout->tv_usec)
1562 Msg.Cmd.tv_usec = 0xffff;
1566 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1570 while(FALSE == isCaller)
1572 SelectParams.ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&SelectParams.Response, SELECT_ID, SL_MAX_SOCKETS);
1574 if(MAX_CONCURRENT_ACTIONS == SelectParams.ObjIdx)
1576 return SL_POOL_IS_EMPTY;
1579 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1582 if(FALSE == g_pCB->MultiSelectCB.ActiveSelect)
1584 g_pCB->MultiSelectCB.ActiveSelect = TRUE;
1588 SelectInProgress = TRUE;
1591 if(!SelectInProgress)
1593 ret = _SlDrvOpenCtrlSocket();
1597 _SlDrvCloseCtrlSocket();
1598 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1599 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1600 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1609 else if(g_pCB->MultiSelectCB.CtrlSockFD == 0xFF)
1611 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1616 g_pCB->MultiSelectCB.ActiveWaiters++;
1618 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1620 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1622 if((_i16)g_pCB->MultiSelectCB.SelectCmdResp.status != SL_RET_CODE_OK)
1624 return (_i16)(g_pCB->MultiSelectCB.SelectCmdResp.status);
1627 SelectInProgress = FALSE;
1639 ret = _SlDrvRegisterForSelectAsync(&SelectParams, &Msg, timeout, SelectInProgress);
1643 return (_SlDrvUnRegisterForSelectAsync(&SelectParams, SelectInProgress));
1647 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[SelectParams.ObjIdx].SyncObj);
1649 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1651 ret = (_i16)g_pCB->MultiSelectCB.SelectCmdResp.status;
1653 if(ret == SL_RET_CODE_OK)
1655 ret = (_i16)SelectParams.Response.Status;
1657 if(ret > SELECT_TIMEOUT)
1661 readsds->fd_array[0] = SelectParams.Response.ReadFds;
1666 writesds->fd_array[0] = SelectParams.Response.WriteFds;
1679 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1682 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1686 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1688 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
1690 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSelectAsyncResponse_t));
1692 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1693 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1695 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1698 SockTriggerEvent.Event = SL_SOCKET_TRIGGER_EVENT_SELECT;
1699 SockTriggerEvent.EventData = 0;
1702 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_RESP_RECEIVED;
1704 SL_DRV_PROTECTION_OBJ_UNLOCK();
1707 _SlDrvHandleSocketTriggerEvents(&SockTriggerEvent);
1709 return SL_OS_RET_CODE_OK;
1713 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1720 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1723 SL_DRV_PROTECTION_OBJ_UNLOCK();
1725 return SL_OS_RET_CODE_OK;
1732 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
1733 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1734 _u8 IsNonBlocking = FALSE;
1739 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1741 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1742 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1744 if( NULL != timeout )
1747 if ( (0 == timeout->tv_sec) && (0 == timeout->tv_usec) )
1749 IsNonBlocking = TRUE;
1753 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1756 if (g_pCB->SocketTriggerSelect.Info.State > SOCK_TRIGGER_READY)
1758 SL_DRV_PROTECTION_OBJ_UNLOCK();
1759 return SL_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR;
1762 SL_DRV_PROTECTION_OBJ_UNLOCK();
1765 if (IsNonBlocking == TRUE)
1768 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1770 return SL_ERROR_BSD_EAGAIN;
1773 else if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_RESP_RECEIVED)
1776 if( ((_i16)g_pCB->SocketTriggerSelect.Resp.Status) >= 0 )
1780 readsds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.ReadFds;
1784 writesds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.WriteFds;
1789 _SlDrvReleasePoolObj(g_pCB->SocketTriggerSelect.Info.ObjPoolIdx);
1791 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = MAX_CONCURRENT_ACTIONS;
1794 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_READY;
1796 return (_i16)g_pCB->SocketTriggerSelect.Resp.Status;
1803 Msg.Cmd.Nfds = (_u8)nfds;
1804 Msg.Cmd.ReadFdsCount = 0;
1805 Msg.Cmd.WriteFdsCount = 0;
1807 Msg.Cmd.ReadFds = 0;
1808 Msg.Cmd.WriteFds = 0;
1813 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1817 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1819 if( NULL == timeout )
1821 Msg.Cmd.tv_sec = 0xffff;
1822 Msg.Cmd.tv_usec = 0xffff;
1826 if( 0xffff <= timeout->tv_sec )
1828 Msg.Cmd.tv_sec = 0xffff;
1832 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1836 timeout->tv_usec = timeout->tv_usec >> 10;
1838 if( 0xffff <= timeout->tv_usec )
1840 Msg.Cmd.tv_usec = 0xffff;
1844 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1850 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, SELECT_ID, SL_MAX_SOCKETS);
1852 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1854 return SL_POOL_IS_EMPTY;
1858 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1860 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
1862 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
1864 Msg.Rsp.status = (_i16)AsyncRsp.Status;
1868 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1873 if ((IsNonBlocking == TRUE) && (AsyncRsp.Status == 0))
1876 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_WAITING_FOR_RESP;
1878 Msg.Cmd.tv_sec = 0xffff;
1879 Msg.Cmd.tv_usec = 0xffff;
1882 _SlDrvReleasePoolObj(ObjIdx);
1885 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&g_pCB->SocketTriggerSelect.Resp, SELECT_ID, SL_MAX_SOCKETS);
1887 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1889 return SL_POOL_IS_EMPTY;
1893 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = ObjIdx;
1896 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1897 return SL_ERROR_BSD_EAGAIN;
1903 if( ((_i16)Msg.Rsp.status) >= 0 )
1907 readsds->fd_array[0] = AsyncRsp.ReadFds;
1911 writesds->fd_array[0] = AsyncRsp.WriteFds;
1916 _SlDrvReleasePoolObj(ObjIdx);
1917 return (_i16)Msg.Rsp.status;
_i16 sl_Bind(_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
Assign a name to a socket.
_u32 sl_Htonl(_u32 val)
Reorder the bytes of a 32-bit unsigned value.
_i16 sl_Select(_i16 nfds, SlFdSet_t *readsds, SlFdSet_t *writesds, SlFdSet_t *exceptsds, struct SlTimeval_t *timeout)
Monitor socket activity.
void slcb_SocketTriggerEventHandler(SlSockTriggerEvent_t *pSlSockTriggerEvent)
Socket trigger routine. This routine will notify the application that a netwrok activity has been com...
_i16 sl_SetSockOpt(_i16 sd, _i16 level, _i16 optname, const void *optval, SlSocklen_t optlen)
Set socket options-.
_u32 slcb_GetTimestamp(void)
Get the timer counter value (timestamp). The timer must count from zero to its MAX value...
_u16 sl_Htons(_u16 val)
Reorder the bytes of a 16-bit unsigned value.
_i16 sl_Close(_i16 sd)
Gracefully close socket.
_i16 sl_Recv(_i16 sd, void *pBuf, _i16 Len, _i16 flags)
Read data from TCP socket.
_i16 sl_GetSockOpt(_i16 sd, _i16 level, _i16 optname, void *optval, SlSocklen_t *optlen)
Get socket options.
_i16 sl_Socket(_i16 Domain, _i16 Type, _i16 Protocol)
Create an endpoint for communication.
_i16 sl_RecvFrom(_i16 sd, void *buf, _i16 Len, _i16 flags, SlSockAddr_t *from, SlSocklen_t *fromlen)
Read data from socket.
_i16 sl_Accept(_i16 sd, SlSockAddr_t *addr, SlSocklen_t *addrlen)
Accept a connection on a socket.
_i16 sl_Connect(_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
Initiate a connection on a socket.
_i16 sl_Listen(_i16 sd, _i16 backlog)
Listen for connections on a socket.
_i16 sl_SendTo(_i16 sd, const void *pBuf, _i16 Len, _i16 flags, const SlSockAddr_t *to, SlSocklen_t tolen)
Write data to socket.
_i16 sl_Send(_i16 sd, const void *pBuf, _i16 Len, _i16 flags)
Write data to TCP socket.