bool mqtt_async::MqttClient::Publish(const std::string& topic, const void* payload, INT32 len, int qos, int retained/*default=0*/, const ActDoneCB& cb) { MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; Token* tok = nullptr; std::shared_ptr<Token> stok; TRACE("mqtt_async::MqttClient::Publish"); if (cb) { TRACE("mqtt_async::MqttClient::Publish with callback"); tok = new Token(this); stok = std::shared_ptr<Token>(tok); stok->act_done_cb = cb; SaveToken(stok); } opts.onSuccess = cb?&Token::OnSuccess : nullptr ; opts.onFailure = cb?&Token::OnFailed : nullptr ; opts.context = tok; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; pubmsg.payload = const_cast<void*>(payload); pubmsg.payloadlen = len; pubmsg.qos = qos; pubmsg.retained = retained; int rc = MQTTAsync_sendMessage(client, (char*)topic.c_str(), &pubmsg, &opts) ; if (rc != MQTTASYNC_SUCCESS) { if (tok) RemoveToken(tok); TRACE("mqtt_async::MqttClient::Publish return false"); return false; } return true; }
/* * Function is used to publish events to the IoT MQTT reciver. * This reuses the "client" */ int publishMQTTMessage(MQTTAsync* client, char *topic, char *payload) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; int rc = MQTTASYNC_SUCCESS; opts.onSuccess = onSend; opts.context = *client; pubmsg.payload = payload; pubmsg.payloadlen = strlen(payload); pubmsg.qos = QOS; pubmsg.retained = 0; deliveredtoken = 0; if ((rc = MQTTAsync_sendMessage(*client, topic, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { #ifdef ERROR syslog(LOG_ERR, "Failed to start sendMessage, return code %d\n", rc); #endif return rc; } #ifdef INFO syslog(LOG_DEBUG, "Waiting for publication of %s on topic %s\n", payload, topic); #endif return rc; }
int test1_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message) { MQTTAsync c = (MQTTAsync)context; static int message_count = 0; int rc; MyLog(LOGA_DEBUG, "In messageArrived callback %p", c); if (++message_count == 1) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11"; pubmsg.payloadlen = 11; pubmsg.qos = 2; pubmsg.retained = 0; rc = MQTTAsync_sendMessage(c, test_topic, &pubmsg, &opts); } else { MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; opts.onSuccess = test1_onUnsubscribe; opts.context = c; rc = MQTTAsync_unsubscribe(c, test_topic, &opts); assert("Unsubscribe successful", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); } MQTTAsync_freeMessage(&message); MQTTAsync_free(topicName); return 1; }
int test3_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message) { client_data* cd = (client_data*)context; int rc; MyLog(LOGA_DEBUG, "In messageArrived callback \"%s\" message count ", cd->clientid); if (++cd->message_count == 1) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11"; pubmsg.payloadlen = 25; pubmsg.qos = 1; pubmsg.retained = 0; rc = MQTTAsync_sendMessage(cd->c, cd->test_topic, &pubmsg, &opts); assert("Good rc from publish", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); } else if (cd->message_count == 2) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = "a QoS 0 message that we can shorten to the extent that we need to payload up to 11"; pubmsg.payloadlen = 29; pubmsg.qos = 0; pubmsg.retained = 0; opts.context = cd; opts.onSuccess = test3_onPublish; rc = MQTTAsync_sendMessage(cd->c, cd->test_topic, &pubmsg, &opts); assert("Good rc from publish", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); } else { MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; opts.onSuccess = test3_onUnsubscribe; opts.context = cd; rc = MQTTAsync_unsubscribe(cd->c, cd->test_topic, &opts); assert("Unsubscribe successful", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); } MQTTAsync_freeMessage(&message); MQTTAsync_free(topicName); return 1; }
int janus_mqtt_client_publish_message(janus_mqtt_context *ctx, char *payload, gboolean admin) { MQTTAsync_message msg = MQTTAsync_message_initializer; msg.payload = payload; msg.payloadlen = strlen(payload); msg.qos = ctx->publish.qos; msg.retained = 0; MQTTAsync_responseOptions options; options.context = ctx; if(admin) { options.onSuccess = janus_mqtt_client_publish_admin_success; options.onFailure = janus_mqtt_client_publish_admin_failure; return MQTTAsync_sendMessage(ctx->client, ctx->admin.publish.topic, &msg, &options); } else { options.onSuccess = janus_mqtt_client_publish_janus_success; options.onFailure = janus_mqtt_client_publish_janus_failure; return MQTTAsync_sendMessage(ctx->client, ctx->publish.topic, &msg, &options); } }
int publish_main(void) { MQTTAsync client; MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_token token; int rc; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL); MQTTAsync_setCallbacks(client, NULL, connlost, NULL, NULL); conn_opts.keepAliveInterval = 700; conn_opts.cleansession = 1; conn_opts.onSuccess = onConnect; conn_opts.onFailure = onConnectFailure; conn_opts.context = client; if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start connect, return code %d\n", rc); exit(-1); } printf("Waiting for publication of %s\n" "on topic %s for client with ClientID: %s\n", PAYLOAD, TOPIC, CLIENTID); /*while (!finished) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif */ sleep(3); int i=0; while(i<5){ i++; pubmsg.payload = msg;//PAYLOAD; pubmsg.payloadlen = strlen(msg);//PAYLOAD); msg[0]=msg[0]+1; if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } } sleep(3600); MQTTAsync_destroy(&client); return rc; }
/** * @brief publish message * @param[in] payload A pointer to the payload of the MQTT message. * @return MQTTASYNC_SUCCESS if the message is accepted for publication. */ int MQTTAsyncPublishMessage(char* payload) { if(mClient == NULL || mPublishTopic == NULL || payload == NULL) { return MQTTASYNC_FAILURE; } MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = payload; pubmsg.payloadlen = strlen(payload); pubmsg.qos = 2; pubmsg.retained = 0; int rc = MQTTAsync_sendMessage(mClient, mPublishTopic, &pubmsg, &opts); return rc; }
void test3cOnConnect(void* context, MQTTAsync_successData* response) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MyLog(LOGA_DEBUG, "In connect onSuccess callback for client d, context %p\n", context); MQTTAsync c = (MQTTAsync)context; int rc; /* send a message to the proxy to break the connection */ pubmsg.payload = "TERMINATE"; pubmsg.payloadlen = strlen(pubmsg.payload); pubmsg.qos = 0; pubmsg.retained = 0; rc = MQTTAsync_sendMessage(c, "MQTTSAS topic", &pubmsg, NULL); assert("Good rc from sendMessage", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); }
/** * @name Publish a message * @brief Used to send message to a broker. * @param[in] message to be published * @param[in] context w.r.t topic the message required to be published * @return boolean, specifies whether the message is successfully published or not */ int send(char *message, Context context) { MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; int rc = 0; char *topic; if (context.name != NULL && context.value != NULL && strcmp(context.name, "topic") == 0) { topic = context.value; } else { printf("Topic not available in the send command\n"); return MQTTASYNC_NULL_PARAMETER; } unsigned long i; struct timeval tv; gettimeofday(&tv,NULL); #if DEBUG printf("start seconds : %ld\n",tv.tv_sec); #endif opts.onSuccess = onSend; opts.onFailure = onSendFailure; opts.context = client; pubmsg.payload = message; pubmsg.payloadlen = strlen(message); pubmsg.qos = QOS; pubmsg.retained = 0; usleep(100); if ((rc = MQTTAsync_sendMessage(client, topic, &pubmsg, &opts)) \ != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } gettimeofday(&tv,NULL); #if DEBUG printf("end seconds : %ld\n",tv.tv_sec); #endif return rc; }
void AWSIoTClient::publish(QString topic, QByteArray msg) { MQTTAsync_responseOptions options = MQTTAsync_responseOptions_initializer; options.onSuccess = onSent; options.onFailure = onSendFailure; options.context = this; MQTTAsync_message message = MQTTAsync_message_initializer; message.payload = msg.data(); message.payloadlen = msg.size(); message.qos = 0; message.retained = 0; int rc = MQTTAsync_sendMessage(client, topic.toUtf8(), &message, &options); if (rc != MQTTASYNC_SUCCESS) { qFatal("Failed to start sendMessage, return code %d\n", rc); } }
int publish(void* msg_p) { int rc=0; pubmsg.payload = msg_p;//PAYLOAD; pubmsg.payloadlen = MPU_MSG_LENGTH;//PAYLOAD; if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } // /sleep(3600); //MQTTAsync_destroy(&client); return rc; }
void onSend(void* context, MQTTAsync_successData* response) { MQTTAsync client = (MQTTAsync)context; MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; int rc; printf("Message with token value %d delivery confirmed\n", response->token); opts.onSuccess = onSendAgain;//onDisconnect; opts.context = client; if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } /*if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); }*/ }
void onConnect(void* context, MQTTAsync_successData* response) { MQTTAsync client = (MQTTAsync)context; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; int rc; printf("Successful connection\n"); opts.onSuccess = onSend; opts.context = client; pubmsg.payload = PAYLOAD; pubmsg.payloadlen = strlen(PAYLOAD); pubmsg.qos = QOS; pubmsg.retained = 0; deliveredtoken = 0; if ((rc = MQTTAsync_sendMessage(client, TOPIC, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } }
/** * The main entry point of the sample. * * This method handles parsing the arguments specified on the * command-line before performing the specified action. */ int main(int argc, char** argv) { int rc = 0; int ch; char url[256]; // Default settings: int i=0; MQTTAsync client; MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_token token; signal(SIGINT, handleSignal); signal(SIGTERM, handleSignal); quietMode = 0; // Parse the arguments - for (i=1; i<argc; i++) { // Check this is a valid argument if (strlen(argv[i]) == 2 && argv[i][0] == '-') { char arg = argv[i][1]; // Handle the no-value arguments if (arg == 'h' || arg == '?') { printHelp(); return 255; } else if (arg == 'q') { quietMode = 1; continue; } // Validate there is a value associated with the argument if (i == argc - 1 || argv[i+1][0] == '-') { printf("Missing value for argument: %s\n", argv[i]); printHelp(); return 255; } switch(arg) { case 'a': options.action = argv[++i]; break; case 't': options.topic = argv[++i]; break; case 'm': options.message = argv[++i]; break; case 's': options.qos = atoi(argv[++i]); break; case 'c': options.message_count = atoi(argv[++i]); break; case 'b': options.broker = argv[++i]; break; case 'p': options.port = argv[++i]; break; default: printf("Unrecognised argument: %s\n", argv[i]); printHelp(); return 255; } } else { printf("Unrecognised argument: %s\n", argv[i]); printHelp(); return 255; } } // Validate the provided arguments if (strcmp(options.action, "publish") != 0 && strcmp(options.action, "subscribe") != 0) { printf("Invalid action: %s\n", options.action); printHelp(); return 255; } if (options.qos < 0 || options.qos > 2) { printf("Invalid QoS: %d\n", options.qos); printHelp(); return 255; } if (options.topic == NULL || ( options.topic != NULL && strlen(options.topic) == 0) ) { // Set the default topic according to the specified action if (strcmp(options.action, "publish") == 0) options.topic = "MQTTV3ASample/C/v3"; else options.topic = "MQTTV3ASample/#"; } // Construct the full broker URL and clientId sprintf(url, "tcp://%s:%s", options.broker, options.port); sprintf(clientId, "SampleCV3A_%s", options.action); MQTTAsync_create(&client, url, clientId, MQTTCLIENT_PERSISTENCE_NONE, NULL); MQTTAsync_setTraceCallback(handleTrace); MQTTAsync_setTraceLevel(MQTTASYNC_TRACE_ERROR); MQTTAsync_setCallbacks(client, client, connectionLost, messageArrived, deliveryComplete); conn_opts.cleansession = 0; conn_opts.onSuccess = onConnect; conn_opts.onFailure = onConnectFailure; conn_opts.context = client; conn_opts.keepAliveInterval = 0; conn_opts.retryInterval = 0; //conn_opts.maxInflight= 30; if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start connect, return code %d\n", rc); goto exit; } printf("Waiting for connect\n"); while (connected == 0 && finished == 0 && toStop == 0) { printf("Waiting for connect: %d %d %d\n", connected, finished, toStop); usleep(10000L); } MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; printf("Waiting for connect: %d %d %d\n", connected, finished, toStop); printf("Successful connection\n"); if (connected == 1 && strcmp(options.action, "publish") == 0) { unsigned long i; struct timeval tv; gettimeofday(&tv,NULL); printf("start seconds : %ld\n",tv.tv_sec); for (i = 0; i < options.message_count; i++) { opts.onSuccess = onSend; opts.onFailure = onSendFailure; opts.context = client; pubmsg.payload = options.message; pubmsg.payloadlen = strlen(options.message); pubmsg.qos = options.qos; pubmsg.retained = 0; deliveredtoken = 0; usleep(100); if ((rc = MQTTAsync_sendMessage(client, options.topic, &pubmsg, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } } gettimeofday(&tv,NULL); printf("end seconds : %ld\n",tv.tv_sec); } else if (strcmp(options.action, "subscribe") == 0) { opts.onSuccess = onSubscribe; opts.onFailure = onSubscribeFailure; opts.context = client; if ((rc = MQTTAsync_subscribe(client, options.topic, options.qos, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to subscribe, return code %d\n", rc); exit(-1); } } while (!finished) { #if defined(WIN32) Sleep(100); #else usleep(1000L); #endif if (toStop == 1) { MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; opts.onSuccess = onDisconnect; opts.context = client; printf("Entering disconnection phase\n"); if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start disconnect, return code %d\n", rc); exit(-1); } toStop = 0; } } exit: printf("calling destroy\n"); MQTTAsync_destroy(&client); return rc; }
int test3(struct Options options) { char* testname = "test3"; int subsqos = 2; MQTTAsync c, d; MQTTAsync_connectOptions opts = MQTTAsync_connectOptions_initializer; MQTTAsync_willOptions wopts = MQTTAsync_willOptions_initializer; MQTTAsync_createOptions createOptions = MQTTAsync_createOptions_initializer; int rc = 0; int count = 0; char clientidc[50]; char clientidd[50]; int i = 0; MQTTAsync_token *tokens; sprintf(willTopic, "paho-test9-3-%s", unique); sprintf(clientidc, "paho-test9-3-c-%s", unique); sprintf(clientidd, "paho-test9-3-d-%s", unique); sprintf(test_topic, "paho-test9-3-test topic %s", unique); test3Finished = 0; failures = 0; MyLog(LOGA_INFO, "Starting Offline buffering 3 - messages while disconnected"); fprintf(xml, "<testcase classname=\"test3\" name=\"%s\"", testname); global_start_time = start_clock(); createOptions.sendWhileDisconnected = 1; rc = MQTTAsync_createWithOptions(&c, options.proxy_connection, clientidc, MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOptions); assert("good rc from create", rc == MQTTASYNC_SUCCESS, "rc was %d \n", rc); if (rc != MQTTASYNC_SUCCESS) { MQTTAsync_destroy(&c); goto exit; } rc = MQTTAsync_create(&d, options.connection, clientidd, MQTTCLIENT_PERSISTENCE_DEFAULT, NULL); assert("good rc from create", rc == MQTTASYNC_SUCCESS, "rc was %d \n", rc); if (rc != MQTTASYNC_SUCCESS) { MQTTAsync_destroy(&c); goto exit; } opts.keepAliveInterval = 20; opts.cleansession = 1; //opts.username = "******"; //opts.password = "******"; rc = MQTTAsync_setCallbacks(d, d, NULL, test3_messageArrived, NULL); assert("Good rc from setCallbacks", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); opts.will = NULL; /* don't need will for this client, as it's going to be connected all the time */ opts.context = d; opts.onSuccess = test3dOnConnect; opts.onFailure = test3dOnFailure; MyLog(LOGA_DEBUG, "Connecting client d"); rc = MQTTAsync_connect(d, &opts); assert("Good rc from connect", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); if (rc != MQTTASYNC_SUCCESS) { failures++; goto exit; } /* wait until d is ready: connected and subscribed */ count = 0; while (!test3dReady && ++count < 10000) MySleep(100); assert("Count should be less than 10000", count < 10000, "count was %d", count); /* wrong */ rc = MQTTAsync_setConnected(c, c, test3cConnected); assert("Good rc from setConnectedCallback", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); /* let client c go: connect, and send disconnect command to proxy */ opts.will = &wopts; opts.will->message = "will message"; opts.will->qos = 1; opts.will->retained = 0; opts.will->topicName = willTopic; opts.onSuccess = test3cOnConnect; opts.onFailure = test3cOnFailure; opts.context = c; opts.cleansession = 0; opts.automaticReconnect = 1; MyLog(LOGA_DEBUG, "Connecting client c"); rc = MQTTAsync_connect(c, &opts); assert("Good rc from connect", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); if (rc != MQTTASYNC_SUCCESS) { failures++; goto exit; } /* wait for will message */ while (!test3_will_message_received && ++count < 10000) MySleep(100); MyLog(LOGA_DEBUG, "Now we can send some messages to be buffered"); test3c_connected = 0; /* send some messages. Then reconnect (check connected callback), and check that those messages are received */ for (i = 0; i < 3; ++i) { char buf[50]; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; sprintf(buf, "QoS %d message", i); pubmsg.payload = buf; pubmsg.payloadlen = strlen(pubmsg.payload) + 1; pubmsg.qos = i; pubmsg.retained = 0; rc = MQTTAsync_sendMessage(c, test_topic, &pubmsg, &opts); assert("Good rc from sendMessage", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); } rc = MQTTAsync_getPendingTokens(c, &tokens); assert("Good rc from getPendingTokens", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); i = 0; if (tokens) { while (tokens[i] != -1) ++i; MQTTAsync_free(tokens); } assert("Number of getPendingTokens should be 3", i == 3, "i was %d ", i); /* wait for client to be reconnected */ while (!test3c_connected == 0 && ++count < 10000) MySleep(100); /* wait for success or failure callback */ while (test3_messages_received < 3 && ++count < 10000) MySleep(100); rc = MQTTAsync_getPendingTokens(c, &tokens); assert("Good rc from getPendingTokens", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); i = 0; if (tokens) { while (tokens[i] != -1) ++i; MQTTAsync_free(tokens); } assert("Number of getPendingTokens should be 0", i == 0, "i was %d ", i); rc = MQTTAsync_disconnect(c, NULL); assert("Good rc from disconnect", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); rc = MQTTAsync_disconnect(d, NULL); assert("Good rc from disconnect", rc == MQTTASYNC_SUCCESS, "rc was %d ", rc); exit: MQTTAsync_destroy(&c); MQTTAsync_destroy(&d); MyLog(LOGA_INFO, "%s: test %s. %d tests run, %d failures.", (failures == 0) ? "passed" : "failed", testname, tests, failures); write_test_result(); return failures; }
int test4_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message) { MQTTAsync c = (MQTTAsync)context; static int message_count = 0; int rc, i; MyLog(LOGA_DEBUG, "In messageArrived callback %p", c); assert("Message size correct", message->payloadlen == test4_payloadlen, "message size was %d", message->payloadlen); for (i = 0; i < options.size; ++i) { if (((char*)test4_payload)[i] != ((char*)message->payload)[i]) { assert("Message contents correct", ((char*)test4_payload)[i] != ((char*)message->payload)[i], "message content was %c", ((char*)message->payload)[i]); break; } } if (++message_count == 1) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = test4_payload; pubmsg.payloadlen = test4_payloadlen; pubmsg.qos = 1; pubmsg.retained = 0; opts.onSuccess = test4_onPublish; opts.context = c; rc = MQTTAsync_sendMessage(c, test_topic, &pubmsg, &opts); } else if (message_count == 2) { MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; pubmsg.payload = test4_payload; pubmsg.payloadlen = test4_payloadlen; pubmsg.qos = 0; pubmsg.retained = 0; opts.onSuccess = test4_onPublish; opts.context = c; rc = MQTTAsync_sendMessage(c, test_topic, &pubmsg, &opts); } else { MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer; opts.onSuccess = test1_onUnsubscribe; opts.context = c; rc = MQTTAsync_unsubscribe(c, test_topic, &opts); assert("Unsubscribe successful", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); } MQTTAsync_freeMessage(&message); MQTTAsync_free(topicName); return 1; }