MQTTPacket* MQTTClient_cycle(int* sock, unsigned long timeout, int* rc)
{
struct timeval tp = {0L, 0L};
static Ack ack;
MQTTPacket* pack = NULL;
FUNC_ENTRY;
if (timeout > 0L)
{
tp.tv_sec = timeout / 1000;
tp.tv_usec = (timeout % 1000) * 1000; /* this field is microseconds! */
}
#if defined(OPENSSL)
if ((*sock = SSLSocket_getPendingRead()) == -1)
{
/* 0 from getReadySocket indicates no work to do, -1 == error, but can happen normally */
#endif
Thread_lock_mutex(socket_mutex);
*sock = Socket_getReadySocket(0, &tp);
Thread_unlock_mutex(socket_mutex);
#if defined(OPENSSL)
}
#endif
Thread_lock_mutex(mqttclient_mutex);
if (*sock > 0)
{
MQTTClients* m = NULL;
if (ListFindItem(handles, sock, clientSockCompare) != NULL)
m = (MQTTClient)(handles->current->content);
if (m != NULL)
{
if (m->c->connect_state == 1 || m->c->connect_state == 2)
*rc = 0; /* waiting for connect state to clear */
else
{
pack = MQTTPacket_Factory(&m->c->net, rc);
if (*rc == TCPSOCKET_INTERRUPTED)
*rc = 0;
}
}
if (pack)
{
int freed = 1;
/* Note that these handle... functions free the packet structure that they are dealing with */
if (pack->header.bits.type == PUBLISH)
*rc = MQTTProtocol_handlePublishes(pack, *sock);
else if (pack->header.bits.type == PUBACK || pack->header.bits.type == PUBCOMP)
{
int msgid;
ack = (pack->header.bits.type == PUBCOMP) ? *(Pubcomp*)pack : *(Puback*)pack;
msgid = ack.msgId;
*rc = (pack->header.bits.type == PUBCOMP) ?
MQTTProtocol_handlePubcomps(pack, *sock) : MQTTProtocol_handlePubacks(pack, *sock);
if (m && m->dc)
{
Log(TRACE_MIN, -1, "Calling deliveryComplete for client %s, msgid %d", m->c->clientID, msgid);
(*(m->dc))(m->context, msgid);
}
}
else if (pack->header.bits.type == PUBREC)
*rc = MQTTProtocol_handlePubrecs(pack, *sock);
else if (pack->header.bits.type == PUBREL)
*rc = MQTTProtocol_handlePubrels(pack, *sock);
else if (pack->header.bits.type == PINGRESP)
*rc = MQTTProtocol_handlePingresps(pack, *sock);
else
freed = 0;
if (freed)
pack = NULL;
}
}
MQTTClient_retry();
Thread_unlock_mutex(mqttclient_mutex);
FUNC_EXIT_RC(*rc);
return pack;
}
/**
* MQTT protocol timeslice for one packet and client - must not take too long!
* @param sock the socket which is ready for the packet to be read from
* @param client the client structure which corresponds to the socket
*/
void MQTTProtocol_timeslice(int sock, Clients* client)
{
int error;
MQTTPacket* pack;
FUNC_ENTRY;
Log(TRACE_MIN, -1, "%d %s About to read packet for peer address %s",
sock, (client == NULL) ? "unknown" : client->clientID, Socket_getpeer(sock));
in_MQTTPacket_Factory = sock;
pack = MQTTPacket_Factory(sock, &error);
in_MQTTPacket_Factory = -1;
if (pack == NULL)
{ /* there was an error on the socket, so clean it up */
if (error == SOCKET_ERROR || error == BAD_MQTT_PACKET)
{
if (client != NULL)
{
client->good = 0; /* make sure we don't try and send messages to ourselves */
if (error == SOCKET_ERROR)
Log(LOG_WARNING, 18, NULL, client->clientID, sock, Socket_getpeer(sock));
else
Log(LOG_WARNING, 19, NULL, client->clientID, sock, Socket_getpeer(sock));
MQTTProtocol_closeSession(client, 1);
}
else
{
if (error == SOCKET_ERROR)
/* Don't do a Socket_getpeer in the case of SOCKET_ERROR -
* otherwise another SOCKET_ERROR will be hit */
Log(LOG_WARNING, 20, NULL, sock, "unknown");
else
Log(LOG_WARNING, 21, NULL, sock, Socket_getpeer(sock));
Socket_close(sock);
}
}
}
else if (handle_packets[pack->header.bits.type] == NULL)
Log(LOG_WARNING, 22, NULL, pack->header.bits.type, sock);
else
{
if (client == NULL && pack->header.bits.type != CONNECT)
{
Log(LOG_WARNING, 23, NULL, sock, Socket_getpeer(sock), MQTTPacket_name(pack->header.bits.type));
MQTTPacket_free_packet(pack);
Socket_close(sock);
}
else
{
Node* elem = NULL;
/* incoming publish at QoS 0 does not result in outgoing communication, so we don't want to count it as contact,
for PING processing on outbound connections */
int update_time = (pack->header.bits.type == PUBLISH && pack->header.bits.qos == 0) ? 0 : 1;
if (client && (update_time || (client->outbound == 0)))
time(&(client->lastContact));
if ((*handle_packets[pack->header.bits.type])(pack, sock, client) == SOCKET_ERROR)
{
/* the client could have been closed during handle_packet, so check to see if it's still in the client list */
elem = TreeFind(bstate->clients, &sock);
if (elem == NULL && client && client->clientID)
elem = TreeFind(bstate->disconnected_clients, client->clientID);
if (elem != NULL)
{
client = (Clients*)(elem->content);
client->good = 0; /* make sure we don't try and send messages to ourselves */
Log(LOG_WARNING, 18, NULL, client->clientID, sock, Socket_getpeer(sock));
MQTTProtocol_closeSession(client, 1);
}
else
{
Log(LOG_WARNING, 20, NULL, sock, Socket_getpeer(sock));
Socket_close(sock);
}
}
}
}
/*MQTTProtocol_housekeeping(); move to Protocol_timeslice*/
FUNC_EXIT;
}
