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> 44 #include <ti/drivers/net/wifi/eventreg.h> 47 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf);
48 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf);
51 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf);
52 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf);
53 _SlReturnVal_t _SlSocketHandleAsync_StartTLS(
void *pVoidBuf);
55 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 56 static _i16 _SlDrvClearCtrlSocket(
void);
57 static _i8 _SlDrvGetNextTimeoutValue(
void);
74 pCmd->IpV4.FamilyAndFlags = (_u8)((addr->sa_family << 4) & 0xF0);
77 if(SL_AF_INET == addr->sa_family)
81 #ifdef SL_SUPPORT_IPV6 84 sl_Memcpy(pCmd->IpV6.Address, ((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, 16 );
97 addr->sa_family = pRsp->IpV4.Family;
102 if(SL_AF_INET == addr->sa_family)
106 #ifdef SL_SUPPORT_IPV6 109 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, pRsp->IpV6.Address, 16);
124 #if _SL_INCLUDE_FUNC(sl_Socket) 128 SL_OPCODE_SOCKET_SOCKET,
135 _SlSockSocketMsg_u Msg;
137 Msg.Cmd.Domain = (_u8)Domain;
138 Msg.Cmd.Type = (_u8)Type;
139 Msg.Cmd.Protocol = (_u8)Protocol;
143 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
145 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockSocketCmdCtrl, &Msg, NULL));
147 if( Msg.Rsp.StatusOrLen < 0 )
149 return ( Msg.Rsp.StatusOrLen);
153 return (_i16)((_u8)Msg.Rsp.Sd);
167 #if _SL_INCLUDE_FUNC(sl_Close) 171 SL_OPCODE_SOCKET_CLOSE,
178 _SlSockCloseMsg_u Msg;
179 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
181 _SlReturnVal_t RetVal;
182 _u8 bSocketInAction = FALSE;
186 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
188 Msg.Cmd.Sd = (_u8)sd;
192 bSocketInAction = !!(g_pCB->ActiveActionsBitmap & (1<<sd));
194 if (bSocketInAction == FALSE)
196 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CLOSE_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
198 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
200 return SL_POOL_IS_EMPTY;
204 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
206 RetVal = Msg.Rsp.StatusOrLen;
208 if (bSocketInAction == FALSE)
210 if( SL_RET_CODE_OK == RetVal)
212 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_LONG, SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT));
214 RetVal = AsyncRsp.StatusOrLen;
217 _SlDrvReleasePoolObj(ObjIdx);
233 #if _SL_INCLUDE_FUNC(sl_Bind) 236 _SlSockBindMsg_u Msg;
241 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
243 switch(addr->sa_family)
246 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
249 #ifdef SL_SUPPORT_IPV6 251 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
257 return SL_RET_CODE_INVALID_INPUT;
260 Msg.Cmd.IpV4.LenOrPadding = 0;
261 Msg.Cmd.IpV4.Sd = (_u8)sd;
263 _SlSocketBuildAddress(addr, &Msg.Cmd);
264 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
266 return Msg.Rsp.StatusOrLen;
279 #if _SL_INCLUDE_FUNC(sl_SendTo) 289 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
291 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
293 return SL_ERROR_BSD_SOC_ERROR;
304 _SlDrvResetCmdExt(&CmdExt);
305 CmdExt.TxPayload1Len = (_u16)Len;
306 CmdExt.pTxPayload1 = (_u8 *)pBuf;
308 switch(to->sa_family)
311 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
314 #ifdef SL_SUPPORT_IPV6 316 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_V6;
322 return SL_RET_CODE_INVALID_INPUT;
325 Msg.Cmd.IpV4.LenOrPadding = Len;
326 Msg.Cmd.IpV4.Sd = (_u8)sd;
327 _SlSocketBuildAddress(to, &Msg.Cmd);
328 Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
330 RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
331 if(SL_OS_RET_CODE_OK != RetVal)
351 SL_OPCODE_SOCKET_RECVFROM,
356 #if _SL_INCLUDE_FUNC(sl_RecvFrom) 359 _SlRecvfromMsg_u Msg;
365 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
368 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
370 return SL_ERROR_BSD_SOC_ERROR;
373 _SlDrvResetCmdExt(&CmdExt);
374 CmdExt.RxPayloadLen = Len;
375 CmdExt.pRxPayload = (_u8 *)buf;
377 Msg.Cmd.Sd = (_u8)sd;
378 Msg.Cmd.StatusOrLen = (_u16)Len;
381 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
383 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
387 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
391 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
395 return SL_RET_CODE_INVALID_INPUT;
398 RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
399 if( RetVal != SL_OS_RET_CODE_OK )
404 RetVal = Msg.Rsp.IpV4.StatusOrLen;
408 VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.Sd);
410 _SlSocketParseAddress(&Msg.Rsp, from, fromlen);
412 from->sa_family = Msg.Rsp.IpV4.Family;
413 if(SL_AF_INET == from->sa_family)
419 #ifdef SL_SUPPORT_IPV6 420 else if(SL_AF_INET6 == from->sa_family)
425 sl_Memcpy(((
SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.Address, 16);
443 }_SlSockConnectMsg_u;
445 #if _SL_INCLUDE_FUNC(sl_Connect) 448 _SlSockConnectMsg_u Msg;
449 _SlReturnVal_t RetVal;
452 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
456 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
459 switch(addr->sa_family)
462 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
466 #ifdef SL_SUPPORT_IPV6 468 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
474 return SL_RET_CODE_INVALID_INPUT;
477 Msg.Cmd.IpV4.LenOrPadding = 0;
478 Msg.Cmd.IpV4.Sd = (_u8)sd;
480 _SlSocketBuildAddress(addr, &Msg.Cmd);
482 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
484 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
486 return SL_POOL_IS_EMPTY;
490 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
491 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
493 RetVal = Msg.Rsp.StatusOrLen;
495 if(SL_RET_CODE_OK == RetVal)
498 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
500 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE));
506 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0));
509 RetVal = AsyncRsp.StatusOrLen;
513 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
517 _SlDrvReleasePoolObj(ObjIdx);
527 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf)
531 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
533 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
534 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
536 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
537 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
539 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
540 SL_DRV_PROTECTION_OBJ_UNLOCK();
542 return SL_OS_RET_CODE_OK;
548 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf)
552 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
554 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
555 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
557 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
558 ((
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;
577 SL_OPCODE_SOCKET_SEND,
582 #if _SL_INCLUDE_FUNC(sl_Send) 583 _i16
sl_Send(_i16 sd,
const void *pBuf, _i16 Len, _i16 flags)
592 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
594 _SlDrvResetCmdExt(&CmdExt);
595 CmdExt.TxPayload1Len = (_u16)Len;
596 CmdExt.pTxPayload1 = (_u8 *)pBuf;
599 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
601 tempVal = (_u32)flags;
602 CmdExt.pRxPayload = (_u8 *)&tempVal;
603 CmdExt.RxPayloadLen = -4;
607 CmdExt.pRxPayload = NULL;
615 Msg.Cmd.StatusOrLen = Len;
616 Msg.Cmd.Sd = (_u8)sd;
617 Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
619 RetVal = _SlDrvDataWriteOp((_u8)sd, (
_SlCmdCtrl_t *)&_SlSendCmdCtrl, &Msg, &CmdExt);
620 if(SL_OS_RET_CODE_OK != RetVal)
638 #if _SL_INCLUDE_FUNC(sl_Listen) 642 SL_OPCODE_SOCKET_LISTEN,
653 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
655 Msg.Cmd.Sd = (_u8)sd;
656 Msg.Cmd.Backlog = (_u8)backlog;
658 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
659 return (_i16)Msg.Rsp.status;
672 #if _SL_INCLUDE_FUNC(sl_Accept) 676 SL_OPCODE_SOCKET_ACCEPT,
683 _SlSockAcceptMsg_u Msg;
684 _SlReturnVal_t RetVal;
687 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
691 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
693 Msg.Cmd.Sd = (_u8)sd;
695 if((addr != NULL) && (addrlen != NULL))
698 Msg.Cmd.Family = (_u8)((
sizeof(
SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6);
703 Msg.Cmd.Family = (_u8)0;
706 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID, (_u8)sd & SL_BSD_SOCKET_ID_MASK);
708 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
710 return SL_POOL_IS_EMPTY;
714 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
715 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
717 RetVal = Msg.Rsp.StatusOrLen;
719 if(SL_OS_RET_CODE_OK == RetVal)
722 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
724 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE));
729 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
732 RetVal = AsyncRsp.IpV4.StatusOrLen;
736 VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
741 _SlSocketParseAddress(&AsyncRsp, addr, addrlen);
743 if((addr != NULL) && (addrlen != NULL))
745 addr->sa_family = AsyncRsp.IpV4.Family;
747 if(SL_AF_INET == addr->sa_family)
752 ((
SlSockAddrIn_t *)addr)->sin_addr.s_addr = AsyncRsp.IpV4.Address;
759 #ifdef SL_SUPPORT_IPV6 760 else if(SL_AF_INET6 == addr->sa_family)
765 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.Address, 16);
777 _SlDrvReleasePoolObj(ObjIdx);
792 p[0] = ((_i8* )&val)[3];
793 p[1] = ((_i8* )&val)[2];
794 p[2] = ((_i8* )&val)[1];
795 p[3] = ((_i8* )&val)[0];
813 p[0] = ((_i8* )&val)[1];
814 p[1] = ((_i8* )&val)[0];
826 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf)
830 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
832 VERIFY_PROTOCOL(( pMsgArgs->IpV4.Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
833 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
835 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSocketAddrResponse_u));
836 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
838 SL_DRV_PROTECTION_OBJ_UNLOCK();
840 return SL_OS_RET_CODE_OK;
852 #if _SL_INCLUDE_FUNC(sl_Recv) 856 SL_OPCODE_SOCKET_RECV,
861 _i16
sl_Recv(_i16 sd,
void *pBuf, _i16 Len, _i16 flags)
865 _SlReturnVal_t status;
869 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
871 _SlDrvResetCmdExt(&CmdExt);
872 CmdExt.RxPayloadLen = Len;
873 CmdExt.pRxPayload = (_u8 *)pBuf;
875 Msg.Cmd.Sd = (_u8)sd;
876 Msg.Cmd.StatusOrLen = (_u16)Len;
879 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
881 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
883 status = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvCmdCtrl, &Msg, &CmdExt);
884 if( status != SL_OS_RET_CODE_OK )
891 return (_i16)Msg.Rsp.StatusOrLen;
906 SL_OPCODE_SOCKET_SETSOCKOPT,
911 #if _SL_INCLUDE_FUNC(sl_SetSockOpt) 912 _i16 sl_SetSockOpt(_i16 sd, _i16 level, _i16 optname,
const void *optval, SlSocklen_t optlen)
914 _SlSetSockOptMsg_u Msg;
919 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
921 _SlDrvResetCmdExt(&CmdExt);
922 CmdExt.TxPayload1Len = optlen;
923 CmdExt.pTxPayload1 = (_u8 *)optval;
925 Msg.Cmd.Sd = (_u8)sd;
926 Msg.Cmd.Level = (_u8)level;
927 Msg.Cmd.OptionLen = (_u8)optlen;
928 Msg.Cmd.OptionName = (_u8)optname;
930 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
932 return (_i16)Msg.Rsp.StatusOrLen;
946 #if _SL_INCLUDE_FUNC(sl_GetSockOpt) 950 SL_OPCODE_SOCKET_GETSOCKOPT,
955 _i16
sl_GetSockOpt(_i16 sd, _i16 level, _i16 optname,
void *optval, SlSocklen_t *optlen)
957 _SlGetSockOptMsg_u Msg;
962 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
968 _SlDrvResetCmdExt(&CmdExt);
969 CmdExt.RxPayloadLen = (_i16)(*optlen);
970 CmdExt.pRxPayload = optval;
972 Msg.Cmd.Sd = (_u8)sd;
973 Msg.Cmd.Level = (_u8)level;
974 Msg.Cmd.OptionLen = (_u8)(*optlen);
975 Msg.Cmd.OptionName = (_u8)optname;
977 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
979 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
981 *optlen = Msg.Rsp.OptionLen;
986 *optlen = (_u8)CmdExt.ActualRxPayloadLen;
988 return (_i16)Msg.Rsp.Status;
995 #if _SL_INCLUDE_FUNC(sl_Select) 1005 SL_OPCODE_SOCKET_SELECT,
1013 void SL_SOCKET_FD_SET(_i16 fd,
SlFdSet_t *fdset)
1015 fdset->fd_array[0] |= (1<< (fd & SL_BSD_SOCKET_ID_MASK));
1021 void SL_SOCKET_FD_CLR(_i16 fd,
SlFdSet_t *fdset)
1023 fdset->fd_array[0] &= ~(1<< (fd & SL_BSD_SOCKET_ID_MASK));
1029 _i16 SL_SOCKET_FD_ISSET(_i16 fd,
SlFdSet_t *fdset)
1031 if( fdset->fd_array[0] & (1<< (fd & SL_BSD_SOCKET_ID_MASK)) )
1041 void SL_SOCKET_FD_ZERO(
SlFdSet_t *fdset)
1043 fdset->fd_array[0] = 0;
1046 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 1053 #define LOCAL_CTRL_PORT (3632) 1054 #define SL_LOOPBACK_ADDR (0x0100007F) 1055 #define DUMMY_BUF_SIZE (4) 1056 #define CTRL_SOCK_FD (((_u16)(1)) << g_pCB->MultiSelectCB.CtrlSockFD) 1057 #define SELECT_TIMEOUT ((_u16)0) 1058 #define SELECT_NO_TIMEOUT (0xFFFFFFFF) 1082 static inline _u8 CountSetBits(_u16 fdList)
1088 Count += (fdList & ((_u16)1));
1089 fdList = fdList >> 1;
1098 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1100 _SlReturnVal_t RetVal;
1104 _u8 TimeoutEvent = 0;
1105 _u16 SelectEvent = 0;
1106 _u8 PendingSelect = FALSE;
1108 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1110 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1112 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1116 if((CTRL_SOCK_FD == pMsgArgs->ReadFds) && (pMsgArgs->Status != SELECT_TIMEOUT))
1118 RetVal = _SlDrvClearCtrlSocket();
1119 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1120 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1121 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1122 Msg.Cmd.tv_sec = 0xFFFF;
1123 Msg.Cmd.tv_usec = 0xFFFF;
1125 RegIdx = _SlDrvGetNextTimeoutValue();
1127 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rAdded caller: call Select with: Write:%x Sec:%d uSec:%d\n\r",
1128 Msg.Cmd.WriteFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1130 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1132 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1134 SL_DRV_PROTECTION_OBJ_UNLOCK();
1140 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1143 for(RegIdx = 0 ; RegIdx < MAX_CONCURRENT_ACTIONS ; RegIdx++)
1145 if(g_pCB->MultiSelectCB.SelectEntry[RegIdx] != NULL)
1150 TimeoutEvent = ((time_now + 100) >= g_pCB->MultiSelectCB.SelectEntry[RegIdx]->TimeStamp);
1152 if(pMsgArgs->Status != SELECT_TIMEOUT)
1154 SelectEvent = ((g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist & pMsgArgs->ReadFds) ||
1155 (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist & pMsgArgs->WriteFds));
1158 if(SelectEvent || TimeoutEvent)
1163 g_pCB->MultiSelectCB.readsds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1164 g_pCB->MultiSelectCB.writesds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1169 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds = (pMsgArgs->ReadFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1170 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFds = (pMsgArgs->WriteFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1171 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1172 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1173 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount +
1174 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount);
1178 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = SELECT_TIMEOUT;
1181 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds &= ~(CTRL_SOCK_FD);
1184 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->MultiSelectCB.SelectEntry[RegIdx]->ObjIdx].SyncObj);
1187 g_pCB->MultiSelectCB.SelectEntry[RegIdx] = NULL;
1191 PendingSelect = TRUE;
1198 if((pMsgArgs->ReadFds & CTRL_SOCK_FD) && (pMsgArgs->Status != SELECT_TIMEOUT))
1200 RetVal = _SlDrvClearCtrlSocket();
1204 if((0 != g_pCB->MultiSelectCB.readsds) || (0 != g_pCB->MultiSelectCB.writesds) || (TRUE == PendingSelect))
1206 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1207 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1208 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1211 Msg.Cmd.tv_sec = 0xFFFF;
1212 Msg.Cmd.tv_usec = 0xFFFF;
1215 RegIdx = _SlDrvGetNextTimeoutValue();
1217 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRelease Partial: call Select with: Read:%x Sec:%d uSec:%d\n\r",
1218 Msg.Cmd.ReadFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1220 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1224 while(g_pCB->MultiSelectCB.ActiveWaiters)
1226 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1227 g_pCB->MultiSelectCB.ActiveWaiters--;
1230 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1232 SL_TRACE1(DBG_MSG, MSG_312,
"\n\rSelect isn't Active: %d\n\r", g_pCB->MultiSelectCB.ActiveSelect);
1235 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1237 SL_DRV_PROTECTION_OBJ_UNLOCK();
1239 return SL_OS_RET_CODE_OK;
1245 static _i8 _SlDrvGetNextTimeoutValue(
void)
1252 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1255 for(idx = 0 ; idx < MAX_CONCURRENT_ACTIONS ; idx++)
1257 if(NULL != g_pCB->MultiSelectCB.SelectEntry[idx])
1260 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp >= time_now)
1268 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp <= g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp)
1278 if(g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp != SELECT_NO_TIMEOUT)
1280 _i32 delta = (g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp - time_now);
1284 Msg.Cmd.tv_sec = (delta / 1000);
1285 Msg.Cmd.tv_usec = (((delta % 1000) * 1000) >> 10);
1291 Msg.Cmd.tv_usec = 0;
1301 static _i16 _SlDrvClearCtrlSocket(
void)
1303 _SlRecvfromMsg_u Msg;
1305 _u8 dummyBuf[DUMMY_BUF_SIZE];
1306 _SlReturnVal_t RetVal;
1309 _SlDrvResetCmdExt(&CmdExt);
1310 _SlDrvMemZero(&Msg,
sizeof(_SlRecvfromMsg_u));
1312 CmdExt.RxPayloadLen = DUMMY_BUF_SIZE;
1313 CmdExt.pRxPayload = (_u8 *)&dummyBuf;
1315 Msg.Cmd.Sd = (_u8)g_pCB->MultiSelectCB.CtrlSockFD;
1316 Msg.Cmd.StatusOrLen = (_u16)DUMMY_BUF_SIZE;
1317 Msg.Cmd.FamilyAndFlags = (SL_AF_INET << 4);
1319 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
1327 static _i16 _SlDrvOpenCtrlSocket(
void)
1332 if(g_pCB->MultiSelectCB.CtrlSockFD != 0xFF)
1338 retVal =
sl_Socket(SL_AF_INET, SL_SOCK_DGRAM, 0);
1340 if(retVal == SL_ERROR_BSD_ENSOCK)
1350 g_pCB->MultiSelectCB.CtrlSockFD = retVal;
1362 static _i16 _SlDrvCloseCtrlSocket(
void)
1368 sockfd = g_pCB->MultiSelectCB.CtrlSockFD;
1376 g_pCB->MultiSelectCB.CtrlSockFD = 0xFF;
1380 return SL_ERROR_BSD_SOC_ERROR;
1389 static inline _u32 to_mSec(
struct SlTimeval_t* timeout)
1391 return (((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10) + (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000));
1397 static _i16 _SlDrvUnRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _u8 SelectInProgress)
1399 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1402 g_pCB->MultiSelectCB.readsds &= ~(pEntry->readlist);
1403 g_pCB->MultiSelectCB.writesds &= ~(pEntry->writelist);
1406 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = NULL;
1408 if(g_pCB->MultiSelectCB.ActiveSelect == FALSE)
1410 _SlDrvCloseCtrlSocket();
1413 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1416 _SlDrvReleasePoolObj(pEntry->ObjIdx);
1418 return SL_ERROR_BSD_SOC_ERROR;
1424 static _i16 _SlDrvRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _SlSelectMsg_u* pMsg,
struct SlTimeval_t *timeout, _u8 SelectInProgress)
1426 _SlReturnVal_t _RetVal = 0;
1427 _u8 dummyBuf[4] = {0};
1430 pEntry->readlist = pMsg->Cmd.ReadFds;
1431 pEntry->writelist = pMsg->Cmd.WriteFds;
1433 if((pMsg->Cmd.tv_sec != 0xFFFF) && (timeout != NULL))
1435 pEntry->TimeStamp = to_mSec(timeout);
1439 pEntry->TimeStamp = SELECT_NO_TIMEOUT;
1442 g_pCB->MultiSelectCB.readsds |= pMsg->Cmd.ReadFds;
1443 g_pCB->MultiSelectCB.writesds |= pMsg->Cmd.WriteFds;
1444 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = pEntry;
1446 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRegistered: Objidx:%d, sec:%d, usec%d\n\r",
1447 pEntry->ObjIdx, pMsg->Cmd.tv_sec, pMsg->Cmd.tv_usec);
1449 if((!SelectInProgress) || (g_pCB->MultiSelectCB.ActiveSelect == FALSE))
1452 pMsg->Cmd.ReadFds |= CTRL_SOCK_FD;
1454 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1456 _RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, pMsg, NULL);
1458 if((_RetVal == SL_RET_CODE_OK) && (g_pCB->MultiSelectCB.CtrlSockFD != 0xFF))
1461 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1466 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1467 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1469 if (_SlDrvIsSpawnOwnGlobalLock())
1475 _SlInternalSpawnWaitForEvent();
1477 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1486 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1489 _RetVal =
sl_SendTo(g_pCB->MultiSelectCB.CtrlSockFD,
1506 _u8 isCaller = FALSE;
1509 _u8 SelectInProgress = FALSE;
1513 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1514 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1517 Msg.Cmd.Nfds = (_u8)nfds;
1521 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1526 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1531 Msg.Cmd.tv_sec = 0xffff;
1532 Msg.Cmd.tv_usec = 0xffff;
1536 if(0xffff <= timeout->tv_sec)
1538 Msg.Cmd.tv_sec = 0xffff;
1542 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1547 timeout->tv_usec = (timeout->tv_usec >> 10);
1549 if(0xffff <= timeout->tv_usec)
1551 Msg.Cmd.tv_usec = 0xffff;
1555 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1559 while(FALSE == isCaller)
1561 SelectParams.ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&SelectParams.Response, SELECT_ID, SL_MAX_SOCKETS);
1563 if(MAX_CONCURRENT_ACTIONS == SelectParams.ObjIdx)
1565 return SL_POOL_IS_EMPTY;
1568 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1571 if(FALSE == g_pCB->MultiSelectCB.ActiveSelect)
1573 g_pCB->MultiSelectCB.ActiveSelect = TRUE;
1577 SelectInProgress = TRUE;
1580 if(!SelectInProgress)
1582 ret = _SlDrvOpenCtrlSocket();
1586 _SlDrvCloseCtrlSocket();
1587 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1588 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1589 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1598 else if(g_pCB->MultiSelectCB.CtrlSockFD == 0xFF)
1600 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1605 g_pCB->MultiSelectCB.ActiveWaiters++;
1607 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1610 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1611 if (_SlDrvIsSpawnOwnGlobalLock())
1617 _SlInternalSpawnWaitForEvent();
1619 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1628 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1632 if((_i16)g_pCB->MultiSelectCB.SelectCmdResp.status != SL_RET_CODE_OK)
1634 return (_i16)(g_pCB->MultiSelectCB.SelectCmdResp.status);
1637 SelectInProgress = FALSE;
1649 ret = _SlDrvRegisterForSelectAsync(&SelectParams, &Msg, timeout, SelectInProgress);
1653 return (_SlDrvUnRegisterForSelectAsync(&SelectParams, SelectInProgress));
1657 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(SelectParams.ObjIdx, 0, 0));
1658 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1660 ret = (_i16)g_pCB->MultiSelectCB.SelectCmdResp.status;
1662 if(ret == SL_RET_CODE_OK)
1664 ret = (_i16)SelectParams.Response.Status;
1666 if(ret > SELECT_TIMEOUT)
1670 readsds->fd_array[0] = SelectParams.Response.ReadFds;
1675 writesds->fd_array[0] = SelectParams.Response.WriteFds;
1688 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1691 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1695 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1697 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
1699 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSelectAsyncResponse_t));
1701 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1702 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1704 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1707 SockTriggerEvent.Event = SL_SOCKET_TRIGGER_EVENT_SELECT;
1708 SockTriggerEvent.EventData = 0;
1710 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_RESP_RECEIVED;
1712 SL_DRV_PROTECTION_OBJ_UNLOCK();
1715 _SlDrvHandleSocketTriggerEvents(&SockTriggerEvent);
1717 return SL_OS_RET_CODE_OK;
1721 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1728 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1731 SL_DRV_PROTECTION_OBJ_UNLOCK();
1733 return SL_OS_RET_CODE_OK;
1740 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1741 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1742 _u8 IsNonBlocking = FALSE;
1747 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1749 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1750 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1752 if( NULL != timeout )
1755 if ( (0 == timeout->tv_sec) && (0 == timeout->tv_usec) )
1757 IsNonBlocking = TRUE;
1761 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1764 if (g_pCB->SocketTriggerSelect.Info.State > SOCK_TRIGGER_READY)
1766 SL_DRV_PROTECTION_OBJ_UNLOCK();
1767 return SL_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR;
1770 SL_DRV_PROTECTION_OBJ_UNLOCK();
1773 if (IsNonBlocking == TRUE)
1776 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1778 return SL_ERROR_BSD_EAGAIN;
1781 else if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_RESP_RECEIVED)
1783 if( ((_i16)g_pCB->SocketTriggerSelect.Resp.Status) >= 0 )
1787 readsds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.ReadFds;
1791 writesds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.WriteFds;
1796 _SlDrvReleasePoolObj(g_pCB->SocketTriggerSelect.Info.ObjPoolIdx);
1798 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = MAX_CONCURRENT_ACTIONS;
1801 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_READY;
1803 return (_i16)g_pCB->SocketTriggerSelect.Resp.Status;
1810 Msg.Cmd.Nfds = (_u8)nfds;
1811 Msg.Cmd.ReadFdsCount = 0;
1812 Msg.Cmd.WriteFdsCount = 0;
1814 Msg.Cmd.ReadFds = 0;
1815 Msg.Cmd.WriteFds = 0;
1820 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1824 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1826 if( NULL == timeout )
1828 Msg.Cmd.tv_sec = 0xffff;
1829 Msg.Cmd.tv_usec = 0xffff;
1833 if( 0xffff <= timeout->tv_sec )
1835 Msg.Cmd.tv_sec = 0xffff;
1839 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1843 timeout->tv_usec = timeout->tv_usec >> 10;
1845 if( 0xffff <= timeout->tv_usec )
1847 Msg.Cmd.tv_usec = 0xffff;
1851 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1857 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, SELECT_ID, SL_MAX_SOCKETS);
1859 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1861 return SL_POOL_IS_EMPTY;
1865 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1867 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
1869 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
1871 Msg.Rsp.status = (_i16)AsyncRsp.Status;
1875 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1880 if ((IsNonBlocking == TRUE) && (AsyncRsp.Status == 0))
1883 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_WAITING_FOR_RESP;
1885 Msg.Cmd.tv_sec = 0xffff;
1886 Msg.Cmd.tv_usec = 0xffff;
1889 _SlDrvReleasePoolObj(ObjIdx);
1892 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&g_pCB->SocketTriggerSelect.Resp, SELECT_ID, SL_MAX_SOCKETS);
1894 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1896 return SL_POOL_IS_EMPTY;
1900 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = ObjIdx;
1903 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1904 return SL_ERROR_BSD_EAGAIN;
1910 if( ((_i16)Msg.Rsp.status) >= 0 )
1914 readsds->fd_array[0] = AsyncRsp.ReadFds;
1918 writesds->fd_array[0] = AsyncRsp.WriteFds;
1923 _SlDrvReleasePoolObj(ObjIdx);
1924 return (_i16)Msg.Rsp.status;
1933 #if _SL_INCLUDE_FUNC(sl_StartTLS) 1936 _SlReturnVal_t RetVal;
1939 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1946 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1950 for (ActionIndex = 0; ActionIndex < MAX_CONCURRENT_ACTIONS; ++ActionIndex)
1952 if(((g_pCB->ObjPool[ActionIndex].AdditionalData & 0x0F) == sd) && ((g_pCB->ObjPool[ActionIndex].ActionID) == START_TLS_ID))
1954 return SL_RET_CODE_STARTTLS_IN_PROGRESS_ON_THIS_SD;
1959 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, START_TLS_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
1961 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1963 return SL_POOL_IS_EMPTY;
1966 startTLS.event = (
void *)_SlSocketHandleAsync_StartTLS;
1967 sl_RegisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);
1970 RetVal = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_STARTTLS, &tempValue,
sizeof(tempValue));
1972 if(SL_RET_CODE_OK == RetVal)
1975 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
1976 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
1978 RetVal = AsyncRsp.Val;
1980 ret = sl_UnregisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);
1985 _SlDrvReleasePoolObj(ObjIdx);
1992 _SlReturnVal_t _SlSocketHandleAsync_StartTLS(
void *pVoidBuf)
1998 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
2000 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
2003 for (ActionIndex = 0; ActionIndex < MAX_CONCURRENT_ACTIONS; ++ActionIndex)
2005 if((g_pCB->ObjPool[ActionIndex].AdditionalData & 0x0F) == pMsgArgs->Sd && ((g_pCB->ObjPool[ActionIndex].ActionID) == START_TLS_ID))
2011 if(ActionIndex == MAX_CONCURRENT_ACTIONS)
2013 return EVENT_PROPAGATION_CONTINUE;
2016 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[ActionIndex].pRespArgs);
2023 SL_DRV_PROTECTION_OBJ_UNLOCK();
2024 if ((SL_SSL_NOTIFICATION_HANDSHAKE_FAILED == pMsgArgs->Type || SL_SSL_NOTIFICATION_CONNECTED_SECURED == pMsgArgs->Type))
2026 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[ActionIndex].SyncObj);
2027 return EVENT_PROPAGATION_BLOCK;
2031 return EVENT_PROPAGATION_CONTINUE;
_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.