int sl_Bind(int sd, const SlSockAddr_t *addr, int addrlen)
{
_SlSockBindMsg_u Msg;
_SlCmdCtrl_t CmdCtrl = {0, 0, sizeof(_SocketResponse_t)};
switch(addr->sa_family)
{
case SL_AF_INET :
CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND;
CmdCtrl.TxDescLen = sizeof(_SocketAddrIPv4Command_t);
break;
case SL_AF_INET6_EUI_48:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
CmdCtrl.TxDescLen = sizeof(_SocketAddrIPv6EUI48Command_t);
break;
#ifdef SL_SUPPORT_IPV6
case AF_INET6:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_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 = (UINT8)sd;
_sl_BuildAddress(addr, addrlen, &Msg.Cmd);
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
return Msg.Rsp.statusOrLen;
}
int sl_WlanSmartConfigStart( const unsigned long groupIdBitmask,
const unsigned char cipher,
const unsigned char publicKeyLen,
const unsigned char group1KeyLen,
const unsigned char group2KeyLen,
const unsigned char* pPublicKey,
const unsigned char* pGroup1Key,
const unsigned char* pGroup2Key)
{
_SlSmartConfigStartMsg_u Msg;
Msg.Cmd.Args.groupIdBitmask = (UINT8)groupIdBitmask;
Msg.Cmd.Args.cipher = (UINT8)cipher;
Msg.Cmd.Args.publicKeyLen = (UINT8)publicKeyLen;
Msg.Cmd.Args.group1KeyLen = (UINT8)group1KeyLen;
Msg.Cmd.Args.group2KeyLen = (UINT8)group2KeyLen;
/* copy keys (if exist) after command (one after another) */
memcpy(SMART_CONFIG_START_PUBLIC_KEY_STRING(&Msg), pPublicKey, publicKeyLen);
memcpy(SMART_CONFIG_START_GROUP1_KEY_STRING(&Msg), pGroup1Key, group1KeyLen);
memcpy(SMART_CONFIG_START_GROUP2_KEY_STRING(&Msg), pGroup2Key, group2KeyLen);
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSmartConfigStartCmdCtrl , &Msg, NULL));
return (int)Msg.Rsp.status;
}
_i16 sl_NetUtilGet(const _u16 Option, const _u32 ObjID, _u8 *pValues, _u16 *pValueLen)
{
SlNetUtilMsgGet_u Msg;
_SlCmdExt_t CmdExt;
_SlDrvResetCmdExt(&CmdExt);
CmdExt.RxPayloadLen = *pValueLen;
CmdExt.pRxPayload = (_u8 *)pValues;
Msg.Cmd.Option = Option;
Msg.Cmd.ObjId = ObjID;
Msg.Cmd.ValueLen = *pValueLen;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetUtilGetCmdCtrl, &Msg, &CmdExt));
if(CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
*pValueLen = CmdExt.RxPayloadLen;
return SL_ESMALLBUF;
}
else
{
*pValueLen = CmdExt.ActualRxPayloadLen;
}
return (_i16)Msg.Rsp.Status;
}
int sl_WlanRxFilterGet(const SLrxFilterOperation_t RxFilterOperation,
unsigned char* pOutputBuffer,
UINT16 OutputbufferLength)
{
_SlRxFilterGetMsg_u Msg;
_SlCmdExt_t CmdExt;
if (OutputbufferLength == 0)
{
return SL_EZEROLEN;
}
CmdExt.TxPayloadLen = 0;
CmdExt.pTxPayload = NULL;
CmdExt.RxPayloadLen = OutputbufferLength;
CmdExt.pRxPayload = (UINT8 *)pOutputBuffer;
CmdExt.ActualRxPayloadLen = 0;
Msg.Cmd.RxFilterOperation = RxFilterOperation;
Msg.Cmd.OutputBufferLength = OutputbufferLength;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlRxFilterGetCmdCtrl, &Msg, &CmdExt) );
if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
return SL_ESMALLBUF;
}
return (int)Msg.Rsp.Status;
}
int sl_FsClose(long FileHdl, unsigned char* pCeritificateFileName,unsigned char* pSignature ,unsigned long SignatureLen)
{
_SlFsCloseMsg_u Msg = {0};
_SlCmdExt_t ExtCtrl;
Msg.Cmd.FileHandle = FileHdl;
if( pCeritificateFileName != NULL )
{
Msg.Cmd.CertificFileNameLength = (sl_Strlen(pCeritificateFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align */
}
Msg.Cmd.SignatureLen = SignatureLen;
ExtCtrl.TxPayloadLen = ((SignatureLen+3) & (~3)); /* align */
ExtCtrl.pTxPayload = pSignature;
ExtCtrl.RxPayloadLen = Msg.Cmd.CertificFileNameLength;
ExtCtrl.pRxPayload = pCeritificateFileName; /* Add signature */
if(ExtCtrl.pRxPayload != NULL && ExtCtrl.RxPayloadLen != 0)
{
g_pCB->RelayFlagsViaRxPayload = TRUE;
}
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsCloseCmdCtrl, &Msg, &ExtCtrl));
return (int)((short)Msg.Rsp.status);
}
int sl_GetSockOpt(int sd, int level, int optname, void *optval, SlSocklen_t *optlen)
{
_SlGetSockOptMsg_u Msg;
_SlCmdExt_t CmdExt;
if (*optlen == 0)
{
return SL_EZEROLEN;
}
CmdExt.TxPayloadLen = 0;
CmdExt.RxPayloadLen = *optlen;
CmdExt.pTxPayload = NULL;
CmdExt.pRxPayload = optval;
CmdExt.ActualRxPayloadLen = 0;
Msg.Cmd.sd = sd;
Msg.Cmd.level = level;
Msg.Cmd.optionLen = *optlen;
Msg.Cmd.optionName = optname;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlGetSockOptCmdCtrl, &Msg, &CmdExt));
if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
*optlen = Msg.Rsp.optionLen;
return SL_ESMALLBUF;
}
else
{
*optlen = (UINT8)CmdExt.ActualRxPayloadLen;
}
return (int)Msg.Rsp.status;
}
long sl_NetAppGet(unsigned char AppId, unsigned char Option,unsigned char *pOptionLen, unsigned char *pOptionValue)
{
_SlNetAppMsgGet_u Msg;
_SlCmdExt_t CmdExt;
if (*pOptionLen == 0)
{
return SL_EZEROLEN;
}
CmdExt.TxPayloadLen = 0;
CmdExt.RxPayloadLen = *pOptionLen;
CmdExt.pTxPayload = NULL;
CmdExt.pRxPayload = (UINT8 *)pOptionValue;
CmdExt.ActualRxPayloadLen = 0;
Msg.Cmd.AppId = AppId;
Msg.Cmd.ConfigOpt = Option;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetAppGetCmdCtrl, &Msg, &CmdExt));
if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
*pOptionLen = (UINT8)CmdExt.RxPayloadLen;
return SL_ESMALLBUF;
}
else
{
*pOptionLen = (UINT8)CmdExt.ActualRxPayloadLen;
}
return (int)Msg.Rsp.Status;
}
_i16 sl_FsGetInfo( const _u8 *pFileName, const _u32 Token,
SlFsFileInfo_t *pFsFileInfo )
{
_SlFsGetInfoMsg_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = ( _sl_Strlen( pFileName ) + 4 ) &
( ~3 ); /* add 4: 1 for NULL and the 3 for align */
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = ( _u8 * )pFileName;
CmdExt.pRxPayload = NULL;
Msg.Cmd.Token = Token;
VERIFY_RET_OK( _SlDrvCmdOp( ( _SlCmdCtrl_t * )&_SlFsGetInfoCmdCtrl, &Msg,
&CmdExt ) );
pFsFileInfo->flags = Msg.Rsp.flags;
pFsFileInfo->FileLen = Msg.Rsp.FileLen;
pFsFileInfo->AllocatedLen = Msg.Rsp.AllocatedLen;
pFsFileInfo->Token[0] = Msg.Rsp.Token[0];
pFsFileInfo->Token[1] = Msg.Rsp.Token[1];
pFsFileInfo->Token[2] = Msg.Rsp.Token[2];
pFsFileInfo->Token[3] = Msg.Rsp.Token[3];
return ( _i16 )( ( _i16 )Msg.Rsp.Status );
}
_i16 sl_FsClose( const _i32 FileHdl, const _u8 *pCeritificateFileName,
const _u8 *pSignature , const _u32 SignatureLen )
{
_SlFsCloseMsg_u Msg = {0};
_SlCmdExt_t ExtCtrl;
Msg.Cmd.FileHandle = FileHdl;
if( pCeritificateFileName != NULL )
{
Msg.Cmd.CertificFileNameLength = ( _sl_Strlen( pCeritificateFileName ) + 4 )
& ( ~3 ); /* add 4: 1 for NULL and the 3 for align */
}
Msg.Cmd.SignatureLen = SignatureLen;
ExtCtrl.TxPayloadLen = ( ( SignatureLen + 3 ) & ( ~3 ) ); /* align */
ExtCtrl.pTxPayload = ( _u8 * )pSignature;
ExtCtrl.RxPayloadLen = ( _i16 )Msg.Cmd.CertificFileNameLength;
ExtCtrl.pRxPayload = ( _u8 * )pCeritificateFileName; /* Add signature */
if( ExtCtrl.pRxPayload != NULL && ExtCtrl.RxPayloadLen != 0 )
ExtCtrl.RxPayloadLen = ExtCtrl.RxPayloadLen * ( -1 );
VERIFY_RET_OK( _SlDrvCmdOp( ( _SlCmdCtrl_t * )&_SlFsCloseCmdCtrl, &Msg,
&ExtCtrl ) );
return ( _i16 )( ( _i16 )Msg.Rsp.status );
}
int sl_WlanRxStatGet(SlGetRxStatResponse_t *pRxStat,unsigned long Flags)
{
_SlCmdCtrl_t CmdCtrl = {SL_OPCODE_WLAN_GETRXSTATCOMMAND, 0, sizeof(SlGetRxStatResponse_t)};
memset(pRxStat,0,sizeof(SlGetRxStatResponse_t));
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, pRxStat, NULL));
return 0;
}
_i16 sl_NetAppStart(_u32 AppBitMap)
{
_SlNetAppStartStopMsg_u Msg;
Msg.Cmd.appId = AppBitMap;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetAppStartCtrl, &Msg, NULL));
return Msg.Rsp.status;
}
int sl_NetAppStop(unsigned long AppBitMap)
{
_SlNetAppStartStopMsg_u Msg;
Msg.Cmd.appId = AppBitMap;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetAppStopCtrl, &Msg, NULL));
return Msg.Rsp.status;
}
int sl_Close(int sd)
{
_SlSockCloseMsg_u Msg;
Msg.Cmd.sd = (UINT8)sd;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
return Msg.Rsp.statusOrLen;
}
int sl_WlanProfileDel(int Index)
{
_SlProfileDelMsg_u Msg;
Msg.Cmd.index = (UINT8)Index;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlProfileDelCmdCtrl, &Msg, NULL));
return (int)Msg.Rsp.status;
}
int sl_Listen(int sd, int backlog)
{
_SlListenMsg_u Msg;
Msg.Cmd.sd = sd;
Msg.Cmd.backlog = backlog;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlListenCmdCtrl, &Msg, NULL));
return (int)Msg.Rsp.status;
}
int sl_EventMaskGet(unsigned char EventClass, unsigned long *pMask)
{
_SlEventMaskGetMsg_u Msg;
Msg.Cmd.group = EventClass;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlEventMaskGetCmdCtrl, &Msg, NULL));
*pMask = Msg.Rsp.mask;
return SL_RET_CODE_OK;
}
int sl_EventMaskSet(unsigned char EventClass , unsigned long Mask)
{
_SlEventMaskSetMsg_u Msg;
Msg.Cmd.group = EventClass;
Msg.Cmd.mask = Mask;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlEventMaskSetCmdCtrl, &Msg, NULL));
return (int)Msg.Rsp.status;
}
int sl_WlanSetMode(const unsigned char mode)
{
_SlwlanSetModeMsg_u Msg;
Msg.Cmd.mode = mode;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlWlanSetModeCmdCtrl , &Msg, NULL));
return (int)Msg.Rsp.status;
}
_i16 sl_Close(_i16 sd)
{
_SlSockCloseMsg_u Msg;
/* 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();
Msg.Cmd.sd = (_u8)sd;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSockCloseCmdCtrl, &Msg, NULL));
return Msg.Rsp.statusOrLen;
}
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;
}
int sl_Stop(unsigned short timeout)
{
int RetVal=0;
_SlStopMsg_u Msg;
_BasicResponse_t AsyncRsp;
int pObjIdx = MAX_CONCURRENT_ACTIONS;
/* if timeout is 0 the shutdown is forced immediately */
if( 0 == timeout )
{
sl_IfRegIntHdlr(NULL, NULL);
sl_DeviceDisable();
RetVal = sl_IfClose(g_pCB->FD);
}
else
{
/* let the device make the shutdown using the defined timeout */
Msg.Cmd.Timeout = timeout;
/* Use Obj to issue the command, if not available try later */
pObjIdx = _SlDrvWaitForPoolObj(START_STOP_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;
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlStopCmdCtrl, &Msg, NULL));
if(SL_OS_RET_CODE_OK == (int)Msg.Rsp.status)
{
OSI_RET_OK_CHECK(sl_SyncObjWait(&g_pCB->ObjPool[pObjIdx].SyncObj, SL_OS_WAIT_FOREVER));
Msg.Rsp.status = AsyncRsp.status;
RetVal = Msg.Rsp.status;
}
_SlDrvReleasePoolObj(pObjIdx);
sl_IfRegIntHdlr(NULL, NULL);
sl_DeviceDisable();
sl_IfClose(g_pCB->FD);
}
_SlDrvDriverCBDeinit();
return RetVal;
}
_i16 sl_FsDel(_u8 *pFileName,_u32 Token)
{
_SlFsDeleteMsg_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = (_sl_Strlen(pFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align */
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = pFileName;
CmdExt.pRxPayload = NULL;
Msg.Cmd.Token = Token;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
return (_i16)((_i16)Msg.Rsp.status);
}
int sl_FsDel(unsigned char *pFileName,unsigned long Token)
{
_SlFsDeleteMsg_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = (sl_Strlen(pFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align */
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = pFileName;
CmdExt.pRxPayload = NULL;
Msg.Cmd.Token = Token;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
return (int)((short)Msg.Rsp.status);
}
long sl_DevGet(unsigned char DeviceGetId, unsigned char *pOption,unsigned char *pConfigLen, unsigned char *pValues)
{
_SlDeviceMsgGet_u Msg;
_SlCmdExt_t CmdExt;
if (*pConfigLen == 0)
{
return SL_EZEROLEN;
}
if( pOption )
{
CmdExt.TxPayloadLen = 0;
CmdExt.RxPayloadLen = *pConfigLen;
CmdExt.pTxPayload = NULL;
CmdExt.pRxPayload = (UINT8 *)pValues;
CmdExt.ActualRxPayloadLen = 0;
Msg.Cmd.DeviceSetId = DeviceGetId;
Msg.Cmd.Option = (UINT16)*pOption;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlDeviceGetCmdCtrl, &Msg, &CmdExt));
if( pOption )
{
*pOption = (UINT8)Msg.Rsp.Option;
}
if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
*pConfigLen = (UINT8)CmdExt.RxPayloadLen;
return SL_ESMALLBUF;
}
else
{
*pConfigLen = (UINT8)CmdExt.ActualRxPayloadLen;
}
return (int)Msg.Rsp.Status;
}
else
{
return -1;
}
}
int sl_UartSetMode(const SlUartIfParams_t* pUartParams)
{
_SlUartSetModeMsg_u Msg;
UINT32 magicCode = 0xFFFFFFFF;
Msg.Cmd.BaudRate = pUartParams->BaudRate;
Msg.Cmd.FlowControlEnable = pUartParams->FlowControlEnable;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlUartSetModeCmdCtrl, &Msg, NULL));
/* cmd response OK, we can continue with the handshake */
if (SL_RET_CODE_OK == Msg.Rsp.status)
{
sl_IfMaskIntHdlr();
/* Close the comm port */
sl_IfClose(g_pCB->FD);
/* Re-open the comm port */
sl_IfOpen((char*)pUartParams, UART_IF_OPEN_FLAG_RE_OPEN);
sl_IfUnMaskIntHdlr();
/* send the magic code and wait for the response */
sl_IfWrite(g_pCB->FD, (unsigned char*)&magicCode, 4);
magicCode = UART_SET_MODE_MAGIC_CODE;
sl_IfWrite(g_pCB->FD, (unsigned char*)&magicCode, 4);
/* clear magic code */
magicCode = 0;
/* wait (blocking) till the magic code to be returned from device */
sl_IfRead(g_pCB->FD, (unsigned char*)&magicCode, 4);
/* check for the received magic code matching */
if (UART_SET_MODE_MAGIC_CODE != magicCode)
{
_SL_ASSERT(0);
}
}
return (int)Msg.Rsp.status;
}
_i32 sl_NetCfgGet(const _u8 ConfigId, _u8 *pConfigOpt,_u8 *pConfigLen, _u8 *pValues)
{
_SlNetCfgMsgGet_u Msg;
_SlCmdExt_t CmdExt;
if (*pConfigLen == 0)
{
return SL_EZEROLEN;
}
_SlDrvResetCmdExt(&CmdExt);
CmdExt.RxPayloadLen = *pConfigLen;
CmdExt.pRxPayload = (_u8 *)pValues;
Msg.Cmd.ConfigLen = *pConfigLen;
Msg.Cmd.ConfigId = ConfigId;
if( pConfigOpt )
{
Msg.Cmd.ConfigOpt = (_u16)*pConfigOpt;
}
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetCfgGetCmdCtrl, &Msg, &CmdExt));
if( pConfigOpt )
{
*pConfigOpt = (_u8)Msg.Rsp.ConfigOpt;
}
if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
{
*pConfigLen = (_u8)CmdExt.RxPayloadLen;
if( SL_MAC_ADDRESS_GET == ConfigId )
{
return SL_RET_CODE_OK; /* sp fix */
}
else
{
return SL_ESMALLBUF;
}
}
else
{
*pConfigLen = (_u8)CmdExt.ActualRxPayloadLen;
}
return (_i16)Msg.Rsp.Status;
}
_i16 sl_Bind(_i16 sd, const SlSockAddr_t *addr, _i16 addrlen)
{
_SlSockBindMsg_u Msg;
_SlCmdCtrl_t CmdCtrl = {0, 0, (_SlArgSize_t)sizeof(_SocketResponse_t)};
/* 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_BIND;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv4Command_t);
break;
#ifndef SL_TINY_EXT
case SL_AF_INET6_EUI_48:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv6EUI48Command_t);
break;
#ifdef SL_SUPPORT_IPV6
case AF_INET6:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_BIND_V6;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv6Command_t);
break;
#endif
#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);
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&CmdCtrl, &Msg, NULL));
return Msg.Rsp.statusOrLen;
}
long sl_DevSet(unsigned char DeviceSetId ,unsigned char Option,unsigned char ConfigLen, unsigned char *pValues)
{
_SlDeviceMsgSet_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = (ConfigLen+3) & (~3);
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = (UINT8 *)pValues;
CmdExt.pRxPayload = NULL;
Msg.Cmd.DeviceSetId = DeviceSetId;
Msg.Cmd.ConfigLen = ConfigLen;
Msg.Cmd.Option = Option;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlDeviceSetCmdCtrl, &Msg, &CmdExt));
return (int)Msg.Rsp.status;
}
int sl_SetSockOpt(int sd, int level, int optname, const void *optval, SlSocklen_t optlen)
{
_SlSetSockOptMsg_u Msg;
_SlCmdExt_t CmdExt;
CmdExt.TxPayloadLen = optlen;
CmdExt.RxPayloadLen = 0;
CmdExt.pTxPayload = (UINT8 *)optval;
CmdExt.pRxPayload = NULL;
Msg.Cmd.sd = sd;
Msg.Cmd.level = level;
Msg.Cmd.optionLen = optlen;
Msg.Cmd.optionName = optname;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSetSockOptCmdCtrl, &Msg, &CmdExt));
return (int)Msg.Rsp.statusOrLen;
}
int sl_Socket(int Domain, int Type, int Protocol)
{
_SlSockSocketMsg_u Msg;
Msg.Cmd.Domain = (UINT8)Domain;
Msg.Cmd.Type = (UINT8)Type;
Msg.Cmd.Protocol = (UINT8)Protocol;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlSockSocketCmdCtrl, &Msg, NULL));
if( Msg.Rsp.statusOrLen < 0 )
{
return( Msg.Rsp.statusOrLen );
}
else
{
return (int)((UINT8)Msg.Rsp.sd);
}
}
