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); } }