_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;
}
_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;
}
_i32 sl_NetCfgSet(const _u8 ConfigId ,const _u8 ConfigOpt,const _u8 ConfigLen,const _u8 *pValues)
{
_SlNetCfgMsgSet_u Msg;
_SlCmdExt_t CmdExt;
_SlDrvResetCmdExt(&CmdExt);
CmdExt.TxPayloadLen = (ConfigLen+3) & (~3);
CmdExt.pTxPayload = (_u8 *)pValues;
Msg.Cmd.ConfigId = ConfigId;
Msg.Cmd.ConfigLen = ConfigLen;
Msg.Cmd.ConfigOpt = ConfigOpt;
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetCfgSetCmdCtrl, &Msg, &CmdExt));
return (_i16)Msg.Rsp.status;
}
_i16 sl_NetUtilCmd(const _u16 Cmd, const _u8 *pAttrib, const _u16 AttribLen,
const _u8 *pInputValues, const _u16 InputLen,
_u8 *pOutputValues, _u16 *pOutputLen)
{
_i16 RetVal=0;
SlNetUtilCmdMsg_u Msg;
_i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
_SlCmdExt_t CmdExt;
_SlNetUtilCmdData_t OutData;
/* prepare the Cmd (control structure and data-buffer) */
Msg.Cmd.Cmd = Cmd;
Msg.Cmd.AttribLen = AttribLen;
Msg.Cmd.InputLen = InputLen;
Msg.Cmd.OutputLen = *pOutputLen;
_SlDrvResetCmdExt(&CmdExt);
_SlDrvMemZero(&OutData, sizeof(_SlNetUtilCmdData_t));
if(AttribLen > 0)
{
CmdExt.pTxPayload1 = (_u8*)pAttrib;
CmdExt.TxPayload1Len = AttribLen;
}
if (InputLen > 0)
{
CmdExt.pTxPayload2 = (_u8*)pInputValues;
CmdExt.TxPayload2Len = InputLen;
}
/* Set the pointers to be filled upon the async event reception */
OutData.pOutputValues = pOutputValues;
OutData.pOutputLen = pOutputLen;
ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&OutData, NETUTIL_CMD_ID, SL_MAX_SOCKETS);
if (MAX_CONCURRENT_ACTIONS == ObjIdx)
{
return SL_POOL_IS_EMPTY;
}
/* send the command */
VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlNetUtilCmdCtrl, &Msg, &CmdExt));
if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
{
/* after the async event is signaled, the data will be copied to the pOutputValues buffer */
SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
/* the response header status */
RetVal = OutData.Status;
}
else
{
RetVal = Msg.Rsp.status;
}
_SlDrvReleasePoolObj((_u8)ObjIdx);
return RetVal;
}
_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_SendTo(_i16 sd, const void *pBuf, _i16 Len, _i16 flags, const SlSockAddr_t *to, SlSocklen_t tolen)
{
_SlSendtoMsg_u Msg;
_SlCmdCtrl_t CmdCtrl = {0, 0, 0};
_SlCmdExt_t CmdExt;
_u16 ChunkLen;
_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.TxPayloadLen = (_u16)Len;
CmdExt.pTxPayload = (_u8 *)pBuf;
switch(to->sa_family)
{
case SL_AF_INET:
CmdCtrl.Opcode = SL_OPCODE_SOCKET_SENDTO;
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_SENDTO_V6;
CmdCtrl.TxDescLen = (_SlArgSize_t)sizeof(_SocketAddrIPv6Command_t);
break;
#endif
#endif
case SL_AF_RF:
default:
return SL_RET_CODE_INVALID_INPUT;
}
ChunkLen = _sl_TruncatePayloadByProtocol(sd,(_u16)Len);
Msg.Cmd.IpV4.lenOrPadding = (_i16)ChunkLen;
CmdExt.TxPayloadLen = ChunkLen;
Msg.Cmd.IpV4.sd = (_u8)sd;
_sl_BuildAddress(to, &Msg.Cmd);
Msg.Cmd.IpV4.FamilyAndFlags |= flags & 0x0F;
do
{
RetVal = _SlDrvDataWriteOp((_SlSd_t)sd, &CmdCtrl, &Msg, &CmdExt);
if(SL_OS_RET_CODE_OK == RetVal)
{
CmdExt.pTxPayload += ChunkLen;
ChunkLen = (_u16)((_u8 *)pBuf + Len - CmdExt.pTxPayload);
ChunkLen = _sl_TruncatePayloadByProtocol(sd,ChunkLen);
CmdExt.TxPayloadLen = ChunkLen;
Msg.Cmd.IpV4.lenOrPadding = (_i16)ChunkLen;
}
else
{
return RetVal;
}
}while(ChunkLen > 0);
return (_i16)Len;
}
