/******************************************************************************
_SlDrvDeviceEventHandler - handles internally device async events
******************************************************************************/
void _SlDrvDeviceEventHandler(void *pArgs)
{
_SlResponseHeader_t *pHdr = (_SlResponseHeader_t *)pArgs;
switch(pHdr->GenHeader.Opcode)
{
case SL_OPCODE_DEVICE_INITCOMPLETE:
_sl_HandleAsync_InitComplete(pHdr);
break;
case SL_OPCODE_DEVICE_STOP_ASYNC_RESPONSE:
_sl_HandleAsync_Stop(pHdr);
break;
case SL_OPCODE_DEVICE_DEVICEASYNCFATALERROR:
#ifdef sl_GeneralEvtHdlr
{
_BasicResponse_t *pMsgArgs = (_BasicResponse_t *)_SL_RESP_ARGS_START(pHdr);
SlDeviceEvent_t devHandler;
devHandler.EventData.deviceEvent.status = pMsgArgs->status & 0xFF;
devHandler.EventData.deviceEvent.sender = (pMsgArgs->status >> 8) & 0xFF;
sl_GeneralEvtHdlr(&devHandler);
}
#endif
break;
default:
SL_ERROR_TRACE2(MSG_306, "ASSERT: _SlDrvDeviceEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
VERIFY_PROTOCOL(0);
}
}
void _sl_HandleAsync_PingResponse(void *pVoidBuf)
{
_PingReportResponse_t *pMsgArgs = (_PingReportResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
SlPingReport_t pingReport;
if(pPingCallBackFunc)
{
CopyPingResultsToReport(pMsgArgs,&pingReport);
pPingCallBackFunc(&pingReport);
}
else
{
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_SOCKET_CB(NULL != g_pCB->PingCB.PingAsync.pAsyncRsp);
if (NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs)
{
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_PingReportResponse_t));
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
}
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
}
return;
}
/***************************************************************************
_SlNetUtilHandleAsync_Cmd - handles NetUtil Cmd response, signalling to
a waiting object
****************************************************************************/
void _SlNetUtilHandleAsync_Cmd(void *pVoidBuf)
{
_SlNetUtilCmdData_t *pOutData;
SlNetUtilCmdRsp_t *pMsgArgs = (SlNetUtilCmdRsp_t *)_SL_RESP_ARGS_START(pVoidBuf);
SL_DRV_PROTECTION_OBJ_LOCK_FOREVER();
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
pOutData = (_SlNetUtilCmdData_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
pOutData->Status = pMsgArgs->Status;
if(SL_RET_CODE_OK == pMsgArgs->Status)
{
if (*(pOutData->pOutputLen) < pMsgArgs->OutputLen)
{
pOutData->Status = SL_ESMALLBUF;
}
else
{
*(pOutData->pOutputLen) = pMsgArgs->OutputLen;
if(*(pOutData->pOutputLen) > 0)
{
/* copy only the data from the global async buffer */
sl_Memcpy(pOutData->pOutputValues, (char*)pMsgArgs + sizeof(SlNetUtilCmdRsp_t), *(pOutData->pOutputLen));
}
}
}
_SlDrvSyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj);
_SlDrvProtectionObjUnLock();
return;
}
void _sl_HandleAsync_Stop(void *pVoidBuf)
{
_BasicResponse_t *pMsgArgs = (_BasicResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
VERIFY_SOCKET_CB(NULL != g_pCB->StopCB.pAsyncRsp);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_BasicResponse_t));
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
void _sl_HandleAsync_Accept(void *pVoidBuf)
{
_SocketAddrResponse_u *pMsgArgs = (_SocketAddrResponse_u *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL(( pMsgArgs->IpV4.sd & BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs,sizeof(_SocketAddrResponse_u));
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
void _sl_HandleAsync_Connect(void *pVoidBuf)
{
_SocketResponse_t *pMsgArgs = (_SocketResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_PROTOCOL((pMsgArgs->sd & BSD_SOCKET_ID_MASK) <= SL_MAX_SOCKETS);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
((_SocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->sd = pMsgArgs->sd;
((_SocketResponse_t *)(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs))->statusOrLen = pMsgArgs->statusOrLen;
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
/*****************************************************************************
_sl_HandleAsync_InitComplete - handles init complete signalling to
a waiting object
****************************************************************************/
void _sl_HandleAsync_InitComplete(void *pVoidBuf)
{
InitComplete_t *pMsgArgs = (InitComplete_t *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
if(g_pCB->pInitCallback)
{
g_pCB->pInitCallback(GetStartResponseConvert(pMsgArgs->Status));
}
else
{
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(InitComplete_t));
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
}
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
if(g_pCB->pInitCallback)
{
_SlDrvReleasePoolObj(g_pCB->FunctionParams.AsyncExt.ActionIndex);
}
}
void _sl_HandleAsync_DnsGetHostByName(void *pVoidBuf)
{
_GetHostByNameIPv4AsyncResponse_t *pMsgArgs = (_GetHostByNameIPv4AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
OSI_RET_OK_CHECK(sl_LockObjLock(&g_pCB->ProtectionLockObj, SL_OS_WAIT_FOREVER));
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
/*IPv6 */
if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
{
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_GetHostByNameIPv6AsyncResponse_t));
}
/*IPv4 */
else
{
memcpy(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs, pMsgArgs, sizeof(_GetHostByNameIPv4AsyncResponse_t));
}
OSI_RET_OK_CHECK(sl_SyncObjSignal(&(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj)));
OSI_RET_OK_CHECK(sl_LockObjUnlock(&g_pCB->ProtectionLockObj));
return;
}
/******************************************************************************
_sl_HandleAsync_DnsGetHostByService
CALLER NWP - Async event on sl_DnsGetHostByService with IPv4 Family
DESCRIPTION:
Async event on sl_DnsGetHostByService command with IPv4 Family.
Return service attributes like IP address, port and text according to service name.
The user sets a service name Full/Part (see example below), and should get the:
1. IP of the service
2. The port of service.
3. The text of service.
Hence it can make a connection to the specific service and use it.
It is similar to get host by name method.
It is done by a single shot query with PTR type on the service name.
Note:
1. The return's attributes are belonged to first service that is found.
It can be other services with the same service name will response to
the query. The results of these responses are saved in the peer cache of the NWP, and
should be read by another API.
PARAMETERS:
pVoidBuf - is point to opcode of the event.
it contains the outputs that are given to the user
outputs description:
1.out_pAddr[] - output: Contain the IP address of the service.
2.out_pPort - output: Contain the port of the service.
3.inout_TextLen - Input: Contain the max length of the text that the user wants to get.
it means that if the test of service is bigger that its value than
the text is cut to inout_TextLen value.
Output: Contain the length of the text that is returned. Can be full text or part
of the text (see above).
4.out_pText - Contain the text of the service (full or part see above- inout_TextLen description).
*
RETURNS: success or fail.
******************************************************************************/
void _sl_HandleAsync_DnsGetHostByService(void *pVoidBuf)
{
_GetHostByServiceAsyncResponse_t* Res;
unsigned short TextLen;
unsigned short UserTextLen;
/*pVoidBuf - is point to opcode of the event.*/
/*set pMsgArgs to point to the attribute of the event.*/
_GetHostByServiceIPv4AsyncResponse_t *pMsgArgs = (_GetHostByServiceIPv4AsyncResponse_t *)_SL_RESP_ARGS_START(pVoidBuf);
VERIFY_SOCKET_CB(NULL != g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs);
/*IPv6*/
if(g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].AdditionalData & SL_NETAPP_FAMILY_MASK)
{
return;
}
/*IPv4*/
else
{
/*************************************************************************************************
1. Copy the attribute part of the evnt to the attribute part of the response
sl_Memcpy(g_pCB->GetHostByServiceCB.pAsyncRsp, pMsgArgs, sizeof(_GetHostByServiceIPv4AsyncResponse_t));
set to TextLen the text length of the service.*/
TextLen = pMsgArgs->TextLen;
/*Res pointed to mDNS global object struct */
Res = (_GetHostByServiceAsyncResponse_t*)g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].pRespArgs;
/*It is 4 bytes so we avoid from memcpy*/
Res->out_pAddr[0] = pMsgArgs->Address;
Res->out_pPort[0] = pMsgArgs->Port;
Res->Status = pMsgArgs->Status;
/*set to TextLen the text length of the user (input fromthe user).*/
UserTextLen = Res->inout_TextLen[0];
/*Cut the service text if the user requested for smaller text.*/
UserTextLen = (TextLen <= UserTextLen) ? TextLen : UserTextLen;
Res->inout_TextLen[0] = UserTextLen ;
/**************************************************************************************************
2. Copy the payload part of the evnt (the text) to the payload part of the response
the lenght of the copy is according to the text length in the attribute part. */
sl_Memcpy(Res->out_pText ,
(char *)(& pMsgArgs[1]) , /* & pMsgArgs[1] -> 1st byte after the fixed header = 1st byte of variable text.*/
UserTextLen );
/**************************************************************************************************/
OSI_RET_OK_CHECK(sl_SyncObjSignal(&g_pCB->ObjPool[g_pCB->FunctionParams.AsyncExt.ActionIndex].SyncObj));
return;
}
}
void _SlDrvNetAppEventHandler(void *pArgs)
{
_SlResponseHeader_t *pHdr = (_SlResponseHeader_t *)pArgs;
SlHttpServerEvent_t httpServerEvent;
SlHttpServerResponse_t httpServerResponse;
switch(pHdr->GenHeader.Opcode)
{
case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE:
case SL_OPCODE_NETAPP_DNSGETHOSTBYNAMEASYNCRESPONSE_V6:
_sl_HandleAsync_DnsGetHostByName(pArgs);
break;
case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE:
case SL_OPCODE_NETAPP_MDNSGETHOSTBYSERVICEASYNCRESPONSE_V6:
_sl_HandleAsync_DnsGetHostByService(pArgs);
break;
case SL_OPCODE_NETAPP_PINGREPORTREQUESTRESPONSE:
_sl_HandleAsync_PingResponse(pArgs);
break;
case SL_OPCODE_NETAPP_HTTPGETTOKENVALUE:
{
UINT8 *pTokenName;
#ifdef sl_HttpServerCallback
slHttpServerData_t Token_value;
#endif
sl_NetAppHttpServerGetToken_t *httpGetToken = (sl_NetAppHttpServerGetToken_t *)_SL_RESP_ARGS_START(pHdr);
pTokenName = (UINT8 *)((sl_NetAppHttpServerGetToken_t *)httpGetToken + 1);
httpServerResponse.Response = SL_NETAPP_HTTPSETTOKENVALUE;
httpServerResponse.ResponseData.token_value.len = MAX_TOKEN_VALUE_LEN;
httpServerResponse.ResponseData.token_value.data = (UINT8 *)_SL_RESP_ARGS_START(pHdr) + MAX_TOKEN_NAME_LEN; //Reuse the async buffer for getting the token value response from the user
#ifdef sl_HttpServerCallback
httpServerEvent.Event = SL_NETAPP_HTTPGETTOKENVALUE;
httpServerEvent.EventData.httpTokenName.len = httpGetToken->token_name_len;
httpServerEvent.EventData.httpTokenName.data = pTokenName;
Token_value.token_name = pTokenName;
sl_HttpServerCallback (&httpServerEvent, &httpServerResponse);
Token_value.value_len = httpServerResponse.ResponseData.token_value.len;
Token_value.name_len = httpServerEvent.EventData.httpTokenName.len;
Token_value.token_value = httpServerResponse.ResponseData.token_value.data;
sl_NetAppSendTokenValue(&Token_value);
#endif
}
break;
case SL_OPCODE_NETAPP_HTTPPOSTTOKENVALUE:
{
UINT8 *pPostParams;
sl_NetAppHttpServerPostToken_t *httpPostTokenArgs = (sl_NetAppHttpServerPostToken_t *)_SL_RESP_ARGS_START(pHdr);
pPostParams = (UINT8 *)((sl_NetAppHttpServerPostToken_t *)httpPostTokenArgs + 1);
httpServerEvent.Event = SL_NETAPP_HTTPPOSTTOKENVALUE;
httpServerEvent.EventData.httpPostData.action.len = httpPostTokenArgs->post_action_len;
httpServerEvent.EventData.httpPostData.action.data = pPostParams;
pPostParams+=httpPostTokenArgs->post_action_len;
httpServerEvent.EventData.httpPostData.token_name.len = httpPostTokenArgs->token_name_len;
httpServerEvent.EventData.httpPostData.token_name.data = pPostParams;
pPostParams+=httpPostTokenArgs->token_name_len;
httpServerEvent.EventData.httpPostData.token_value.len = httpPostTokenArgs->token_value_len;
httpServerEvent.EventData.httpPostData.token_value.data = pPostParams;
httpServerResponse.Response = SL_NETAPP_RESPONSE_NONE;
#ifdef sl_HttpServerCallback
sl_HttpServerCallback (&httpServerEvent, &httpServerResponse);
#endif
}
break;
default:
SL_ERROR_TRACE2(MSG_305, "ASSERT: _SlDrvNetAppEventHandler : invalid opcode = 0x%x = %1", pHdr->GenHeader.Opcode, pHdr->GenHeader.Opcode);
VERIFY_PROTOCOL(0);
}
}