42 #include <ti/drivers/net/wifi/simplelink.h> 43 #include <ti/drivers/net/wifi/source/protocol.h> 44 #include <ti/drivers/net/wifi/source/driver.h> 53 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByName(
void *pVoidBuf);
55 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByService(
void *pVoidBuf);
56 _SlReturnVal_t _SlNetAppHandleAsync_PingResponse(
void *pVoidBuf);
59 _i16 _SlNetAppMDNSRegisterUnregisterService(
const _i8* pServiceName,
60 const _u8 ServiceNameLen,
72 #define SL_NETAPP_SERVICE_SIZE_MASK (0x7) 73 #define SL_NETAPP_PING_GUARD_INTERVAL (20000) 75 static _u16 NetAppServiceSizeLUT[] =
91 }_SlNetAppStartStopMsg_u;
94 #if _SL_INCLUDE_FUNC(sl_NetAppStart) 98 SL_OPCODE_NETAPP_START_COMMAND,
105 _SlNetAppStartStopMsg_u Msg;
106 Msg.Cmd.AppId = AppBitMap;
110 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
111 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppStartCtrl, &Msg, NULL));
113 return Msg.Rsp.status;
120 #if _SL_INCLUDE_FUNC(sl_NetAppStop) 124 SL_OPCODE_NETAPP_STOP_COMMAND,
131 _SlNetAppStartStopMsg_u Msg;
135 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
136 Msg.Cmd.AppId = AppBitMap;
137 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppStopCtrl, &Msg, NULL));
139 return Msg.Rsp.status;
148 #if _SL_INCLUDE_FUNC(sl_NetAppArpFlush) 155 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
157 return _SlDrvBasicCmd(SL_OPCODE_NETAPP_ARPFLUSH);
165 #if _SL_INCLUDE_FUNC(sl_NetAppNdFlush) 172 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
174 return _SlDrvBasicCmd(SL_OPCODE_NETAPP_NDFLUSH_V6);
187 }NetappGetServiceListCMD_t;
191 NetappGetServiceListCMD_t Cmd;
193 }_SlNetappGetServiceListMsg_u;
196 #if _SL_INCLUDE_FUNC(sl_NetAppGetServiceList) 200 SL_OPCODE_NETAPP_NETAPP_MDNS_LOOKUP_SERVICE,
201 (_SlArgSize_t)
sizeof(NetappGetServiceListCMD_t),
206 const _u8 MaxServiceCount,
209 const _u32 BufferLength
214 _SlNetappGetServiceListMsg_u Msg;
216 _u16 ServiceSize = 0;
221 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
229 ServiceSize = NetAppServiceSizeLUT[Flags & SL_NETAPP_SERVICE_SIZE_MASK];
230 BufferSize = MaxServiceCount * ServiceSize;
234 if(BufferLength < BufferSize)
236 return SL_ERROR_NET_APP_RX_BUFFER_LENGTH;
239 _SlDrvResetCmdExt(&CmdExt);
240 CmdExt.RxPayloadLen = (_i16)BufferSize;
241 CmdExt.pRxPayload = (_u8 *)pBuffer;
243 Msg.Cmd.IndexOffest = IndexOffest;
244 Msg.Cmd.MaxServiceCount = MaxServiceCount;
245 Msg.Cmd.Flags = Flags;
248 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetServiceListeCtrl, &Msg, &CmdExt));
249 retVal = Msg.Rsp.status;
285 }NetappMdnsSetService_t;
289 NetappMdnsSetService_t Cmd;
291 }_SlNetappMdnsRegisterServiceMsg_u;
293 #if (_SL_INCLUDE_FUNC(sl_NetAppMDNSRegisterService) || _SL_INCLUDE_FUNC(sl_NetAppMDNSUnregisterService)) 297 SL_OPCODE_NETAPP_MDNSREGISTERSERVICE,
298 (_SlArgSize_t)
sizeof(NetappMdnsSetService_t),
374 _i16 _SlNetAppMDNSRegisterUnregisterService(
const _i8* pServiceName,
375 const _u8 ServiceNameLen,
382 _SlNetappMdnsRegisterServiceMsg_u Msg;
384 _i8 ServiceNameAndTextBuffer[SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH];
389 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
408 Msg.Cmd.ServiceNameLen = ServiceNameLen;
409 Msg.Cmd.Options = Options;
411 Msg.Cmd.TextLen = TextLen;
419 if(TextLen + ServiceNameLen > (SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH - 1 ))
424 _SlDrvMemZero(ServiceNameAndTextBuffer, (_u16)SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH);
427 sl_Memcpy(ServiceNameAndTextBuffer,
433 TextPtr = &ServiceNameAndTextBuffer[ServiceNameLen];
440 _SlDrvResetCmdExt(&CmdExt);
441 CmdExt.TxPayload1Len = (TextLen + ServiceNameLen);
442 CmdExt.pTxPayload1 = (_u8 *)ServiceNameAndTextBuffer;
444 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlRegisterServiceCtrl, &Msg, &CmdExt));
446 return (_i16)Msg.Rsp.status;
451 #if _SL_INCLUDE_FUNC(sl_NetAppMDNSRegisterService) 454 const _u8 ServiceNameLen,
463 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
485 Options |= SL_NETAPP_MDNS_OPTIONS_ADD_SERVICE_BIT;
487 return _SlNetAppMDNSRegisterUnregisterService(pServiceName,
500 #if _SL_INCLUDE_FUNC(sl_NetAppMDNSUnRegisterService) 503 const _u8 ServiceNameLen,_u32 Options)
508 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
526 Options &= (~SL_NETAPP_MDNS_OPTIONS_ADD_SERVICE_BIT);
528 return _SlNetAppMDNSRegisterUnregisterService( pServiceName,
558 }_GetHostByServiceCommand_t;
581 }_GetHostByServiceIPv6AsyncResponse_t;
594 }_GetHostByServiceAsyncResponse_t;
598 _GetHostByServiceCommand_t Cmd;
600 }_SlGetHostByServiceMsg_u;
602 #if _SL_INCLUDE_FUNC(sl_NetAppDnsGetHostByService) 606 SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICE,
607 (_SlArgSize_t)
sizeof(_GetHostByServiceCommand_t),
614 const _u8 ServiceLen,
622 _SlGetHostByServiceMsg_u Msg;
624 _GetHostByServiceAsyncResponse_t AsyncRsp;
625 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
629 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
630 _SlDrvMemZero(&AsyncRsp,
sizeof(_GetHostByServiceAsyncResponse_t));
651 Msg.Cmd.ServiceLen = ServiceLen;
652 Msg.Cmd.AddrLen = Family;
657 _SlDrvResetCmdExt(&CmdExt);
658 CmdExt.TxPayload1Len = ServiceLen;
659 CmdExt.pTxPayload1 = (_u8 *)pServiceName;
665 AsyncRsp.out_pText = pText;
666 AsyncRsp.inout_TextLen = (_u16* )pTextLen;
667 AsyncRsp.out_pPort = pPort;
668 AsyncRsp.out_pAddr = (_u32 *)&pAddr[0];
670 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, GETHOSYBYSERVICE_ID, SL_MAX_SOCKETS);
672 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
674 return SL_POOL_IS_EMPTY;
677 if (SL_AF_INET6 == Family)
679 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
682 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByServiceCtrl, &Msg, &CmdExt));
685 if(SL_RET_CODE_OK == Msg.Rsp.status)
687 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
692 Msg.Rsp.status = AsyncRsp.Status;
695 _SlDrvReleasePoolObj(ObjIdx);
696 return Msg.Rsp.status;
754 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByService(
void *pVoidBuf)
758 _GetHostByServiceAsyncResponse_t* Res= NULL;
759 _GetHostByServiceIPv6AsyncResponse_t *pMsgArgs = (_GetHostByServiceIPv6AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
761 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
763 Res = (_GetHostByServiceAsyncResponse_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
765 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
767 Res->out_pAddr[1] = pMsgArgs->Address[1];
768 Res->out_pAddr[2] = pMsgArgs->Address[2];
769 Res->out_pAddr[3] = pMsgArgs->Address[3];
772 TextLen = pMsgArgs->TextLen;
775 Res->out_pAddr[0] = pMsgArgs->Address[0];
776 Res->out_pPort[0] = pMsgArgs->Port;
777 Res->Status = (_i16)pMsgArgs->Status;
779 UserTextLen = Res->inout_TextLen[0];
782 UserTextLen = (TextLen <= UserTextLen) ? TextLen : UserTextLen;
783 Res->inout_TextLen[0] = UserTextLen ;
791 if (g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
793 sl_Memcpy(Res->out_pText,
794 (_i8 *)(& pMsgArgs[1]),
799 sl_Memcpy(Res->out_pText,
800 (_i8 *)(& pMsgArgs->Address[1]),
804 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
806 return SL_OS_RET_CODE_OK;
812 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByAddr(
void *pVoidBuf)
814 SL_TRACE0(DBG_MSG, MSG_303,
"STUB: _SlNetAppHandleAsync_DnsGetHostByAddr not implemented yet!");
815 return SL_OS_RET_CODE_OK;
825 }_GetHostByNameAsyncResponse_u;
831 }_SlGetHostByNameMsg_u;
833 #if _SL_INCLUDE_FUNC(sl_NetAppDnsGetHostByName) 836 SL_OPCODE_NETAPP_DNSGETHOSTBYNAME,
843 _SlGetHostByNameMsg_u Msg;
845 _GetHostByNameAsyncResponse_u AsyncRsp;
846 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
850 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
852 _SlDrvResetCmdExt(&ExtCtrl);
853 ExtCtrl.TxPayload1Len = NameLen;
854 ExtCtrl.pTxPayload1 = (_u8 *)pHostName;
856 Msg.Cmd.Len = NameLen;
857 Msg.Cmd.Family = Family;
860 ObjIdx = _SlDrvWaitForPoolObj(GETHOSYBYNAME_ID,SL_MAX_SOCKETS);
861 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
863 return SL_POOL_IS_EMPTY;
865 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
867 return SL_RET_CODE_STOP_IN_PROGRESS;
870 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
872 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&AsyncRsp;
874 if (SL_AF_INET6 == Family)
876 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
879 SL_DRV_PROTECTION_OBJ_UNLOCK();
881 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByNameCtrl, &Msg, &ExtCtrl));
883 if(SL_RET_CODE_OK == Msg.Rsp.status)
885 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0));
887 Msg.Rsp.status = (_i16)AsyncRsp.IpV4.Status;
889 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
891 sl_Memcpy((_i8 *)OutIpAddr,
892 (_i8 *)&AsyncRsp.IpV4.Ip0,
893 (SL_AF_INET == Family) ? SL_IPV4_ADDRESS_SIZE : SL_IPV6_ADDRESS_SIZE);
896 _SlDrvReleasePoolObj(ObjIdx);
897 return Msg.Rsp.status;
905 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByName(
void *pVoidBuf)
909 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
911 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
914 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
924 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
925 SL_DRV_PROTECTION_OBJ_UNLOCK();
926 return SL_OS_RET_CODE_OK;
931 pReport->PacketsSent = pResults->NumSendsPings;
932 pReport->PacketsReceived = pResults->NumSuccsessPings;
933 pReport->MinRoundTime = pResults->RttMin;
934 pReport->MaxRoundTime = pResults->RttMax;
935 pReport->AvgRoundTime = pResults->RttAvg;
936 pReport->TestTime = pResults->TestTime;
942 _SlReturnVal_t _SlNetAppHandleAsync_PingResponse(
void *pVoidBuf)
947 if(pPingCallBackFunc)
949 _SlNetAppCopyPingResultsToReport(pMsgArgs,&pingReport);
950 pPingCallBackFunc(&pingReport);
954 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
956 VERIFY_SOCKET_CB(NULL != g_pCB->PingCB.PingAsync.pAsyncRsp);
958 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
960 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlPingReportResponse_t));
961 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
963 SL_DRV_PROTECTION_OBJ_UNLOCK();
966 return SL_OS_RET_CODE_OK;
980 CMD_PING_TEST_RUNNING = 0,
981 CMD_PING_TEST_STOPPED
984 #if _SL_INCLUDE_FUNC(sl_NetAppPing) 988 _SlPingStartMsg_u Msg;
990 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
991 _u32 PingTimeout = 0;
995 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
997 if(NULL != pPingParams)
999 if(SL_AF_INET == Family)
1001 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1002 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV4_ADDRESS_SIZE);
1006 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART_V6;
1007 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV6_ADDRESS_SIZE);
1010 Msg.Cmd.PingIntervalTime = pPingParams->PingIntervalTime;
1011 Msg.Cmd.PingSize = pPingParams->PingSize;
1012 Msg.Cmd.PingRequestTimeout = pPingParams->PingRequestTimeout;
1013 Msg.Cmd.TotalNumberOfAttempts = pPingParams->TotalNumberOfAttempts;
1014 Msg.Cmd.Flags = pPingParams->Flags;
1018 PingTimeout = SL_NETAPP_PING_GUARD_INTERVAL + (pPingParams->PingIntervalTime * pPingParams->TotalNumberOfAttempts);
1020 if (Msg.Cmd.Ip != 0)
1027 if ((pPingCallback == NULL) && (pPingParams->Flags == 0) && (pPingParams->TotalNumberOfAttempts == 0))
1029 return SL_RET_CODE_NET_APP_PING_INVALID_PARAMS;
1034 pPingCallBackFunc = pPingCallback;
1039 ObjIdx = _SlDrvWaitForPoolObj(PING_ID,SL_MAX_SOCKETS);
1040 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1042 return SL_POOL_IS_EMPTY;
1044 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
1046 return SL_RET_CODE_STOP_IN_PROGRESS;
1048 OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
1050 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&PingRsp;
1051 pPingCallBackFunc = NULL;
1052 OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
1059 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1063 VERIFY_RET_OK(_SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
1064 if (Msg.Cmd.Ip != 0)
1066 if(CMD_PING_TEST_RUNNING == (_i16)Msg.Rsp.Status || CMD_PING_TEST_STOPPED == (_i16)Msg.Rsp.Status )
1069 if( NULL == pPingCallback )
1071 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, PingTimeout, SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE));
1073 if( SL_OS_RET_CODE_OK == (_i16)PingRsp.Status )
1075 _SlNetAppCopyPingResultsToReport(&PingRsp,pReport);
1077 _SlDrvReleasePoolObj(ObjIdx);
1082 if( NULL == pPingCallback )
1084 _SlDrvReleasePoolObj(ObjIdx);
1088 return (_i16)Msg.Rsp.Status;
1101 #if _SL_INCLUDE_FUNC(sl_NetAppSet) 1105 SL_OPCODE_NETAPP_NETAPPSET,
1110 _i16
sl_NetAppSet(
const _u8 AppId ,
const _u8 Option,
const _u8 OptionLen,
const _u8 *pOptionValue)
1112 _SlNetAppMsgSet_u Msg;
1117 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1119 _SlDrvResetCmdExt(&CmdExt);
1120 CmdExt.TxPayload1Len = (OptionLen+3) & (~3);
1121 CmdExt.pTxPayload1 = (_u8 *)pOptionValue;
1123 Msg.Cmd.AppId = AppId;
1124 Msg.Cmd.ConfigLen = OptionLen;
1125 Msg.Cmd.ConfigOpt = Option;
1127 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppSetCmdCtrl, &Msg, &CmdExt));
1129 return (_i16)Msg.Rsp.status;
1140 }_SlNetAppMsgSendTokenValue_u;
1144 SL_OPCODE_NETAPP_HTTPSENDTOKENVALUE,
1151 _SlNetAppMsgSendTokenValue_u Msg;
1154 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1156 CmdExt.TxPayload1Len = (Token_value->ValueLen+3) & (~3);
1157 CmdExt.pTxPayload1 = (_u8 *) Token_value->pTokenValue;
1159 Msg.Cmd.TokenValueLen = Token_value->ValueLen;
1160 Msg.Cmd.TokenNameLen = Token_value->NameLen;
1161 sl_Memcpy(&Msg.Cmd.TokenName[0], Token_value->pTokenName, Token_value->NameLen);
1163 VERIFY_RET_OK(_SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendTokenValueCmdCtrl, &Msg, &CmdExt));
1165 return Msg.Rsp.status;
1175 }_SlNetAppMsgSendResponse_u;
1179 SL_OPCODE_NETAPP_RESPONSE,
1186 _SlNetAppMsgSendResponse_u Msg;
1188 _SlReturnVal_t RetVal;
1191 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1193 dataLen = NetAppResponse->ResponseData.MetadataLen + NetAppResponse->ResponseData.PayloadLen;
1195 if ((NetAppResponse->ResponseData.MetadataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN) && (dataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN))
1200 CmdExt.pTxPayload1 = NetAppResponse->ResponseData.pMetadata;
1201 CmdExt.TxPayload1Len = NetAppResponse->ResponseData.MetadataLen;
1203 CmdExt.pTxPayload2 = NetAppResponse->ResponseData.pPayload;
1204 CmdExt.TxPayload2Len = NetAppResponse->ResponseData.PayloadLen;
1208 CmdExt.pTxPayload1 = NULL;
1209 CmdExt.pTxPayload2 = NULL;
1212 CmdExt.RxPayloadLen = 0;
1213 CmdExt.pRxPayload = NULL;
1215 Msg.Cmd.Handle = handle;
1216 Msg.Cmd.status = NetAppResponse->Status;
1217 Msg.Cmd.MetadataLen = NetAppResponse->ResponseData.MetadataLen;
1218 Msg.Cmd.PayloadLen = NetAppResponse->ResponseData.PayloadLen;
1219 Msg.Cmd.Flags = NetAppResponse->ResponseData.Flags;
1221 RetVal = _SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendResponseCmdCtrl, &Msg, &CmdExt);
1226 RetVal = SL_ERROR_BSD_ENOMEM;
1239 }_SlNetAppReceiveMsg_u;
1241 #if _SL_INCLUDE_FUNC(sl_NetAppRecv) 1245 SL_OPCODE_NETAPP_RECEIVEREQUEST,
1250 _SlReturnVal_t
sl_NetAppRecv( _u16 Handle, _u16 *DataLen, _u8 *pData, _u32 *Flags)
1252 _SlNetAppReceiveMsg_u Msg;
1256 _SlReturnVal_t RetVal;
1257 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1261 if ((NULL == pData) || (0==DataLen))
1263 return SL_ERROR_BSD_EINVAL;
1267 _SlDrvResetCmdExt(&CmdExt);
1268 CmdExt.RxPayloadLen = *DataLen;
1269 CmdExt.pRxPayload = pData;
1272 Msg.Cmd.Handle = Handle;
1273 Msg.Cmd.MaxBufferLen = *DataLen;
1274 Msg.Cmd.Flags = *Flags;
1277 ObjIdx = _SlDrvWaitForPoolObj(NETAPP_RECEIVE_ID, SL_MAX_SOCKETS);
1279 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1281 return SL_POOL_IS_EMPTY;
1283 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
1285 return SL_RET_CODE_STOP_IN_PROGRESS;
1289 AsyncRsp.Handle = Handle;
1291 AsyncRsp.PayloadLen = 0;
1293 _SlDrvProtectionObjLockWaitForever();
1295 pArgsData.pData = (_u8 *) &CmdExt;
1296 pArgsData.pArgs = (_u8 *) &AsyncRsp;
1298 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&pArgsData;
1300 _SlDrvProtectionObjUnLock();
1303 RetVal = _SlDrvCmdSend((
_SlCmdCtrl_t *)&_SlNetAppReceiveCmdCtrl, &Msg, &CmdExt);
1305 if(SL_OS_RET_CODE_OK == RetVal)
1308 VERIFY_RET_OK(_SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0));
1311 *DataLen = AsyncRsp.PayloadLen;
1312 *Flags = AsyncRsp.Flags;
1315 _SlDrvReleasePoolObj(ObjIdx);
1324 void _SlNetAppHandleAsync_NetAppReceive(
void *pVoidBuf)
1334 _SlDrvProtectionObjLockWaitForever();
1336 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
1339 CmdExt = (
_SlCmdExt_t *) ((
_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))-> pData;
1341 if (pMsgArgs->Handle == AsyncRsp->Handle)
1343 if (pMsgArgs->PayloadLen <= CmdExt->RxPayloadLen)
1345 len = pMsgArgs->PayloadLen;
1349 len = CmdExt->RxPayloadLen;
1353 sl_Memcpy (CmdExt->pRxPayload, pData, len);
1356 AsyncRsp->PayloadLen = len;
1357 AsyncRsp->Flags = pMsgArgs->Flags;
1361 _SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1362 _SlDrvProtectionObjUnLock();
1376 }_SlNetAppMsgSend_u;
1380 SL_OPCODE_NETAPP_SEND,
1387 _SlNetAppMsgSend_u Msg;
1390 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1392 if ((((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) && (DataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN)) ||
1393 (((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == 0) && (DataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN)))
1395 CmdExt.TxPayload1Len = (DataLen+3) & (~3);
1396 CmdExt.pTxPayload1 = (_u8 *) pData;
1398 Msg.Cmd.Handle = Handle;
1399 Msg.Cmd.DataLen = DataLen;
1400 Msg.Cmd.Flags = Flags;
1402 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppSendCmdCtrl, &Msg, &CmdExt));
1406 Msg.Rsp.status = SL_ERROR_BSD_ENOMEM;
1409 return Msg.Rsp.status;
1421 #if _SL_INCLUDE_FUNC(sl_NetAppGet) 1424 SL_OPCODE_NETAPP_NETAPPGET,
1429 _i16
sl_NetAppGet(
const _u8 AppId,
const _u8 Option,_u8 *pOptionLen, _u8 *pOptionValue)
1431 _SlNetAppMsgGet_u Msg;
1436 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1438 if (*pOptionLen == 0)
1443 _SlDrvResetCmdExt(&CmdExt);
1444 CmdExt.RxPayloadLen = (_i16)(*pOptionLen);
1445 CmdExt.pRxPayload = (_u8 *)pOptionValue;
1447 Msg.Cmd.AppId = AppId;
1448 Msg.Cmd.ConfigOpt = Option;
1449 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppGetCmdCtrl, &Msg, &CmdExt));
1452 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
1454 *pOptionLen = (_u8)CmdExt.RxPayloadLen;
1455 return SL_ESMALLBUF;
1459 *pOptionLen = (_u8)CmdExt.ActualRxPayloadLen;
1462 return (_i16)Msg.Rsp.Status;
1469 _SlReturnVal_t _SlNetAppEventHandler(
void* pArgs)
1472 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1476 switch(pHdr->GenHeader.Opcode)
1478 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE:
1479 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE_V6:
1480 _SlNetAppHandleAsync_DnsGetHostByName(pArgs);
1482 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE:
1483 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE_V6:
1484 _SlNetAppHandleAsync_DnsGetHostByService(pArgs);
1486 case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE:
1487 _SlNetAppHandleAsync_PingResponse(pArgs);
1490 case SL_OPCODE_NETAPP_HTTPGETTOKENVALUE:
1492 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1498 httpServerResponse.Response = SL_NETAPP_HTTPSETTOKENVALUE;
1499 httpServerResponse.ResponseData.TokenValue.Len = SL_NETAPP_MAX_TOKEN_VALUE_LEN;
1502 httpServerResponse.ResponseData.TokenValue.pData = (_u8 *)_SL_RESP_ARGS_START(pHdr) + SL_NETAPP_MAX_TOKEN_NAME_LEN;
1504 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_GET;
1505 httpServerEvent.EventData.HttpTokenName.Len = httpGetToken->TokenNameLen;
1506 httpServerEvent.EventData.HttpTokenName.pData = pTokenName;
1508 Token_value.pTokenName = pTokenName;
1510 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1512 Token_value.ValueLen = httpServerResponse.ResponseData.TokenValue.Len;
1513 Token_value.NameLen = httpServerEvent.EventData.HttpTokenName.Len;
1514 Token_value.pTokenValue = httpServerResponse.ResponseData.TokenValue.pData;
1516 _SlNetAppSendTokenValue(&Token_value);
1524 Token_value.pTokenName = pTokenName;
1525 Token_value.ValueLen = 0;
1526 Token_value.NameLen = httpGetToken->TokenNameLen;
1527 Token_value.pTokenValue = NULL;
1529 _SlNetAppSendTokenValue(&Token_value);
1534 case SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE:
1536 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1542 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_POST;
1544 httpServerEvent.EventData.HttpPostData.Action.Len = httpPostTokenArgs->PostActionLen;
1545 httpServerEvent.EventData.HttpPostData.Action.pData = pPostParams;
1546 pPostParams+=httpPostTokenArgs->PostActionLen;
1548 httpServerEvent.EventData.HttpPostData.TokenName.Len = httpPostTokenArgs->TokenNameLen;
1549 httpServerEvent.EventData.HttpPostData.TokenName.pData = pPostParams;
1550 pPostParams+=httpPostTokenArgs->TokenNameLen;
1552 httpServerEvent.EventData.HttpPostData.TokenValue.Len = httpPostTokenArgs->TokenValueLen;
1553 httpServerEvent.EventData.HttpPostData.TokenValue.pData = pPostParams;
1555 httpServerResponse.Response = SL_NETAPP_HTTPRESPONSE_NONE;
1557 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1562 case SL_OPCODE_NETAPP_REQUEST:
1564 #if defined(slcb_NetAppRequestHdlr) || defined(EXT_LIB_REGISTERED_NETAPP_REQUEST_EVENTS) 1573 NetAppRequest.AppId = protocol_NetAppRequest->AppId;
1574 NetAppRequest.Type = protocol_NetAppRequest->RequestType;
1575 NetAppRequest.Handle = protocol_NetAppRequest->Handle;
1576 NetAppRequest.requestData.Flags = protocol_NetAppRequest->Flags;
1580 NetAppRequest.requestData.pMetadata = pData;
1581 NetAppRequest.requestData.MetadataLen = protocol_NetAppRequest->MetadataLen;
1584 pData+=protocol_NetAppRequest->MetadataLen;
1585 NetAppRequest.requestData.pPayload = pData;
1586 NetAppRequest.requestData.PayloadLen = protocol_NetAppRequest->PayloadLen;
1589 sl_Memset(&NetAppResponse, 0,
sizeof (NetAppResponse));
1590 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1593 _SlDrvDispatchNetAppRequestEvents (&NetAppRequest, &NetAppResponse);
1596 status = _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1598 #if (defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_NetAppRequestMemFree)) 1599 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_MEM_FREE))
1601 if ((NetAppResponse.ResponseData.MetadataLen > 0) && (NetAppResponse.ResponseData.pMetadata != NULL))
1603 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pMetadata);
1606 if ((NetAppResponse.ResponseData.PayloadLen > 0) && (NetAppResponse.ResponseData.pPayload != NULL))
1608 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pPayload);
1616 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1617 NetAppResponse.ResponseData.pMetadata = NULL;
1618 NetAppResponse.ResponseData.MetadataLen = 0;
1619 NetAppResponse.ResponseData.pPayload = NULL;
1620 NetAppResponse.ResponseData.PayloadLen = 0;
1621 NetAppResponse.ResponseData.Flags = 0;
1624 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1634 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1635 NetAppResponse.ResponseData.pMetadata = NULL;
1636 NetAppResponse.ResponseData.MetadataLen = 0;
1637 NetAppResponse.ResponseData.pPayload = NULL;
1638 NetAppResponse.ResponseData.PayloadLen = 0;
1639 NetAppResponse.ResponseData.Flags = 0;
1642 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1653 return SL_OS_RET_CODE_OK;
_i16 sl_NetAppArpFlush(void)
Flush IPv4 ARP table.
_i16 sl_NetAppSet(const _u8 AppId, const _u8 Option, const _u8 OptionLen, const _u8 *pOptionValue)
Setting network application configurations.
_i16 sl_NetAppMDNSUnRegisterService(const _i8 *pServiceName, const _u8 ServiceNameLen, _u32 Options)
Unregister mDNS service This function deletes the mDNS service from the mDNS package and the database...
_SlReturnVal_t sl_NetAppRecv(_u16 Handle, _u16 *DataLen, _u8 *pData, _u32 *Flags)
Function for retrieving data from the network processor following a Netapp request event (i...
_i16 sl_NetAppDnsGetHostByService(_i8 *pServiceName, const _u8 ServiceLen, const _u8 Family, _u32 pAddr[], _u32 *pPort, _u16 *pTextLen, _i8 *pText)
Return service attributes like IP address, port and text according to service name The user sets a s...
_i16 sl_NetAppDnsGetHostByName(_i8 *pHostName, const _u16 NameLen, _u32 *OutIpAddr, const _u8 Family)
Get host IP by name Obtain the IP Address of machine on network, by machine name. ...
_i16 sl_NetAppPing(const SlNetAppPingCommand_t *pPingParams, const _u8 Family, SlNetAppPingReport_t *pReport, const P_SL_DEV_PING_CALLBACK pPingCallback)
send ICMP ECHO_REQUEST to network hosts
_i16 sl_NetAppStart(const _u32 AppBitMap)
Starts a network application.
_i16 sl_NetAppMDNSRegisterService(const _i8 *pServiceName, const _u8 ServiceNameLen, const _i8 *pText, const _u8 TextLen, const _u16 Port, const _u32 TTL, _u32 Options)
Register a new mDNS service This function registers a new mDNS service to the mDNS package and the D...
_i16 sl_NetAppNdFlush(void)
Flush IPv6 Neighbor Discovery table.
_i16 sl_NetAppGetServiceList(const _u8 IndexOffest, const _u8 MaxServiceCount, const _u8 Flags, _i8 *pBuffer, const _u32 BufferLength)
Get service list Insert into out pBuffer a list of peer's services that are in the NWP without issui...
_i16 sl_NetAppStop(const _u32 AppBitMap)
Stops a network application.
_u16 sl_NetAppSend(_u16 Handle, _u16 DataLen, _u8 *pData, _u32 Flags)
Function for sending Netapp response or data following a Netapp request event (i.e. HTTP GET request)
_i16 sl_NetAppGet(const _u8 AppId, const _u8 Option, _u8 *pOptionLen, _u8 *pOptionValue)
Getting network applications configurations.