/******************************************************************************
_SlDrvDeviceEventHandler - handles internally device async events
******************************************************************************/
void _SlDrvDeviceEventHandler(void *pArgs)
{
_SlResponseHeader_t *pHdr = (_SlResponseHeader_t *)pArgs;
switch(pHdr->GenHeader.Opcode)
{
case SL_OPCODE_DEVICE_INITCOMPLETE:
_sl_HandleAsync_InitComplete(pHdr);
break;
case SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE:
_sl_HandleAsync_Stop(pHdr);
break;
case SL_OPCODE_DEVICE_DEVICEASYNCFATALERROR:
#ifdef sl_GeneralEvtHdlr
{
_BasicResponse_t *pMsgArgs = (_BasicResponse_t *)_SL_RESP_ARGS_START(pHdr);
SlDeviceEvent_t devHandler;
devHandler.EventData.deviceEvent.status = pMsgArgs->status & 0xFF;
devHandler.EventData.deviceEvent.sender = (pMsgArgs->status >> 8) & 0xFF;
sl_GeneralEvtHdlr(&devHandler);
}
#endif
break;
default:
SL_ERROR_TRACE2(MSG_306, "ASSERT: _SlDrvDeviceEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
VERIFY_PROTOCOL(0);
}
}
void _sl_HandleAsync_Accept(void *pVoidBuf)
{
_SocketAddrResponse_u *pMsgArgs = (_SocketAddrResponse_u *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL(( pMsgArgs->IpV4.sd & BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,sizeof(_SocketAddrResponse_u));
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
void _sl_HandleAsync_Connect(void *pVoidBuf)
{
_SocketResponse_t *pMsgArgs = (_SocketResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL((pMsgArgs->sd & BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
((_SocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->sd = pMsgArgs->sd;
((_SocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->statusOrLen = pMsgArgs->statusOrLen;
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
int sl_Accept(int sd, SlSockAddr_t *addr, SlSocklen_t *addrlen)
{
_SlSockAcceptMsg_u Msg;
_SlReturnVal_t RetVal;
_SocketAddrResponse_u AsyncRsp;
UINT8 pObjIdx = MAX_CONCURRENT_ACTIONS;
Msg.Cmd.sd = sd;
Msg.Cmd.family = (sizeof(SlSockAddrIn_t) == *addrlen) ? SL_AF_INET : SL_AF_INET6;
/* Use Obj to issue the command, if not available try later */
pObjIdx = _SlDrvWaitForPoolObj(ACCEPT_ID, sd & BSD_SOCKET_ID_MASK);
if (MAX_CONCURRENT_ACTIONS == pObjIdx)
{
return SL_POOL_IS_EMPTY;
}
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
g_pCB->ObjPool[pObjIdx].pRespArgs = (UINT8 *)&AsyncRsp;
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
/* send the command */
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlAcceptCmdCtrl, &Msg, NULL));
VERIFY_PROTOCOL(Msg.Rsp.sd == sd);
RetVal = Msg.Rsp.statusOrLen;
if(SL_OS_RET_CODE_OK == RetVal)
{
/* wait for async and get Data Read parameters */
OSI_RET_OK_CHECK(sl_SyncObjWait(&g_pCB->ObjPool[pObjIdx].SyncObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL(AsyncRsp.IpV4.sd == sd);
RetVal = AsyncRsp.IpV4.statusOrLen;
if( (NULL != addr) && (NULL != addrlen) )
{
#if 0 /* Kept for backup */
_sl_ParseAddress(&AsyncRsp, addr, addrlen);
#else
addr->sa_family = AsyncRsp.IpV4.family;
if(SL_AF_INET == addr->sa_family)
{
if( *addrlen == sizeof( SlSockAddrIn_t ) )
{
((SlSockAddrIn_t *)addr)->sin_port = AsyncRsp.IpV4.port;
((SlSockAddrIn_t *)addr)->sin_addr.s_addr = AsyncRsp.IpV4.address;
}
else
{
*addrlen = 0;
}
}
else if (SL_AF_INET6_EUI_48 == addr->sa_family )
{
if( *addrlen == sizeof( SlSockAddrIn6_t ) )
{
((SlSockAddrIn6_t *)addr)->sin6_port = AsyncRsp.IpV6EUI48.port ;
/* will be called from here and from _sl_BuildAddress*/
sl_Memcpy(((SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u8, AsyncRsp.IpV6EUI48.address, 6);
}
else
{
*addrlen = 0;
}
}
#ifdef SL_SUPPORT_IPV6
else
{
if( *addrlen == sizeof( sockaddr_in6 ) )
{
((sockaddr_in6 *)addr)->sin6_port = AsyncRsp.IpV6.port ;
sl_Memcpy(((sockaddr_in6 *)addr)->sin6_addr._S6_un._S6_u32, AsyncRsp.IpV6.address, 16);
}
else
{
*addrlen = 0;
}
}
#endif
#endif
}
}
_SlDrvReleasePoolObj(pObjIdx);
return (int)RetVal;
}
int sl_Connect(int sd, const SlSockAddr_t *addr, int addrlen)
{
_SlSockConnectMsg_u Msg;
_SlReturnVal_t RetVal;
_SlCmdCtrl_t CmdCtrl = {0, 0, sizeof(_SocketResponse_t)};
_SocketResponse_t AsyncRsp;
UINT8 pObjIdx = MAX_CONCURRENT_ACTIONS;
switch(addr->sa_family)
{
case SL_AF_INET :
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
CmdCtrl.TxDescLen = sizeof(_SocketAddrIPv4Command_t);
break;
case SL_AF_INET6_EUI_48:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
CmdCtrl.TxDescLen = sizeof(_SocketAddrIPv6EUI48Command_t);
break;
#ifdef SL_SUPPORT_IPV6
case AF_INET6:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
CmdCtrl.TxDescLen = sizeof(_SocketAddrIPv6Command_t);
break;
#endif
case SL_AF_RF :
default:
return SL_RET_CODE_INVALID_INPUT;
}
Msg.Cmd.IpV4.lenOrPadding = 0;
Msg.Cmd.IpV4.sd = sd;
_sl_BuildAddress(addr, addrlen, &Msg.Cmd);
/* Use Obj to issue the command, if not available try later */
pObjIdx = _SlDrvWaitForPoolObj(CONNECT_ID, sd & BSD_SOCKET_ID_MASK);
if (MAX_CONCURRENT_ACTIONS == pObjIdx)
{
return SL_POOL_IS_EMPTY;
}
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
g_pCB->ObjPool[pObjIdx].pRespArgs = (UINT8 *)&AsyncRsp;
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
/* send the command */
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
VERIFY_PROTOCOL(Msg.Rsp.sd == sd)
RetVal = Msg.Rsp.statusOrLen;
if(SL_RET_CODE_OK == RetVal)
{
/* wait for async and get Data Read parameters */
OSI_RET_OK_CHECK(sl_SyncObjWait(&g_pCB->ObjPool[pObjIdx].SyncObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL(AsyncRsp.sd == sd);
RetVal = AsyncRsp.statusOrLen;
}
_SlDrvReleasePoolObj(pObjIdx);
return RetVal;
}
int sl_RecvFrom(int sd, void *buf, int Len, int flags, SlSockAddr_t *from, SlSocklen_t *fromlen)
{
_SlRecvfromMsg_u Msg;
_SlCmdExt_t CmdExt;
int RetVal;
CmdExt.TxPayloadLen = 0;
CmdExt.RxPayloadLen = Len;
CmdExt.pTxPayload = NULL;
CmdExt.pRxPayload = (UINT8 *)buf;
Msg.Cmd.sd = sd;
Msg.Cmd.StatusOrLen = Len;
/* no size truncation in recv path */
CmdExt.RxPayloadLen = Msg.Cmd.StatusOrLen;
if(sizeof(SlSockAddrIn_t) == *fromlen)
{
Msg.Cmd.FamilyAndFlags = SL_AF_INET;
}
else if (sizeof(SlSockAddrIn6_t) == *fromlen)
{
Msg.Cmd.FamilyAndFlags = SL_AF_INET6;
}
else
{
return SL_RET_CODE_INVALID_INPUT;
}
Msg.Cmd.FamilyAndFlags = (Msg.Cmd.FamilyAndFlags << 4) & 0xF0;
Msg.Cmd.FamilyAndFlags |= flags & 0x0F;
RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
if( RetVal != SL_OS_RET_CODE_OK )
{
return RetVal;
}
RetVal = Msg.Rsp.IpV4.statusOrLen;
if(RetVal >= 0)
{
VERIFY_PROTOCOL(sd == Msg.Rsp.IpV4.sd);
#if 0
_sl_ParseAddress(&Msg.Rsp, from, fromlen);
#else
from->sa_family = Msg.Rsp.IpV4.family;
if(SL_AF_INET == from->sa_family)
{
((SlSockAddrIn_t *)from)->sin_port = Msg.Rsp.IpV4.port;
((SlSockAddrIn_t *)from)->sin_addr.s_addr = Msg.Rsp.IpV4.address;
*fromlen = sizeof(SlSockAddrIn_t);
}
else if (SL_AF_INET6_EUI_48 == from->sa_family )
{
((SlSockAddrIn6_t *)from)->sin6_port = Msg.Rsp.IpV6EUI48.port;
sl_Memcpy(((SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u8, Msg.Rsp.IpV6EUI48.address, 6);
}
#ifdef SL_SUPPORT_IPV6
else if(AF_INET6 == from->sa_family)
{
VERIFY_PROTOCOL(*fromlen >= sizeof(sockaddr_in6));
((sockaddr_in6 *)from)->sin6_port = Msg.Rsp.IpV6.port;
sl_Memcpy(((sockaddr_in6 *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.address, 16);
*fromlen = sizeof(sockaddr_in6);
}
#endif
#endif
}
return (int)RetVal;
}
void _SlDrvNetAppEventHandler(void *pArgs)
{
_SlResponseHeader_t *pHdr = (_SlResponseHeader_t *)pArgs;
SlHttpServerEvent_t httpServerEvent;
SlHttpServerResponse_t httpServerResponse;
switch(pHdr->GenHeader.Opcode)
{
case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE:
case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE_V6:
_sl_HandleAsync_DnsGetHostByName(pArgs);
break;
case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE:
case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE_V6:
_sl_HandleAsync_DnsGetHostByService(pArgs);
break;
case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE:
_sl_HandleAsync_PingResponse(pArgs);
break;
case SL_OPCODE_NETAPP_HTTPGETTOKENVALUE:
{
UINT8 *pTokenName;
#ifdef sl_HttpServerCallback
slHttpServerData_t Token_value;
#endif
sl_NetAppHttpServerGetToken_t *httpGetToken = (sl_NetAppHttpServerGetToken_t *)_SL_RESP_ARGS_START(pHdr);
pTokenName = (UINT8 *)((sl_NetAppHttpServerGetToken_t *)httpGetToken + 1);
httpServerResponse.Response = SL_NETAPP_HTTPSETTOKENVALUE;
httpServerResponse.ResponseData.token_value.len = MAX_TOKEN_VALUE_LEN;
httpServerResponse.ResponseData.token_value.data = (UINT8 *)_SL_RESP_ARGS_START(pHdr) + MAX_TOKEN_NAME_LEN; //Reuse the async buffer for getting the token value response from the user
#ifdef sl_HttpServerCallback
httpServerEvent.Event = SL_NETAPP_HTTPGETTOKENVALUE;
httpServerEvent.EventData.httpTokenName.len = httpGetToken->token_name_len;
httpServerEvent.EventData.httpTokenName.data = pTokenName;
Token_value.token_name = pTokenName;
sl_HttpServerCallback (&httpServerEvent, &httpServerResponse);
Token_value.value_len = httpServerResponse.ResponseData.token_value.len;
Token_value.name_len = httpServerEvent.EventData.httpTokenName.len;
Token_value.token_value = httpServerResponse.ResponseData.token_value.data;
sl_NetAppSendTokenValue(&Token_value);
#endif
}
break;
case SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE:
{
UINT8 *pPostParams;
sl_NetAppHttpServerPostToken_t *httpPostTokenArgs = (sl_NetAppHttpServerPostToken_t *)_SL_RESP_ARGS_START(pHdr);
pPostParams = (UINT8 *)((sl_NetAppHttpServerPostToken_t *)httpPostTokenArgs + 1);
httpServerEvent.Event = SL_NETAPP_HTTPPOSTTOKENVALUE;
httpServerEvent.EventData.httpPostData.action.len = httpPostTokenArgs->post_action_len;
httpServerEvent.EventData.httpPostData.action.data = pPostParams;
pPostParams+=httpPostTokenArgs->post_action_len;
httpServerEvent.EventData.httpPostData.token_name.len = httpPostTokenArgs->token_name_len;
httpServerEvent.EventData.httpPostData.token_name.data = pPostParams;
pPostParams+=httpPostTokenArgs->token_name_len;
httpServerEvent.EventData.httpPostData.token_value.len = httpPostTokenArgs->token_value_len;
httpServerEvent.EventData.httpPostData.token_value.data = pPostParams;
httpServerResponse.Response = SL_NETAPP_RESPONSE_NONE;
#ifdef sl_HttpServerCallback
sl_HttpServerCallback (&httpServerEvent, &httpServerResponse);
#endif
}
break;
default:
SL_ERROR_TRACE2(MSG_305, "ASSERT: _SlDrvNetAppEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
VERIFY_PROTOCOL(0);
}
}
int sl_WlanConnect(char* pName, int NameLen, unsigned char *pMacAddr, SlSecParams_t* pSecParams , SlSecParamsExt_t* pSecExtParams)
{
_SlWlanConnectMsg_u Msg = {0};
_SlCmdCtrl_t CmdCtrl = {0};
CmdCtrl.TxDescLen = 0;/* init */
CmdCtrl.RxDescLen = sizeof(_BasicResponse_t);
/* verify SSID length */
VERIFY_PROTOCOL(NameLen <= MAX_SSID_LEN);
/* update SSID length */
Msg.Cmd.Args.Common.SsidLen = NameLen;
/* Profile with no security */
/* Enterprise security profile */
if (NULL != pSecExtParams)
{
/* Update command opcode */
CmdCtrl.Opcode = SL_OPCODE_WLAN_WLANCONNECTEAPCOMMAND;
CmdCtrl.TxDescLen += sizeof(_WlanConnectEapCommand_t);
/* copy SSID */
sl_Memcpy(EAP_SSID_STRING(&Msg), pName, NameLen);
CmdCtrl.TxDescLen += NameLen;
/* Copy password if supplied */
if ((NULL != pSecParams) && (pSecParams->KeyLen > 0))
{
/* update security type */
Msg.Cmd.Args.Common.SecType = pSecParams->Type;
/* verify key length */
if (pSecParams->KeyLen > MAX_KEY_LEN)
{
return SL_INVALPARAM;
}
/* update key length */
Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;
ARG_CHECK_PTR(pSecParams->Key);
/* copy key */
sl_Memcpy(EAP_PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
CmdCtrl.TxDescLen += pSecParams->KeyLen;
}
else
{
Msg.Cmd.Args.Common.PasswordLen = 0;
}
ARG_CHECK_PTR(pSecExtParams);
/* Update Eap bitmask */
Msg.Cmd.Args.EapBitmask = pSecExtParams->EapMethod;
/* Update Certificate file ID index - currently not supported */
Msg.Cmd.Args.CertIndex = pSecExtParams->CertIndex;
/* verify user length */
if (pSecExtParams->UserLen > MAX_USER_LEN)
{
return SL_INVALPARAM;
}
Msg.Cmd.Args.UserLen = pSecExtParams->UserLen;
/* copy user name (identity) */
if(pSecExtParams->UserLen > 0)
{
sl_Memcpy(EAP_USER_STRING(&Msg), pSecExtParams->User, pSecExtParams->UserLen);
CmdCtrl.TxDescLen += pSecExtParams->UserLen;
}
/* verify Anonymous user length */
if (pSecExtParams->AnonUserLen > MAX_ANON_USER_LEN)
{
return SL_INVALPARAM;
}
Msg.Cmd.Args.AnonUserLen = pSecExtParams->AnonUserLen;
/* copy Anonymous user */
if(pSecExtParams->AnonUserLen > 0)
{
sl_Memcpy(EAP_ANON_USER_STRING(&Msg), pSecExtParams->AnonUser, pSecExtParams->AnonUserLen);
CmdCtrl.TxDescLen += pSecExtParams->AnonUserLen;
}
}
/* Regular or open security profile */
else
{
/* Update command opcode */
CmdCtrl.Opcode = SL_OPCODE_WLAN_WLANCONNECTCOMMAND;
CmdCtrl.TxDescLen += sizeof(_WlanConnectCommon_t);
/* copy SSID */
memcpy(SSID_STRING(&Msg), pName, NameLen);
CmdCtrl.TxDescLen += NameLen;
/* Copy password if supplied */
if( NULL != pSecParams )
{
/* update security type */
Msg.Cmd.Args.Common.SecType = pSecParams->Type;
/* verify key length is valid */
if (pSecParams->KeyLen > MAX_KEY_LEN)
{
return SL_INVALPARAM;
}
/* update key length */
Msg.Cmd.Args.Common.PasswordLen = pSecParams->KeyLen;
CmdCtrl.TxDescLen += pSecParams->KeyLen;
/* copy key (could be no key in case of WPS pin) */
if( NULL != pSecParams->Key )
{
sl_Memcpy(PASSWORD_STRING(&Msg), pSecParams->Key, pSecParams->KeyLen);
}
}
/* Profile with no security */
else
{
Msg.Cmd.Args.Common.PasswordLen = 0;
Msg.Cmd.Args.Common.SecType = SL_SEC_TYPE_OPEN;
}
}
/* If BSSID is not null, copy to buffer, otherwise set to 0 */
if(NULL != pMacAddr)
{
sl_Memcpy(Msg.Cmd.Args.Common.Bssid, pMacAddr, sizeof(Msg.Cmd.Args.Common.Bssid));
}
else
{
sl_Memset(Msg.Cmd.Args.Common.Bssid, 0, sizeof(Msg.Cmd.Args.Common.Bssid));
}
VERIFY_RET_OK ( _SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
return (int)Msg.Rsp.status;
}
_i16 sl_Connect(_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
{
_SlSockConnectMsg_u Msg;
_SlReturnVal_t RetVal;
_SlCmdCtrl_t CmdCtrl = {0, (_SlArgSize_t)0, (_SlArgSize_t)sizeof(_SocketResponse_t)};
_SocketResponse_t AsyncRsp;
_u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
/* verify no erorr handling in progress. if in progress than
ignore the API execution and return immediately with an error */
VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
switch(addr->sa_family)
{
case SL_AF_INET :
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv4Command_t);
/* Do nothing - cmd already initialized to this type */
break;
case SL_AF_INET6_EUI_48:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv6EUI48Command_t);
break;
#ifdef SL_SUPPORT_IPV6
case AF_INET6:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_CONNECT_V6;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv6Command_t);
break;
#endif
case SL_AF_RF:
default:
return SL_RET_CODE_INVALID_INPUT;
}
Msg.Cmd.IpV4.lenOrPadding = 0;
Msg.Cmd.IpV4.sd = (_u8)sd;
_sl_BuildAddress(addr, &Msg.Cmd);
ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, CONNECT_ID, (_u8)(sd & BSD_SOCKET_ID_MASK));
if (MAX_CONCURRENT_ACTIONS == ObjIdx)
{
return SL_POOL_IS_EMPTY;
}
/* send the command */
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
VERIFY_PROTOCOL(Msg.Rsp.sd == (_u8)sd)
RetVal = Msg.Rsp.statusOrLen;
if(SL_RET_CODE_OK == RetVal)
{
#ifndef SL_TINY_EXT
/*In case socket is non-blocking one, the async event should be received immediately */
if( g_pCB->SocketNonBlocking >> (sd & BSD_SOCKET_ID_MASK))
{
SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
SL_DRIVER_TIMEOUT_SHORT,
SL_DRIVER_API_SOCKET_CONNECT
);
}
else
#endif
{
/* wait for async and get Data Read parameters */
SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
}
VERIFY_PROTOCOL(AsyncRsp.sd == (_u8)sd);
RetVal = AsyncRsp.statusOrLen;
}
_i16 sl_RecvFrom(_i16 sd, void *buf, _i16 Len, _i16 flags, SlSockAddr_t *from, SlSocklen_t *fromlen)
{
_SlRecvfromMsg_u Msg;
_SlCmdExt_t CmdExt;
_i16 RetVal;
/* verify no erorr handling in progress. if in progress than
ignore the API execution and return immediately with an error */
VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
_SlDrvResetCmdExt(&CmdExt);
CmdExt.RxPayloadLen = Len;
CmdExt.pRxPayload = (_u8 *)buf;
Msg.Cmd.sd = (_u8)sd;
Msg.Cmd.StatusOrLen = (_u16)Len;
/* no size truncation in recv path */
CmdExt.RxPayloadLen = (_i16)Msg.Cmd.StatusOrLen;
Msg.Cmd.FamilyAndFlags = (_u8)(flags & 0x0F);
if(sizeof(SlSockAddrIn_t) == *fromlen)
{
Msg.Cmd.FamilyAndFlags |= (SL_AF_INET << 4);
}
else if (sizeof(SlSockAddrIn6_t) == *fromlen)
{
Msg.Cmd.FamilyAndFlags |= (SL_AF_INET6 << 4);
}
else
{
return SL_RET_CODE_INVALID_INPUT;
}
RetVal = _SlDrvDataReadOp((_SlSd_t)sd, (_SlCmdCtrl_t *)&_SlRecvfomCmdCtrl, &Msg, &CmdExt);
if( RetVal != SL_OS_RET_CODE_OK )
{
return RetVal;
}
RetVal = Msg.Rsp.IpV4.statusOrLen;
if(RetVal >= 0)
{
VERIFY_PROTOCOL(sd == (_i16)Msg.Rsp.IpV4.sd);
#if 0
_sl_ParseAddress(&Msg.Rsp, from, fromlen);
#else
from->sa_family = Msg.Rsp.IpV4.family;
if(SL_AF_INET == from->sa_family)
{
((SlSockAddrIn_t *)from)->sin_port = Msg.Rsp.IpV4.port;
((SlSockAddrIn_t *)from)->sin_addr.s_addr = Msg.Rsp.IpV4.address;
*fromlen = (SlSocklen_t)sizeof(SlSockAddrIn_t);
}
else if (SL_AF_INET6_EUI_48 == from->sa_family )
{
((SlSockAddrIn6_t *)from)->sin6_port = Msg.Rsp.IpV6EUI48.port;
sl_Memcpy(((SlSockAddrIn6_t *)from)->sin6_addr._S6_un._S6_u8, Msg.Rsp.IpV6EUI48.address, 6);
}
#ifdef SL_SUPPORT_IPV6
else if(AF_INET6 == from->sa_family)
{
VERIFY_PROTOCOL(*fromlen >= sizeof(sockaddr_in6));
((sockaddr_in6 *)from)->sin6_port = Msg.Rsp.IpV6.port;
sl_Memcpy(((sockaddr_in6 *)from)->sin6_addr._S6_un._S6_u32, Msg.Rsp.IpV6.address, 16);
*fromlen = sizeof(sockaddr_in6);
}
#endif
#endif
}
return (_i16)RetVal;
}
