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);
56 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByService(
void *pVoidBuf);
57 _SlReturnVal_t _SlNetAppHandleAsync_PingResponse(
void *pVoidBuf);
62 _i16 _SlNetAppMDNSRegisterUnregisterService(
const _i8* pServiceName,
63 const _u8 ServiceNameLen,
76 #define SL_NETAPP_SERVICE_SIZE_MASK (0x7) 77 #define SL_NETAPP_PING_GUARD_INTERVAL (20000) 79 static _u16 NetAppServiceSizeLUT[] =
95 }_SlNetAppStartStopMsg_u;
98 #if _SL_INCLUDE_FUNC(sl_NetAppStart) 103 SL_OPCODE_NETAPP_START_COMMAND,
110 _SlNetAppStartStopMsg_u Msg;
111 Msg.Cmd.AppId = AppBitMap;
115 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
116 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppStartCtrl, &Msg, NULL));
118 return Msg.Rsp.status;
125 #if _SL_INCLUDE_FUNC(sl_NetAppStop) 130 SL_OPCODE_NETAPP_STOP_COMMAND,
139 _SlNetAppStartStopMsg_u Msg;
143 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
144 Msg.Cmd.AppId = AppBitMap;
145 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppStopCtrl, &Msg, NULL));
147 return Msg.Rsp.status;
161 }NetappGetServiceListCMD_t;
165 NetappGetServiceListCMD_t Cmd;
167 }_SlNetappGetServiceListMsg_u;
170 #if _SL_INCLUDE_FUNC(sl_NetAppGetServiceList) 174 SL_OPCODE_NETAPP_NETAPP_MDNS_LOOKUP_SERVICE,
175 (_SlArgSize_t)
sizeof(NetappGetServiceListCMD_t),
180 const _u8 MaxServiceCount,
183 const _u32 BufferLength
188 _SlNetappGetServiceListMsg_u Msg;
190 _u16 ServiceSize = 0;
195 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
203 ServiceSize = NetAppServiceSizeLUT[Flags & SL_NETAPP_SERVICE_SIZE_MASK];
204 BufferSize = MaxServiceCount * ServiceSize;
208 if(BufferLength < BufferSize)
210 return SL_ERROR_NET_APP_RX_BUFFER_LENGTH;
213 _SlDrvResetCmdExt(&CmdExt);
214 CmdExt.RxPayloadLen = (_i16)BufferSize;
215 CmdExt.pRxPayload = (_u8 *)pBuffer;
217 Msg.Cmd.IndexOffest = IndexOffest;
218 Msg.Cmd.MaxServiceCount = MaxServiceCount;
219 Msg.Cmd.Flags = Flags;
222 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetServiceListeCtrl, &Msg, &CmdExt));
223 retVal = Msg.Rsp.status;
260 }NetappMdnsSetService_t;
264 NetappMdnsSetService_t Cmd;
266 }_SlNetappMdnsRegisterServiceMsg_u;
269 #if (_SL_INCLUDE_FUNC(sl_NetAppMDNSRegisterService) || _SL_INCLUDE_FUNC(sl_NetAppMDNSUnregisterService)) 273 SL_OPCODE_NETAPP_MDNSREGISTERSERVICE,
274 (_SlArgSize_t)
sizeof(NetappMdnsSetService_t),
352 _i16 _SlNetAppMDNSRegisterUnregisterService(
const _i8* pServiceName,
353 const _u8 ServiceNameLen,
361 _SlNetappMdnsRegisterServiceMsg_u Msg;
363 _i8 ServiceNameAndTextBuffer[SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH];
368 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
388 Msg.Cmd.ServiceNameLen = ServiceNameLen;
389 Msg.Cmd.Options = Options;
391 Msg.Cmd.TextLen = TextLen;
399 if(TextLen + ServiceNameLen > (SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH - 1 ))
404 _SlDrvMemZero(ServiceNameAndTextBuffer, (_u16)SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH);
408 sl_Memcpy(ServiceNameAndTextBuffer,
415 TextPtr = &ServiceNameAndTextBuffer[ServiceNameLen];
424 _SlDrvResetCmdExt(&CmdExt);
425 CmdExt.TxPayload1Len = (TextLen + ServiceNameLen);
426 CmdExt.pTxPayload1 = (_u8 *)ServiceNameAndTextBuffer;
429 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlRegisterServiceCtrl, &Msg, &CmdExt));
431 return (_i16)Msg.Rsp.status;
438 #if _SL_INCLUDE_FUNC(sl_NetAppMDNSRegisterService) 441 const _u8 ServiceNameLen,
452 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
474 Options |= SL_NETAPP_MDNS_OPTIONS_ADD_SERVICE_BIT;
476 return _SlNetAppMDNSRegisterUnregisterService( pServiceName,
492 #if _SL_INCLUDE_FUNC(sl_NetAppMDNSUnRegisterService) 495 const _u8 ServiceNameLen,_u32 Options)
502 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
520 Options &= (~SL_NETAPP_MDNS_OPTIONS_ADD_SERVICE_BIT);
522 return _SlNetAppMDNSRegisterUnregisterService( pServiceName,
553 }_GetHostByServiceCommand_t;
579 }_GetHostByServiceIPv6AsyncResponse_t;
592 }_GetHostByServiceAsyncResponse_t;
598 _GetHostByServiceCommand_t Cmd;
600 }_SlGetHostByServiceMsg_u;
603 #if _SL_INCLUDE_FUNC(sl_NetAppDnsGetHostByService) 607 SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICE,
608 (_SlArgSize_t)
sizeof(_GetHostByServiceCommand_t),
615 const _u8 ServiceLen,
623 _SlGetHostByServiceMsg_u Msg;
625 _GetHostByServiceAsyncResponse_t AsyncRsp;
626 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
630 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
631 _SlDrvMemZero(&AsyncRsp,
sizeof(_GetHostByServiceAsyncResponse_t));
653 Msg.Cmd.ServiceLen = ServiceLen;
654 Msg.Cmd.AddrLen = Family;
659 _SlDrvResetCmdExt(&CmdExt);
660 CmdExt.TxPayload1Len = ServiceLen;
661 CmdExt.pTxPayload1 = (_u8 *)pServiceName;
667 AsyncRsp.out_pText = pText;
668 AsyncRsp.inout_TextLen = (_u16* )pTextLen;
669 AsyncRsp.out_pPort = pPort;
670 AsyncRsp.out_pAddr = (_u32 *)&pAddr[0];
672 ObjIdx = _SlDrvProtectAsyncRespSetting((_u8*)&AsyncRsp, GETHOSYBYSERVICE_ID, SL_MAX_SOCKETS);
674 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
676 return SL_POOL_IS_EMPTY;
680 if (SL_AF_INET6 == Family)
682 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
685 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByServiceCtrl, &Msg, &CmdExt));
690 if(SL_RET_CODE_OK == Msg.Rsp.status)
692 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
697 Msg.Rsp.status = AsyncRsp.Status;
700 _SlDrvReleasePoolObj(ObjIdx);
701 return Msg.Rsp.status;
764 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByService(
void *pVoidBuf)
768 _GetHostByServiceAsyncResponse_t* Res= NULL;
769 _GetHostByServiceIPv6AsyncResponse_t *pMsgArgs = (_GetHostByServiceIPv6AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
771 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
773 Res = (_GetHostByServiceAsyncResponse_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
775 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
777 Res->out_pAddr[1] = pMsgArgs->Address[1];
778 Res->out_pAddr[2] = pMsgArgs->Address[2];
779 Res->out_pAddr[3] = pMsgArgs->Address[3];
782 TextLen = pMsgArgs->TextLen;
785 Res->out_pAddr[0] = pMsgArgs->Address[0];
786 Res->out_pPort[0] = pMsgArgs->Port;
787 Res->Status = (_i16)pMsgArgs->Status;
789 UserTextLen = Res->inout_TextLen[0];
792 UserTextLen = (TextLen <= UserTextLen) ? TextLen : UserTextLen;
793 Res->inout_TextLen[0] = UserTextLen ;
802 if (g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
804 sl_Memcpy(Res->out_pText ,
805 (_i8 *)(& pMsgArgs[1]) ,
810 sl_Memcpy(Res->out_pText ,
811 (_i8 *)(& pMsgArgs->Address[1]) ,
816 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
818 return SL_OS_RET_CODE_OK;
825 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByAddr(
void *pVoidBuf)
827 SL_TRACE0(DBG_MSG, MSG_303,
"STUB: _SlNetAppHandleAsync_DnsGetHostByAddr not implemented yet!");
828 return SL_OS_RET_CODE_OK;
839 }_GetHostByNameAsyncResponse_u;
845 }_SlGetHostByNameMsg_u;
848 #if _SL_INCLUDE_FUNC(sl_NetAppDnsGetHostByName) 851 SL_OPCODE_NETAPP_DNSGETHOSTBYNAME,
858 _SlGetHostByNameMsg_u Msg;
860 _GetHostByNameAsyncResponse_u AsyncRsp;
861 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
865 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
867 _SlDrvResetCmdExt(&ExtCtrl);
868 ExtCtrl.TxPayload1Len = NameLen;
869 ExtCtrl.pTxPayload1 = (_u8 *)pHostName;
871 Msg.Cmd.Len = NameLen;
872 Msg.Cmd.Family = Family;
875 ObjIdx = (_u8)_SlDrvWaitForPoolObj(GETHOSYBYNAME_ID,SL_MAX_SOCKETS);
876 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
878 return SL_POOL_IS_EMPTY;
881 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
883 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&AsyncRsp;
885 if (SL_AF_INET6 == Family)
887 g_pCB->ObjPool[ObjIdx].AdditionalData |= SL_NETAPP_FAMILY_MASK;
890 SL_DRV_PROTECTION_OBJ_UNLOCK();
892 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlGetHostByNameCtrl, &Msg, &ExtCtrl));
894 if(SL_RET_CODE_OK == Msg.Rsp.status)
896 SL_DRV_SYNC_OBJ_WAIT_FOREVER(&g_pCB->ObjPool[ObjIdx].SyncObj);
898 Msg.Rsp.status = (_i16)AsyncRsp.IpV4.Status;
900 if(SL_OS_RET_CODE_OK == (_i16)Msg.Rsp.status)
902 sl_Memcpy((_i8 *)OutIpAddr,
903 (_i8 *)&AsyncRsp.IpV4.Ip0,
904 (SL_AF_INET == Family) ? SL_IPV4_ADDRESS_SIZE : SL_IPV6_ADDRESS_SIZE);
907 _SlDrvReleasePoolObj(ObjIdx);
908 return Msg.Rsp.status;
916 _SlReturnVal_t _SlNetAppHandleAsync_DnsGetHostByName(
void *pVoidBuf)
920 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
922 VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
925 if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
935 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
936 SL_DRV_PROTECTION_OBJ_UNLOCK();
937 return SL_OS_RET_CODE_OK;
944 pReport->PacketsSent = pResults->NumSendsPings;
945 pReport->PacketsReceived = pResults->NumSuccsessPings;
946 pReport->MinRoundTime = pResults->RttMin;
947 pReport->MaxRoundTime = pResults->RttMax;
948 pReport->AvgRoundTime = pResults->RttAvg;
949 pReport->TestTime = pResults->TestTime;
955 _SlReturnVal_t _SlNetAppHandleAsync_PingResponse(
void *pVoidBuf)
960 if(pPingCallBackFunc)
962 _SlNetAppCopyPingResultsToReport(pMsgArgs,&pingReport);
963 pPingCallBackFunc(&pingReport);
968 SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
970 VERIFY_SOCKET_CB(NULL != g_pCB->PingCB.PingAsync.pAsyncRsp);
972 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
974 sl_Memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,
sizeof(
SlPingReportResponse_t));
975 SL_DRV_SYNC_OBJ_SIGNAL(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
977 SL_DRV_PROTECTION_OBJ_UNLOCK();
980 return SL_OS_RET_CODE_OK;
996 CMD_PING_TEST_RUNNING = 0,
997 CMD_PING_TEST_STOPPED
1001 #if _SL_INCLUDE_FUNC(sl_NetAppPing) 1005 _SlPingStartMsg_u Msg;
1007 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
1008 _u32 PingTimeout = 0;
1012 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1014 if(NULL != pPingParams)
1017 if(SL_AF_INET == Family)
1019 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1020 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV4_ADDRESS_SIZE);
1024 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART_V6;
1025 sl_Memcpy(&Msg.Cmd.Ip, &pPingParams->Ip, SL_IPV6_ADDRESS_SIZE);
1028 Msg.Cmd.PingIntervalTime = pPingParams->PingIntervalTime;
1029 Msg.Cmd.PingSize = pPingParams->PingSize;
1030 Msg.Cmd.PingRequestTimeout = pPingParams->PingRequestTimeout;
1031 Msg.Cmd.TotalNumberOfAttempts = pPingParams->TotalNumberOfAttempts;
1032 Msg.Cmd.Flags = pPingParams->Flags;
1036 PingTimeout = SL_NETAPP_PING_GUARD_INTERVAL + (pPingParams->PingIntervalTime * pPingParams->TotalNumberOfAttempts);
1038 if (Msg.Cmd.Ip != 0)
1046 if ((pPingCallback == NULL) && (pPingParams->Flags == 0) && (pPingParams->TotalNumberOfAttempts == 0))
1048 return SL_RET_CODE_NET_APP_PING_INVALID_PARAMS;
1053 pPingCallBackFunc = pPingCallback;
1058 ObjIdx = (_u8)_SlDrvWaitForPoolObj(PING_ID,SL_MAX_SOCKETS);
1059 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1061 return SL_POOL_IS_EMPTY;
1063 OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
1065 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&PingRsp;
1066 pPingCallBackFunc = NULL;
1067 OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
1074 CmdCtrl.Opcode = SL_OPCODE_NETAPP_PINGSTART;
1078 VERIFY_RET_OK(_SlDrvCmdOp(&CmdCtrl, &Msg, NULL));
1079 if (Msg.Cmd.Ip != 0)
1081 if(CMD_PING_TEST_RUNNING == (_i16)Msg.Rsp.Status || CMD_PING_TEST_STOPPED == (_i16)Msg.Rsp.Status )
1084 if( NULL == pPingCallback )
1087 _SlDrvSyncObjWaitForever(&g_pCB->ObjPool[ObjIdx].SyncObj);
1089 SL_DRV_SYNC_OBJ_WAIT_TIMEOUT(&g_pCB->ObjPool[ObjIdx].SyncObj,
1091 SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE
1095 if( SL_OS_RET_CODE_OK == (_i16)PingRsp.Status )
1097 _SlNetAppCopyPingResultsToReport(&PingRsp,pReport);
1099 _SlDrvReleasePoolObj(ObjIdx);
1105 if( NULL == pPingCallback )
1107 _SlDrvReleasePoolObj(ObjIdx);
1112 return (_i16)Msg.Rsp.Status;
1126 #if _SL_INCLUDE_FUNC(sl_NetAppSet) 1130 SL_OPCODE_NETAPP_NETAPPSET,
1135 _i16
sl_NetAppSet(
const _u8 AppId ,
const _u8 Option,
const _u8 OptionLen,
const _u8 *pOptionValue)
1137 _SlNetAppMsgSet_u Msg;
1142 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1144 _SlDrvResetCmdExt(&CmdExt);
1145 CmdExt.TxPayload1Len = (OptionLen+3) & (~3);
1146 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;
1171 SL_OPCODE_NETAPP_HTTPSENDTOKENVALUE,
1178 _SlNetAppMsgSendTokenValue_u Msg;
1181 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1183 CmdExt.TxPayload1Len = (Token_value->ValueLen+3) & (~3);
1184 CmdExt.pTxPayload1 = (_u8 *) Token_value->pTokenValue;
1186 Msg.Cmd.TokenValueLen = Token_value->ValueLen;
1187 Msg.Cmd.TokenNameLen = Token_value->NameLen;
1188 sl_Memcpy(&Msg.Cmd.TokenName[0], Token_value->pTokenName, Token_value->NameLen);
1191 VERIFY_RET_OK(_SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendTokenValueCmdCtrl, &Msg, &CmdExt));
1193 return Msg.Rsp.status;
1205 }_SlNetAppMsgSendResponse_u;
1210 SL_OPCODE_NETAPP_RESPONSE,
1217 _SlNetAppMsgSendResponse_u Msg;
1219 _SlReturnVal_t RetVal;
1222 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1224 dataLen = NetAppResponse->ResponseData.MetadataLen + NetAppResponse->ResponseData.PayloadLen;
1226 if ((NetAppResponse->ResponseData.MetadataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN) && (dataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN))
1231 CmdExt.pTxPayload1 = NetAppResponse->ResponseData.pMetadata;
1232 CmdExt.TxPayload1Len = NetAppResponse->ResponseData.MetadataLen;
1234 CmdExt.pTxPayload2 = NetAppResponse->ResponseData.pPayload;
1235 CmdExt.TxPayload2Len = NetAppResponse->ResponseData.PayloadLen;
1239 CmdExt.pTxPayload1 = NULL;
1240 CmdExt.pTxPayload2 = NULL;
1243 CmdExt.RxPayloadLen = 0;
1244 CmdExt.pRxPayload = NULL;
1246 Msg.Cmd.Handle = handle;
1247 Msg.Cmd.status = NetAppResponse->Status;
1248 Msg.Cmd.MetadataLen = NetAppResponse->ResponseData.MetadataLen;
1249 Msg.Cmd.PayloadLen = NetAppResponse->ResponseData.PayloadLen;
1250 Msg.Cmd.Flags = NetAppResponse->ResponseData.Flags;
1252 RetVal = _SlDrvCmdSend_noLock((
_SlCmdCtrl_t *)&_SlNetAppSendResponseCmdCtrl, &Msg, &CmdExt);
1258 RetVal = SL_ERROR_BSD_ENOMEM;
1272 }_SlNetAppReceiveMsg_u;
1274 #if _SL_INCLUDE_FUNC(sl_NetAppRecv) 1278 SL_OPCODE_NETAPP_RECEIVEREQUEST,
1283 _SlReturnVal_t
sl_NetAppRecv( _u16 Handle, _u16 *DataLen, _u8 *pData, _u32 *Flags)
1285 _SlNetAppReceiveMsg_u Msg;
1289 _SlReturnVal_t RetVal;
1290 _u8 ObjIdx = MAX_CONCURRENT_ACTIONS;
1294 if ((NULL == pData) || (0==DataLen))
1296 return SL_ERROR_BSD_EINVAL;
1300 _SlDrvResetCmdExt(&CmdExt);
1301 CmdExt.RxPayloadLen = *DataLen;
1302 CmdExt.pRxPayload = pData;
1305 Msg.Cmd.Handle = Handle;
1306 Msg.Cmd.MaxBufferLen = *DataLen;
1307 Msg.Cmd.Flags = *Flags;
1310 ObjIdx = (_u8)_SlDrvWaitForPoolObj(NETAPP_RECEIVE_ID, SL_MAX_SOCKETS);
1312 if (MAX_CONCURRENT_ACTIONS == ObjIdx)
1314 return SL_POOL_IS_EMPTY;
1318 AsyncRsp.Handle = Handle;
1320 AsyncRsp.PayloadLen = 0;
1322 _SlDrvProtectionObjLockWaitForever();
1324 pArgsData.pData = (_u8 *) &CmdExt;
1325 pArgsData.pArgs = (_u8 *) &AsyncRsp;
1327 g_pCB->ObjPool[ObjIdx].pRespArgs = (_u8 *)&pArgsData;
1329 _SlDrvProtectionObjUnLock();
1332 RetVal = _SlDrvCmdSend((
_SlCmdCtrl_t *)&_SlNetAppReceiveCmdCtrl, &Msg, &CmdExt);
1334 if(SL_OS_RET_CODE_OK == RetVal)
1337 _SlDrvSyncObjWaitForever(&g_pCB->ObjPool[ObjIdx].SyncObj);
1340 *DataLen = AsyncRsp.PayloadLen;
1341 *Flags = AsyncRsp.Flags;
1344 _SlDrvReleasePoolObj(ObjIdx);
1354 void _SlNetAppHandleAsync_NetAppReceive(
void *pVoidBuf)
1364 _SlDrvProtectionObjLockWaitForever();
1366 if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
1369 CmdExt = (
_SlCmdExt_t *) ((
_SlArgsData_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))-> pData;
1371 if (pMsgArgs->Handle == AsyncRsp->Handle)
1373 if (pMsgArgs->PayloadLen <= CmdExt->RxPayloadLen)
1375 len = pMsgArgs->PayloadLen;
1379 len = CmdExt->RxPayloadLen;
1383 sl_Memcpy (CmdExt->pRxPayload, pData, len);
1386 AsyncRsp->PayloadLen = len;
1387 AsyncRsp->Flags = pMsgArgs->Flags;
1391 _SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
1392 _SlDrvProtectionObjUnLock();
1406 }_SlNetAppMsgSend_u;
1411 SL_OPCODE_NETAPP_SEND,
1418 _SlNetAppMsgSend_u Msg;
1421 _SlDrvMemZero(&CmdExt, (_u16)
sizeof(
_SlCmdExt_t));
1423 if ((((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) && (DataLen <= SL_NETAPP_REQUEST_MAX_METADATA_LEN)) ||
1424 (((Flags & SL_NETAPP_REQUEST_RESPONSE_FLAGS_METADATA) == 0) && (DataLen <= SL_NETAPP_REQUEST_MAX_DATA_LEN)))
1426 CmdExt.TxPayload1Len = (DataLen+3) & (~3);
1427 CmdExt.pTxPayload1 = (_u8 *) pData;
1429 Msg.Cmd.Handle = Handle;
1430 Msg.Cmd.DataLen = DataLen;
1431 Msg.Cmd.Flags = Flags;
1433 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppSendCmdCtrl, &Msg, &CmdExt));
1437 Msg.Rsp.status = SL_ERROR_BSD_ENOMEM;
1440 return Msg.Rsp.status;
1454 #if _SL_INCLUDE_FUNC(sl_NetAppGet) 1457 SL_OPCODE_NETAPP_NETAPPGET,
1462 _i16
sl_NetAppGet(
const _u8 AppId,
const _u8 Option,_u8 *pOptionLen, _u8 *pOptionValue)
1464 _SlNetAppMsgGet_u Msg;
1469 VERIFY_API_ALLOWED(SL_OPCODE_SILO_NETAPP);
1471 if (*pOptionLen == 0)
1476 _SlDrvResetCmdExt(&CmdExt);
1477 CmdExt.RxPayloadLen = (_i16)(*pOptionLen);
1478 CmdExt.pRxPayload = (_u8 *)pOptionValue;
1480 Msg.Cmd.AppId = AppId;
1481 Msg.Cmd.ConfigOpt = Option;
1482 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlNetAppGetCmdCtrl, &Msg, &CmdExt));
1485 if (CmdExt.RxPayloadLen < CmdExt.ActualRxPayloadLen)
1487 *pOptionLen = (_u8)CmdExt.RxPayloadLen;
1488 return SL_ESMALLBUF;
1492 *pOptionLen = (_u8)CmdExt.ActualRxPayloadLen;
1495 return (_i16)Msg.Rsp.Status;
1506 _SlReturnVal_t _SlNetAppEventHandler(
void* pArgs)
1509 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1513 switch(pHdr->GenHeader.Opcode)
1515 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE:
1516 case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE_V6:
1517 _SlNetAppHandleAsync_DnsGetHostByName(pArgs);
1520 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE:
1521 case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE_V6:
1522 _SlNetAppHandleAsync_DnsGetHostByService(pArgs);
1524 case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE:
1525 _SlNetAppHandleAsync_PingResponse(pArgs);
1529 case SL_OPCODE_NETAPP_HTTPGETTOKENVALUE:
1531 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1537 httpServerResponse.Response = SL_NETAPP_HTTPSETTOKENVALUE;
1538 httpServerResponse.ResponseData.TokenValue.Len = SL_NETAPP_MAX_TOKEN_VALUE_LEN;
1541 httpServerResponse.ResponseData.TokenValue.pData = (_u8 *)_SL_RESP_ARGS_START(pHdr) + SL_NETAPP_MAX_TOKEN_NAME_LEN;
1543 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_GET;
1544 httpServerEvent.EventData.HttpTokenName.Len = httpGetToken->TokenNameLen;
1545 httpServerEvent.EventData.HttpTokenName.pData = pTokenName;
1547 Token_value.pTokenName = pTokenName;
1549 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1551 Token_value.ValueLen = httpServerResponse.ResponseData.TokenValue.Len;
1552 Token_value.NameLen = httpServerEvent.EventData.HttpTokenName.Len;
1553 Token_value.pTokenValue = httpServerResponse.ResponseData.TokenValue.pData;
1555 _SlNetAppSendTokenValue(&Token_value);
1563 Token_value.pTokenName = pTokenName;
1564 Token_value.ValueLen = 0;
1565 Token_value.NameLen = httpGetToken->TokenNameLen;
1566 Token_value.pTokenValue = NULL;
1568 _SlNetAppSendTokenValue(&Token_value);
1573 case SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE:
1575 #if defined(slcb_NetAppHttpServerHdlr) || defined(EXT_LIB_REGISTERED_HTTP_SERVER_EVENTS) 1581 httpServerEvent.Event = SL_NETAPP_EVENT_HTTP_TOKEN_POST;
1583 httpServerEvent.EventData.HttpPostData.Action.Len = httpPostTokenArgs->PostActionLen;
1584 httpServerEvent.EventData.HttpPostData.Action.pData = pPostParams;
1585 pPostParams+=httpPostTokenArgs->PostActionLen;
1587 httpServerEvent.EventData.HttpPostData.TokenName.Len = httpPostTokenArgs->TokenNameLen;
1588 httpServerEvent.EventData.HttpPostData.TokenName.pData = pPostParams;
1589 pPostParams+=httpPostTokenArgs->TokenNameLen;
1591 httpServerEvent.EventData.HttpPostData.TokenValue.Len = httpPostTokenArgs->TokenValueLen;
1592 httpServerEvent.EventData.HttpPostData.TokenValue.pData = pPostParams;
1594 httpServerResponse.Response = SL_NETAPP_HTTPRESPONSE_NONE;
1596 _SlDrvDispatchHttpServerEvents (&httpServerEvent, &httpServerResponse);
1601 case SL_OPCODE_NETAPP_REQUEST:
1604 #if defined(slcb_NetAppRequestHdlr) || defined(EXT_LIB_REGISTERED_NETAPP_REQUEST_EVENTS) 1614 NetAppRequest.AppId = protocol_NetAppRequest->AppId;
1615 NetAppRequest.Type = protocol_NetAppRequest->RequestType;
1616 NetAppRequest.Handle = protocol_NetAppRequest->Handle;
1617 NetAppRequest.requestData.Flags = protocol_NetAppRequest->Flags;
1621 NetAppRequest.requestData.pMetadata = pData;
1622 NetAppRequest.requestData.MetadataLen = protocol_NetAppRequest->MetadataLen;
1625 pData+=protocol_NetAppRequest->MetadataLen;
1626 NetAppRequest.requestData.pPayload = pData;
1627 NetAppRequest.requestData.PayloadLen = protocol_NetAppRequest->PayloadLen;
1631 sl_Memset(&NetAppResponse, 0,
sizeof (NetAppResponse));
1632 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1636 _SlDrvDispatchNetAppRequestEvents (&NetAppRequest, &NetAppResponse);
1639 status = _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1641 #if defined(SL_RUNTIME_EVENT_REGISTERATION) 1642 if(1 == _SlIsEventRegistered(SL_EVENT_HDL_MEM_FREE))
1644 if ((NetAppResponse.ResponseData.MetadataLen > 0) && (NetAppResponse.ResponseData.pMetadata != NULL))
1647 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pMetadata);
1651 if ((NetAppResponse.ResponseData.PayloadLen > 0) && (NetAppResponse.ResponseData.pPayload != NULL))
1654 _SlDrvHandleNetAppRequestMemFreeEvents (NetAppResponse.ResponseData.pPayload);
1663 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1664 NetAppResponse.ResponseData.pMetadata = NULL;
1665 NetAppResponse.ResponseData.MetadataLen = 0;
1666 NetAppResponse.ResponseData.pPayload = NULL;
1667 NetAppResponse.ResponseData.PayloadLen = 0;
1668 NetAppResponse.ResponseData.Flags = 0;
1671 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1682 NetAppResponse.Status = SL_NETAPP_HTTP_RESPONSE_404_NOT_FOUND;
1683 NetAppResponse.ResponseData.pMetadata = NULL;
1684 NetAppResponse.ResponseData.MetadataLen = 0;
1685 NetAppResponse.ResponseData.pPayload = NULL;
1686 NetAppResponse.ResponseData.PayloadLen = 0;
1687 NetAppResponse.ResponseData.Flags = 0;
1690 _SlNetAppSendResponse(protocol_NetAppRequest->Handle, &NetAppResponse);
1703 return SL_OS_RET_CODE_OK;
_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_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.