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);
}
}
_i16 _SlInternalSpawn(_SlSpawnEntryFunc_t pEntry , void* pValue , _u32 flags)
{
_i16 Res = 0;
_SlInternalSpawnEntry_t* pSpawnEntry;
if (NULL == pEntry)
{
Res = -1;
}
else
{
sl_LockObjLock(&g_SlInternalSpawnCB.LockObj,SL_OS_WAIT_FOREVER);
pSpawnEntry = g_SlInternalSpawnCB.pFree;
g_SlInternalSpawnCB.pFree = pSpawnEntry->pNext;
pSpawnEntry->pEntry = pEntry;
pSpawnEntry->pValue = pValue;
pSpawnEntry->pNext = NULL;
if (NULL == g_SlInternalSpawnCB.pWaitForExe)
{
g_SlInternalSpawnCB.pWaitForExe = pSpawnEntry;
g_SlInternalSpawnCB.pLastInWaitList = pSpawnEntry;
}
else
{
g_SlInternalSpawnCB.pLastInWaitList->pNext = pSpawnEntry;
g_SlInternalSpawnCB.pLastInWaitList = pSpawnEntry;
}
sl_LockObjUnlock(&g_SlInternalSpawnCB.LockObj);
/* this sync is called after releasing the lock object to avoid unnecessary context switches */
sl_SyncObjSignal(&g_SlInternalSpawnCB.SyncObj);
}
return Res;
}
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;
}
}
