LWMsgStatus
lwmsg_assoc_recv(
LWMsgAssoc* assoc,
LWMsgTag* out_type,
void** out_object
)
{
LWMsgStatus status = LWMSG_STATUS_SUCCESS;
LWMsgMessage message = LWMSG_MESSAGE_INITIALIZER;
BAIL_ON_ERROR(status = lwmsg_assoc_recv_message(assoc, &message));
*out_type = message.tag;
*out_object = message.data;
error:
return status;
}
static
LWMsgStatus
lwmsg_peer_task_run_dispatch(
LWMsgPeer* peer,
PeerAssocTask* task,
LWMsgTaskTrigger* trigger,
LWMsgTaskTrigger* next_trigger,
LWMsgTime* next_timeout
)
{
LWMsgStatus status = LWMSG_STATUS_SUCCESS;
LWMsgStatus finish_status = LWMSG_STATUS_PENDING;
LWMsgStatus recv_status = LWMSG_STATUS_PENDING;
LWMsgStatus send_status = LWMSG_STATUS_PENDING;
LWMsgTime* timeout = NULL;
pthread_mutex_lock(&task->session->lock);
/* Did we hit a timeout? */
if (*trigger & LWMSG_TASK_TRIGGER_TIME)
{
BAIL_ON_ERROR(status = lwmsg_peer_task_handle_assoc_error(
peer,
task,
LWMSG_STATUS_TIMEOUT));
}
/* Are we shutting down? */
else if (*trigger & LWMSG_TASK_TRIGGER_CANCEL)
{
/* Drop the task unceremoniously in the interest
of shutting down quickly */
task->type = PEER_TASK_DROP;
}
else
{
/* Try to finish any outstanding sends/receives */
finish_status = lwmsg_peer_task_finish_transceive(peer, task);
switch (finish_status)
{
case LWMSG_STATUS_SUCCESS:
case LWMSG_STATUS_PENDING:
break;
default:
BAIL_ON_ERROR(status = finish_status);
}
/* Try to receive and dispatch the next message */
if (!task->incoming && !task->recv_blocked)
{
recv_status = lwmsg_assoc_recv_message(task->assoc, &task->incoming_message);
switch (recv_status)
{
case LWMSG_STATUS_SUCCESS:
task->recv_partial = LWMSG_FALSE;
BAIL_ON_ERROR(status = lwmsg_peer_task_dispatch_incoming_message(task));
break;
case LWMSG_STATUS_PENDING:
task->incoming = LWMSG_TRUE;
break;
default:
BAIL_ON_ERROR(status = recv_status);
}
}
/* Try to send any outgoing call requests or incoming call replies */
if (!task->outgoing && !task->send_blocked)
{
send_status = lwmsg_peer_task_dispatch_calls(task);
switch (send_status)
{
case LWMSG_STATUS_SUCCESS:
case LWMSG_STATUS_PENDING:
break;
default:
BAIL_ON_ERROR(status = send_status);
}
}
/* If we could not make any progress finishing pended I/O,
dispatching outgoing calls or incoming call replies,
or receiving new calls, then we should go to sleep */
if (finish_status == LWMSG_STATUS_PENDING &&
send_status == LWMSG_STATUS_PENDING &&
recv_status == LWMSG_STATUS_PENDING)
{
if ((!task->incoming || !task->recv_partial) && !task->outgoing)
{
timeout = &peer->timeout.idle;
}
else
{
timeout = &peer->timeout.message;
}
lwmsg_peer_task_set_timeout(peer, task, timeout, *trigger, next_trigger, next_timeout);
BAIL_ON_ERROR(status = LWMSG_STATUS_PENDING);
}
}
error:
pthread_mutex_unlock(&task->session->lock);
switch (status)
{
case LWMSG_STATUS_SUCCESS:
case LWMSG_STATUS_PENDING:
break;
default:
status = lwmsg_peer_task_handle_assoc_error(
peer,
task,
status);
break;
}
return status;
}
