41 #include <ti/drivers/net/wifi/simplelink.h> 42 #include <ti/drivers/net/wifi/source/protocol.h> 43 #include <ti/drivers/net/wifi/source/driver.h> 46 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf);
47 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf);
50 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf);
51 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf);
52 _SlReturnVal_t _SlSocketHandleAsync_StartTLS(
void *pVoidBuf);
54 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 55 static _i16 _SlDrvClearCtrlSocket(
void);
56 static _i8 _SlDrvGetNextTimeoutValue(
void);
73 pCmd->IpV4.FamilyAndFlags = (_u8)((addr->sa_family << 4) & 0xF0);
76 if(SL_AF_INET == addr->sa_family)
80 #ifdef SL_SUPPORT_IPV6 83 sl_Memcpy(pCmd->IpV6.Address, ((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, 16 );
96 addr->sa_family = pRsp->IpV4.Family;
101 if(SL_AF_INET == addr->sa_family)
105 #ifdef SL_SUPPORT_IPV6 108 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, pRsp->IpV6.Address, 16);
123 #if _SL_INCLUDE_FUNC(sl_Socket) 127 SL_OPCODE_SOCKET_SOCKET,
134 _SlSockSocketMsg_u Msg;
136 Msg.Cmd.Domain = (_u8)Domain;
137 Msg.Cmd.Type = (_u8)Type;
138 Msg.Cmd.Protocol = (_u8)Protocol;
142 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
144 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockSocketCmdCtrl, &Msg, NULL));
146 if( Msg.Rsp.StatusOrLen < 0 )
148 return ( Msg.Rsp.StatusOrLen);
152 return (_i16)((_u8)Msg.Rsp.Sd);
166 #if _SL_INCLUDE_FUNC(sl_Close) 170 SL_OPCODE_SOCKET_CLOSE,
177 _SlSockCloseMsg_u Msg;
178 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
180 _SlReturnVal_t RetVal;
181 _u8 bSocketInAction = FALSE;
185 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
187 Msg.Cmd.Sd = (_u8)sd;
191 bSocketInAction = !!(g_pCB->ActiveActionsBitmap & (1<<sd));
193 if (bSocketInAction == FALSE)
195 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CLOSE_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
197 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
199 return SL_POOL_IS_EMPTY;
203 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
205 RetVal = Msg.Rsp.StatusOrLen;
207 if (bSocketInAction == FALSE)
209 if( SL_RET_CODE_OK == RetVal)
211 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_LONG, SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT));
213 RetVal = AsyncRsp.StatusOrLen;
216 _SlDrvReleasePoolObj(ObjIdx);
232 #if _SL_INCLUDE_FUNC(sl_Bind) 235 _SlSockBindMsg_u Msg;
240 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
242 switch(addr->sa_family)
245 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
248 #ifdef SL_SUPPORT_IPV6 250 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
256 return SL_RET_CODE_INVALID_INPUT;
259 Msg.Cmd.IpV4.LenOrPadding = 0;
260 Msg.Cmd.IpV4.Sd = (_u8)sd;
262 _SlSocketBuildAddress(addr, &Msg.Cmd);
263 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
265 return Msg.Rsp.StatusOrLen;
278 #if _SL_INCLUDE_FUNC(sl_SendTo) 288 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
290 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
292 return SL_ERROR_BSD_SOC_ERROR;
303 _SlDrvResetCmdExt(&CmdExt);
304 CmdExt.TxPayload1Len = (_u16)Len;
305 CmdExt.pTxPayload1 = (_u8 *)pBuf;
307 switch(to->sa_family)
310 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
313 #ifdef SL_SUPPORT_IPV6 315 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_V6;
321 return SL_RET_CODE_INVALID_INPUT;
324 Msg.Cmd.IpV4.LenOrPadding = Len;
325 Msg.Cmd.IpV4.Sd = (_u8)sd;
326 _SlSocketBuildAddress(to, &Msg.Cmd);
327 Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
329 RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
330 if(SL_OS_RET_CODE_OK != RetVal)
350 SL_OPCODE_SOCKET_RECVFROM,
355 #if _SL_INCLUDE_FUNC(sl_RecvFrom) 358 _SlRecvfromMsg_u Msg;
364 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
367 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
369 return SL_ERROR_BSD_SOC_ERROR;
372 _SlDrvResetCmdExt(&CmdExt);
373 CmdExt.RxPayloadLen = Len;
374 CmdExt.pRxPayload = (_u8 *)buf;
376 Msg.Cmd.Sd = (_u8)sd;
377 Msg.Cmd.StatusOrLen = (_u16)Len;
380 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
382 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
386 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
390 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
394 return SL_RET_CODE_INVALID_INPUT;
397 RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
398 if( RetVal != SL_OS_RET_CODE_OK )
403 RetVal = Msg.Rsp.IpV4.StatusOrLen;
407 VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.Sd);
409 _SlSocketParseAddress(&Msg.Rsp, from, fromlen);
411 from->sa_family = Msg.Rsp.IpV4.Family;
412 if(SL_AF_INET == from->sa_family)
418 #ifdef SL_SUPPORT_IPV6 419 else if(SL_AF_INET6 == from->sa_family)
424 sl_Memcpy(((
SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.Address, 16);
442 }_SlSockConnectMsg_u;
444 #if _SL_INCLUDE_FUNC(sl_Connect) 447 _SlSockConnectMsg_u Msg;
448 _SlReturnVal_t RetVal;
451 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
455 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
458 switch(addr->sa_family)
461 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
465 #ifdef SL_SUPPORT_IPV6 467 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
473 return SL_RET_CODE_INVALID_INPUT;
476 Msg.Cmd.IpV4.LenOrPadding = 0;
477 Msg.Cmd.IpV4.Sd = (_u8)sd;
479 _SlSocketBuildAddress(addr, &Msg.Cmd);
481 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
483 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
485 return SL_POOL_IS_EMPTY;
489 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
490 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
492 RetVal = Msg.Rsp.StatusOrLen;
494 if(SL_RET_CODE_OK == RetVal)
497 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
499 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE));
505 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0));
508 RetVal = AsyncRsp.StatusOrLen;
512 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
516 _SlDrvReleasePoolObj(ObjIdx);
526 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf)
530 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
532 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
533 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
535 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
536 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
538 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
539 SL_DRV_PROTECTION_OBJ_UNLOCK();
541 return SL_OS_RET_CODE_OK;
547 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf)
551 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
553 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
554 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;
559 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
560 SL_DRV_PROTECTION_OBJ_UNLOCK();
562 return SL_OS_RET_CODE_OK;
576 SL_OPCODE_SOCKET_SEND,
581 #if _SL_INCLUDE_FUNC(sl_Send) 582 _i16
sl_Send(_i16 sd,
const void *pBuf, _i16 Len, _i16 flags)
591 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
593 _SlDrvResetCmdExt(&CmdExt);
594 CmdExt.TxPayload1Len = (_u16)Len;
595 CmdExt.pTxPayload1 = (_u8 *)pBuf;
598 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
600 tempVal = (_u32)flags;
601 CmdExt.pRxPayload = (_u8 *)&tempVal;
602 CmdExt.RxPayloadLen = -4;
606 CmdExt.pRxPayload = NULL;
614 Msg.Cmd.StatusOrLen = Len;
615 Msg.Cmd.Sd = (_u8)sd;
616 Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
618 RetVal = _SlDrvDataWriteOp((_u8)sd, (
_SlCmdCtrl_t *)&_SlSendCmdCtrl, &Msg, &CmdExt);
619 if(SL_OS_RET_CODE_OK != RetVal)
637 #if _SL_INCLUDE_FUNC(sl_Listen) 641 SL_OPCODE_SOCKET_LISTEN,
652 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
654 Msg.Cmd.Sd = (_u8)sd;
655 Msg.Cmd.Backlog = (_u8)backlog;
657 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
658 return (_i16)Msg.Rsp.status;
671 #if _SL_INCLUDE_FUNC(sl_Accept) 675 SL_OPCODE_SOCKET_ACCEPT,
682 _SlSockAcceptMsg_u Msg;
683 _SlReturnVal_t RetVal;
686 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
690 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
692 Msg.Cmd.Sd = (_u8)sd;
694 if((addr != NULL) && (addrlen != NULL))
697 Msg.Cmd.Family = (_u8)((
sizeof(
SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6);
702 Msg.Cmd.Family = (_u8)0;
705 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID, (_u8)sd & SL_BSD_SOCKET_ID_MASK);
707 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
709 return SL_POOL_IS_EMPTY;
713 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
714 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
716 RetVal = Msg.Rsp.StatusOrLen;
718 if(SL_OS_RET_CODE_OK == RetVal)
721 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
723 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE));
728 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
731 RetVal = AsyncRsp.IpV4.StatusOrLen;
735 VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
740 _SlSocketParseAddress(&AsyncRsp, addr, addrlen);
742 if((addr != NULL) && (addrlen != NULL))
744 addr->sa_family = AsyncRsp.IpV4.Family;
746 if(SL_AF_INET == addr->sa_family)
751 ((
SlSockAddrIn_t *)addr)->sin_addr.s_addr = AsyncRsp.IpV4.Address;
758 #ifdef SL_SUPPORT_IPV6 759 else if(SL_AF_INET6 == addr->sa_family)
764 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.Address, 16);
776 _SlDrvReleasePoolObj(ObjIdx);
791 p[0] = ((_i8* )&val)[3];
792 p[1] = ((_i8* )&val)[2];
793 p[2] = ((_i8* )&val)[1];
794 p[3] = ((_i8* )&val)[0];
812 p[0] = ((_i8* )&val)[1];
813 p[1] = ((_i8* )&val)[0];
825 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf)
829 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
831 VERIFY_PROTOCOL(( pMsgArgs->IpV4.Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
832 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
834 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSocketAddrResponse_u));
835 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
837 SL_DRV_PROTECTION_OBJ_UNLOCK();
839 return SL_OS_RET_CODE_OK;
851 #if _SL_INCLUDE_FUNC(sl_Recv) 855 SL_OPCODE_SOCKET_RECV,
860 _i16
sl_Recv(_i16 sd,
void *pBuf, _i16 Len, _i16 flags)
864 _SlReturnVal_t status;
868 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
870 _SlDrvResetCmdExt(&CmdExt);
871 CmdExt.RxPayloadLen = Len;
872 CmdExt.pRxPayload = (_u8 *)pBuf;
874 Msg.Cmd.Sd = (_u8)sd;
875 Msg.Cmd.StatusOrLen = (_u16)Len;
878 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
880 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
882 status = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvCmdCtrl, &Msg, &CmdExt);
883 if( status != SL_OS_RET_CODE_OK )
890 return (_i16)Msg.Rsp.StatusOrLen;
905 SL_OPCODE_SOCKET_SETSOCKOPT,
910 #if _SL_INCLUDE_FUNC(sl_SetSockOpt) 911 _i16 sl_SetSockOpt(_i16 sd, _i16 level, _i16 optname,
const void *optval, SlSocklen_t optlen)
913 _SlSetSockOptMsg_u Msg;
918 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
920 _SlDrvResetCmdExt(&CmdExt);
921 CmdExt.TxPayload1Len = optlen;
922 CmdExt.pTxPayload1 = (_u8 *)optval;
924 Msg.Cmd.Sd = (_u8)sd;
925 Msg.Cmd.Level = (_u8)level;
926 Msg.Cmd.OptionLen = (_u8)optlen;
927 Msg.Cmd.OptionName = (_u8)optname;
929 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
931 return (_i16)Msg.Rsp.StatusOrLen;
945 #if _SL_INCLUDE_FUNC(sl_GetSockOpt) 949 SL_OPCODE_SOCKET_GETSOCKOPT,
954 _i16
sl_GetSockOpt(_i16 sd, _i16 level, _i16 optname,
void *optval, SlSocklen_t *optlen)
956 _SlGetSockOptMsg_u Msg;
961 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
967 _SlDrvResetCmdExt(&CmdExt);
968 CmdExt.RxPayloadLen = (_i16)(*optlen);
969 CmdExt.pRxPayload = optval;
971 Msg.Cmd.Sd = (_u8)sd;
972 Msg.Cmd.Level = (_u8)level;
973 Msg.Cmd.OptionLen = (_u8)(*optlen);
974 Msg.Cmd.OptionName = (_u8)optname;
976 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
978 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
980 *optlen = Msg.Rsp.OptionLen;
985 *optlen = (_u8)CmdExt.ActualRxPayloadLen;
987 return (_i16)Msg.Rsp.Status;
994 #if _SL_INCLUDE_FUNC(sl_Select) 1004 SL_OPCODE_SOCKET_SELECT,
1012 void SL_SOCKET_FD_SET(_i16 fd,
SlFdSet_t *fdset)
1014 fdset->fd_array[0] |= (1<< (fd & SL_BSD_SOCKET_ID_MASK));
1020 void SL_SOCKET_FD_CLR(_i16 fd,
SlFdSet_t *fdset)
1022 fdset->fd_array[0] &= ~(1<< (fd & SL_BSD_SOCKET_ID_MASK));
1028 _i16 SL_SOCKET_FD_ISSET(_i16 fd,
SlFdSet_t *fdset)
1030 if( fdset->fd_array[0] & (1<< (fd & SL_BSD_SOCKET_ID_MASK)) )
1040 void SL_SOCKET_FD_ZERO(
SlFdSet_t *fdset)
1042 fdset->fd_array[0] = 0;
1045 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 1052 #define LOCAL_CTRL_PORT (3632) 1053 #define SL_LOOPBACK_ADDR (0x0100007F) 1054 #define DUMMY_BUF_SIZE (4) 1055 #define CTRL_SOCK_FD (((_u16)(1)) << g_pCB->MultiSelectCB.CtrlSockFD) 1056 #define SELECT_TIMEOUT ((_u16)0) 1057 #define SELECT_NO_TIMEOUT (0xFFFFFFFF) 1081 static inline _u8 CountSetBits(_u16 fdList)
1087 Count += (fdList & ((_u16)1));
1088 fdList = fdList >> 1;
1097 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1099 _SlReturnVal_t RetVal;
1103 _u8 TimeoutEvent = 0;
1104 _u16 SelectEvent = 0;
1105 _u8 PendingSelect = FALSE;
1107 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1109 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1111 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1115 if((CTRL_SOCK_FD == pMsgArgs->ReadFds) && (pMsgArgs->Status != SELECT_TIMEOUT))
1117 RetVal = _SlDrvClearCtrlSocket();
1118 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1119 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1120 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1121 Msg.Cmd.tv_sec = 0xFFFF;
1122 Msg.Cmd.tv_usec = 0xFFFF;
1124 RegIdx = _SlDrvGetNextTimeoutValue();
1126 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rAdded caller: call Select with: Write:%x Sec:%d uSec:%d\n\r",
1127 Msg.Cmd.WriteFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1129 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1131 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1133 SL_DRV_PROTECTION_OBJ_UNLOCK();
1139 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1142 for(RegIdx = 0 ; RegIdx < MAX_CONCURRENT_ACTIONS ; RegIdx++)
1144 if(g_pCB->MultiSelectCB.SelectEntry[RegIdx] != NULL)
1149 TimeoutEvent = ((time_now + 100) >= g_pCB->MultiSelectCB.SelectEntry[RegIdx]->TimeStamp);
1151 if(pMsgArgs->Status != SELECT_TIMEOUT)
1153 SelectEvent = ((g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist & pMsgArgs->ReadFds) ||
1154 (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist & pMsgArgs->WriteFds));
1157 if(SelectEvent || TimeoutEvent)
1162 g_pCB->MultiSelectCB.readsds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1163 g_pCB->MultiSelectCB.writesds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1168 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds = (pMsgArgs->ReadFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1169 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFds = (pMsgArgs->WriteFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1170 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1171 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1172 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount +
1173 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount);
1177 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = SELECT_TIMEOUT;
1180 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds &= ~(CTRL_SOCK_FD);
1183 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->MultiSelectCB.SelectEntry[RegIdx]->ObjIdx].SyncObj);
1186 g_pCB->MultiSelectCB.SelectEntry[RegIdx] = NULL;
1190 PendingSelect = TRUE;
1197 if((pMsgArgs->ReadFds & CTRL_SOCK_FD) && (pMsgArgs->Status != SELECT_TIMEOUT))
1199 RetVal = _SlDrvClearCtrlSocket();
1203 if((0 != g_pCB->MultiSelectCB.readsds) || (0 != g_pCB->MultiSelectCB.writesds) || (TRUE == PendingSelect))
1205 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1206 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1207 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1210 Msg.Cmd.tv_sec = 0xFFFF;
1211 Msg.Cmd.tv_usec = 0xFFFF;
1214 RegIdx = _SlDrvGetNextTimeoutValue();
1216 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRelease Partial: call Select with: Read:%x Sec:%d uSec:%d\n\r",
1217 Msg.Cmd.ReadFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1219 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1223 while(g_pCB->MultiSelectCB.ActiveWaiters)
1225 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1226 g_pCB->MultiSelectCB.ActiveWaiters--;
1229 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1231 SL_TRACE1(DBG_MSG, MSG_312,
"\n\rSelect isn't Active: %d\n\r", g_pCB->MultiSelectCB.ActiveSelect);
1234 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1236 SL_DRV_PROTECTION_OBJ_UNLOCK();
1238 return SL_OS_RET_CODE_OK;
1244 static _i8 _SlDrvGetNextTimeoutValue(
void)
1251 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1254 for(idx = 0 ; idx < MAX_CONCURRENT_ACTIONS ; idx++)
1256 if(NULL != g_pCB->MultiSelectCB.SelectEntry[idx])
1259 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp >= time_now)
1267 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp <= g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp)
1277 if(g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp != SELECT_NO_TIMEOUT)
1279 _i32 delta = (g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp - time_now);
1283 Msg.Cmd.tv_sec = (delta / 1000);
1284 Msg.Cmd.tv_usec = (((delta % 1000) * 1000) >> 10);
1290 Msg.Cmd.tv_usec = 0;
1300 static _i16 _SlDrvClearCtrlSocket(
void)
1302 _SlRecvfromMsg_u Msg;
1304 _u8 dummyBuf[DUMMY_BUF_SIZE];
1305 _SlReturnVal_t RetVal;
1308 _SlDrvResetCmdExt(&CmdExt);
1309 _SlDrvMemZero(&Msg,
sizeof(_SlRecvfromMsg_u));
1311 CmdExt.RxPayloadLen = DUMMY_BUF_SIZE;
1312 CmdExt.pRxPayload = (_u8 *)&dummyBuf;
1314 Msg.Cmd.Sd = (_u8)g_pCB->MultiSelectCB.CtrlSockFD;
1315 Msg.Cmd.StatusOrLen = (_u16)DUMMY_BUF_SIZE;
1316 Msg.Cmd.FamilyAndFlags = (SL_AF_INET << 4);
1318 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
1326 static _i16 _SlDrvOpenCtrlSocket(
void)
1331 if(g_pCB->MultiSelectCB.CtrlSockFD != 0xFF)
1337 retVal =
sl_Socket(SL_AF_INET, SL_SOCK_DGRAM, 0);
1339 if(retVal == SL_ERROR_BSD_ENSOCK)
1349 g_pCB->MultiSelectCB.CtrlSockFD = retVal;
1361 static _i16 _SlDrvCloseCtrlSocket(
void)
1367 sockfd = g_pCB->MultiSelectCB.CtrlSockFD;
1375 g_pCB->MultiSelectCB.CtrlSockFD = 0xFF;
1379 return SL_ERROR_BSD_SOC_ERROR;
1388 static inline _u32 to_mSec(
struct SlTimeval_t* timeout)
1390 return (((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10) + (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000));
1396 static _i16 _SlDrvUnRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _u8 SelectInProgress)
1398 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1401 g_pCB->MultiSelectCB.readsds &= ~(pEntry->readlist);
1402 g_pCB->MultiSelectCB.writesds &= ~(pEntry->writelist);
1405 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = NULL;
1407 if(g_pCB->MultiSelectCB.ActiveSelect == FALSE)
1409 _SlDrvCloseCtrlSocket();
1412 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1415 _SlDrvReleasePoolObj(pEntry->ObjIdx);
1417 return SL_ERROR_BSD_SOC_ERROR;
1423 static _i16 _SlDrvRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _SlSelectMsg_u* pMsg,
struct SlTimeval_t *timeout, _u8 SelectInProgress)
1425 _SlReturnVal_t _RetVal = 0;
1426 _u8 dummyBuf[4] = {0};
1429 pEntry->readlist = pMsg->Cmd.ReadFds;
1430 pEntry->writelist = pMsg->Cmd.WriteFds;
1432 if((pMsg->Cmd.tv_sec != 0xFFFF) && (timeout != NULL))
1434 pEntry->TimeStamp = to_mSec(timeout);
1438 pEntry->TimeStamp = SELECT_NO_TIMEOUT;
1441 g_pCB->MultiSelectCB.readsds |= pMsg->Cmd.ReadFds;
1442 g_pCB->MultiSelectCB.writesds |= pMsg->Cmd.WriteFds;
1443 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = pEntry;
1445 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRegistered: Objidx:%d, sec:%d, usec%d\n\r",
1446 pEntry->ObjIdx, pMsg->Cmd.tv_sec, pMsg->Cmd.tv_usec);
1448 if((!SelectInProgress) || (g_pCB->MultiSelectCB.ActiveSelect == FALSE))
1451 pMsg->Cmd.ReadFds |= CTRL_SOCK_FD;
1453 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1455 _RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, pMsg, NULL);
1457 if((_RetVal == SL_RET_CODE_OK) && (g_pCB->MultiSelectCB.CtrlSockFD != 0xFF))
1460 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1465 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1466 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1468 if (_SlDrvIsSpawnOwnGlobalLock())
1474 _SlInternalSpawnWaitForEvent();
1476 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1485 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1488 _RetVal =
sl_SendTo(g_pCB->MultiSelectCB.CtrlSockFD,
1505 _u8 isCaller = FALSE;
1508 _u8 SelectInProgress = FALSE;
1512 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1513 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1516 Msg.Cmd.Nfds = (_u8)nfds;
1520 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1525 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1530 Msg.Cmd.tv_sec = 0xffff;
1531 Msg.Cmd.tv_usec = 0xffff;
1535 if(0xffff <= timeout->tv_sec)
1537 Msg.Cmd.tv_sec = 0xffff;
1541 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1546 timeout->tv_usec = (timeout->tv_usec >> 10);
1548 if(0xffff <= timeout->tv_usec)
1550 Msg.Cmd.tv_usec = 0xffff;
1554 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1558 while(FALSE == isCaller)
1560 SelectParams.ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&SelectParams.Response, SELECT_ID, SL_MAX_SOCKETS);
1562 if(MAX_CONCURRENT_ACTIONS == SelectParams.ObjIdx)
1564 return SL_POOL_IS_EMPTY;
1567 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1570 if(FALSE == g_pCB->MultiSelectCB.ActiveSelect)
1572 g_pCB->MultiSelectCB.ActiveSelect = TRUE;
1576 SelectInProgress = TRUE;
1579 if(!SelectInProgress)
1581 ret = _SlDrvOpenCtrlSocket();
1585 _SlDrvCloseCtrlSocket();
1586 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1587 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1588 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1597 else if(g_pCB->MultiSelectCB.CtrlSockFD == 0xFF)
1599 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1604 g_pCB->MultiSelectCB.ActiveWaiters++;
1606 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1609 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1610 if (_SlDrvIsSpawnOwnGlobalLock())
1616 _SlInternalSpawnWaitForEvent();
1618 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1627 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1631 if((_i16)g_pCB->MultiSelectCB.SelectCmdResp.status != SL_RET_CODE_OK)
1633 return (_i16)(g_pCB->MultiSelectCB.SelectCmdResp.status);
1636 SelectInProgress = FALSE;
1648 ret = _SlDrvRegisterForSelectAsync(&SelectParams, &Msg, timeout, SelectInProgress);
1652 return (_SlDrvUnRegisterForSelectAsync(&SelectParams, SelectInProgress));
1656 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(SelectParams.ObjIdx, 0, 0));
1657 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1659 ret = (_i16)g_pCB->MultiSelectCB.SelectCmdResp.status;
1661 if(ret == SL_RET_CODE_OK)
1663 ret = (_i16)SelectParams.Response.Status;
1665 if(ret > SELECT_TIMEOUT)
1669 readsds->fd_array[0] = SelectParams.Response.ReadFds;
1674 writesds->fd_array[0] = SelectParams.Response.WriteFds;
1687 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1690 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1694 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1696 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
1698 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSelectAsyncResponse_t));
1700 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1701 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1703 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1706 SockTriggerEvent.Event = SL_SOCKET_TRIGGER_EVENT_SELECT;
1707 SockTriggerEvent.EventData = 0;
1709 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_RESP_RECEIVED;
1711 SL_DRV_PROTECTION_OBJ_UNLOCK();
1714 _SlDrvHandleSocketTriggerEvents(&SockTriggerEvent);
1716 return SL_OS_RET_CODE_OK;
1720 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1727 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1730 SL_DRV_PROTECTION_OBJ_UNLOCK();
1732 return SL_OS_RET_CODE_OK;
1739 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1740 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1741 _u8 IsNonBlocking = FALSE;
1746 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1748 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1749 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1751 if( NULL != timeout )
1754 if ( (0 == timeout->tv_sec) && (0 == timeout->tv_usec) )
1756 IsNonBlocking = TRUE;
1760 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1763 if (g_pCB->SocketTriggerSelect.Info.State > SOCK_TRIGGER_READY)
1765 SL_DRV_PROTECTION_OBJ_UNLOCK();
1766 return SL_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR;
1769 SL_DRV_PROTECTION_OBJ_UNLOCK();
1772 if (IsNonBlocking == TRUE)
1775 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1777 return SL_ERROR_BSD_EAGAIN;
1780 else if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_RESP_RECEIVED)
1782 if( ((_i16)g_pCB->SocketTriggerSelect.Resp.Status) >= 0 )
1786 readsds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.ReadFds;
1790 writesds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.WriteFds;
1795 _SlDrvReleasePoolObj(g_pCB->SocketTriggerSelect.Info.ObjPoolIdx);
1797 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = MAX_CONCURRENT_ACTIONS;
1800 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_READY;
1802 return (_i16)g_pCB->SocketTriggerSelect.Resp.Status;
1809 Msg.Cmd.Nfds = (_u8)nfds;
1810 Msg.Cmd.ReadFdsCount = 0;
1811 Msg.Cmd.WriteFdsCount = 0;
1813 Msg.Cmd.ReadFds = 0;
1814 Msg.Cmd.WriteFds = 0;
1819 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1823 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1825 if( NULL == timeout )
1827 Msg.Cmd.tv_sec = 0xffff;
1828 Msg.Cmd.tv_usec = 0xffff;
1832 if( 0xffff <= timeout->tv_sec )
1834 Msg.Cmd.tv_sec = 0xffff;
1838 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1842 timeout->tv_usec = timeout->tv_usec >> 10;
1844 if( 0xffff <= timeout->tv_usec )
1846 Msg.Cmd.tv_usec = 0xffff;
1850 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1856 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, SELECT_ID, SL_MAX_SOCKETS);
1858 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1860 return SL_POOL_IS_EMPTY;
1864 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1866 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
1868 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
1870 Msg.Rsp.status = (_i16)AsyncRsp.Status;
1874 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1879 if ((IsNonBlocking == TRUE) && (AsyncRsp.Status == 0))
1882 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_WAITING_FOR_RESP;
1884 Msg.Cmd.tv_sec = 0xffff;
1885 Msg.Cmd.tv_usec = 0xffff;
1888 _SlDrvReleasePoolObj(ObjIdx);
1891 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&g_pCB->SocketTriggerSelect.Resp, SELECT_ID, SL_MAX_SOCKETS);
1893 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1895 return SL_POOL_IS_EMPTY;
1899 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = ObjIdx;
1902 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1903 return SL_ERROR_BSD_EAGAIN;
1909 if( ((_i16)Msg.Rsp.status) >= 0 )
1913 readsds->fd_array[0] = AsyncRsp.ReadFds;
1917 writesds->fd_array[0] = AsyncRsp.WriteFds;
1922 _SlDrvReleasePoolObj(ObjIdx);
1923 return (_i16)Msg.Rsp.status;
1932 #if _SL_INCLUDE_FUNC(sl_StartTLS) 1935 _SlReturnVal_t RetVal;
1938 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1942 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1945 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, START_TLS_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
1947 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1949 return SL_POOL_IS_EMPTY;
1953 RetVal = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_STARTTLS, &tempValue,
sizeof(tempValue));
1955 if(SL_RET_CODE_OK == RetVal)
1958 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
1960 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
1966 if ( (SL_SSL_NOTIFICATION_CONNECTED_SECURED == AsyncRsp.Type) && (AsyncRsp.Val >= 0) )
1968 RetVal = SL_RET_CODE_OK;
1972 RetVal = AsyncRsp.Val;
1976 _SlDrvReleasePoolObj(ObjIdx);
1983 _SlReturnVal_t _SlSocketHandleAsync_StartTLS(
void *pVoidBuf)
1987 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1989 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
1990 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
1992 ((
SlSocketAsyncEvent_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
1993 ((
SlSocketAsyncEvent_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Type = pMsgArgs->Type;
1994 ((
SlSocketAsyncEvent_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Val = pMsgArgs->Val;
1996 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1997 SL_DRV_PROTECTION_OBJ_UNLOCK();
1999 return SL_OS_RET_CODE_OK;
_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...
_u32 slcb_GetTimestamp(void)
Get the timer counter value (timestamp). The timer must count from zero to its MAX value...
_i16 sl_StartTLS(_i16 sd)
Initiate TLS connection on a socket.
_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.