static void sendMsgComplete(IOTHUB_MESSAGE_LIST* iothubMsgList, PMQTTTRANSPORT_HANDLE_DATA transportState, IOTHUB_BATCHSTATE_RESULT batchResult)
{
DLIST_ENTRY messageCompleted;
DList_InitializeListHead(&messageCompleted);
DList_InsertTailList(&messageCompleted, &(iothubMsgList->entry));
IoTHubClient_LL_SendComplete(transportState->llClientHandle, &messageCompleted, batchResult);
}
IOTHUB_CLIENT_RESULT IoTHubClient_LL_SendEventAsync(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback)
{
IOTHUB_CLIENT_RESULT result;
/*Codes_SRS_IOTHUBCLIENT_LL_02_011: [IoTHubClient_LL_SendEventAsync shall fail and return IOTHUB_CLIENT_INVALID_ARG if parameter iotHubClientHandle or eventMessageHandle is NULL.]*/
if (
(iotHubClientHandle == NULL) ||
(eventMessageHandle == NULL) ||
/*Codes_SRS_IOTHUBCLIENT_LL_02_012: [IoTHubClient_LL_SendEventAsync shall fail and return IOTHUB_CLIENT_INVALID_ARG if parameter eventConfirmationCallback is NULL and userContextCallback is not NULL.] */
((eventConfirmationCallback == NULL) && (userContextCallback != NULL))
)
{
result = IOTHUB_CLIENT_INVALID_ARG;
LOG_ERROR;
}
else
{
IOTHUB_MESSAGE_LIST *newEntry = (IOTHUB_MESSAGE_LIST*)malloc(sizeof(IOTHUB_MESSAGE_LIST));
if (newEntry == NULL)
{
result = IOTHUB_CLIENT_ERROR;
LOG_ERROR;
}
else
{
IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)iotHubClientHandle;
if (attach_ms_timesOutAfter(handleData, newEntry) != 0)
{
result = IOTHUB_CLIENT_ERROR;
LOG_ERROR;
free(newEntry);
}
else
{
/*Codes_SRS_IOTHUBCLIENT_LL_02_013: [IoTHubClient_SendEventAsync shall add the DLIST waitingToSend a new record cloning the information from eventMessageHandle, eventConfirmationCallback, userContextCallback.]*/
if ((newEntry->messageHandle = IoTHubMessage_Clone(eventMessageHandle)) == NULL)
{
/*Codes_SRS_IOTHUBCLIENT_LL_02_014: [If cloning and/or adding the information fails for any reason, IoTHubClient_LL_SendEventAsync shall fail and return IOTHUB_CLIENT_ERROR.] */
result = IOTHUB_CLIENT_ERROR;
free(newEntry);
LOG_ERROR;
}
else
{
IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)iotHubClientHandle;
/*Codes_SRS_IOTHUBCLIENT_LL_02_013: [IoTHubClient_SendEventAsync shall add the DLIST waitingToSend a new record cloning the information from eventMessageHandle, eventConfirmationCallback, userContextCallback.]*/
newEntry->callback = eventConfirmationCallback;
newEntry->context = userContextCallback;
DList_InsertTailList(&(handleData->waitingToSend), &(newEntry->entry));
/*Codes_SRS_IOTHUBCLIENT_LL_02_015: [Otherwise IoTHubClient_LL_SendEventAsync shall succeed and return IOTHUB_CLIENT_OK.] */
result = IOTHUB_CLIENT_OK;
}
}
}
}
return result;
}
extern void IoTHubTransportMqtt_DoWork(TRANSPORT_HANDLE handle, IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle)
{
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_026: [IoTHubTransportMqtt_DoWork shall do nothing if parameter handle and/or iotHubClientHandle is NULL.] */
PMQTTTRANSPORT_HANDLE_DATA transportState = (PMQTTTRANSPORT_HANDLE_DATA)handle;
if (transportState != NULL && iotHubClientHandle != NULL)
{
transportState->llClientHandle = iotHubClientHandle;
if (InitializeConnection(transportState, true) != 0)
{
// Don't want to flood the logs with failures here
}
else
{
if (transportState->currPacketState == CONNACK_TYPE)
{
(void)SubscribeToMqttProtocol(transportState);
}
else if (transportState->currPacketState == SUBACK_TYPE)
{
// Publish can be called now
transportState->currPacketState = PUBLISH_TYPE;
}
else if (transportState->currPacketState == PUBLISH_TYPE)
{
PDLIST_ENTRY currentListEntry = transportState->waitingForAck.Flink;
while (currentListEntry != &transportState->waitingForAck)
{
MQTT_MESSAGE_DETAILS_LIST* mqttMsgEntry = containingRecord(currentListEntry, MQTT_MESSAGE_DETAILS_LIST, entry);
DLIST_ENTRY nextListEntry;
nextListEntry.Flink = currentListEntry->Flink;
uint64_t current_ms;
(void)tickcounter_get_current_ms(g_msgTickCounter, ¤t_ms);
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_033: [IoTHubTransportMqtt_DoWork shall iterate through the Waiting Acknowledge messages looking for any message that has been waiting longer than 2 min.]*/
if (((current_ms - mqttMsgEntry->msgPublishTime) / 1000) > RESEND_TIMEOUT_VALUE_MIN)
{
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_034: [If IoTHubTransportMqtt_DoWork has resent the message two times then it shall fail the message] */
if (mqttMsgEntry->retryCount >= MAX_SEND_RECOUNT_LIMIT)
{
(void)DList_RemoveEntryList(currentListEntry);
sendMsgComplete(mqttMsgEntry->iotHubMessageEntry, transportState, IOTHUB_BATCHSTATE_FAILED);
free(mqttMsgEntry);
}
else
{
size_t messageLength;
const unsigned char* messagePayload = RetrieveMessagePayload(mqttMsgEntry->iotHubMessageEntry->messageHandle, &messageLength);
if (messageLength == 0 || messagePayload == NULL)
{
LogError("Failure from creating Message IoTHubMessage_GetData\r\n");
}
else
{
if (publishMqttMessage(transportState, mqttMsgEntry, messagePayload, messageLength) != 0)
{
(void)DList_RemoveEntryList(currentListEntry);
sendMsgComplete(mqttMsgEntry->iotHubMessageEntry, transportState, IOTHUB_BATCHSTATE_FAILED);
free(mqttMsgEntry);
}
}
}
}
currentListEntry = nextListEntry.Flink;
}
currentListEntry = transportState->waitingToSend->Flink;
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_027: [IoTHubTransportMqtt_DoWork shall inspect the “waitingToSend” DLIST passed in config structure.] */
while (currentListEntry != transportState->waitingToSend)
{
IOTHUB_MESSAGE_LIST* iothubMsgList = containingRecord(currentListEntry, IOTHUB_MESSAGE_LIST, entry);
DLIST_ENTRY savedFromCurrentListEntry;
savedFromCurrentListEntry.Flink = currentListEntry->Flink;
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_027: [IoTHubTransportMqtt_DoWork shall inspect the “waitingToSend” DLIST passed in config structure.] */
size_t messageLength;
const unsigned char* messagePayload = RetrieveMessagePayload(iothubMsgList->messageHandle, &messageLength);
if (messageLength == 0 || messagePayload == NULL)
{
LogError("Failure result from IoTHubMessage_GetData\r\n");
}
else
{
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_029: [IoTHubTransportMqtt_DoWork shall create a MQTT_MESSAGE_HANDLE and pass this to a call to mqtt_client_publish.] */
MQTT_MESSAGE_DETAILS_LIST* mqttMsgEntry = (MQTT_MESSAGE_DETAILS_LIST*)malloc(sizeof(MQTT_MESSAGE_DETAILS_LIST));
if (mqttMsgEntry == NULL)
{
LogError("Allocation Error: Failure allocating MQTT Message Detail List.\r\n");
}
else
{
mqttMsgEntry->retryCount = 0;
mqttMsgEntry->msgPacketId = transportState->packetId;
mqttMsgEntry->iotHubMessageEntry = iothubMsgList;
if (publishMqttMessage(transportState, mqttMsgEntry, messagePayload, messageLength) != 0)
{
(void)(DList_RemoveEntryList(currentListEntry));
sendMsgComplete(iothubMsgList, transportState, IOTHUB_BATCHSTATE_FAILED);
free(mqttMsgEntry);
}
else
{
(void)(DList_RemoveEntryList(currentListEntry));
DList_InsertTailList(&(transportState->waitingForAck), &(mqttMsgEntry->entry));
}
}
}
currentListEntry = savedFromCurrentListEntry.Flink;
}
}
/* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_030: [IoTHubTransportMqtt_DoWork shall call mqtt_client_dowork everytime it is called if it is connected.] */
mqtt_client_dowork(transportState->mqttClient);
}
}
}
void MQTTAPI_DoWork(MQTTAPI_HANDLE instance)
{
PMQTTTAPI_HANDLE_DATA handle = instance;
/* Codes_SRS_MQTTAPI_04_050: [if parameter instance is NULL then MQTTAPI_DoWork shall not perform any action.] */
if (handle != NULL)
{
if (!checkAndTryToConnect(handle))
{
LogError("Client Not Connected and could not connect.\r\n");
}
else
{
if (Lock(handle->LockHandle) == LOCK_OK)
{
//message
{
PDLIST_ENTRY received;
while ((received = DList_RemoveHeadList(&(handle->messagesReceived))) != &(handle->messagesReceived))
{
MQTTAPI_MESSAGE_RECEIVED_LIST* temp = containingRecord(received, MQTTAPI_MESSAGE_RECEIVED_LIST, entry);
if (handle->maCallBack != NULL)
{
if (!handle->maCallBack(handle->maCallbackContext, temp->messageReceived))
{
LogError("Client could not handle message, dropping it.");
}
}
free(temp->messageReceived->payload);
free(temp->messageReceived);
free(temp);
}
}
Unlock(handle->LockHandle);
}
else
{
LogError("Could not aquire lock for message.\r\n");
}
//Event
{
PDLIST_ENTRY messageToSend;
while ((messageToSend = DList_RemoveHeadList(&(handle->messagesToSend))) != &(handle->messagesToSend))
{
MQTTAPI_MESSAGE_SEND_LIST* temp = containingRecord(messageToSend, MQTTAPI_MESSAGE_SEND_LIST, entry);
if (MQTTClient_publishMessage(handle->client, STRING_c_str(temp->topicName), temp->messageToSend, &(temp->dt)) != MQTTCLIENT_SUCCESS)
{
handle->dcCallback(temp->context, MQTTAPI_CONFIRMATION_ERROR);
MQTTClient_freeMessage(&(temp->messageToSend));
free(temp->messageToSend);
STRING_delete(temp->topicName);
free(temp);
}
else
{
DList_InsertTailList(&(handle->messagesSent), &(temp->entry));
}
}
}
}
}
}