// This function is going to use uIP's protosockets to handle the connection.
// This means it must return int, because of the way the protosockets work.
// In a nutshell, when a PSOCK_* macro needs to wait for something, it will
// return from handle_connection so that other work can take place. When the
// event is triggered, uip_callback() will call this function again and the
// switch() statement (see below) will take care of resuming execution where
// it left off. It *looks* like this function runs from start to finish, but
// that's just an illusion to make it easier to code :-)
int
UIPClient::handle_connection(uip_tcp_appstate_t *s)
{
// All protosockets must start with this macro. Its internal implementation
// is that of a switch() statement, so all code between PSOCK_BEGIN and
// PSOCK_END is actually inside a switch block. (This means for example,
// that you can't declare variables in the middle of it!)
struct psock *p = &s->p;
uip_userdata_t *u = (uip_userdata_t *) s->user;
PSOCK_BEGIN(p);
if (uip_newdata() && readyToReceive(s))
{
PSOCK_READBUF_LEN(p, 0); //TODO check what happens when there's more new data incoming than space left in UIPClients buffer (most likely this is just discarded, isn't it?)
dataReceived(s);
}
if (readyToSend(s))
{
PSOCK_SEND(p, u->out_buffer, u->out_len);
dataSent(s);
}
if (isClosed(s))
{
// Disconnect.
PSOCK_CLOSE(p);
}
// All protosockets must end with this macro. It closes the switch().
PSOCK_END(p);
}
static PT_THREAD(handle_mqtt_connection(mqtt_state_t* state))
{
static struct etimer keepalive_timer;
uint8_t msg_type;
uint8_t msg_qos;
uint16_t msg_id;
PSOCK_BEGIN(&state->ps);
// Initialise and send CONNECT message
mqtt_msg_init(&state->mqtt_connection, state->out_buffer, state->out_buffer_length);
state->outbound_message = mqtt_msg_connect(&state->mqtt_connection, state->connect_info);
PSOCK_SEND(&state->ps, state->outbound_message->data, state->outbound_message->length);
state->outbound_message = NULL;
// Wait for CONACK message
PSOCK_READBUF_LEN(&state->ps, 2);
if(mqtt_get_type(state->in_buffer) != MQTT_MSG_TYPE_CONNACK)
PSOCK_CLOSE_EXIT(&state->ps);
// Tell the client we're connected
mqtt_flags |= MQTT_FLAG_CONNECTED;
complete_pending(state, MQTT_EVENT_TYPE_CONNECTED);
// Setup the keep alive timer and enter main message processing loop
etimer_set(&keepalive_timer, CLOCK_SECOND * state->connect_info->keepalive);
while(1)
{
// Wait for something to happen:
// new incoming data,
// new outgoing data,
// keep alive timer expired
PSOCK_WAIT_UNTIL(&state->ps, PSOCK_NEWDATA(&state->ps) ||
state->outbound_message != NULL ||
etimer_expired(&keepalive_timer));
// If there's a new message waiting to go out, then send it
if(state->outbound_message != NULL)
{
PSOCK_SEND(&state->ps, state->outbound_message->data, state->outbound_message->length);
state->outbound_message = NULL;
// If it was a PUBLISH message with QoS-0 then tell the client it's done
if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == 0)
complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED);
// Reset the keepalive timer as we've just sent some data
etimer_restart(&keepalive_timer);
continue;
}
// If the keep-alive timer expired then prepare a ping for sending
// and reset the timer
if(etimer_expired(&keepalive_timer))
{
state->outbound_message = mqtt_msg_pingreq(&state->mqtt_connection);
etimer_reset(&keepalive_timer);
continue;
}
// If we get here we must have woken for new incoming data,
// read and process it.
PSOCK_READBUF_LEN(&state->ps, 2);
state->message_length_read = PSOCK_DATALEN(&state->ps);
state->message_length = mqtt_get_total_length(state->in_buffer, state->message_length_read);
msg_type = mqtt_get_type(state->in_buffer);
msg_qos = mqtt_get_qos(state->in_buffer);
msg_id = mqtt_get_id(state->in_buffer, state->in_buffer_length);
switch(msg_type)
{
case MQTT_MSG_TYPE_SUBACK:
if(state->pending_msg_type == MQTT_MSG_TYPE_SUBSCRIBE && state->pending_msg_id == msg_id)
complete_pending(state, MQTT_EVENT_TYPE_SUBSCRIBED);
break;
case MQTT_MSG_TYPE_UNSUBACK:
if(state->pending_msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && state->pending_msg_id == msg_id)
complete_pending(state, MQTT_EVENT_TYPE_UNSUBSCRIBED);
break;
case MQTT_MSG_TYPE_PUBLISH:
if(msg_qos == 1)
state->outbound_message = mqtt_msg_puback(&state->mqtt_connection, msg_id);
else if(msg_qos == 2)
state->outbound_message = mqtt_msg_pubrec(&state->mqtt_connection, msg_id);
deliver_publish(state, state->in_buffer, state->message_length_read);
break;
case MQTT_MSG_TYPE_PUBACK:
if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == msg_id)
complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED);
break;
case MQTT_MSG_TYPE_PUBREC:
state->outbound_message = mqtt_msg_pubrel(&state->mqtt_connection, msg_id);
break;
case MQTT_MSG_TYPE_PUBREL:
state->outbound_message = mqtt_msg_pubcomp(&state->mqtt_connection, msg_id);
break;
case MQTT_MSG_TYPE_PUBCOMP:
if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == msg_id)
complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED);
break;
case MQTT_MSG_TYPE_PINGREQ:
state->outbound_message = mqtt_msg_pingresp(&state->mqtt_connection);
break;
case MQTT_MSG_TYPE_PINGRESP:
// Ignore
break;
}
// NOTE: this is done down here and not in the switch case above
// because the PSOCK_READBUF_LEN() won't work inside a switch
// statement due to the way protothreads resume.
if(msg_type == MQTT_MSG_TYPE_PUBLISH)
{
uint16_t len;
// adjust message_length and message_length_read so that
// they only account for the publish data and not the rest of the
// message, this is done so that the offset passed with the
// continuation event is the offset within the publish data and
// not the offset within the message as a whole.
len = state->message_length_read;
mqtt_get_publish_data(state->in_buffer, &len);
len = state->message_length_read - len;
state->message_length -= len;
state->message_length_read -= len;
while(state->message_length_read < state->message_length)
{
PSOCK_READBUF_LEN(&state->ps, state->message_length - state->message_length_read);
deliver_publish_continuation(state, state->message_length_read, state->in_buffer, PSOCK_DATALEN(&state->ps));
state->message_length_read += PSOCK_DATALEN(&state->ps);
}
}
}
PSOCK_END(&state->ps);
}
