void _sl_ParseAddress(_SocketAddrResponse_u *pRsp, SlSockAddr_t *addr, SlSocklen_t *addrlen)
{
/* Note: parsing of family and port in the generic way for all IPV4, IPV6 and EUI48 */
/* is possible as long as these parameters are in the same offset and size for these */
/* three families. */
addr->sa_family = pRsp->IpV4.family;
((SlSockAddrIn_t *)addr)->sin_port = pRsp->IpV4.port;
*addrlen = (SL_AF_INET == addr->sa_family) ? sizeof(SlSockAddrIn_t) : sizeof(SlSockAddrIn6_t);
if(SL_AF_INET == addr->sa_family)
{
((SlSockAddrIn_t *)addr)->sin_addr.s_addr = pRsp->IpV4.address;
}
else if (SL_AF_INET6_EUI_48 == addr->sa_family )
{
sl_Memcpy(((SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u8, pRsp->IpV6EUI48.address, 6);
}
#ifdef SL_SUPPORT_IPV6
else
{
sl_Memcpy(((sockaddr_in6 *)addr)->sin6_addr._S6_un._S6_u32, pRsp->IpV6.address, 16);
}
#endif
}
/***************************************************************************
_SlNetUtilHandleAsync_Cmd - handles NetUtil Cmd response, signalling to
a waiting object
****************************************************************************/
void _SlNetUtilHandleAsync_Cmd(void *pVoidBuf)
{
_SlNetUtilCmdData_t *pOutData;
SlNetUtilCmdRsp_t *pMsgArgs = (SlNetUtilCmdRsp_t *)_SL_RESP_ARGS_START(pVoidBuf);
SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
pOutData = (_SlNetUtilCmdData_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
pOutData->Status = pMsgArgs->Status;
if(SL_RET_CODE_OK == pMsgArgs->Status)
{
if (*(pOutData->pOutputLen) < pMsgArgs->OutputLen)
{
pOutData->Status = SL_ESMALLBUF;
}
else
{
*(pOutData->pOutputLen) = pMsgArgs->OutputLen;
if(*(pOutData->pOutputLen) > 0)
{
/* copy only the data from the global async buffer */
sl_Memcpy(pOutData->pOutputValues, (char*)pMsgArgs + sizeof(SlNetUtilCmdRsp_t), *(pOutData->pOutputLen));
}
}
}
_SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
_SlDrvProtectionObjUnLock();
return;
}
void _sl_HandleAsync_PingResponse(void *pVoidBuf)
{
_PingReportResponse_t *pMsgArgs = (_PingReportResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
SlPingReport_t pingReport;
if(pPingCallBackFunc)
{
CopyPingResultsToReport(pMsgArgs,&pingReport);
pPingCallBackFunc(&pingReport);
}
else
{
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_SOCKET_CB(NULL != g_pCB->PingCB.PingAsync.pAsyncRsp);
if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
{
sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_PingReportResponse_t));
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;
}
SlrxFilterID_t sl_WlanRxFilterAdd( SlrxFilterRuleType_t RuleType,
SlrxFilterFlags_t FilterFlags,
const SlrxFilterRule_t* const Rule,
const SlrxFilterTrigger_t* const Trigger,
const SlrxFilterAction_t* const Action,
SlrxFilterID_t* pFilterId)
{
_SlrxFilterAddMsg_u Msg;
Msg.Cmd.RuleType = RuleType;
/* filterId is zero */
Msg.Cmd.FilterId = 0;
Msg.Cmd.FilterFlags = FilterFlags;
sl_Memcpy( &(Msg.Cmd.Rule), Rule, sizeof(SlrxFilterRule_t) );
sl_Memcpy( &(Msg.Cmd.Trigger), Trigger, sizeof(SlrxFilterTrigger_t) );
sl_Memcpy( &(Msg.Cmd.Action), Action, sizeof(SlrxFilterAction_t) );
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRxFilterAddtCmdCtrl, &Msg, NULL) );
*pFilterId = Msg.Rsp.FilterId;
return (int)Msg.Rsp.Status;
}
void _sl_HandleAsync_DnsGetHostByName(void *pVoidBuf)
{
_GetHostByNameIPv4AsyncResponse_t *pMsgArgs = (_GetHostByNameIPv4AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
/*IPv6 */
if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
{
sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_GetHostByNameIPv6AsyncResponse_t));
}
/*IPv4 */
else
{
sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_GetHostByNameIPv4AsyncResponse_t));
}
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_NetAppDnsGetHostByName(char * hostname, unsigned short usNameLen, unsigned long* out_ip_addr,unsigned char family)
{
_SlGetHostByNameMsg_u Msg;
_SlCmdExt_t ExtCtrl;
_GetHostByNameAsyncResponse_u AsyncRsp;
UINT8 pObjIdx = MAX_CONCURRENT_ACTIONS;
ExtCtrl.TxPayloadLen = usNameLen;
ExtCtrl.RxPayloadLen = 0;
ExtCtrl.pTxPayload = (UINT8 *)hostname;
ExtCtrl.pRxPayload = 0;
Msg.Cmd.Len = usNameLen;
Msg.Cmd.family = family;
/*Use Obj to issue the command, if not available try later */
pObjIdx = _SlDrvWaitForPoolObj(GETHOSYBYNAME_ID,SL_MAX_SOCKETS);
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;
/*set bit to indicate IPv6 address is expected */
if (SL_AF_INET6 == family)
{
g_pCB->ObjPool[pObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
}
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlGetHostByNameCtrl, &Msg, &ExtCtrl));
if(SL_RET_CODE_OK == Msg.Rsp.status)
{
OSI_RET_OK_CHECK(sl_SyncObjWait(&g_pCB->ObjPool[pObjIdx].SyncObj, SL_OS_WAIT_FOREVER));
Msg.Rsp.status = AsyncRsp.IpV4.status;
if(SL_OS_RET_CODE_OK == (int)Msg.Rsp.status)
{
sl_Memcpy((char *)out_ip_addr,
(char *)&AsyncRsp.IpV4.ip0,
(SL_AF_INET == family) ? SL_IPV4_ADDRESS_SIZE : SL_IPV6_ADDRESS_SIZE);
}
}
_SlDrvReleasePoolObj(pObjIdx);
return Msg.Rsp.status;
}
/* ******************************************************************************/
void _sl_BuildAddress(const SlSockAddr_t *addr, int addrlen, _SocketAddrCommand_u *pCmd)
{
/* Note: parsing of family and port in the generic way for all IPV4, IPV6 and EUI48 */
/* is possible as long as these parameters are in the same offset and size for these */
/* three families. */
pCmd->IpV4.FamilyAndFlags = (addr->sa_family << 4) & 0xF0;
pCmd->IpV4.port = ((SlSockAddrIn_t *)addr)->sin_port;
if(SL_AF_INET == addr->sa_family)
{
pCmd->IpV4.address = ((SlSockAddrIn_t *)addr)->sin_addr.s_addr;
}
else if (SL_AF_INET6_EUI_48 == addr->sa_family )
{
sl_Memcpy( pCmd->IpV6EUI48.address,((SlSockAddrIn6_t *)addr)->sin6_addr._S6_un._S6_u8, 6);
}
#ifdef SL_SUPPORT_IPV6
else
{
sl_Memcpy(pCmd->IpV6.address, ((sockaddr_in6 *)addr)->sin6_addr._S6_un._S6_u32, 16 );
}
#endif
}
UINT16 sl_NetAppSendTokenValue(slHttpServerData_t * Token_value)
{
_SlNetAppMsgSendTokenValue_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = (Token_value->value_len+3) & (~3);
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = (UINT8 *) Token_value->token_value;
CmdExt.pRxPayload = NULL;
Msg.Cmd.token_value_len = Token_value->value_len;
Msg.Cmd.token_name_len = Token_value->name_len;
sl_Memcpy(&Msg.Cmd.token_name[0], Token_value->token_name, Token_value->name_len);
VERIFY_RET_OK(_SlDrvCmdSend((_SlCmdCtrl_t *)&_SlNetAppSendTokenValueCmdCtrl, &Msg, &CmdExt));
return Msg.Rsp.status;
}
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_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;
}
/******************************************************************************
_sl_HandleAsync_DnsGetHostByService
CALLER NWP - Async event on sl_DnsGetHostByService with IPv4 Family
DESCRIPTION:
Async event on sl_DnsGetHostByService command with IPv4 Family.
Return service attributes like IP address, port and text according to service name.
The user sets a service name Full/Part (see example below), and should get the:
1. IP of the service
2. The port of service.
3. The text of service.
Hence it can make a connection to the specific service and use it.
It is similar to get host by name method.
It is done by a single shot query with PTR type on the service name.
Note:
1. The return's attributes are belonged to first service that is found.
It can be other services with the same service name will response to
the query. The results of these responses are saved in the peer cache of the NWP, and
should be read by another API.
PARAMETERS:
pVoidBuf - is point to opcode of the event.
it contains the outputs that are given to the user
outputs description:
1.out_pAddr[] - output: Contain the IP address of the service.
2.out_pPort - output: Contain the port of the service.
3.inout_TextLen - Input: Contain the max length of the text that the user wants to get.
it means that if the test of service is bigger that its value than
the text is cut to inout_TextLen value.
Output: Contain the length of the text that is returned. Can be full text or part
of the text (see above).
4.out_pText - Contain the text of the service (full or part see above- inout_TextLen description).
*
RETURNS: success or fail.
******************************************************************************/
void _sl_HandleAsync_DnsGetHostByService(void *pVoidBuf)
{
_GetHostByServiceAsyncResponse_t* Res;
unsigned short TextLen;
unsigned short UserTextLen;
/*pVoidBuf - is point to opcode of the event.*/
/*set pMsgArgs to point to the attribute of the event.*/
_GetHostByServiceIPv4AsyncResponse_t *pMsgArgs = (_GetHostByServiceIPv4AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
/*IPv6*/
if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
{
return;
}
/*IPv4*/
else
{
/*************************************************************************************************
1. Copy the attribute part of the evnt to the attribute part of the response
sl_Memcpy(g_pCB->GetHostByServiceCB.pAsyncRsp, pMsgArgs, sizeof(_GetHostByServiceIPv4AsyncResponse_t));
set to TextLen the text length of the service.*/
TextLen = pMsgArgs->TextLen;
/*Res pointed to mDNS global object struct */
Res = (_GetHostByServiceAsyncResponse_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
/*It is 4 bytes so we avoid from memcpy*/
Res->out_pAddr[0] = pMsgArgs->Address;
Res->out_pPort[0] = pMsgArgs->Port;
Res->Status = pMsgArgs->Status;
/*set to TextLen the text length of the user (input fromthe user).*/
UserTextLen = Res->inout_TextLen[0];
/*Cut the service text if the user requested for smaller text.*/
UserTextLen = (TextLen <= UserTextLen) ? TextLen : UserTextLen;
Res->inout_TextLen[0] = UserTextLen ;
/**************************************************************************************************
2. Copy the payload part of the evnt (the text) to the payload part of the response
the lenght of the copy is according to the text length in the attribute part. */
sl_Memcpy(Res->out_pText ,
(char *)(& pMsgArgs[1]) , /* & pMsgArgs[1] -> 1st byte after the fixed header = 1st byte of variable text.*/
UserTextLen );
/**************************************************************************************************/
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
return;
}
}
int sl_NetAppMDNSRegisterUnregisterService( const char* pServiceName,
unsigned char ServiceNameLen,
const char* pText,
unsigned char TextLen,
unsigned short Port,
unsigned long TTL,
unsigned long Options)
{
_SlNetappMdnsRegisterServiceMsg_u Msg;
_SlCmdExt_t CmdExt ;
char ServiceNameAndTextBuffer[NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH];
char *TextPtr;
/*
NOTE - pay attention
1. Temporary - there is an allocation on stack of internal buffer.
Its size is NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH.
It means that the sum of the text length and service name length cannot be bigger than
NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH.
If it is - An error is returned.
2. According to now from certain constraints the variables parameters are set in the
attribute part (contain constant parameters)
*/
/*build the attribute part of the command.
It contains the constant parameters of the command*/
Msg.Cmd.ServiceNameLen = ServiceNameLen;
Msg.Cmd.Options = Options;
Msg.Cmd.Port = Port;
Msg.Cmd.TextLen = TextLen;
Msg.Cmd.TTL = TTL;
/*Build the payload part of the command
Copy the service name and text to one buffer.
NOTE - pay attention
The size of the service length + the text length should be smaller than 255,
Until the simplelink drive supports to variable length through SPI command. */
if(TextLen + ServiceNameLen > (NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH - 1 )) /*-1 is for giving a place to set null termination at the end of the text*/
{
return -1;
}
memset(ServiceNameAndTextBuffer,0,NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH);
/*Copy the service name*/
sl_Memcpy(ServiceNameAndTextBuffer,
pServiceName,
ServiceNameLen);
if(TextLen > 0 )
{
TextPtr = &ServiceNameAndTextBuffer[ServiceNameLen];
/*Copy the text just after the service name*/
sl_Memcpy(TextPtr,
pText,
TextLen);
}
CmdExt.TxPayloadLen = (TextLen + ServiceNameLen);
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = (UINT8 *)ServiceNameAndTextBuffer;
CmdExt.pRxPayload = NULL;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRegisterServiceCtrl, &Msg, &CmdExt));
return (int)Msg.Rsp.status;
}
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_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;
}
_i16 sl_NetAppPingStart(SlPingStartCommand_t* pPingParams,_u8 family,SlPingReport_t *pReport,const P_SL_DEV_PING_CALLBACK pPingCallback)
{
_SlCmdCtrl_t CmdCtrl = {0, sizeof(_PingStartCommand_t), sizeof(_BasicResponse_t)};
_SlPingStartMsg_u Msg;
_PingReportResponse_t PingRsp;
_u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
if( 0 == pPingParams->Ip ) // stop any ongoing ping
{
return _SlDrvBasicCmd(SL_OPCODE_NETAPP_PINGSTOP);
}
if(SL_AF_INET == family)
{
CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
sl_Memcpy(&Msg.Cmd.ip0, &pPingParams->Ip, SL_IPV4_ADDRESS_SIZE);
}
else
{
CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART_V6;
sl_Memcpy(&Msg.Cmd.ip0, &pPingParams->Ip, SL_IPV6_ADDRESS_SIZE);
}
Msg.Cmd.pingIntervalTime = pPingParams->PingIntervalTime;
Msg.Cmd.PingSize = pPingParams->PingSize;
Msg.Cmd.pingRequestTimeout = pPingParams->PingRequestTimeout;
Msg.Cmd.totalNumberOfAttempts = pPingParams->TotalNumberOfAttempts;
Msg.Cmd.flags = pPingParams->Flags;
if( pPingCallback )
{
pPingCallBackFunc = pPingCallback;
}
else
{
/*Use Obj to issue the command, if not available try later */
ObjIdx = (_u8)_SlDrvWaitForPoolObj(PING_ID,SL_MAX_SOCKETS);
if (MAX_CONCURRENT_ACTIONS == ObjIdx)
{
return SL_POOL_IS_EMPTY;
}
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
/* async response handler for non callback mode */
g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&PingRsp;
pPingCallBackFunc = NULL;
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
}
VERIFY_RET_OK(_SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
/*send the command*/
if(CMD_PING_TEST_RUNNING == (_i16)Msg.Rsp.status || CMD_PING_TEST_STOPPED == (_i16)Msg.Rsp.status )
{
/* block waiting for results if no callback function is used */
if( NULL == pPingCallback )
{
OSI_RET_OK_CHECK(sl_SyncObjWait(&g_pCB->ObjPool[ObjIdx].SyncObj, SL_OS_WAIT_FOREVER));
if( SL_OS_RET_CODE_OK == (_i16)PingRsp.status )
{
CopyPingResultsToReport(&PingRsp,pReport);
}
_SlDrvReleasePoolObj(ObjIdx);
}
}
else
{ /* ping failure, no async response */
if( NULL == pPingCallback )
{
_SlDrvReleasePoolObj(ObjIdx);
}
}
return Msg.Rsp.status;
}
