//--------------------------------------------------------------------------------------------------
le_result_t mqtt_Publish
(
mqtt_SessionRef_t sessionRef, ///< [IN] Session
const char* topicPtr, ///< [IN] Topic
const uint8_t* payloadPtr, ///< [IN] Message
size_t payloadLen, ///< [IN] Message length
mqtt_Qos_t qos, ///< [IN] QoS mode
bool retain ///< [IN] Retain flag for message
)
{
mqtt_Session* s = le_ref_Lookup(SessionRefMap, sessionRef);
if (s == NULL)
{
LE_KILL_CLIENT("Session doesn't exist");
return LE_FAULT;
}
if (s->clientSession != mqtt_GetClientSessionRef())
{
LE_KILL_CLIENT("Session doesn't belong to this client");
return LE_FAULT;
}
MQTTClient_deliveryToken* dtNotUsed = NULL;
const int publishResult = MQTTClient_publish(
s->client, topicPtr, payloadLen, (void*)payloadPtr, QosEnumToValue(qos), retain, dtNotUsed);
le_result_t result = LE_OK;
if (publishResult != MQTTCLIENT_SUCCESS)
{
LE_WARN("Publish failed with error code (%d)", publishResult);
result = LE_FAULT;
}
return result;
}
/*********************************************************************
Test: single-threaded client
*********************************************************************/
void singleThread_sendAndReceive(MQTTClient* c, int qos, char* test_topic)
{
MQTTClient_deliveryToken dt;
MQTTClient_message pubmsg = MQTTClient_message_initializer;
MQTTClient_message* m = NULL;
char* topicName = NULL;
int topicLen;
int i = 0;
int iterations = 50;
int rc;
MyLog(LOGA_DEBUG, "%d messages at QoS %d", iterations, qos);
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 = qos;
pubmsg.retained = 0;
for (i = 0; i< iterations; ++i)
{
if (i % 10 == 0)
rc = MQTTClient_publish(c, test_topic, pubmsg.payloadlen, pubmsg.payload, pubmsg.qos, pubmsg.retained, NULL);
else
rc = MQTTClient_publishMessage(c, test_topic, &pubmsg, &dt);
assert("Good rc from publish", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
if (qos > 0)
{
rc = MQTTClient_waitForCompletion(c, dt, 20000L);
assert("Good rc from waitforCompletion", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
}
rc = MQTTClient_receive(c, &topicName, &topicLen, &m, 10000);
assert("Good rc from receive", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
if (topicName)
{
MyLog(LOGA_DEBUG, "Message received on topic %s is %.*s", topicName, m->payloadlen, (char*)(m->payload));
if (pubmsg.payloadlen != m->payloadlen ||
memcmp(m->payload, pubmsg.payload, m->payloadlen) != 0)
{
failures++;
MyLog(LOGA_INFO, "Error: wrong data - received lengths %d %d", pubmsg.payloadlen, m->payloadlen);
break;
}
MQTTClient_free(topicName);
MQTTClient_freeMessage(&m);
}
else
printf("No message received within timeout period\n");
}
/* receive any outstanding messages */
MQTTClient_receive(c, &topicName, &topicLen, &m, 1000);
while (topicName)
{
printf("Message received on topic %s is %.*s.\n", topicName, m->payloadlen, (char*)(m->payload));
MQTTClient_free(topicName);
MQTTClient_freeMessage(&m);
MQTTClient_receive(c, &topicName, &topicLen, &m, 1000);
}
}
int publisher(char *msg, int msg_len, char *msg_type)
{
int r;
char topic[MAX_TOPIC_LEN];
strcpy(topic, mqtt_topic_pub);
strcat(topic, msg_type);
printf("publishing to %s\n", topic);
printf("content: %.*s\n", msg_len, msg);
printf("length: %d\n", msg_len);
r = MQTTClient_publish(client, topic, msg_len -1, msg, 2, false, NULL);
printf("publish returned %d\n", r);
return r;
}
/*
* Update the temperature values and send the values to IBM Bluemix
* - blink the led to show the temperature was measured and data updated
*/
void temperature_update(upm::GroveTemp* temperature_sensor,
upm::GroveLed* led)
{
// other helper variables
int temperature; // temperature sensor value in degrees Celsius
std::stringstream row_1; // temperature
// update temperature values
temperature = temperature_sensor->value();
// convert the message into JSON format
row_1 << "{ \"temp\": \"" << temperature << "\" }";
// send message to IBM Bluemix
char payload[80];
sprintf(payload, "{ \"temp\": \"%d\" }", temperature);
int payloadlen = strlen(payload);
int retained = 0;
MQTTClient_deliveryToken dt;
int rc = MQTTClient_publish(client, const_cast<char *>(topic),
payloadlen, const_cast<char *>(payload), MQTT_DEFAULT_QOS, retained, &dt);
if (rc == MQTTCLIENT_SUCCESS) {
printf("Waiting for message with token %d to be published...\n", dt);
rc = MQTTClient_waitForCompletion(client, dt, 1000);
if (rc == MQTTCLIENT_SUCCESS) {
printf("Message with token %d published\n", dt);
} else {
std::cerr << "Failed to publish message with token " << dt << std::endl;
}
} else {
std::cerr << "Failed to publish message with token " << dt << std::endl;
}
// blink the led for 50 ms to show the temperature was actually sampled
led->on();
usleep(50000);
led->off();
}
// -------------------------------------------------------------------
// !!!!!!!!!!! FONCTION DEBUG A RETRAVAILLER...
// -------------------------------------------------------------------
int algo_putMessage(char *topic, char *data, unsigned short lenght){
short j;
int rc;
unsigned short crc16=0;
// Generation du CRC du message
for(j=0;j < lenght;j++){
crc16=update_crc_16(crc16, data[j]);
}
// Ajout du CRC dans la trame
data[lenght++]=(crc16&0xFF00)>>8;
data[lenght++]=(crc16&0x00FF);
// Publication du message
//printf("\n PUBLICATION: ");
//for(i=0;i<lenght; i++) printf(" %x", data[i]);
MQTTClient_publish(client, topic, lenght, data, QOS, 0, &token);
rc = MQTTClient_waitForCompletion(client, token, TIMEOUT);
return (rc);
}
int MQTTClient_publishMessage(MQTTClient handle, const char* topicName, MQTTClient_message* message,
MQTTClient_deliveryToken* deliveryToken)
{
int rc = MQTTCLIENT_SUCCESS;
FUNC_ENTRY;
if (message == NULL)
{
rc = MQTTCLIENT_NULL_PARAMETER;
goto exit;
}
if (strncmp(message->struct_id, "MQTM", 4) != 0 || message->struct_version != 0)
{
rc = MQTTCLIENT_BAD_STRUCTURE;
goto exit;
}
rc = MQTTClient_publish(handle, topicName, message->payloadlen, message->payload,
message->qos, message->retained, deliveryToken);
exit:
FUNC_EXIT_RC(rc);
return rc;
}
static PyObject* mqttv3_publish(PyObject* self, PyObject *args)
{
MQTTClient c;
char* topicName;
int payloadlen;
void* payload;
int qos = 0;
int retained = 0;
MQTTClient_deliveryToken dt;
int rc;
if (!PyArg_ParseTuple(args, "kss#|ii", &c, &topicName, &payload,
&payloadlen, &qos, &retained))
return NULL;
Py_BEGIN_ALLOW_THREADS rc = MQTTClient_publish(c, topicName, payloadlen,
payload, qos, retained, &dt);
Py_END_ALLOW_THREADS
if (rc == MQTTCLIENT_SUCCESS && qos > 0)
return Py_BuildValue("ii", rc, dt);
else
return Py_BuildValue("i", rc);
}
void multiThread_sendAndReceive(MQTTClient* c, int qos, char* test_topic)
{
MQTTClient_deliveryToken dt;
int i = 0;
int iterations = 50;
int rc = 0;
int wait_seconds = 0;
multiThread_deliveryCompleted = 0;
multiThread_arrivedcount = 0;
MyLog(LOGA_DEBUG, "%d messages at QoS %d", iterations, qos);
multiThread_pubmsg.payload = "a much longer message that we can shorten to the extent that we need to";
multiThread_pubmsg.payloadlen = 27;
multiThread_pubmsg.qos = qos;
multiThread_pubmsg.retained = 0;
for (i = 1; i <= iterations; ++i)
{
if (i % 10 == 0)
rc = MQTTClient_publish(c, test_topic, multiThread_pubmsg.payloadlen, multiThread_pubmsg.payload,
multiThread_pubmsg.qos, multiThread_pubmsg.retained, NULL);
else
rc = MQTTClient_publishMessage(c, test_topic, &multiThread_pubmsg, &dt);
assert("Good rc from publish", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
#if defined(WIN32)
Sleep(100);
#else
usleep(100000L);
#endif
wait_seconds = 20;
while ((multiThread_arrivedcount < i) && (wait_seconds-- > 0))
{
MyLog(LOGA_DEBUG, "Arrived %d count %d", multiThread_arrivedcount, i);
#if defined(WIN32)
Sleep(1000);
#else
usleep(1000000L);
#endif
}
assert("Message Arrived", wait_seconds > 0,
"Time out waiting for message %d\n", i );
}
if (qos > 0)
{
/* MQ Telemetry can send a message to a subscriber before the server has
completed the QoS 2 handshake with the publisher. For QoS 1 and 2,
allow time for the final delivery complete callback before checking
that all expected callbacks have been made */
wait_seconds = 10;
while ((multiThread_deliveryCompleted < iterations) && (wait_seconds-- > 0))
{
MyLog(LOGA_DEBUG, "Delivery Completed %d count %d", multiThread_deliveryCompleted, i);
#if defined(WIN32)
Sleep(1000);
#else
usleep(1000000L);
#endif
}
assert("All Deliveries Complete", wait_seconds > 0,
"Number of deliveryCompleted callbacks was %d\n",
multiThread_deliveryCompleted);
}
}
int main(int argc, char** argv)
{
//MQTTClient client;
// MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
char topic[200] = "";
char* buffer = NULL;
int rc = 0;
char url[100];
char broker[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);
// char a[200] = "55e6ba684a481fa955f3912e";
// char b[200] = "hello";
strcpy(topic, argv[1]);
//opts.appkey = a;
//topic = b;
printf("Using topic %s\n", topic);
int res = MQTTClient_setup_with_appkey_and_deviceid(opts.appkey, opts.deviceid, &my_reg_info);
if (res < 0) {
printf("can't get reg info\n");
return 0;
}
printf("Get reg info: client_id:%s,username:%s,password:%s, devide_id:%s\n", my_reg_info.client_id, my_reg_info.username, my_reg_info.password, my_reg_info.device_id);
res = MQTTClient_get_host(opts.appkey, url);
if (res < 0) {
printf("can't get host info\n");
return 0;
}
printf("Get url info: %s\n", url);
rc = MQTTClient_create(&client, url, my_reg_info.client_id, MQTTCLIENT_PERSISTENCE_NONE, NULL);
MQTTClient_get_broker(&client, broker);
printf("get broker:%s\n", broker);
// MQTTClient_set_broker(&client, "localhost");
if (opts.authkey != NULL) {
printf("set authkey\r\n");
int status;
rc = MQTTClient_set_authkey(my_reg_info.client_id, opts.appkey, opts.authkey, &status);
if (rc >= 0)
printf("set authkey result: status:%i\r\n", status);
char auth[80];
rc = MQTTClient_get_authkey(my_reg_info.client_id, opts.appkey, auth, &status);
if (rc >= 0)
printf("get authkey result: status:%i, authkey:%s\r\n", status, auth);
}
MQTTClient_get_broker(&client, broker);
printf("get broker:%s\n", broker);
signal(SIGINT, cfinish);
signal(SIGTERM, cfinish);
rc = MQTTClient_setCallbacks(client, NULL, connectionLost, messageArrived, NULL, extendedCmdArrive);
conn_opts.keepAliveInterval = 300;
conn_opts.reliable = 0;
conn_opts.cleansession = 0;
conn_opts.username = my_reg_info.username;
conn_opts.password = my_reg_info.password;
myconnect(&client, &conn_opts);
buffer = malloc(opts.maxdatalen);
rc = MQTTClient_subscribe(client, topic, 1);
printf("subscribe topic:%s, %i\n", topic, rc);
if (opts.alias != NULL) {
printf("set alias: %s\n", opts.alias);
MQTTClient_set_alias(client, opts.alias);
}
//MQTTClient_presence(client, topic);
int ret;
ret = MQTTClient_get_aliaslist(client, topic);
printf("get aliaslist:%i, topic:%s\n", ret, topic);
ret = MQTTClient_get_topic(client, "band1111");
printf("get topic:%i\n", ret);
ret = MQTTClient_get_status(client, "band1111");
printf("get status:%i\n", ret);
ret = MQTTClient_report(client, "domytest", "abc");
printf("report status:%i\n", ret);
ret = MQTTClient_get_status2(client, "baidu");
printf("get status2:%i\n", ret);
ret = MQTTClient_get_topiclist2(client, topic);
printf("get topic list2:%i\n", ret);
ret = MQTTClient_get_aliaslist2(client, topic);
printf("get aliaslist2:%i\n", ret);
sleep(7);
cJSON *apn_json, *aps;
cJSON *Opt = cJSON_CreateObject();
cJSON_AddStringToObject(Opt,"time_to_live", "120");
cJSON_AddStringToObject(Opt,"time_delay", "1100");
cJSON_AddStringToObject(Opt,"apn_json", "{\"aps\":{\"alert\":\"FENCE alarm\", \"sound\":\"alarm.mp3\"}}");
ret = MQTTClient_publish2(client, topic, strlen("test") + 1, "test", Opt);
cJSON_Delete(Opt);
printf("publish2 status:%i\n", ret);
while (!toStop)
{
int data_len = 0;
int delim_len = 0;
delim_len = 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);
rc = MQTTClient_publish(client, topic, data_len, buffer);
if (rc != 0)
{
myconnect(&client, &conn_opts);
rc = MQTTClient_publish(client, topic, data_len, buffer);
printf("reconnect %i\n", rc);
}
if (opts.qos > 0)
MQTTClient_yield();
}
printf("Stopping\n");
free(buffer);
MQTTClient_disconnect(client, 0);
MQTTClient_destroy(&client);
return 0;
}
int main(int argc, char** argv)
{
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_SSLOptions ssl_opts = MQTTClient_SSLOptions_initializer;
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);
rc = MQTTClient_create(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL);
signal(SIGINT, cfinish);
signal(SIGTERM, cfinish);
rc = MQTTClient_setCallbacks(client, NULL, NULL, messageArrived, NULL);
conn_opts.keepAliveInterval = 10;
conn_opts.reliable = 0;
conn_opts.cleansession = 1;
conn_opts.username = opts.username;
conn_opts.password = opts.password;
ssl_opts.enableServerCertAuth = 0;
conn_opts.ssl = &ssl_opts;
myconnect(&client, &conn_opts);
buffer = malloc(opts.maxdatalen);
while (!toStop)
{
int data_len = 0;
int delim_len = 0;
delim_len = 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);
rc = MQTTClient_publish(client, topic, data_len, buffer, opts.qos, opts.retained, NULL);
if (rc != 0)
{
myconnect(&client, &conn_opts);
rc = MQTTClient_publish(client, topic, data_len, buffer, opts.qos, opts.retained, NULL);
}
if (opts.qos > 0)
MQTTClient_yield();
}
printf("Stopping\n");
free(buffer);
MQTTClient_disconnect(client, 0);
MQTTClient_destroy(&client);
return 0;
}
