bool mqtt_async::MqttClient::Disconnect(int tmout, const ActDoneCB& cb) { MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; Token* tok = nullptr; std::shared_ptr<Token> stok; if (cb) { 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.timeout = tmout; opts.context = tok; int rc; if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { if (tok) RemoveToken(tok); throw rc; } return true; }
int janus_mqtt_client_disconnect(janus_mqtt_context *ctx) { MQTTAsync_disconnectOptions options = MQTTAsync_disconnectOptions_initializer; options.onSuccess = janus_mqtt_client_disconnect_success; options.onFailure = janus_mqtt_client_disconnect_failure; options.context = ctx; options.timeout = ctx->disconnect.timeout; return MQTTAsync_disconnect(ctx->client, &options); }
int main(int argc, char* argv[]) { MQTTAsync client; MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer; MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer; MQTTAsync_message pubmsg = MQTTAsync_message_initializer; MQTTAsync_token token; int rc; int ch; MQTTAsync_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL); MQTTAsync_setCallbacks(client, NULL, connlost, msgarrvd, NULL); conn_opts.keepAliveInterval = 20; 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(EXIT_FAILURE); } while (!subscribed) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif if (finished) goto exit; do { ch = getchar(); } while (ch!='Q' && ch != 'q'); disc_opts.onSuccess = onDisconnect; if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start disconnect, return code %d\n", rc); exit(EXIT_FAILURE); } while (!disc_finished) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif exit: MQTTAsync_destroy(&client); return rc; }
void test3_onUnsubscribe(void* context, MQTTAsync_successData* response) { client_data* cd = (client_data*)context; MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; int rc; MyLog(LOGA_DEBUG, "In onUnsubscribe onSuccess callback \"%s\"", cd->clientid); opts.onSuccess = test3_onDisconnect; opts.context = cd; rc = MQTTAsync_disconnect(cd->c, &opts); assert("Disconnect successful", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); }
void test1_onUnsubscribe(void* context, MQTTAsync_successData* response) { MQTTAsync c = (MQTTAsync)context; MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; int rc; MyLog(LOGA_DEBUG, "In onUnsubscribe onSuccess callback %p", c); opts.onSuccess = test1_onDisconnect; opts.context = c; rc = MQTTAsync_disconnect(c, &opts); assert("Disconnect successful", rc == MQTTASYNC_SUCCESS, "rc was %d", rc); }
/** * @brief disconnect mqtt */ int MQTTAsyncDisconnect() { #ifdef SPT_DEBUG_ENABLE SPTekDebugLog(LOG_LEVEL_INFO, "MQTTAsyncDisconnect()"); #else SKTDebugPrint(LOG_LEVEL_INFO, "MQTTAsyncDisconnect()"); #endif MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer; disc_opts.onSuccess = OnDisconnect; int rc; if(mClient != NULL) { rc = MQTTAsync_disconnect(mClient, &disc_opts); } return rc; }
/* * After sending the message disconnect from IoT/mqtt server */ int disconnect_mqtt_client(MQTTAsync* client) { MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; int rc = MQTTASYNC_SUCCESS; opts.context = client; if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { #ifdef ERROR syslog(LOG_ERR, "Failed to start sendMessage, return code %d\n", rc); #endif } MQTTAsync_destroy(client); return rc; }
void onSendAgain(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 = onDisconnect; opts.context = client; if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start sendMessage, return code %d\n", rc); exit(-1); } }
int MQTTConnector::stop() { IBMRAS_DEBUG(debug, "stop"); if (mqttClient != NULL) { if (MQTTAsync_isConnected(mqttClient)) { // Send will message before our clean termination char* message = new char[willMessage.length() + 1]; strcpy(message, willMessage.c_str()); MQTTAsync_send(mqttClient, willTopic.c_str(), strlen(message), message, 1, 0, NULL); delete[] message; return MQTTAsync_disconnect(mqttClient, NULL); } } return -1; }
/** * @name Cleanup the MQTT client * @brief Used to close the connections and for cleanup activities. * @return boolean, which specifies whether the connection is disconnected or not */ int done() { MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer; int rc = 0; opts.onSuccess = onDisconnect; opts.context = client; if ((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start disconnect, return code %d\n", rc); exit(-1); } finished = 1; toStop = 0; MQTTAsync_destroy(&client); return rc; }
/** * 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 main(int argc, char** argv) { MQTTAsync client; MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer; int rc = 0; char url[100]; if (argc < 2) usage(); topic = argv[1]; if (strchr(topic, '#') || strchr(topic, '+')) opts.showtopics = 1; if (opts.showtopics) printf("topic is %s\n", topic); getopts(argc, argv); sprintf(url, "%s:%s", opts.host, opts.port); rc = MQTTAsync_create(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL); MQTTAsync_setCallbacks(client, client, connectionLost, messageArrived, NULL); signal(SIGINT, cfinish); signal(SIGTERM, cfinish); conn_opts.keepAliveInterval = opts.keepalive; conn_opts.cleansession = 1; conn_opts.username = opts.username; conn_opts.password = opts.password; 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(EXIT_FAILURE); } while (!subscribed) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif if (finished) goto exit; while (!finished) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif disc_opts.onSuccess = onDisconnect; if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start disconnect, return code %d\n", rc); exit(EXIT_FAILURE); } while (!disconnected) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif exit: MQTTAsync_destroy(&client); return EXIT_SUCCESS; }
int main(int argc, char** argv) { MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer; MQTTAsync_responseOptions pub_opts = MQTTAsync_responseOptions_initializer; MQTTAsync_createOptions create_opts = MQTTAsync_createOptions_initializer; MQTTAsync client; char* topic = NULL; char* buffer = NULL; int rc = 0; char url[100]; if (argc < 2) usage(); getopts(argc, argv); sprintf(url, "%s:%s", opts.host, opts.port); if (opts.verbose) printf("URL is %s\n", url); topic = argv[1]; printf("Using topic %s\n", topic); create_opts.sendWhileDisconnected = 1; rc = MQTTAsync_createWithOptions(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL, &create_opts); signal(SIGINT, cfinish); signal(SIGTERM, cfinish); rc = MQTTAsync_setCallbacks(client, client, connectionLost, messageArrived, NULL); myconnect(&client); buffer = malloc(opts.maxdatalen); while (!toStop) { int data_len = 0; int delim_len = 0; delim_len = (int)strlen(opts.delimiter); do { buffer[data_len++] = getchar(); if (data_len > delim_len) { /* printf("comparing %s %s\n", opts.delimiter, &buffer[data_len - delim_len]); */ if (strncmp(opts.delimiter, &buffer[data_len - delim_len], delim_len) == 0) break; } } while (data_len < opts.maxdatalen); if (opts.verbose) printf("Publishing data of length %d\n", data_len); pub_opts.onSuccess = onPublish; pub_opts.onFailure = onPublishFailure; do { rc = MQTTAsync_send(client, topic, data_len, buffer, opts.qos, opts.retained, &pub_opts); } while (rc != MQTTASYNC_SUCCESS); } printf("Stopping\n"); free(buffer); disc_opts.onSuccess = onDisconnect; if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS) { printf("Failed to start disconnect, return code %d\n", rc); exit(EXIT_FAILURE); } while (!disconnected) #if defined(WIN32) Sleep(100); #else usleep(10000L); #endif MQTTAsync_destroy(&client); return EXIT_SUCCESS; }
MQTTConnector::~MQTTConnector() { if (mqttClient != NULL) { MQTTAsync_disconnect(mqttClient, NULL); MQTTAsync_destroy(&mqttClient); } }