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));
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 RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_LONG, SL_OPCODE_SOCKET_SOCKETCLOSEASYNCEVENT);
216 RetVal = AsyncRsp.StatusOrLen;
220 _SlDrvReleasePoolObj(ObjIdx);
236 #if _SL_INCLUDE_FUNC(sl_Bind) 239 _SlSockBindMsg_u Msg;
244 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
246 switch(addr->sa_family)
249 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
252 #ifdef SL_SUPPORT_IPV6 254 CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
260 return SL_RET_CODE_INVALID_INPUT;
263 Msg.Cmd.IpV4.LenOrPadding = 0;
264 Msg.Cmd.IpV4.Sd = (_u8)sd;
266 _SlSocketBuildAddress(addr, &Msg.Cmd);
267 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
269 return Msg.Rsp.StatusOrLen;
282 #if _SL_INCLUDE_FUNC(sl_SendTo) 292 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
294 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
296 return SL_ERROR_BSD_SOC_ERROR;
307 _SlDrvResetCmdExt(&CmdExt);
308 CmdExt.TxPayload1Len = (_u16)Len;
309 CmdExt.pTxPayload1 = (_u8 *)pBuf;
311 switch(to->sa_family)
314 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
317 #ifdef SL_SUPPORT_IPV6 319 CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO_V6;
325 return SL_RET_CODE_INVALID_INPUT;
328 Msg.Cmd.IpV4.LenOrPadding = Len;
329 Msg.Cmd.IpV4.Sd = (_u8)sd;
330 _SlSocketBuildAddress(to, &Msg.Cmd);
331 Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
333 RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
334 if(SL_OS_RET_CODE_OK != RetVal)
354 SL_OPCODE_SOCKET_RECVFROM,
359 #if _SL_INCLUDE_FUNC(sl_RecvFrom) 362 _SlRecvfromMsg_u Msg;
368 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
371 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
373 return SL_ERROR_BSD_SOC_ERROR;
376 _SlDrvResetCmdExt(&CmdExt);
377 CmdExt.RxPayloadLen = Len;
378 CmdExt.pRxPayload = (_u8 *)buf;
380 Msg.Cmd.Sd = (_u8)sd;
381 Msg.Cmd.StatusOrLen = (_u16)Len;
384 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
386 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
390 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
394 Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
398 return SL_RET_CODE_INVALID_INPUT;
401 RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
402 if( RetVal != SL_OS_RET_CODE_OK )
407 RetVal = Msg.Rsp.IpV4.StatusOrLen;
411 VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.Sd);
413 _SlSocketParseAddress(&Msg.Rsp, from, fromlen);
415 from->sa_family = Msg.Rsp.IpV4.Family;
416 if(SL_AF_INET == from->sa_family)
422 #ifdef SL_SUPPORT_IPV6 423 else if(SL_AF_INET6 == from->sa_family)
428 sl_Memcpy(((
SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.Address, 16);
446 }_SlSockConnectMsg_u;
448 #if _SL_INCLUDE_FUNC(sl_Connect) 451 _SlSockConnectMsg_u Msg;
452 _SlReturnVal_t RetVal;
455 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
459 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
462 switch(addr->sa_family)
465 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
469 #ifdef SL_SUPPORT_IPV6 471 CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
477 return SL_RET_CODE_INVALID_INPUT;
480 Msg.Cmd.IpV4.LenOrPadding = 0;
481 Msg.Cmd.IpV4.Sd = (_u8)sd;
483 _SlSocketBuildAddress(addr, &Msg.Cmd);
485 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
493 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
494 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
496 RetVal = Msg.Rsp.StatusOrLen;
499 if(SL_RET_CODE_OK == RetVal)
502 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
504 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_CONNECTASYNCRESPONSE);
509 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0);
512 RetVal = AsyncRsp.StatusOrLen;
516 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
520 _SlDrvReleasePoolObj(ObjIdx);
538 _SlReturnVal_t _SlSocketHandleAsync_Connect(
void *pVoidBuf)
542 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
544 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
545 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
547 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
548 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
550 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
551 SL_DRV_PROTECTION_OBJ_UNLOCK();
553 return SL_OS_RET_CODE_OK;
559 _SlReturnVal_t _SlSocketHandleAsync_Close(
void *pVoidBuf)
563 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
565 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
566 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
568 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->Sd = pMsgArgs->Sd;
569 ((
SlSocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->StatusOrLen = pMsgArgs->StatusOrLen;
571 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
572 SL_DRV_PROTECTION_OBJ_UNLOCK();
574 return SL_OS_RET_CODE_OK;
588 SL_OPCODE_SOCKET_SEND,
593 #if _SL_INCLUDE_FUNC(sl_Send) 594 _i16
sl_Send(_i16 sd,
const void *pBuf, _i16 Len, _i16 flags)
603 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
605 _SlDrvResetCmdExt(&CmdExt);
606 CmdExt.TxPayload1Len = (_u16)Len;
607 CmdExt.pTxPayload1 = (_u8 *)pBuf;
610 if ((sd & SL_SOCKET_PAYLOAD_TYPE_MASK) == SL_SOCKET_PAYLOAD_TYPE_RAW_TRANCEIVER)
612 tempVal = (_u32)flags;
613 CmdExt.pRxPayload = (_u8 *)&tempVal;
614 CmdExt.RxPayloadLen = -4;
618 CmdExt.pRxPayload = NULL;
626 Msg.Cmd.StatusOrLen = Len;
627 Msg.Cmd.Sd = (_u8)sd;
628 Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
630 RetVal = _SlDrvDataWriteOp((_u8)sd, (
_SlCmdCtrl_t *)&_SlSendCmdCtrl, &Msg, &CmdExt);
631 if(SL_OS_RET_CODE_OK != RetVal)
649 #if _SL_INCLUDE_FUNC(sl_Listen) 653 SL_OPCODE_SOCKET_LISTEN,
664 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
666 Msg.Cmd.Sd = (_u8)sd;
667 Msg.Cmd.Backlog = (_u8)backlog;
669 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
670 return (_i16)Msg.Rsp.status;
683 #if _SL_INCLUDE_FUNC(sl_Accept) 687 SL_OPCODE_SOCKET_ACCEPT,
694 _SlSockAcceptMsg_u Msg;
695 _SlReturnVal_t RetVal;
699 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
703 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
705 Msg.Cmd.Sd = (_u8)sd;
707 if((addr != NULL) && (addrlen != NULL))
710 Msg.Cmd.Family = (_u8)((
sizeof(
SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6);
715 Msg.Cmd.Family = (_u8)0;
718 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, ACCEPT_ID, (_u8)sd & SL_BSD_SOCKET_ID_MASK);
726 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
727 VERIFY_PROTOCOL(Msg.Rsp.Sd == (_u8)sd);
729 RetVal = Msg.Rsp.StatusOrLen;
731 if(SL_OS_RET_CODE_OK == RetVal)
734 if( g_pCB->SocketNonBlocking & (1<<(sd & SL_BSD_SOCKET_ID_MASK) ))
736 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx, SL_DRIVER_TIMEOUT_SHORT, SL_OPCODE_SOCKET_ACCEPTASYNCRESPONSE);
741 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
744 RetVal = AsyncRsp.IpV4.StatusOrLen;
748 VERIFY_PROTOCOL(AsyncRsp.IpV4.Sd == (_u8)sd);
753 _SlSocketParseAddress(&AsyncRsp, addr, addrlen);
755 if((addr != NULL) && (addrlen != NULL))
757 addr->sa_family = AsyncRsp.IpV4.Family;
759 if(SL_AF_INET == addr->sa_family)
764 ((
SlSockAddrIn_t *)addr)->sin_addr.s_addr = AsyncRsp.IpV4.Address;
771 #ifdef SL_SUPPORT_IPV6 772 else if(SL_AF_INET6 == addr->sa_family)
777 sl_Memcpy(((
SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.Address, 16);
789 _SlDrvReleasePoolObj(ObjIdx);
812 p[0] = ((_i8* )&val)[3];
813 p[1] = ((_i8* )&val)[2];
814 p[2] = ((_i8* )&val)[1];
815 p[3] = ((_i8* )&val)[0];
833 p[0] = ((_i8* )&val)[1];
834 p[1] = ((_i8* )&val)[0];
846 _SlReturnVal_t _SlSocketHandleAsync_Accept(
void *pVoidBuf)
850 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
852 VERIFY_PROTOCOL(( pMsgArgs->IpV4.Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
853 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
855 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSocketAddrResponse_u));
856 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
858 SL_DRV_PROTECTION_OBJ_UNLOCK();
860 return SL_OS_RET_CODE_OK;
872 #if _SL_INCLUDE_FUNC(sl_Recv) 876 SL_OPCODE_SOCKET_RECV,
881 _i16
sl_Recv(_i16 sd,
void *pBuf, _i16 Len, _i16 flags)
885 _SlReturnVal_t status;
889 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
891 _SlDrvResetCmdExt(&CmdExt);
892 CmdExt.RxPayloadLen = Len;
893 CmdExt.pRxPayload = (_u8 *)pBuf;
895 Msg.Cmd.Sd = (_u8)sd;
896 Msg.Cmd.StatusOrLen = (_u16)Len;
899 CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
901 Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
903 status = _SlDrvDataReadOp((_SlSd_t)sd, (
_SlCmdCtrl_t *)&_SlRecvCmdCtrl, &Msg, &CmdExt);
904 if( status != SL_OS_RET_CODE_OK )
911 return (_i16)Msg.Rsp.StatusOrLen;
926 SL_OPCODE_SOCKET_SETSOCKOPT,
931 #if _SL_INCLUDE_FUNC(sl_SetSockOpt) 932 _i16 sl_SetSockOpt(_i16 sd, _i16 level, _i16 optname,
const void *optval, SlSocklen_t optlen)
934 _SlSetSockOptMsg_u Msg;
939 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
941 _SlDrvResetCmdExt(&CmdExt);
942 CmdExt.TxPayload1Len = optlen;
943 CmdExt.pTxPayload1 = (_u8 *)optval;
945 Msg.Cmd.Sd = (_u8)sd;
946 Msg.Cmd.Level = (_u8)level;
947 Msg.Cmd.OptionLen = (_u8)optlen;
948 Msg.Cmd.OptionName = (_u8)optname;
950 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
952 return (_i16)Msg.Rsp.StatusOrLen;
966 #if _SL_INCLUDE_FUNC(sl_GetSockOpt) 970 SL_OPCODE_SOCKET_GETSOCKOPT,
975 _i16
sl_GetSockOpt(_i16 sd, _i16 level, _i16 optname,
void *optval, SlSocklen_t *optlen)
977 _SlGetSockOptMsg_u Msg;
982 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
988 _SlDrvResetCmdExt(&CmdExt);
989 CmdExt.RxPayloadLen = (_i16)(*optlen);
990 CmdExt.pRxPayload = optval;
992 Msg.Cmd.Sd = (_u8)sd;
993 Msg.Cmd.Level = (_u8)level;
994 Msg.Cmd.OptionLen = (_u8)(*optlen);
995 Msg.Cmd.OptionName = (_u8)optname;
997 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
999 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
1001 *optlen = Msg.Rsp.OptionLen;
1002 return SL_ESMALLBUF;
1006 *optlen = (_u8)CmdExt.ActualRxPayloadLen;
1008 return (_i16)Msg.Rsp.Status;
1015 #if _SL_INCLUDE_FUNC(sl_Select) 1025 SL_OPCODE_SOCKET_SELECT,
1033 void SL_SOCKET_FD_SET(_i16 fd,
SlFdSet_t *fdset)
1035 fdset->fd_array[0] |= (1<< (fd & SL_BSD_SOCKET_ID_MASK));
1041 void SL_SOCKET_FD_CLR(_i16 fd,
SlFdSet_t *fdset)
1043 fdset->fd_array[0] &= ~(1<< (fd & SL_BSD_SOCKET_ID_MASK));
1049 _i16 SL_SOCKET_FD_ISSET(_i16 fd,
SlFdSet_t *fdset)
1051 if( fdset->fd_array[0] & (1<< (fd & SL_BSD_SOCKET_ID_MASK)) )
1061 void SL_SOCKET_FD_ZERO(
SlFdSet_t *fdset)
1063 fdset->fd_array[0] = 0;
1066 #if (defined(SL_PLATFORM_MULTI_THREADED) && !defined(slcb_SocketTriggerEventHandler)) 1073 #define LOCAL_CTRL_PORT (3632) 1074 #define SL_LOOPBACK_ADDR (0x0100007F) 1075 #define DUMMY_BUF_SIZE (4) 1076 #define CTRL_SOCK_FD (((_u16)(1)) << g_pCB->MultiSelectCB.CtrlSockFD) 1077 #define SELECT_TIMEOUT ((_u16)0) 1078 #define SELECT_NO_TIMEOUT (0xFFFFFFFF) 1102 static inline _u8 CountSetBits(_u16 fdList)
1108 Count += (fdList & ((_u16)1));
1109 fdList = fdList >> 1;
1118 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1120 _SlReturnVal_t RetVal;
1124 _u8 TimeoutEvent = 0;
1125 _u16 SelectEvent = 0;
1126 _u8 PendingSelect = FALSE;
1128 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1130 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1132 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1136 if((CTRL_SOCK_FD == pMsgArgs->ReadFds) && (pMsgArgs->Status != SELECT_TIMEOUT))
1138 RetVal = _SlDrvClearCtrlSocket();
1139 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1140 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1141 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1142 Msg.Cmd.tv_sec = 0xFFFF;
1143 Msg.Cmd.tv_usec = 0xFFFF;
1145 RegIdx = _SlDrvGetNextTimeoutValue();
1147 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rAdded caller: call Select with: Write:%x Sec:%d uSec:%d\n\r",
1148 Msg.Cmd.WriteFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1150 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1152 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1154 SL_DRV_PROTECTION_OBJ_UNLOCK();
1160 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1163 for(RegIdx = 0 ; RegIdx < MAX_CONCURRENT_ACTIONS ; RegIdx++)
1165 if(g_pCB->MultiSelectCB.SelectEntry[RegIdx] != NULL)
1170 TimeoutEvent = ((time_now + 100) >= g_pCB->MultiSelectCB.SelectEntry[RegIdx]->TimeStamp);
1172 if(pMsgArgs->Status != SELECT_TIMEOUT)
1174 SelectEvent = ((g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist & pMsgArgs->ReadFds) ||
1175 (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist & pMsgArgs->WriteFds));
1178 if(SelectEvent || TimeoutEvent)
1183 g_pCB->MultiSelectCB.readsds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1184 g_pCB->MultiSelectCB.writesds &= ~(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1189 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds = (pMsgArgs->ReadFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1190 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFds = (pMsgArgs->WriteFds & g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1191 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->readlist);
1192 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount = CountSetBits(g_pCB->MultiSelectCB.SelectEntry[RegIdx]->writelist);
1193 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = (g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFdsCount +
1194 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.WriteFdsCount);
1198 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.Status = SELECT_TIMEOUT;
1201 g_pCB->MultiSelectCB.SelectEntry[RegIdx]->Response.ReadFds &= ~(CTRL_SOCK_FD);
1204 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->MultiSelectCB.SelectEntry[RegIdx]->ObjIdx].SyncObj);
1207 g_pCB->MultiSelectCB.SelectEntry[RegIdx] = NULL;
1211 PendingSelect = TRUE;
1218 if((pMsgArgs->ReadFds & CTRL_SOCK_FD) && (pMsgArgs->Status != SELECT_TIMEOUT))
1220 RetVal = _SlDrvClearCtrlSocket();
1224 if((0 != g_pCB->MultiSelectCB.readsds) || (0 != g_pCB->MultiSelectCB.writesds) || (TRUE == PendingSelect))
1226 Msg.Cmd.ReadFds = g_pCB->MultiSelectCB.readsds;
1227 Msg.Cmd.ReadFds |= CTRL_SOCK_FD;
1228 Msg.Cmd.WriteFds = g_pCB->MultiSelectCB.writesds;
1231 Msg.Cmd.tv_sec = 0xFFFF;
1232 Msg.Cmd.tv_usec = 0xFFFF;
1235 RegIdx = _SlDrvGetNextTimeoutValue();
1237 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRelease Partial: call Select with: Read:%x Sec:%d uSec:%d\n\r",
1238 Msg.Cmd.ReadFds, Msg.Cmd.tv_sec, Msg.Cmd.tv_usec);
1240 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL);
1244 while(g_pCB->MultiSelectCB.ActiveWaiters)
1246 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1247 g_pCB->MultiSelectCB.ActiveWaiters--;
1250 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1252 SL_TRACE1(DBG_MSG, MSG_312,
"\n\rSelect isn't Active: %d\n\r", g_pCB->MultiSelectCB.ActiveSelect);
1255 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1257 SL_DRV_PROTECTION_OBJ_UNLOCK();
1259 return SL_OS_RET_CODE_OK;
1265 static _i8 _SlDrvGetNextTimeoutValue(
void)
1272 time_now = ((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10);
1275 for(idx = 0 ; idx < MAX_CONCURRENT_ACTIONS ; idx++)
1277 if(NULL != g_pCB->MultiSelectCB.SelectEntry[idx])
1280 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp >= time_now)
1288 if(g_pCB->MultiSelectCB.SelectEntry[idx]->TimeStamp <= g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp)
1300 if(g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp != SELECT_NO_TIMEOUT)
1302 _i32 delta = (g_pCB->MultiSelectCB.SelectEntry[Found]->TimeStamp - time_now);
1306 Msg.Cmd.tv_sec = (delta / 1000);
1307 Msg.Cmd.tv_usec = (((delta % 1000) * 1000) >> 10);
1313 Msg.Cmd.tv_usec = 0;
1324 static _i16 _SlDrvClearCtrlSocket(
void)
1326 _SlRecvfromMsg_u Msg;
1328 _u8 dummyBuf[DUMMY_BUF_SIZE];
1329 _SlReturnVal_t RetVal;
1332 _SlDrvResetCmdExt(&CmdExt);
1333 _SlDrvMemZero(&Msg,
sizeof(_SlRecvfromMsg_u));
1335 CmdExt.RxPayloadLen = DUMMY_BUF_SIZE;
1336 CmdExt.pRxPayload = (_u8 *)&dummyBuf;
1338 Msg.Cmd.Sd = (_u8)g_pCB->MultiSelectCB.CtrlSockFD;
1339 Msg.Cmd.StatusOrLen = (_u16)DUMMY_BUF_SIZE;
1340 Msg.Cmd.FamilyAndFlags = (SL_AF_INET << 4);
1342 RetVal = _SlDrvCmdSend_noWait((
_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
1350 static _i16 _SlDrvOpenCtrlSocket(
void)
1355 if(g_pCB->MultiSelectCB.CtrlSockFD != 0xFF)
1361 retVal =
sl_Socket(SL_AF_INET, SL_SOCK_DGRAM, 0);
1363 if(retVal == SL_ERROR_BSD_ENSOCK)
1373 g_pCB->MultiSelectCB.CtrlSockFD = retVal;
1385 static _i16 _SlDrvCloseCtrlSocket(
void)
1391 sockfd = g_pCB->MultiSelectCB.CtrlSockFD;
1399 g_pCB->MultiSelectCB.CtrlSockFD = 0xFF;
1403 return SL_ERROR_BSD_SOC_ERROR;
1412 static inline _u32 to_mSec(
struct SlTimeval_t* timeout)
1414 return (((
slcb_GetTimestamp() / SL_TIMESTAMP_TICKS_IN_10_MILLISECONDS) * 10) + (timeout->tv_sec * 1000) + (timeout->tv_usec / 1000));
1420 static _i16 _SlDrvUnRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _u8 SelectInProgress)
1422 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1425 g_pCB->MultiSelectCB.readsds &= ~(pEntry->readlist);
1426 g_pCB->MultiSelectCB.writesds &= ~(pEntry->writelist);
1429 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = NULL;
1431 if(g_pCB->MultiSelectCB.ActiveSelect == FALSE)
1433 _SlDrvCloseCtrlSocket();
1436 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1439 _SlDrvReleasePoolObj(pEntry->ObjIdx);
1441 return SL_ERROR_BSD_SOC_ERROR;
1447 static _i16 _SlDrvRegisterForSelectAsync(
_SlSelectEntry_t* pEntry, _SlSelectMsg_u* pMsg,
struct SlTimeval_t *timeout, _u8 SelectInProgress)
1449 _SlReturnVal_t _RetVal = 0;
1450 _u8 dummyBuf[4] = {0};
1453 pEntry->readlist = pMsg->Cmd.ReadFds;
1454 pEntry->writelist = pMsg->Cmd.WriteFds;
1456 if((pMsg->Cmd.tv_sec != 0xFFFF) && (timeout != NULL))
1458 pEntry->TimeStamp = to_mSec(timeout);
1462 pEntry->TimeStamp = SELECT_NO_TIMEOUT;
1465 g_pCB->MultiSelectCB.readsds |= pMsg->Cmd.ReadFds;
1466 g_pCB->MultiSelectCB.writesds |= pMsg->Cmd.WriteFds;
1467 g_pCB->MultiSelectCB.SelectEntry[pEntry->ObjIdx] = pEntry;
1469 SL_TRACE3(DBG_MSG, MSG_312,
"\n\rRegistered: Objidx:%d, sec:%d, usec%d\n\r",
1470 pEntry->ObjIdx, pMsg->Cmd.tv_sec, pMsg->Cmd.tv_usec);
1472 if((!SelectInProgress) || (g_pCB->MultiSelectCB.ActiveSelect == FALSE))
1475 pMsg->Cmd.ReadFds |= CTRL_SOCK_FD;
1477 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1479 _RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, pMsg, NULL);
1481 if((_RetVal == SL_RET_CODE_OK) && (g_pCB->MultiSelectCB.CtrlSockFD != 0xFF))
1484 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->MultiSelectCB.SelectSyncObj);
1489 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1490 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1492 if (_SlDrvIsSpawnOwnGlobalLock())
1498 _SlInternalSpawnWaitForEvent();
1500 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1509 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1512 _RetVal =
sl_SendTo(g_pCB->MultiSelectCB.CtrlSockFD,
1529 _u8 isCaller = FALSE;
1532 _u8 SelectInProgress = FALSE;
1536 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1537 _SlDrvMemZero(&Msg,
sizeof(_SlSelectMsg_u));
1540 Msg.Cmd.Nfds = (_u8)nfds;
1544 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1549 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1554 Msg.Cmd.tv_sec = 0xffff;
1555 Msg.Cmd.tv_usec = 0xffff;
1559 if(0xffff <= timeout->tv_sec)
1561 Msg.Cmd.tv_sec = 0xffff;
1565 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1568 if(0xffff <= (timeout->tv_usec >> 10))
1570 Msg.Cmd.tv_usec = 0xffff;
1576 Msg.Cmd.tv_usec = (_u16)(timeout->tv_usec >> 10);
1580 while(FALSE == isCaller)
1582 SelectParams.ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&SelectParams.Response, SELECT_ID, SL_MAX_SOCKETS);
1584 if (SelectParams.ObjIdx < 0)
1586 return SelectParams.ObjIdx;
1589 SL_DRV_OBJ_LOCK_FOREVER(&g_pCB->MultiSelectCB.SelectLockObj);
1592 if(FALSE == g_pCB->MultiSelectCB.ActiveSelect)
1594 g_pCB->MultiSelectCB.ActiveSelect = TRUE;
1598 SelectInProgress = TRUE;
1601 if(!SelectInProgress)
1603 ret = _SlDrvOpenCtrlSocket();
1607 _SlDrvCloseCtrlSocket();
1608 g_pCB->MultiSelectCB.ActiveSelect = FALSE;
1609 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1610 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1619 else if(g_pCB->MultiSelectCB.CtrlSockFD == 0xFF)
1621 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1626 g_pCB->MultiSelectCB.ActiveWaiters++;
1628 SL_DRV_OBJ_UNLOCK(&g_pCB->MultiSelectCB.SelectLockObj);
1631 #if (defined (SL_PLATFORM_MULTI_THREADED)) && (!defined (SL_PLATFORM_EXTERNAL_SPAWN)) 1632 if (_SlDrvIsSpawnOwnGlobalLock())
1638 _SlInternalSpawnWaitForEvent();
1640 if (0 == sl_SyncObjWait(&g_pCB->MultiSelectCB.SelectSyncObj, SL_OS_NO_WAIT))
1649 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->MultiSelectCB.SelectSyncObj);
1653 if((_i16)g_pCB->MultiSelectCB.SelectCmdResp.status != SL_RET_CODE_OK)
1655 return (_i16)(g_pCB->MultiSelectCB.SelectCmdResp.status);
1658 SelectInProgress = FALSE;
1670 ret = _SlDrvRegisterForSelectAsync(&SelectParams, &Msg, timeout, SelectInProgress);
1674 return (_SlDrvUnRegisterForSelectAsync(&SelectParams, SelectInProgress));
1678 ret = _SlDrvWaitForInternalAsyncEvent(SelectParams.ObjIdx, 0, 0);
1680 _SlDrvReleasePoolObj(SelectParams.ObjIdx);
1686 ret = (_i16)g_pCB->MultiSelectCB.SelectCmdResp.status;
1688 if(ret == SL_RET_CODE_OK)
1690 ret = (_i16)SelectParams.Response.Status;
1692 if(ret > SELECT_TIMEOUT)
1696 readsds->fd_array[0] = SelectParams.Response.ReadFds;
1701 writesds->fd_array[0] = SelectParams.Response.WriteFds;
1714 _SlReturnVal_t _SlSocketHandleAsync_Select(
void *pVoidBuf)
1717 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1721 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1723 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
1725 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlSelectAsyncResponse_t));
1727 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1728 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1730 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1733 SockTriggerEvent.Event = SL_SOCKET_TRIGGER_EVENT_SELECT;
1734 SockTriggerEvent.EventData = 0;
1736 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_RESP_RECEIVED;
1738 SL_DRV_PROTECTION_OBJ_UNLOCK();
1741 _SlDrvHandleSocketTriggerEvents(&SockTriggerEvent);
1743 return SL_OS_RET_CODE_OK;
1747 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1754 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1757 SL_DRV_PROTECTION_OBJ_UNLOCK();
1759 return SL_OS_RET_CODE_OK;
1766 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1768 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1769 _u8 IsNonBlocking = FALSE;
1774 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1776 #if ((defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_SocketTriggerEventHandler))) 1777 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1779 if( NULL != timeout )
1782 if ( (0 == timeout->tv_sec) && (0 == timeout->tv_usec) )
1784 IsNonBlocking = TRUE;
1788 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
1791 if (g_pCB->SocketTriggerSelect.Info.State > SOCK_TRIGGER_READY)
1793 SL_DRV_PROTECTION_OBJ_UNLOCK();
1794 return SL_RET_CODE_SOCKET_SELECT_IN_PROGRESS_ERROR;
1797 SL_DRV_PROTECTION_OBJ_UNLOCK();
1800 if (IsNonBlocking == TRUE)
1803 if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_WAITING_FOR_RESP)
1805 return SL_ERROR_BSD_EAGAIN;
1808 else if (g_pCB->SocketTriggerSelect.Info.State == SOCK_TRIGGER_RESP_RECEIVED)
1810 if( ((_i16)g_pCB->SocketTriggerSelect.Resp.Status) >= 0 )
1814 readsds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.ReadFds;
1818 writesds->fd_array[0] = g_pCB->SocketTriggerSelect.Resp.WriteFds;
1823 _SlDrvReleasePoolObj(g_pCB->SocketTriggerSelect.Info.ObjPoolIdx);
1825 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = MAX_CONCURRENT_ACTIONS;
1828 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_READY;
1830 return (_i16)g_pCB->SocketTriggerSelect.Resp.Status;
1837 Msg.Cmd.Nfds = (_u8)nfds;
1838 Msg.Cmd.ReadFdsCount = 0;
1839 Msg.Cmd.WriteFdsCount = 0;
1841 Msg.Cmd.ReadFds = 0;
1842 Msg.Cmd.WriteFds = 0;
1847 Msg.Cmd.ReadFds = (_u16)readsds->fd_array[0];
1851 Msg.Cmd.WriteFds = (_u16)writesds->fd_array[0];
1853 if( NULL == timeout )
1855 Msg.Cmd.tv_sec = 0xffff;
1856 Msg.Cmd.tv_usec = 0xffff;
1860 if( 0xffff <= timeout->tv_sec )
1862 Msg.Cmd.tv_sec = 0xffff;
1866 Msg.Cmd.tv_sec = (_u16)timeout->tv_sec;
1870 timeout->tv_usec = timeout->tv_usec >> 10;
1872 if( 0xffff <= timeout->tv_usec )
1874 Msg.Cmd.tv_usec = 0xffff;
1878 Msg.Cmd.tv_usec = (_u16)timeout->tv_usec;
1884 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, SELECT_ID, SL_MAX_SOCKETS);
1892 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1894 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
1896 ret = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
1898 Msg.Rsp.status = (_i16)AsyncRsp.Status;
1902 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_SOCKET_TRIGGER))
1907 if ((IsNonBlocking == TRUE) && (AsyncRsp.Status == 0))
1910 g_pCB->SocketTriggerSelect.Info.State = SOCK_TRIGGER_WAITING_FOR_RESP;
1912 Msg.Cmd.tv_sec = 0xffff;
1913 Msg.Cmd.tv_usec = 0xffff;
1916 _SlDrvReleasePoolObj(ObjIdx);
1924 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&g_pCB->SocketTriggerSelect.Resp, SELECT_ID, SL_MAX_SOCKETS);
1926 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1928 return SL_POOL_IS_EMPTY;
1932 g_pCB->SocketTriggerSelect.Info.ObjPoolIdx = ObjIdx;
1935 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlSelectCmdCtrl, &Msg, NULL));
1936 return SL_ERROR_BSD_EAGAIN;
1942 if( ((_i16)Msg.Rsp.status) >= 0 )
1946 readsds->fd_array[0] = AsyncRsp.ReadFds;
1950 writesds->fd_array[0] = AsyncRsp.WriteFds;
1955 _SlDrvReleasePoolObj(ObjIdx);
1962 return (_i16)Msg.Rsp.status;
1971 #if _SL_INCLUDE_FUNC(sl_StartTLS) 1974 _SlReturnVal_t RetVal;
1977 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1985 VERIFY_API_ALLOWED(SL_OPCODE_SILO_SOCKET);
1989 for (ActionIndex = 0; ActionIndex < MAX_CONCURRENT_ACTIONS; ++ActionIndex)
1991 if(((g_pCB->ObjPool[ActionIndex].AdditionalData & 0x0F) == sd) && ((g_pCB->ObjPool[ActionIndex].ActionID) == START_TLS_ID))
1993 return SL_RET_CODE_STARTTLS_IN_PROGRESS_ON_THIS_SD;
1998 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, START_TLS_ID, (_u8)(sd & SL_BSD_SOCKET_ID_MASK));
2005 startTLS.event = (
void *)_SlSocketHandleAsync_StartTLS;
2006 sl_RegisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);
2009 RetVal = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_STARTTLS, &tempValue,
sizeof(tempValue));
2011 if(SL_RET_CODE_OK == RetVal)
2014 ret_pool = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
2016 VERIFY_PROTOCOL(AsyncRsp.Sd == (_u8)sd);
2018 RetVal = AsyncRsp.Val;
2021 ret = sl_UnregisterLibsEventHandler(SL_EVENT_HDL_SOCKET, &startTLS);
2022 _SlDrvReleasePoolObj(ObjIdx);
2039 _SlReturnVal_t _SlSocketHandleAsync_StartTLS(
void *pVoidBuf)
2045 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
2047 VERIFY_PROTOCOL((pMsgArgs->Sd & SL_BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
2050 for (ActionIndex = 0; ActionIndex < MAX_CONCURRENT_ACTIONS; ++ActionIndex)
2052 if((g_pCB->ObjPool[ActionIndex].AdditionalData & 0x0F) == pMsgArgs->Sd && ((g_pCB->ObjPool[ActionIndex].ActionID) == START_TLS_ID))
2058 if(ActionIndex == MAX_CONCURRENT_ACTIONS)
2060 return EVENT_PROPAGATION_CONTINUE;
2063 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[ActionIndex].pRespArgs);
2070 SL_DRV_PROTECTION_OBJ_UNLOCK();
2071 if ((SL_SSL_NOTIFICATION_HANDSHAKE_FAILED == pMsgArgs->Type || SL_SSL_NOTIFICATION_CONNECTED_SECURED == pMsgArgs->Type))
2073 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[ActionIndex].SyncObj);
2074 return EVENT_PROPAGATION_BLOCK;
2078 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.