int MQTTProtocol_connect(const char* ip_address, Clients* aClient, int MQTTVersion) #endif #endif { int rc, port; char* addr; FUNC_ENTRY; aClient->good = 1; addr = MQTTProtocol_addressPort(ip_address, &port); #if defined(__GNUC__) && defined(__linux__) if (timeout < 0) rc = -1; else rc = Socket_new(addr, port, &(aClient->net.socket), timeout); #else rc = Socket_new(addr, port, &(aClient->net.socket)); #endif if (rc == EINPROGRESS || rc == EWOULDBLOCK) aClient->connect_state = 1; /* TCP connect called - wait for connect completion */ else if (rc == 0) { /* TCP connect completed. If SSL, send SSL connect */ #if defined(OPENSSL) if (ssl) { if (SSLSocket_setSocketForSSL(&aClient->net, aClient->sslopts) == 1) { rc = SSLSocket_connect(aClient->net.ssl, aClient->net.socket); if (rc == -1) aClient->connect_state = 2; /* SSL connect called - wait for completion */ } else rc = SOCKET_ERROR; } #endif if (rc == 0) { /* Now send the MQTT connect packet */ if ((rc = MQTTPacket_send_connect(aClient, MQTTVersion)) == 0) aClient->connect_state = 3; /* MQTT Connect sent - wait for CONNACK */ else aClient->connect_state = 0; } } if (addr != ip_address) free(addr); FUNC_EXIT_RC(rc); return rc; }
int MQTTClient_connectURIVersion(MQTTClient handle, MQTTClient_connectOptions* options, const char* serverURI, int MQTTVersion, START_TIME_TYPE start, long millisecsTimeout) { MQTTClients* m = handle; int rc = SOCKET_ERROR; int sessionPresent = 0; FUNC_ENTRY; if (m->ma && !running) { Thread_start(MQTTClient_run, handle); if (MQTTClient_elapsed(start) >= millisecsTimeout) { rc = SOCKET_ERROR; goto exit; } MQTTClient_sleep(100L); } Log(TRACE_MIN, -1, "Connecting to serverURI %s with MQTT version %d", serverURI, MQTTVersion); #if defined(OPENSSL) rc = MQTTProtocol_connect(serverURI, m->c, m->ssl, MQTTVersion); #else rc = MQTTProtocol_connect(serverURI, m->c, MQTTVersion); #endif if (rc == SOCKET_ERROR) goto exit; if (m->c->connect_state == 0) { rc = SOCKET_ERROR; goto exit; } if (m->c->connect_state == 1) /* TCP connect started - wait for completion */ { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (rc != 0) { rc = SOCKET_ERROR; goto exit; } #if defined(OPENSSL) if (m->ssl) { if (SSLSocket_setSocketForSSL(&m->c->net, m->c->sslopts) != MQTTCLIENT_SUCCESS) { if (m->c->session != NULL) if ((rc = SSL_set_session(m->c->net.ssl, m->c->session)) != 1) Log(TRACE_MIN, -1, "Failed to set SSL session with stored data, non critical"); rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket); if (rc == TCPSOCKET_INTERRUPTED) m->c->connect_state = 2; /* the connect is still in progress */ else if (rc == SSL_FATAL) { rc = SOCKET_ERROR; goto exit; } else if (rc == 1) { rc = MQTTCLIENT_SUCCESS; m->c->connect_state = 3; if (MQTTPacket_send_connect(m->c, MQTTVersion) == SOCKET_ERROR) { rc = SOCKET_ERROR; goto exit; } if (!m->c->cleansession && m->c->session == NULL) m->c->session = SSL_get1_session(m->c->net.ssl); } } else { rc = SOCKET_ERROR; goto exit; } } else { #endif m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */ if (MQTTPacket_send_connect(m->c, MQTTVersion) == SOCKET_ERROR) { rc = SOCKET_ERROR; goto exit; } #if defined(OPENSSL) } #endif } #if defined(OPENSSL) if (m->c->connect_state == 2) /* SSL connect sent - wait for completion */ { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (rc != 1) { rc = SOCKET_ERROR; goto exit; } if(!m->c->cleansession && m->c->session == NULL) m->c->session = SSL_get1_session(m->c->net.ssl); m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */ if (MQTTPacket_send_connect(m->c, MQTTVersion) == SOCKET_ERROR) { rc = SOCKET_ERROR; goto exit; } } #endif if (m->c->connect_state == 3) /* MQTT connect sent - wait for CONNACK */ { MQTTPacket* pack = NULL; Thread_unlock_mutex(mqttclient_mutex); pack = MQTTClient_waitfor(handle, CONNACK, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (pack == NULL) rc = SOCKET_ERROR; else { Connack* connack = (Connack*)pack; Log(TRACE_PROTOCOL, 1, NULL, m->c->net.socket, m->c->clientID, connack->rc); if ((rc = connack->rc) == MQTTCLIENT_SUCCESS) { m->c->connected = 1; m->c->good = 1; m->c->connect_state = 0; if (MQTTVersion == 4) sessionPresent = connack->flags.bits.sessionPresent; if (m->c->cleansession) rc = MQTTClient_cleanSession(m->c); if (m->c->outboundMsgs->count > 0) { ListElement* outcurrent = NULL; while (ListNextElement(m->c->outboundMsgs, &outcurrent)) { Messages* m = (Messages*)(outcurrent->content); m->lastTouch = 0; } MQTTProtocol_retry((time_t)0, 1, 1); if (m->c->connected != 1) rc = MQTTCLIENT_DISCONNECTED; } } free(connack); m->pack = NULL; } } exit: if (rc == MQTTCLIENT_SUCCESS) { if (options->struct_version == 4) /* means we have to fill out return values */ { options->returned.serverURI = serverURI; options->returned.MQTTVersion = MQTTVersion; options->returned.sessionPresent = sessionPresent; } } else { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_disconnect1(handle, 0, 0, (MQTTVersion == 3)); /* not "internal" because we don't want to call connection lost */ Thread_lock_mutex(mqttclient_mutex); } FUNC_EXIT_RC(rc); return rc; }
/* This is the thread function that handles the calling of callback functions if set */ thread_return_type WINAPI MQTTClient_run(void* n) { long timeout = 10L; /* first time in we have a small timeout. Gets things started more quickly */ FUNC_ENTRY; running = 1; run_id = Thread_getid(); Thread_lock_mutex(mqttclient_mutex); while (!tostop) { int rc = SOCKET_ERROR; int sock = -1; MQTTClients* m = NULL; MQTTPacket* pack = NULL; Thread_unlock_mutex(mqttclient_mutex); pack = MQTTClient_cycle(&sock, timeout, &rc); Thread_lock_mutex(mqttclient_mutex); if (tostop) break; timeout = 1000L; /* find client corresponding to socket */ if (ListFindItem(handles, &sock, clientSockCompare) == NULL) { /* assert: should not happen */ continue; } m = (MQTTClient)(handles->current->content); if (m == NULL) { /* assert: should not happen */ continue; } if (rc == SOCKET_ERROR) { if (m->c->connected) { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_disconnect_internal(m, 0); Thread_lock_mutex(mqttclient_mutex); } else { if (m->c->connect_state == 2 && !Thread_check_sem(m->connect_sem)) { Log(TRACE_MIN, -1, "Posting connect semaphore for client %s", m->c->clientID); Thread_post_sem(m->connect_sem); } if (m->c->connect_state == 3 && !Thread_check_sem(m->connack_sem)) { Log(TRACE_MIN, -1, "Posting connack semaphore for client %s", m->c->clientID); Thread_post_sem(m->connack_sem); } } } else { if (m->c->messageQueue->count > 0) { qEntry* qe = (qEntry*)(m->c->messageQueue->first->content); int topicLen = qe->topicLen; if (strlen(qe->topicName) == topicLen) topicLen = 0; Log(TRACE_MIN, -1, "Calling messageArrived for client %s, queue depth %d", m->c->clientID, m->c->messageQueue->count); Thread_unlock_mutex(mqttclient_mutex); rc = (*(m->ma))(m->context, qe->topicName, topicLen, qe->msg); Thread_lock_mutex(mqttclient_mutex); /* if 0 (false) is returned by the callback then it failed, so we don't remove the message from * the queue, and it will be retried later. If 1 is returned then the message data may have been freed, * so we must be careful how we use it. */ if (rc) ListRemove(m->c->messageQueue, qe); else Log(TRACE_MIN, -1, "False returned from messageArrived for client %s, message remains on queue", m->c->clientID); } if (pack) { if (pack->header.bits.type == CONNACK && !Thread_check_sem(m->connack_sem)) { Log(TRACE_MIN, -1, "Posting connack semaphore for client %s", m->c->clientID); m->pack = pack; Thread_post_sem(m->connack_sem); } else if (pack->header.bits.type == SUBACK) { Log(TRACE_MIN, -1, "Posting suback semaphore for client %s", m->c->clientID); m->pack = pack; Thread_post_sem(m->suback_sem); } else if (pack->header.bits.type == UNSUBACK) { Log(TRACE_MIN, -1, "Posting unsuback semaphore for client %s", m->c->clientID); m->pack = pack; Thread_post_sem(m->unsuback_sem); } } else if (m->c->connect_state == 1 && !Thread_check_sem(m->connect_sem)) { int error; socklen_t len = sizeof(error); if ((m->rc = getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len)) == 0) m->rc = error; Log(TRACE_MIN, -1, "Posting connect semaphore for client %s rc %d", m->c->clientID, m->rc); Thread_post_sem(m->connect_sem); } #if defined(OPENSSL) else if (m->c->connect_state == 2 && !Thread_check_sem(m->connect_sem)) { rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket); if (rc == 1 || rc == SSL_FATAL) { if (rc == 1 && !m->c->cleansession && m->c->session == NULL) m->c->session = SSL_get1_session(m->c->net.ssl); m->rc = rc; Log(TRACE_MIN, -1, "Posting connect semaphore for SSL client %s rc %d", m->c->clientID, m->rc); Thread_post_sem(m->connect_sem); } } #endif } } run_id = 0; running = tostop = 0; Thread_unlock_mutex(mqttclient_mutex); FUNC_EXIT; return 0; }
MQTTPacket* MQTTClient_waitfor(MQTTClient handle, int packet_type, int* rc, long timeout) { MQTTPacket* pack = NULL; MQTTClients* m = handle; START_TIME_TYPE start = MQTTClient_start_clock(); FUNC_ENTRY; if (((MQTTClients*)handle) == NULL) { *rc = MQTTCLIENT_FAILURE; goto exit; } if (running) { if (packet_type == CONNECT) { if ((*rc = Thread_wait_sem(m->connect_sem, timeout)) == 0) *rc = m->rc; } else if (packet_type == CONNACK) *rc = Thread_wait_sem(m->connack_sem, timeout); else if (packet_type == SUBACK) *rc = Thread_wait_sem(m->suback_sem, timeout); else if (packet_type == UNSUBACK) *rc = Thread_wait_sem(m->unsuback_sem, timeout); if (*rc == 0 && packet_type != CONNECT && m->pack == NULL) Log(LOG_ERROR, -1, "waitfor unexpectedly is NULL for client %s, packet_type %d, timeout %ld", m->c->clientID, packet_type, timeout); pack = m->pack; } else { *rc = TCPSOCKET_COMPLETE; while (1) { int sock = -1; pack = MQTTClient_cycle(&sock, 100L, rc); if (sock == m->c->net.socket) { if (*rc == SOCKET_ERROR) break; if (pack && (pack->header.bits.type == packet_type)) break; if (m->c->connect_state == 1) { int error; socklen_t len = sizeof(error); if ((*rc = getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len)) == 0) *rc = error; break; } #if defined(OPENSSL) else if (m->c->connect_state == 2) { *rc = SSLSocket_connect(m->c->net.ssl, sock); if (*rc == SSL_FATAL) break; else if (*rc == 1) /* rc == 1 means SSL connect has finished and succeeded */ { if (!m->c->cleansession && m->c->session == NULL) m->c->session = SSL_get1_session(m->c->net.ssl); break; } } #endif else if (m->c->connect_state == 3) { int error; socklen_t len = sizeof(error); if (getsockopt(m->c->net.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len) == 0) { if (error) { *rc = error; break; } } } } if (MQTTClient_elapsed(start) > timeout) { pack = NULL; break; } } } exit: FUNC_EXIT_RC(*rc); return pack; }
int MQTTClient_connect(MQTTClient handle, MQTTClient_connectOptions* options) { MQTTClients* m = handle; int rc = SOCKET_ERROR; START_TIME_TYPE start; long millisecsTimeout = 30000L; FUNC_ENTRY; Thread_lock_mutex(mqttclient_mutex); if (options == NULL) { rc = MQTTCLIENT_NULL_PARAMETER; goto exit; } if (strncmp(options->struct_id, "MQTC", 4) != 0 || (options->struct_version != 0 && options->struct_version != 1)) { rc = MQTTCLIENT_BAD_STRUCTURE; goto exit; } if (options->will) /* check validity of will options structure */ { if (strncmp(options->will->struct_id, "MQTW", 4) != 0 || options->will->struct_version != 0) { rc = MQTTCLIENT_BAD_STRUCTURE; goto exit; } } #if defined(OPENSSL) if (options->struct_version != 0 && options->ssl) /* check validity of SSL options structure */ { if (strncmp(options->ssl->struct_id, "MQTS", 4) != 0 || options->ssl->struct_version != 0) { rc = MQTTCLIENT_BAD_STRUCTURE; goto exit; } } #endif if ((options->username && !UTF8_validateString(options->username)) || (options->password && !UTF8_validateString(options->password))) { rc = MQTTCLIENT_BAD_UTF8_STRING; goto exit; } millisecsTimeout = options->connectTimeout * 1000; start = MQTTClient_start_clock(); if (m->ma && !running) { Thread_start(MQTTClient_run, handle); if (MQTTClient_elapsed(start) >= millisecsTimeout) { rc = SOCKET_ERROR; goto exit; } MQTTClient_sleep(100L); } m->c->keepAliveInterval = options->keepAliveInterval; m->c->cleansession = options->cleansession; m->c->maxInflightMessages = (options->reliable) ? 1 : 10; if (options->will && options->will->struct_version == 0) { m->c->will = malloc(sizeof(willMessages)); m->c->will->msg = options->will->message; m->c->will->qos = options->will->qos; m->c->will->retained = options->will->retained; m->c->will->topic = options->will->topicName; } #if defined(OPENSSL) if (options->struct_version != 0 && options->ssl) m->c->sslopts = options->ssl; #endif m->c->username = options->username; m->c->password = options->password; m->c->retryInterval = options->retryInterval; Log(TRACE_MIN, -1, "Connecting to serverURI %s", m->serverURI); #if defined(OPENSSL) rc = MQTTProtocol_connect(m->serverURI, m->c, m->ssl); #else rc = MQTTProtocol_connect(m->serverURI, m->c); #endif if (rc == SOCKET_ERROR) goto exit; if (m->c->connect_state == 0) { rc = SOCKET_ERROR; goto exit; } if (m->c->connect_state == 1) /* TCP connect started - wait for completion */ { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (rc != 0) { rc = SOCKET_ERROR; goto exit; } #if defined(OPENSSL) if (m->ssl) { if (SSLSocket_setSocketForSSL(&m->c->net, m->c->sslopts) != MQTTCLIENT_SUCCESS) { if (m->c->session != NULL) if ((rc = SSL_set_session(m->c->net.ssl, m->c->session)) != 1) Log(TRACE_MIN, -1, "Failed to set SSL session with stored data, non critical"); rc = SSLSocket_connect(m->c->net.ssl, m->c->net.socket); if (rc == -1) m->c->connect_state = 2; else if (rc == SSL_FATAL) { rc = SOCKET_ERROR; goto exit; } else if (rc == 1 && !m->c->cleansession && m->c->session == NULL) m->c->session = SSL_get1_session(m->c->net.ssl); } else { rc = SOCKET_ERROR; goto exit; } } else { #endif m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */ if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR) { rc = SOCKET_ERROR; goto exit; } #if defined(OPENSSL) } #endif } #if defined(OPENSSL) if (m->c->connect_state == 2) /* SSL connect sent - wait for completion */ { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_waitfor(handle, CONNECT, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (rc != 1) { rc = SOCKET_ERROR; goto exit; } m->c->connect_state = 3; /* TCP connect completed, in which case send the MQTT connect packet */ if (MQTTPacket_send_connect(m->c) == SOCKET_ERROR) { rc = SOCKET_ERROR; goto exit; } } #endif if (m->c->connect_state == 3) /* MQTT connect sent - wait for CONNACK */ { MQTTPacket* pack = NULL; Thread_unlock_mutex(mqttclient_mutex); pack = MQTTClient_waitfor(handle, CONNACK, &rc, millisecsTimeout - MQTTClient_elapsed(start)); Thread_lock_mutex(mqttclient_mutex); if (pack == NULL) rc = SOCKET_ERROR; else { Connack* connack = (Connack*)pack; Log(LOG_PROTOCOL, 1, NULL, m->c->net.socket, m->c->clientID, connack->rc); if ((rc = connack->rc) == MQTTCLIENT_SUCCESS) { m->c->connected = 1; m->c->good = 1; m->c->connect_state = 0; if (m->c->cleansession) rc = MQTTClient_cleanSession(m->c); if (m->c->outboundMsgs->count > 0) { ListElement* outcurrent = NULL; while (ListNextElement(m->c->outboundMsgs, &outcurrent)) { Messages* m = (Messages*)(outcurrent->content); m->lastTouch = 0; } MQTTProtocol_retry(m->c->net.lastContact, 1); if (m->c->connected != 1) rc = MQTTCLIENT_DISCONNECTED; } } free(connack); m->pack = NULL; } } exit: if (rc != MQTTCLIENT_SUCCESS) { Thread_unlock_mutex(mqttclient_mutex); MQTTClient_disconnect(handle, 0); /* not "internal" because we don't want to call connection lost */ Thread_lock_mutex(mqttclient_mutex); } if (m->c->will) { free(m->c->will); m->c->will = NULL; } Thread_unlock_mutex(mqttclient_mutex); FUNC_EXIT_RC(rc); return rc; }