int mqttClient_disconnect(mqttClient_t* clientData)
{
int rc = LE_OK;
LE_ASSERT(clientData);
if (le_timer_IsRunning(clientData->session.connTimer))
{
rc = le_timer_Stop(clientData->session.connTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
}
if (le_timer_IsRunning(clientData->session.cmdTimer))
{
rc = le_timer_Stop(clientData->session.cmdTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
}
rc = le_timer_Stop(clientData->session.pingTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
int len = MQTTSerialize_disconnect(clientData->session.tx.buf, sizeof(clientData->session.tx.buf));
if (len > 0)
{
rc = mqttClient_write(clientData, len);
if (rc)
{
LE_ERROR("mqttClient_write() failed(%d)", rc);
goto cleanup;
}
}
le_timer_Delete(clientData->session.pingTimer);
le_timer_Delete(clientData->session.cmdTimer);
le_timer_Delete(clientData->session.connTimer);
clientData->session.isConnected = 0;
cleanup:
return rc;
}
//--------------------------------------------------------------------------------------------------
static void ResetClientWatchdog
(
int32_t timeout ///< [IN] The timeout to reset the watchdog timer to (in milliseconds).
)
{
le_clk_Time_t timeoutValue;
WatchdogObj_t* watchDogPtr = GetClientWatchdogPtr();
if (watchDogPtr != NULL)
{
le_timer_Stop(watchDogPtr->timer);
if (timeout == TIMEOUT_KICK)
{
timeoutValue = watchDogPtr->kickTimeoutInterval;
}
else
{
timeoutValue = MakeTimerInterval(timeout);
}
if (timeout != LE_WDOG_TIMEOUT_NEVER)
{
// timer should be stopped here so this should never fail
// testing
LE_ASSERT(LE_OK == le_timer_SetInterval(watchDogPtr->timer, timeoutValue));
le_timer_Start(watchDogPtr->timer);
}
else
{
LE_DEBUG("Timeout set to NEVER!");
}
}
}
//--------------------------------------------------------------------------------------------------
void ni_Release
(
ni_IteratorRef_t iteratorRef ///< [IN] Free the resources used by this iterator.
)
//--------------------------------------------------------------------------------------------------
{
LE_ASSERT(iteratorRef != NULL);
// Make sure that the transaction timer isn't still running.
if (iteratorRef->timerRef != NULL)
{
if (le_timer_GetExpiryCount(iteratorRef->timerRef) == 0)
{
le_timer_Stop(iteratorRef->timerRef);
}
le_timer_Delete(iteratorRef->timerRef);
iteratorRef->timerRef = NULL;
}
// Release the rest of the iterator's resources.
LE_DEBUG("Releasing iterator, <%p> with a lifetime of %d seconds.",
iteratorRef,
(uint32_t)(le_clk_GetRelativeTime().sec - iteratorRef->creationTime.sec));
ni_Close(iteratorRef);
tdb_UnregisterIterator(iteratorRef->treeRef, iteratorRef);
le_pathIter_Delete(iteratorRef->pathIterRef);
tdb_ReleaseTree(iteratorRef->treeRef);
le_mem_Release(iteratorRef);
}
static int mqttClient_processPubAck(mqttClient_t* clientData)
{
int32_t rc = LE_OK;
uint16_t packetId;
uint8_t dup;
uint8_t type;
LE_DEBUG("---> UNSUBACK");
LE_ASSERT(clientData);
rc = le_timer_Stop(clientData->session.cmdTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
rc = MQTTDeserialize_ack(&type, &dup, &packetId, clientData->session.rx.buf, sizeof(clientData->session.rx.buf));
if (rc != 1)
{
LE_ERROR("MQTTDeserialize_ack() failed");
rc = LE_BAD_PARAMETER;
goto cleanup;
}
else if (clientData->session.nextPacketId != packetId)
{
LE_ERROR("invalid packet ID(%u != %u)", clientData->session.nextPacketId, packetId);
rc = LE_BAD_PARAMETER;
goto cleanup;
}
cleanup:
return rc;
}
static int mqttClient_processConnAck(mqttClient_t* clientData)
{
int32_t rc = LE_OK;
uint8_t sessionPresent = 0;
uint8_t connack_rc = 0;
LE_DEBUG("---> CONNACK");
LE_ASSERT(clientData);
rc = le_timer_Stop(clientData->session.cmdTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
rc = MQTTDeserialize_connack((unsigned char*)&sessionPresent, &connack_rc, clientData->session.rx.buf, sizeof(clientData->session.rx.buf));
if (rc != 1)
{
LE_ERROR("MQTTDeserialize_connack() failed(%d)", rc);
rc = LE_BAD_PARAMETER;
goto cleanup;
}
LE_DEBUG("session present(%u) connection ACK(%u)", sessionPresent, connack_rc);
clientData->session.isConnected = (connack_rc == MQTT_CLIENT_CONNECT_SUCCESS);
if (clientData->session.isConnected)
{
mqttClient_SendConnStateEvent(true, 0, rc);
LE_INFO("subscribe('%s')", clientData->subscribeTopic);
rc = mqttClient_subscribe(clientData, clientData->subscribeTopic, 0, mqttClient_onIncomingMessage);
if (rc)
{
LE_ERROR("mqttClient_subscribe() failed(%d)", rc);
goto cleanup;
}
}
else
{
LE_ERROR("response('%s')", mqttClient_connectionRsp(connack_rc));
rc = LE_BAD_PARAMETER;
goto cleanup;
}
cleanup:
return rc;
}
static int mqttClient_processSubAck(mqttClient_t* clientData)
{
int count = 0;
int grantedQoS = -1;
int rc = LE_OK;
unsigned short packetId = 0;
LE_DEBUG("---> SUBACK");
LE_ASSERT(clientData);
rc = le_timer_Stop(clientData->session.cmdTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
rc = MQTTDeserialize_suback(&packetId, 1, &count, &grantedQoS, clientData->session.rx.buf, sizeof(clientData->session.rx.buf));
if (rc != 1)
{
LE_ERROR("MQTTDeserialize_suback() failed");
rc = LE_BAD_PARAMETER;
goto cleanup;
}
else if (clientData->session.nextPacketId != packetId)
{
LE_ERROR("invalid packet ID(%u != %u)", clientData->session.nextPacketId, packetId);
rc = LE_BAD_PARAMETER;
goto cleanup;
}
rc = LE_OK;
LE_DEBUG("returned count(%u) granted QoS(0x%02x)", count, grantedQoS);
if ((count == 0) && (grantedQoS == 0x80))
{
LE_ERROR("no granted QoS");
rc = LE_BAD_PARAMETER;
goto cleanup;
}
cleanup:
return rc;
}
//--------------------------------------------------------------------------------------------------
le_avdata_RequestSessionObjRef_t le_avdata_RequestSession
(
void
)
{
le_result_t result = LE_OK;
// If this is a duplicate request send the existing reference.
le_ref_IterRef_t iterRef = le_ref_GetIterator(AvSessionRequestRefMap);
while (le_ref_NextNode(iterRef) == LE_OK)
{
if (le_ref_GetValue(iterRef) == le_avdata_GetClientSessionRef())
{
LE_DEBUG("Duplicate session request from client.");
return (le_avdata_RequestSessionObjRef_t) le_ref_GetSafeRef(iterRef);
}
}
le_timer_Stop(SessionReleaseTimerRef);
// Ask the avc server to pass the request to control app or to initiate a session.
result = avcServer_RequestSession();
// If the fresh request fails, return NULL.
if (result != LE_OK)
{
return NULL;
}
// Need to return a unique reference that will be used by release. Use the client session ref
// as the data, since we need to delete the ref when the client closes.
le_avdata_RequestSessionObjRef_t requestRef = le_ref_CreateRef(AvSessionRequestRefMap,
le_avdata_GetClientSessionRef());
return requestRef;
}
//--------------------------------------------------------------------------------------------------
static void MyCallEventHandler
(
le_mcc_CallRef_t callRef,
le_mcc_Event_t callEvent,
void* contextPtr
)
{
le_result_t res;
static bool firstConnectCall = true;
LE_INFO("MCC TEST: New Call event: %d for Call %p", callEvent, callRef);
if (callEvent == LE_MCC_EVENT_ALERTING)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_ALERTING.");
if (firstConnectCall)
{
LE_INFO("---!!!! PLEASE CHECK ON THE REMOTE SIDE IF THE PHONE NUMBER IS %s !!!!---",
((ClirStatus == LE_ON) ? "HIDED" : "DISPLAYED"));
LE_INFO("---!!!! PLEASE HANG UP ON THE REMOTE SIDE !!!!---");
}
}
else if (callEvent == LE_MCC_EVENT_CONNECTED)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_CONNECTED.");
if (firstConnectCall)
{
LE_INFO("---!!!! PLEASE TERMINATE THE CALL on THE REMOTE SIDE !!!!---");
firstConnectCall = false;
}
}
else if (callEvent == LE_MCC_EVENT_TERMINATED)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_TERMINATED.");
le_mcc_TerminationReason_t term = le_mcc_GetTerminationReason(callRef);
int32_t code = le_mcc_GetPlatformSpecificTerminationCode(callRef);
switch(term)
{
case LE_MCC_TERM_NETWORK_FAIL:
LE_ERROR("Termination reason is LE_MCC_TERM_NETWORK_FAIL");
exit(EXIT_FAILURE);
break;
case LE_MCC_TERM_UNASSIGNED_NUMBER:
LE_ERROR("Termination reason is LE_MCC_TERM_UNASSIGNED_NUMBER");
exit(EXIT_FAILURE);
break;
case LE_MCC_TERM_USER_BUSY:
LE_ERROR("Termination reason is LE_MCC_TERM_USER_BUSY");
exit(EXIT_FAILURE);
break;
case LE_MCC_TERM_LOCAL_ENDED:
LE_INFO("Termination reason is LE_MCC_TERM_LOCAL_ENDED");
LE_INFO("mccTest Sequence SUCCESS");
LE_INFO("mccTest test exit");
le_mcc_Delete(callRef);
exit(EXIT_SUCCESS);
break;
case LE_MCC_TERM_REMOTE_ENDED:
LE_INFO("Termination reason is LE_MCC_TERM_REMOTE_ENDED");
LE_INFO("---!!!! PLEASE CREATE AN INCOMING CALL !!!!---");
break;
case LE_MCC_TERM_UNDEFINED:
LE_ERROR("Termination reason is LE_MCC_TERM_UNDEFINED");
LE_ERROR("---!!!! PLEASE CREATE AN INCOMING CALL !!!!---");
break;
default:
LE_ERROR("Termination reason is %d", term);
exit(EXIT_FAILURE);
break;
}
LE_INFO("Termination code is 0x%X", code);
if (HangUpTimer)
{
le_timer_Stop(HangUpTimer);
}
}
else if (callEvent == LE_MCC_EVENT_INCOMING)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_INCOMING.");
res = le_mcc_Answer(callRef);
if (res == LE_OK)
{
LE_INFO("Check MyCallEventHandler passed, I answered the call");
LE_INFO("All calls will be hung-up in 10 seconds");
LE_ASSERT(le_timer_Start(HangUpTimer) == LE_OK);
}
else
{
LE_ERROR("Check MyCallEventHandler failed to answer the call.");
}
}
else if (callEvent == LE_MCC_EVENT_ORIGINATING)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_ORIGINATING.");
}
else if (callEvent == LE_MCC_EVENT_SETUP)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_EVENT_SETUP.");
}
else
{
LE_ERROR("Check MyCallEventHandler failed, unknowm event %d.", callEvent);
}
}
static void mqttClient_socketFdEventHandler(int sockFd, short events)
{
mqttClient_t* clientData = le_fdMonitor_GetContextPtr();
int rc = LE_OK;
LE_ASSERT(clientData);
LE_DEBUG("events(0x%08x)", events);
if (events & POLLOUT)
{
le_fdMonitor_Disable(clientData->session.sockFdMonitor, POLLOUT);
if ((clientData->session.sock != MQTT_CLIENT_INVALID_SOCKET) && !clientData->session.isConnected)
{
LE_INFO("connected(%s:%d)", clientData->session.config.brokerUrl, clientData->session.config.portNumber);
rc = le_timer_Stop(clientData->session.connTimer);
if (rc)
{
LE_ERROR("le_timer_Stop() failed(%d)", rc);
goto cleanup;
}
MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
data.willFlag = 0;
data.MQTTVersion = MQTT_CLIENT_MQTT_VERSION;
LE_INFO("deviceId('%s'), pwd('%s')", clientData->deviceId, clientData->session.secret);
if (strlen(clientData->deviceId) > 0)
{
data.clientID.cstring = clientData->deviceId;
data.username.cstring = clientData->deviceId;
data.password.cstring = clientData->session.secret;
}
data.keepAliveInterval = clientData->session.config.keepAlive;
data.cleansession = 1;
rc = mqttClient_sendConnect(clientData, &data);
if (rc)
{
LE_ERROR("mqttClient_sendConnect() failed(%d)", rc);
goto cleanup;
}
}
else if (clientData->session.tx.bytesLeft)
{
rc = mqttClient_write(clientData, 0);
if (rc)
{
LE_ERROR("mqttClient_write() failed(%d)", rc);
goto cleanup;
}
}
}
else if (events & POLLIN)
{
uint16_t packetType = MQTTPacket_read(clientData->session.rx.buf, sizeof(clientData->session.rx.buf), mqttClient_read);
LE_DEBUG("packet type(%d)", packetType);
switch (packetType)
{
case CONNACK:
rc = mqttClient_processConnAck(clientData);
if (rc)
{
LE_ERROR("mqttClient_processConnAck() failed(%d)", rc);
goto cleanup;
}
break;
case PUBACK:
rc = mqttClient_processPubAck(clientData);
if (rc)
{
LE_ERROR("mqttClient_processPubAck() failed(%d)", rc);
goto cleanup;
}
break;
case SUBACK:
rc = mqttClient_processSubAck(clientData);
if (rc)
{
LE_ERROR("mqttClient_processSubAck() failed(%d)", rc);
goto cleanup;
}
break;
case UNSUBACK:
rc = mqttClient_processUnSubAck(clientData);
if (rc)
{
LE_ERROR("mqttClient_processUnSubAck() failed(%d)", rc);
goto cleanup;
}
break;
case PUBLISH:
rc = mqttClient_processPublish(clientData);
if (rc)
{
LE_ERROR("mqttClient_processPublish() failed(%d)", rc);
goto cleanup;
}
break;
case PUBREC:
rc = mqttClient_processPubRec(clientData);
if (rc)
{
LE_ERROR("mqttClient_processPubRec() failed(%d)", rc);
goto cleanup;
}
break;
case PUBCOMP:
rc = mqttClient_processPubComp(clientData);
if (rc)
{
LE_ERROR("mqttClient_processPubComp() failed(%d)", rc);
goto cleanup;
}
break;
case PINGRESP:
mqttClient_processPingResp(clientData);
break;
default:
LE_ERROR("unknown packet type(%u)", packetType);
break;
}
clientData->session.cmdRetries = 0;
}
cleanup:
return;
}
//--------------------------------------------------------------------------------------------------
static void MyCallEventHandler(le_mcc_call_ObjRef_t callRef, le_mcc_call_Event_t callEvent, void* contextPtr)
{
le_result_t res;
LE_INFO("MCC TEST: New Call event: %d for Call %p", callEvent, callRef);
if (callEvent == LE_MCC_CALL_EVENT_ALERTING)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_CALL_EVENT_ALERTING.");
}
else if (callEvent == LE_MCC_CALL_EVENT_CONNECTED)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_CALL_EVENT_CONNECTED.");
}
else if (callEvent == LE_MCC_CALL_EVENT_TERMINATED)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_CALL_EVENT_TERMINATED.");
le_mcc_call_TerminationReason_t term = le_mcc_call_GetTerminationReason(callRef);
switch(term)
{
case LE_MCC_CALL_TERM_NETWORK_FAIL:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_NETWORK_FAIL");
break;
case LE_MCC_CALL_TERM_BAD_ADDRESS:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_BAD_ADDRESS");
break;
case LE_MCC_CALL_TERM_BUSY:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_BUSY");
break;
case LE_MCC_CALL_TERM_LOCAL_ENDED:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_LOCAL_ENDED");
break;
case LE_MCC_CALL_TERM_REMOTE_ENDED:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_REMOTE_ENDED");
break;
case LE_MCC_CALL_TERM_NOT_DEFINED:
LE_INFO("Termination reason is LE_MCC_CALL_TERM_NOT_DEFINED");
break;
default:
LE_INFO("Termination reason is %d", term);
break;
}
le_mcc_call_Delete(callRef);
if (HangUpTimer)
{
le_timer_Stop(HangUpTimer);
}
}
else if (callEvent == LE_MCC_CALL_EVENT_INCOMING)
{
LE_INFO("Check MyCallEventHandler passed, event is LE_MCC_CALL_EVENT_INCOMING.");
res = le_mcc_call_Answer(callRef);
if (res == LE_OK)
{
LE_INFO("Check MyCallEventHandler passed, I answered the call");
LE_INFO("All calls will be hung-up in 10 seconds");
LE_ASSERT(le_timer_Start(HangUpTimer) == LE_OK);
}
else
{
LE_INFO("Check MyCallEventHandler failed to answer the call.");
}
}
else
{
LE_INFO("Check MyCallEventHandler failed, unknowm event.");
}
}
