/// Receive an event from the underlying comms connection.
/// @param event the type of event.
/// @param weak_ptr a weak ponter to the underlying comms connection.
void event_handler(int event,
typename connection_type::weak_pointer weak_ptr)
{
// Use the raw pointer of the connection as the map key.
void* pointer(weak_ptr.lock().get());
if (!pointer)
return;
switch(event)
{
case via::comms::CONNECTED:
timer_.cancel();
rx_buffer_.clear();
rx_.clear();
if (connected_handler_)
connected_handler_();
break;
case via::comms::RECEIVED:
receive_handler();
break;
case via::comms::SENT:
if (message_sent_handler_)
message_sent_handler_();
break;
case via::comms::DISCONNECTED:
disconnected_handler();
break;
default:
break;
}
}
/**
* Callback function for data received from the network. Note that
* both "available" and "errCode" would be 0 if the read simply timed out.
*
* @param cls closure
* @param buf pointer to received data
* @param available number of bytes availabe in "buf",
* possibly 0 (on errors)
* @param addr address of the sender
* @param addrlen size of addr
* @param errCode value of errno (on errors receiving)
*/
static void
receive_helper (void *cls, const void *buf, size_t available,
const struct sockaddr *addr, socklen_t addrlen, int errCode)
{
struct GNUNET_CLIENT_Connection *client = cls;
struct GNUNET_TIME_Relative remaining;
GNUNET_CLIENT_MessageHandler receive_handler;
void *receive_handler_cls;
GNUNET_assert (GNUNET_NO == client->msg_complete);
GNUNET_assert (GNUNET_YES == client->in_receive);
client->in_receive = GNUNET_NO;
if ((0 == available) || (NULL == client->connection) || (0 != errCode))
{
/* signal timeout! */
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Timeout in receive_helper, available %u, client->connection %s, errCode `%s'\n",
(unsigned int) available, NULL == client->connection ? "NULL" : "non-NULL",
STRERROR (errCode));
if (NULL != (receive_handler = client->receiver_handler))
{
receive_handler_cls = client->receiver_handler_cls;
client->receiver_handler = NULL;
receive_handler (receive_handler_cls, NULL);
}
return;
}
/* FIXME: optimize for common fast case where buf contains the
* entire message and we need no copying... */
/* slow path: append to array */
if (client->received_size < client->received_pos + available)
GNUNET_array_grow (client->received_buf, client->received_size,
client->received_pos + available);
memcpy (&client->received_buf[client->received_pos], buf, available);
client->received_pos += available;
check_complete (client);
/* check for timeout */
remaining = GNUNET_TIME_absolute_get_remaining (client->receive_timeout);
if (0 == remaining.rel_value)
{
/* signal timeout! */
if (NULL != client->receiver_handler)
client->receiver_handler (client->receiver_handler_cls, NULL);
return;
}
/* back to receive -- either for more data or to call callback! */
GNUNET_CLIENT_receive (client, client->receiver_handler,
client->receiver_handler_cls, remaining);
}
