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;
630 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
631 _SlDrvMemZero(&AsyncRsp,
sizeof(_GetHostByServiceAsyncResponse_t));
652 Msg.Cmd.ServiceLen = ServiceLen;
653 Msg.Cmd.AddrLen = Family;
658 _SlDrvResetCmdExt(&CmdExt);
659 CmdExt.TxPayload1Len = ServiceLen;
660 CmdExt.pTxPayload1 = (_u8 *)pServiceName;
666 AsyncRsp.out_pText = pText;
667 AsyncRsp.inout_TextLen = (_u16* )pTextLen;
668 AsyncRsp.out_pPort = pPort;
669 AsyncRsp.out_pAddr = (_u32 *)&pAddr[0];
671 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, GETHOSYBYSERVICE_ID, SL_MAX_SOCKETS);
678 if (SL_AF_INET6 == Family)
680 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
683 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByServiceCtrl, &Msg, &CmdExt));
686 if(SL_RET_CODE_OK == Msg.Rsp.status)
688 RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
693 Msg.Rsp.status = AsyncRsp.Status;
696 _SlDrvReleasePoolObj(ObjIdx);
703 return Msg.Rsp.status;
762 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByService(
void *pVoidBuf)
766 _GetHostByServiceAsyncResponse_t* Res= NULL;
767 _GetHostByServiceIPv6AsyncResponse_t *pMsgArgs = (_GetHostByServiceIPv6AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
769 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
771 Res = (_GetHostByServiceAsyncResponse_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
773 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
775 Res->out_pAddr[1] = pMsgArgs->Address[1];
776 Res->out_pAddr[2] = pMsgArgs->Address[2];
777 Res->out_pAddr[3] = pMsgArgs->Address[3];
780 TextLen = pMsgArgs->TextLen;
783 Res->out_pAddr[0] = pMsgArgs->Address[0];
784 Res->out_pPort[0] = pMsgArgs->Port;
785 Res->Status = (_i16)pMsgArgs->Status;
787 UserTextLen = Res->inout_TextLen[0];
790 UserTextLen = (TextLen <= UserTextLen) ? TextLen : UserTextLen;
791 Res->inout_TextLen[0] = UserTextLen ;
799 if (g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
801 sl_Memcpy(Res->out_pText,
802 (_i8 *)(& pMsgArgs[1]),
807 sl_Memcpy(Res->out_pText,
808 (_i8 *)(& pMsgArgs->Address[1]),
812 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
814 return SL_OS_RET_CODE_OK;
820 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByAddr(
void *pVoidBuf)
822 SL_TRACE0(DBG_MSG, MSG_303,
"STUB: _SlNetAppHandleAsync_DnsGetHostByAddr not implemented yet!");
823 return SL_OS_RET_CODE_OK;
833 }_GetHostByNameAsyncResponse_u;
839 }_SlGetHostByNameMsg_u;
841 #if _SL_INCLUDE_FUNC(sl_NetAppDnsGetHostByName) 844 SL_OPCODE_NETAPP_DNSGETHOSTBYNAME,
851 _SlGetHostByNameMsg_u Msg;
853 _GetHostByNameAsyncResponse_u AsyncRsp;
854 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
859 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
861 _SlDrvResetCmdExt(&ExtCtrl);
862 ExtCtrl.TxPayload1Len = NameLen;
863 ExtCtrl.pTxPayload1 = (_u8 *)pHostName;
865 Msg.Cmd.Len = NameLen;
866 Msg.Cmd.Family = Family;
869 ObjIdx = _SlDrvWaitForPoolObj(GETHOSYBYNAME_ID,SL_MAX_SOCKETS);
870 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
872 return SL_POOL_IS_EMPTY;
874 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
876 return SL_RET_CODE_STOP_IN_PROGRESS;
879 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
881 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&AsyncRsp;
883 if (SL_AF_INET6 == Family)
885 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
888 SL_DRV_PROTECTION_OBJ_UNLOCK();
890 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByNameCtrl, &Msg, &ExtCtrl));
892 if(SL_RET_CODE_OK == Msg.Rsp.status)
895 RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx,0,0);
897 Msg.Rsp.status = (_i16)AsyncRsp.IpV4.Status;
899 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
901 sl_Memcpy((_i8 *)OutIpAddr,
902 (_i8 *)&AsyncRsp.IpV4.Ip0,
903 (SL_AF_INET == Family) ? SL_IPV4_ADDRESS_SIZE : SL_IPV6_ADDRESS_SIZE);
907 _SlDrvReleasePoolObj(ObjIdx);
914 return Msg.Rsp.status;
923 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByName(
void *pVoidBuf)
927 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
929 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
932 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
942 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
943 SL_DRV_PROTECTION_OBJ_UNLOCK();
944 return SL_OS_RET_CODE_OK;
949 pReport->PacketsSent = pResults->NumSendsPings;
950 pReport->PacketsReceived = pResults->NumSuccsessPings;
951 pReport->MinRoundTime = pResults->RttMin;
952 pReport->MaxRoundTime = pResults->RttMax;
953 pReport->AvgRoundTime = pResults->RttAvg;
954 pReport->TestTime = pResults->TestTime;
960 _SlReturnVal_t _SlNetAppHandleAsync_PingResponse(
void *pVoidBuf)
965 if(pPingCallBackFunc)
967 _SlNetAppCopyPingResultsToReport(pMsgArgs,&pingReport);
968 pPingCallBackFunc(&pingReport);
972 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
974 VERIFY_SOCKET_CB(NULL != g_pCB->PingCB.PingAsync.pAsyncRsp);
976 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
978 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlPingReportResponse_t));
979 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
981 SL_DRV_PROTECTION_OBJ_UNLOCK();
984 return SL_OS_RET_CODE_OK;
998 CMD_PING_TEST_RUNNING = 0,
999 CMD_PING_TEST_STOPPED
1002 #if _SL_INCLUDE_FUNC(sl_NetAppPing) 1006 _SlPingStartMsg_u Msg;
1008 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1009 _u32 PingTimeout = 0;
1015 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1017 if(NULL != pPingParams)
1019 if(SL_AF_INET == Family)
1021 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1022 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV4_ADDRESS_SIZE);
1026 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART_V6;
1027 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV6_ADDRESS_SIZE);
1030 Msg.Cmd.PingIntervalTime = pPingParams->PingIntervalTime;
1031 Msg.Cmd.PingSize = pPingParams->PingSize;
1032 Msg.Cmd.PingRequestTimeout = pPingParams->PingRequestTimeout;
1033 Msg.Cmd.TotalNumberOfAttempts = pPingParams->TotalNumberOfAttempts;
1034 Msg.Cmd.Flags = pPingParams->Flags;
1038 PingTimeout = SL_NETAPP_PING_GUARD_INTERVAL + (pPingParams->PingIntervalTime * pPingParams->TotalNumberOfAttempts);
1040 if (Msg.Cmd.Ip != 0)
1047 if ((pPingCallback == NULL) && (pPingParams->Flags == 0) && (pPingParams->TotalNumberOfAttempts == 0))
1049 return SL_RET_CODE_NET_APP_PING_INVALID_PARAMS;
1054 pPingCallBackFunc = pPingCallback;
1059 ObjIdx = _SlDrvWaitForPoolObj(PING_ID,SL_MAX_SOCKETS);
1060 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1062 return SL_POOL_IS_EMPTY;
1064 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
1066 return SL_RET_CODE_STOP_IN_PROGRESS;
1068 OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
1070 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&PingRsp;
1071 pPingCallBackFunc = NULL;
1072 OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
1079 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1083 VERIFY_RET_OK(_SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
1084 if (Msg.Cmd.Ip != 0)
1086 if(CMD_PING_TEST_RUNNING == (_i16)Msg.Rsp.Status || CMD_PING_TEST_STOPPED == (_i16)Msg.Rsp.Status )
1089 if( NULL == pPingCallback )
1092 RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx, PingTimeout, SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE);
1094 if( SL_OS_RET_CODE_OK == (_i16)PingRsp.Status )
1096 _SlNetAppCopyPingResultsToReport(&PingRsp,pReport);
1099 _SlDrvReleasePoolObj(ObjIdx);
1108 if( NULL == pPingCallback )
1110 _SlDrvReleasePoolObj(ObjIdx);
1114 return (_i16)Msg.Rsp.Status;
1127 #if _SL_INCLUDE_FUNC(sl_NetAppSet) 1131 SL_OPCODE_NETAPP_NETAPPSET,
1136 _i16
sl_NetAppSet(
const _u8 AppId ,
const _u8 Option,
const _u8 OptionLen,
const _u8 *pOptionValue)
1138 _SlNetAppMsgSet_u Msg;
1143 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1145 _SlDrvResetCmdExt(&CmdExt);
1146 CmdExt.TxPayload1Len = (OptionLen+3) & (~3);
1147 CmdExt.pTxPayload1 = (_u8 *)pOptionValue;
1149 Msg.Cmd.AppId = AppId;
1150 Msg.Cmd.ConfigLen = OptionLen;
1151 Msg.Cmd.ConfigOpt = Option;
1153 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppSetCmdCtrl, &Msg, &CmdExt));
1155 return (_i16)Msg.Rsp.status;
1166 }_SlNetAppMsgSendTokenValue_u;
1170 SL_OPCODE_NETAPP_HTTPSENDTOKENVALUE,
1177 _SlNetAppMsgSendTokenValue_u Msg;
1180 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1182 CmdExt.TxPayload1Len = (Token_value->ValueLen+3) & (~3);
1183 CmdExt.pTxPayload1 = (_u8 *) Token_value->pTokenValue;
1185 Msg.Cmd.TokenValueLen = Token_value->ValueLen;
1186 Msg.Cmd.TokenNameLen = Token_value->NameLen;
1187 sl_Memcpy(&Msg.Cmd.TokenName[0], Token_value->pTokenName, Token_value->NameLen);
1189 VERIFY_RET_OK(_SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendTokenValueCmdCtrl, &Msg, &CmdExt));
1191 return Msg.Rsp.status;
1201 }_SlNetAppMsgSendResponse_u;
1205 SL_OPCODE_NETAPP_RESPONSE,
1212 _SlNetAppMsgSendResponse_u Msg;
1214 _SlReturnVal_t RetVal;
1217 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1219 dataLen = NetAppResponse->ResponseData.MetadataLen + NetAppResponse->ResponseData.PayloadLen;
1221 if ((NetAppResponse->ResponseData.MetadataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN) && (dataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN))
1226 CmdExt.pTxPayload1 = NetAppResponse->ResponseData.pMetadata;
1227 CmdExt.TxPayload1Len = NetAppResponse->ResponseData.MetadataLen;
1229 CmdExt.pTxPayload2 = NetAppResponse->ResponseData.pPayload;
1230 CmdExt.TxPayload2Len = NetAppResponse->ResponseData.PayloadLen;
1234 CmdExt.pTxPayload1 = NULL;
1235 CmdExt.pTxPayload2 = NULL;
1238 CmdExt.RxPayloadLen = 0;
1239 CmdExt.pRxPayload = NULL;
1241 Msg.Cmd.Handle = handle;
1242 Msg.Cmd.status = NetAppResponse->Status;
1243 Msg.Cmd.MetadataLen = NetAppResponse->ResponseData.MetadataLen;
1244 Msg.Cmd.PayloadLen = NetAppResponse->ResponseData.PayloadLen;
1245 Msg.Cmd.Flags = NetAppResponse->ResponseData.Flags;
1247 RetVal = _SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendResponseCmdCtrl, &Msg, &CmdExt);
1252 RetVal = SL_ERROR_BSD_ENOMEM;
1265 }_SlNetAppReceiveMsg_u;
1267 #if _SL_INCLUDE_FUNC(sl_NetAppRecv) 1271 SL_OPCODE_NETAPP_RECEIVEREQUEST,
1276 _SlReturnVal_t
sl_NetAppRecv( _u16 Handle, _u16 *DataLen, _u8 *pData, _u32 *Flags)
1278 _SlNetAppReceiveMsg_u Msg;
1282 _SlReturnVal_t RetVal;
1283 _i16 ObjIdx = MAX_CONCURRENT_ACTIONS;
1287 if ((NULL == pData) || (0==DataLen))
1289 return SL_ERROR_BSD_EINVAL;
1293 _SlDrvResetCmdExt(&CmdExt);
1294 CmdExt.RxPayloadLen = *DataLen;
1295 CmdExt.pRxPayload = pData;
1298 Msg.Cmd.Handle = Handle;
1299 Msg.Cmd.MaxBufferLen = *DataLen;
1300 Msg.Cmd.Flags = *Flags;
1303 ObjIdx = _SlDrvWaitForPoolObj(NETAPP_RECEIVE_ID, SL_MAX_SOCKETS);
1305 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1307 return SL_POOL_IS_EMPTY;
1309 if (SL_RET_CODE_STOP_IN_PROGRESS == ObjIdx)
1311 return SL_RET_CODE_STOP_IN_PROGRESS;
1315 AsyncRsp.Handle = Handle;
1317 AsyncRsp.PayloadLen = 0;
1319 _SlDrvProtectionObjLockWaitForever();
1321 pArgsData.pData = (_u8 *) &CmdExt;
1322 pArgsData.pArgs = (_u8 *) &AsyncRsp;
1324 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&pArgsData;
1326 _SlDrvProtectionObjUnLock();
1329 RetVal = _SlDrvCmdSend((
_SlCmdCtrl_t *)&_SlNetAppReceiveCmdCtrl, &Msg, &CmdExt);
1331 if(SL_OS_RET_CODE_OK == RetVal)
1335 RetVal = _SlDrvWaitForInternalAsyncEvent(ObjIdx, 0, 0);
1338 *DataLen = AsyncRsp.PayloadLen;
1339 *Flags = AsyncRsp.Flags;
1342 _SlDrvReleasePoolObj(ObjIdx);
1351 void _SlNetAppHandleAsync_NetAppReceive(
void *pVoidBuf)
1361 _SlDrvProtectionObjLockWaitForever();
1363 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
1366 CmdExt = (
_SlCmdExt_t *) ((
_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))-> pData;
1368 if (pMsgArgs->Handle == AsyncRsp->Handle)
1370 if (pMsgArgs->PayloadLen <= CmdExt->RxPayloadLen)
1372 len = pMsgArgs->PayloadLen;
1376 len = CmdExt->RxPayloadLen;
1380 sl_Memcpy (CmdExt->pRxPayload, pData, len);
1383 AsyncRsp->PayloadLen = len;
1384 AsyncRsp->Flags = pMsgArgs->Flags;
1388 _SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1389 _SlDrvProtectionObjUnLock();
1403 }_SlNetAppMsgSend_u;
1407 SL_OPCODE_NETAPP_SEND,
1414 _SlNetAppMsgSend_u Msg;
1417 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1419 if ((((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) && (DataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN)) ||
1420 (((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == 0) && (DataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN)))
1422 CmdExt.TxPayload1Len = (DataLen+3) & (~3);
1423 CmdExt.pTxPayload1 = (_u8 *) pData;
1425 Msg.Cmd.Handle = Handle;
1426 Msg.Cmd.DataLen = DataLen;
1427 Msg.Cmd.Flags = Flags;
1429 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppSendCmdCtrl, &Msg, &CmdExt));
1433 Msg.Rsp.status = SL_ERROR_BSD_ENOMEM;
1436 return Msg.Rsp.status;
1448 #if _SL_INCLUDE_FUNC(sl_NetAppGet) 1451 SL_OPCODE_NETAPP_NETAPPGET,
1456 _i16
sl_NetAppGet(
const _u8 AppId,
const _u8 Option,_u8 *pOptionLen, _u8 *pOptionValue)
1458 _SlNetAppMsgGet_u Msg;
1463 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1465 if (*pOptionLen == 0)
1470 _SlDrvResetCmdExt(&CmdExt);
1471 CmdExt.RxPayloadLen = (_i16)(*pOptionLen);
1472 CmdExt.pRxPayload = (_u8 *)pOptionValue;
1474 Msg.Cmd.AppId = AppId;
1475 Msg.Cmd.ConfigOpt = Option;
1476 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppGetCmdCtrl, &Msg, &CmdExt));
1479 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
1481 *pOptionLen = (_u8)CmdExt.RxPayloadLen;
1482 return SL_ESMALLBUF;
1486 *pOptionLen = (_u8)CmdExt.ActualRxPayloadLen;
1489 return (_i16)Msg.Rsp.Status;
1496 _SlReturnVal_t _SlNetAppEventHandler(
void* pArgs)
1499 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1503 switch(pHdr->GenHeader.Opcode)
1505 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE:
1506 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE_V6:
1507 _SlNetAppHandleAsync_DnsGetHostByName(pArgs);
1509 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE:
1510 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE_V6:
1511 _SlNetAppHandleAsync_DnsGetHostByService(pArgs);
1513 case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE:
1514 _SlNetAppHandleAsync_PingResponse(pArgs);
1517 case SL_OPCODE_NETAPP_HTTPGETTOKENVALUE:
1519 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1525 httpServerResponse.Response = SL_NETAPP_HTTPSETTOKENVALUE;
1526 httpServerResponse.ResponseData.TokenValue.Len = SL_NETAPP_MAX_TOKEN_VALUE_LEN;
1529 httpServerResponse.ResponseData.TokenValue.pData = (_u8 *)_SL_RESP_ARGS_START(pHdr) + SL_NETAPP_MAX_TOKEN_NAME_LEN;
1531 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_GET;
1532 httpServerEvent.EventData.HttpTokenName.Len = httpGetToken->TokenNameLen;
1533 httpServerEvent.EventData.HttpTokenName.pData = pTokenName;
1535 Token_value.pTokenName = pTokenName;
1537 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1539 Token_value.ValueLen = httpServerResponse.ResponseData.TokenValue.Len;
1540 Token_value.NameLen = httpServerEvent.EventData.HttpTokenName.Len;
1541 Token_value.pTokenValue = httpServerResponse.ResponseData.TokenValue.pData;
1543 _SlNetAppSendTokenValue(&Token_value);
1551 Token_value.pTokenName = pTokenName;
1552 Token_value.ValueLen = 0;
1553 Token_value.NameLen = httpGetToken->TokenNameLen;
1554 Token_value.pTokenValue = NULL;
1556 _SlNetAppSendTokenValue(&Token_value);
1561 case SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE:
1563 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1569 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_POST;
1571 httpServerEvent.EventData.HttpPostData.Action.Len = httpPostTokenArgs->PostActionLen;
1572 httpServerEvent.EventData.HttpPostData.Action.pData = pPostParams;
1573 pPostParams+=httpPostTokenArgs->PostActionLen;
1575 httpServerEvent.EventData.HttpPostData.TokenName.Len = httpPostTokenArgs->TokenNameLen;
1576 httpServerEvent.EventData.HttpPostData.TokenName.pData = pPostParams;
1577 pPostParams+=httpPostTokenArgs->TokenNameLen;
1579 httpServerEvent.EventData.HttpPostData.TokenValue.Len = httpPostTokenArgs->TokenValueLen;
1580 httpServerEvent.EventData.HttpPostData.TokenValue.pData = pPostParams;
1582 httpServerResponse.Response = SL_NETAPP_HTTPRESPONSE_NONE;
1584 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1589 case SL_OPCODE_NETAPP_REQUEST:
1591 #if defined(slcb_NetAppRequestHdlr) || defined(EXT_LIB_REGISTERED_NETAPP_REQUEST_EVENTS) 1600 NetAppRequest.AppId = protocol_NetAppRequest->AppId;
1601 NetAppRequest.Type = protocol_NetAppRequest->RequestType;
1602 NetAppRequest.Handle = protocol_NetAppRequest->Handle;
1603 NetAppRequest.requestData.Flags = protocol_NetAppRequest->Flags;
1607 NetAppRequest.requestData.pMetadata = pData;
1608 NetAppRequest.requestData.MetadataLen = protocol_NetAppRequest->MetadataLen;
1611 pData+=protocol_NetAppRequest->MetadataLen;
1612 NetAppRequest.requestData.pPayload = pData;
1613 NetAppRequest.requestData.PayloadLen = protocol_NetAppRequest->PayloadLen;
1616 sl_Memset(&NetAppResponse, 0,
sizeof (NetAppResponse));
1617 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1620 _SlDrvDispatchNetAppRequestEvents (&NetAppRequest, &NetAppResponse);
1623 status = _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1625 #if (defined(SL_RUNTIME_EVENT_REGISTERATION) || defined(slcb_NetAppRequestMemFree)) 1626 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_MEM_FREE))
1628 if ((NetAppResponse.ResponseData.MetadataLen > 0) && (NetAppResponse.ResponseData.pMetadata != NULL))
1630 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pMetadata);
1633 if ((NetAppResponse.ResponseData.PayloadLen > 0) && (NetAppResponse.ResponseData.pPayload != NULL))
1635 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pPayload);
1643 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1644 NetAppResponse.ResponseData.pMetadata = NULL;
1645 NetAppResponse.ResponseData.MetadataLen = 0;
1646 NetAppResponse.ResponseData.pPayload = NULL;
1647 NetAppResponse.ResponseData.PayloadLen = 0;
1648 NetAppResponse.ResponseData.Flags = 0;
1651 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1661 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1662 NetAppResponse.ResponseData.pMetadata = NULL;
1663 NetAppResponse.ResponseData.MetadataLen = 0;
1664 NetAppResponse.ResponseData.pPayload = NULL;
1665 NetAppResponse.ResponseData.PayloadLen = 0;
1666 NetAppResponse.ResponseData.Flags = 0;
1669 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1680 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.