void PICNTRL::listenForMessages(char* topic) {
this->_topic = (char*) malloc(strlen(topic) + 1);
if (NULL == this->_topic) {
printf("Error, failed to allocation string for topic\n");
return;
}
strcpy(this->_topic, topic);
MQTTClient_create(&_myClient, _mqttBroker, "PICntrl", MQTTCLIENT_PERSISTENCE_NONE, (void*) this);
MQTTClient_setCallbacks(_myClient, (void*) this, &(PICNTRL::connectionLost), &(PICNTRL::messageArrived), NULL);
_mqttOptions.keepAliveInterval = 10;
_mqttOptions.cleansession = 1;
_mqttOptions.reliable = 0;
int connectResult = MQTTClient_connect(_myClient, &_mqttOptions);
if(MQTTCLIENT_SUCCESS != connectResult) {
printf("Failed to connect to MQTT broker, exiting\n");
return;
}
MQTTClient_subscribe(_myClient, this->_topic, QOS_AT_MOST_ONCE_0);
while(1) {
usleep(1000 * 1000);
MQTTClient_yield();
}
}
bool CConMQTT::bConnect(char* szAddr)
{
// 局所変数宣言
HANDLE hThread; // スレッドハンドル
DWORD dwRet; // 関数呼出しの戻り値
// クライアントの作成
MQTTClient_create(&m_Client, szAddr, CLIENT_ID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
// 非同期通信におけるコールバックの設定
MQTTClient_setCallbacks(m_Client, NULL, vConnLost, iMsgArrived, vDelivered);
hThread = CreateThread(NULL, 0, vTryConnect, &m_Client, 0, NULL);
/* *** MQTTClient_connectOptionsのconnectTimeoutの使い方が *** */
/* *** 分からなかったのでスレッドの終了まちで対応 *** */
/* *** 3000 [ms] でタイムアウト *** */
dwRet = WaitForSingleObject(hThread, 3000);
if (WAIT_TIMEOUT == dwRet) {
TerminateThread(hThread, -1);
return false;
}
m_bConected = true;
return true;
}
int main(int argc, char* argv[])
{
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_message pubmsg = MQTTClient_message_initializer;
MQTTClient_deliveryToken token;
int rc;
MQTTClient_create(&client, ADDRESS, CLIENTID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
exit(-1);
}
pubmsg.payload = PAYLOAD;
pubmsg.payloadlen = strlen(PAYLOAD);
pubmsg.qos = QOS;
pubmsg.retained = 0;
deliveredtoken = 0;
MQTTClient_publishMessage(client, TOPIC, &pubmsg, &token);
printf("Waiting for publication of %s\n"
"on topic %s for client with ClientID: %s\n",
PAYLOAD, TOPIC, CLIENTID);
while(deliveredtoken != token);
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
int main(int argc, char* argv[])
{
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
int rc;
int ch;
MQTTClient_create(&client, ADDRESS, CLIENTID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
exit(EXIT_FAILURE);
}
printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
"Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
MQTTClient_subscribe(client, TOPIC, QOS);
do
{
ch = getchar();
} while(ch!='Q' && ch != 'q');
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
int main()
{
// check that we are running on Galileo or Edison
mraa::Platform platform = mraa::getPlatformType();
if ((platform != mraa::INTEL_GALILEO_GEN1) &&
(platform != mraa::INTEL_GALILEO_GEN2) &&
(platform != mraa::INTEL_EDISON_FAB_C)) {
std::cerr << "Unsupported platform, exiting" << std::endl;
return mraa::ERROR_INVALID_PLATFORM;
}
// create the MQTT client
int rc = 0;
rc = MQTTClient_create(&client, const_cast<char *>(host),
const_cast<char *>(clientID), MQTTCLIENT_PERSISTENCE_NONE, NULL);
if (rc != MQTTCLIENT_SUCCESS) {
std::cerr << "Failed to create MQTT client, exiting" << std::endl;
exit(rc);
}
// setup call backs before connecting the client to the server
MQTTClient_setCallbacks(client, NULL,
&connection_lost, NULL, &delivery_complete);
MQTTClient_connectOptions data = MQTTClient_connectOptions_initializer;
data.username = const_cast<char *>(username);
data.password = const_cast<char *>(password);
// connect the client to the server
rc = MQTTClient_connect(client, &data);
if (rc != MQTTCLIENT_SUCCESS) {
std::cerr << "Failed to connect MQTT client, exiting" << std::endl;
exit(rc);
}
// led connected to D3 (digital out)
upm::GroveLed* led = new upm::GroveLed(3);
// temperature sensor connected to A0 (analog in)
upm::GroveTemp* temp_sensor = new upm::GroveTemp(0);
// simple error checking
if ((led == NULL) || (temp_sensor == NULL)) {
std::cerr << "Can't create all objects, exiting" << std::endl;
return mraa::ERROR_UNSPECIFIED;
}
// loop forever updating the temperature values every second
for (;;) {
temperature_update(temp_sensor, led);
sleep(1);
}
printf("Stopping\n");
int timeout = 100;
MQTTClient_disconnect(client, timeout);
MQTTClient_destroy(&client);
return mraa::SUCCESS;
}
/**
* @name Create and initialize the MQTT client
* @brief initializes the plugin.
* @param[in] servQuery is the service query being queried for
* @return boolean, which specifies whether the connection is successfully established or not
*
* Establishes the connection with an MQTT broker.
*/
int init(void *servQuery) {
ServiceQuery *serviceQuery = (ServiceQuery *) servQuery;
int rc = 0;
char uri[256];
if (isPresentPropertyInCommParams(serviceQuery, "ssl") == true && \
strcasecmp(getValueInCommParams(serviceQuery, "ssl"), "true") == 0) {
sprintf(uri, "ssl://%s:%d", serviceQuery->address, serviceQuery->port);
conn_opts.ssl = &sslopts;
if (isPresentPropertyInCommParams(serviceQuery, "keyStore")) {
conn_opts.ssl->keyStore = getValueInCommParams(serviceQuery, "keyStore");
}
if (isPresentPropertyInCommParams(serviceQuery, "privateKey")) {
conn_opts.ssl->privateKey = getValueInCommParams(serviceQuery, "privateKey");
}
if (isPresentPropertyInCommParams(serviceQuery, "trustStore")) {
conn_opts.ssl->trustStore = getValueInCommParams(serviceQuery, "trustStore");
}
conn_opts.ssl->enableServerCertAuth = 0;
} else {
if (serviceQuery->address != NULL) {
sprintf(uri, "tcp://%s:%d", serviceQuery->address, serviceQuery->port);
} else {
sprintf(uri, "tcp://localhost:%d", serviceQuery->port);
}
}
// Default settings:
char clientID[256];
sprintf(clientID, "%s_%d", CLIENTID, getpid());
MQTTClient_create(&client, uri, clientID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
MQTTClient_setCallbacks(client, serviceQuery, connectionLost, messageArrived, NULL);
conn_opts.cleansession = 0;
conn_opts.keepAliveInterval = 20;
conn_opts.retryInterval = 0;
if (isPresentPropertyInCommParams(serviceQuery, "username") == true && \
isPresentPropertyInCommParams(serviceQuery, "password") == true) {
conn_opts.username = getValueInCommParams(serviceQuery, "username");
conn_opts.password = getValueInCommParams(serviceQuery, "password");
}
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS) {
printf("Failed to start connect, return code %d\n", rc);
exit(1);
}
return rc;
}
MQTTClient *mqtt_create(char *clientid, MQTTClient_messageArrived *arrived) {
int rc = 0;
MQTTClient *context = (MQTTClient*)malloc(sizeof(MQTTClient));
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_create(context, MQTT_ADDRESS, clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 0;
conn_opts.cleansession = 1;
if(arrived) MQTTClient_setCallbacks(*context, NULL, NULL, arrived, NULL);
MQTTClient_connect(*context, &conn_opts);
return context;
}
int mainSubASync(int argc, char* argv[])
{
initializeObjects();
readFile();
printf("\n Broker URL is := %s \n",brokerUrl);
initiliazeMQTT(argc,argv);
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
int rc;
int ch;
MQTTClient_create(&client, ADDRESS, CLIENTID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
exit(-1);
}
printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
"Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
MQTTClient_subscribe(client, TOPIC, QOS);
// do
// {
// ch = getchar();
// } while(ch!='Q' && ch != 'q');
while(1){
ch = getchar();
if(ch=='Q'){
printf("\n Quit! \n");
} else {
if(ch != '\n'){
ch=='0';
printf("\n Sending Message to publish \n");
publishMessage(userid);
}
}
}
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
//--------------------------------------------------------------------------------------------------
le_result_t mqtt_CreateSession
(
const char* brokerURIPtr, ///< [IN] The URI of the MQTT broker to connect to. Should be in
/// the form protocol://host:port. eg. tcp://1.2.3.4:1883 or
/// ssl://example.com:8883
const char* clientIdPtr, ///< [IN] Any unique string. If a client connects to an MQTT
/// broker using the same clientId as an existing session, then
/// the existing session will be terminated.
mqtt_SessionRef_t* sessionRefPtr ///< [OUT] The created session if the return result is LE_OK
)
{
mqtt_Session* s = le_mem_ForceAlloc(MQTTSessionPoolRef);
LE_ASSERT(s);
memset(s, 0, sizeof(*s));
const MQTTClient_connectOptions initConnOpts = MQTTClient_connectOptions_initializer;
memcpy(&(s->connectOptions), &initConnOpts, sizeof(initConnOpts));
const MQTTClient_SSLOptions initSslOpts = MQTTClient_SSLOptions_initializer;
memcpy(&(s->sslOptions), &initSslOpts, sizeof(initSslOpts));
s->sslOptions.trustStore = SslCaCertsPathPtr;
const int createResult = MQTTClient_create(
&(s->client),
brokerURIPtr,
clientIdPtr,
MQTTCLIENT_PERSISTENCE_NONE,
NULL);
if (createResult != MQTTCLIENT_SUCCESS)
{
LE_ERROR("Couldn't create MQTT session. Paho error code: %d", createResult);
le_mem_Release(s);
return LE_FAULT;
}
le_msg_SessionRef_t clientSession = mqtt_GetClientSessionRef();
s->clientSession = clientSession;
*sessionRefPtr = le_ref_CreateRef(SessionRefMap, s);
LE_ASSERT(MQTTClient_setCallbacks(
s->client,
*sessionRefPtr,
&ConnectionLostHandler,
&MessageArrivedHandler,
NULL) == MQTTCLIENT_SUCCESS);
return LE_OK;
}
static PyObject* mqttv3_setcallbacks(PyObject* self, PyObject *args)
{
MQTTClient c;
CallbackEntry* e = NULL;
int rc;
e = malloc(sizeof(CallbackEntry));
if (!PyArg_ParseTuple(args, "kOOOO", &c, (PyObject**) &e->context, &e->cl,
&e->ma, &e->dc))
return NULL;
e->c = c;
printf("setCallbacks MQTTClient pointer %p\n", c);
if ((e->cl != Py_None && !PyCallable_Check(e->cl))
|| (e->ma != Py_None && !PyCallable_Check(e->ma))
|| (e->dc != Py_None && !PyCallable_Check(e->dc)))
{
PyErr_SetString(PyExc_TypeError,
"3rd, 4th and 5th parameters must be callable or None");
return NULL;
}
Py_BEGIN_ALLOW_THREADS rc = MQTTClient_setCallbacks(c, e, connectionLost,
messageArrived, deliveryComplete);
Py_END_ALLOW_THREADS
if (rc == MQTTCLIENT_SUCCESS)
{
ListElement* temp = NULL;
if ((temp = ListFindItem(callbacks, c, clientCompare)) != NULL)
{
ListDetach(callbacks, temp->content);
free(temp->content);
}
ListAppend(callbacks, e, sizeof(e));
Py_XINCREF(e->cl);
Py_XINCREF(e->ma);
Py_XINCREF(e->dc);
Py_XINCREF(e->context);
}
return Py_BuildValue("i", rc);
}
int main(int argc, char* argv[])
//int mainSubasync(int argc, char* argv[])
{
initializeObjects();
readFile();
initiliazeMQTT(argc,argv);
MQTTClient client;
MQTTClient_connectOptions conn_opts_sub = MQTTClient_connectOptions_initializer;
int rc;
int ch;
//ADDRESS = brokerUrl;
MQTTClient_create(&client, brokerUrl, CLIENTID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts_sub.keepAliveInterval = 20;
conn_opts_sub.cleansession = 1;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts_sub)) != MQTTCLIENT_SUCCESS)
{
if(SUBASYNCLOGGER){
printf("Failed to connect, return code %d\n", rc);
}
exit(-1);
}
// if(SUBASYNCLOGGER){
// printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
// "Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
// }
MQTTClient_subscribe(client, TOPIC, QOS);
// if(SUBASYNCLOGGER){
// printf("In Main pthread_create getpid: %d getpthread_self: %lu \n",getpid(), pthread_self());
// }
argv[1] = serialPort;
argv[2] = "mon";
mainGW(argc,argv);
//mainGWMyHub(argc,argv);
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
int main(int argc, char* argv[])
{
if(argc < 4) {
std::cout << "usage: " << argv[0] << " server_url user password" << std::endl;
return -1;
}
std::cout << argv[0] << " " << argv[1] << " " << argv[2] << " " << argv[3] << std::endl;
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_message pubmsg = MQTTClient_message_initializer;
MQTTClient_deliveryToken token;
int rc;
MQTTClient_create(&client, argv[1], CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
conn_opts.username = argv[2];
conn_opts.password = argv[3];
conn_opts.connectTimeout = 200;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
exit(-1);
}
pubmsg.payload = const_cast<char*>(PAYLOAD);
pubmsg.payloadlen = strlen(PAYLOAD);
pubmsg.qos = QOS;
pubmsg.retained = 0;
deliveredtoken = 0;
MQTTClient_publishMessage(client, TOPIC, &pubmsg, &token);
printf("Waiting for publication of %s\n"
"on topic %s for client with ClientID: %s\n",
PAYLOAD, TOPIC, CLIENTID);
while(deliveredtoken != token);
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
// -------------------------------------------------------------------
// INITIALISATION DE LA CONNEXION AU BROCKER MQTT
// -------------------------------------------------------------------
int mqtt_init(const char *IPaddress, const char *clientID, MQTTClient_messageArrived* msgarr){
int rc;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
//MQTTClient_message pubmsg = MQTTClient_message_initializer;
// Configuration des param�tres de connexion
MQTTClient_create(&client, IPaddress, clientID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
// Fin de config connexion
// Configuration de la fonction callback de souscription
MQTTClient_setCallbacks(client, NULL, connlost, msgarr, delivered);
// Tentative de connexion au broker mqtt
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
return(rc);
}else return 0;
}
int mqtt_client_connect(MQTTClient* pClient, const char* address, const char* clientid , MQTTClient_connectionLost* connlost,
MQTTClient_messageArrived* msgarrvd, MQTTClient_deliveryComplete* delivered)
{
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
int rc;
// int ch;
MQTTClient_create(pClient, address, clientid,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
MQTTClient_setCallbacks(*pClient, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(*pClient, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
LOG_E("Failed to connect, return code %d\n", rc);
MQTTClient_destroy(pClient);
return -1;
}
return rc;
}
// 通信の開始
bool CConMQTT::bConnect(const char* szAddress)
{
//MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_create(&m_client, szAddress, CLIENT_ID,
MQTTCLIENT_PERSISTENCE_NONE, NULL);
//conn_opts.keepAliveInterval = 20;
//conn_opts.cleansession = 1;
//conn_opts.connectTimeout = 0;
//conn_opts.retryInterval = 3;
// 非同期通信におけるコールバックの設定
MQTTClient_setCallbacks(m_client, this, connlost, msgarrvd, delivered);
//int iWaitTime = 10;
//_beginthread(waitConnect, 0x200, &iWaitTime);
HANDLE hThread;
DWORD dwRet;
hThread = CreateThread(NULL, 0, startConnect, &m_client, 0, NULL);
// MQTTClient_connectOptionsのconnectTimeoutの使い方が分からなかったので
// スレッドの終了まちで対応
dwRet = WaitForSingleObject(hThread, 3000);
if (WAIT_TIMEOUT == dwRet) {
TerminateThread(hThread, -1);
return false;
}
printf("Subscribing to topic %s\nfor client %s using QoS%d\n",
TOPIC, CLIENT_ID, QOS);
MQTTClient_subscribe(m_client, TOPIC, QOS);
return true;
}
int mqtt_init(char *hostname, int port, char *certfile, char *nodeKeyS, char *nodeSecret)
{
int rc;
char hostaddress[50];
bool use_ssl = false;
if (port == 8883 || (certfile != NULL && strlen(certfile) > 0))
use_ssl = true;
Yodiwo_Plegma_NodeKey_t nodeKey;
if (nodeKeyS == NULL || nodeSecret == NULL) {
return -1;
}
NodeKey_FromString(&nodeKey, nodeKeyS);
sprintf(mqtt_topic_sub, "/api/out/" YODIWO_API_VERSION_STR "/%s/#", nodeKeyS);
sprintf(mqtt_topic_pub, "/api/in/" YODIWO_API_VERSION_STR "/%s/%s/", nodeKey.UserKey.UserID, nodeKeyS);
printf("topic to subscribe: %s\n", mqtt_topic_sub);
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
MQTTClient_SSLOptions ssl_opts = MQTTClient_SSLOptions_initializer;
MQTTClient_deliveryToken token;
sprintf(hostaddress,
use_ssl ? "ssl://%s:%d" : "%s:%d",
hostname, port);
rc = MQTTClient_create(&client, hostaddress, nodeKeyS, MQTTCLIENT_PERSISTENCE_NONE, NULL);
if (rc != MQTTCLIENT_SUCCESS) {
return -1;
}
if (use_ssl) {
ssl_opts.enableServerCertAuth = (certfile != NULL && strlen(certfile) > 0);
ssl_opts.trustStore = certfile;
conn_opts.ssl = &ssl_opts;
}
// conn_opts.connectTimeout = 50000;
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
conn_opts.MQTTVersion = 4;
conn_opts.username = nodeKeyS;
conn_opts.password = nodeSecret;
MQTTClient_setCallbacks(client, NULL, on_mqtt_disconnected, on_mqtt_message, NULL);
printf("connecting to MQTT broker: %s:%d\n", hostname, port);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
return -1;
}
printf("MQTT connected\n") ;
if ((rc = MQTTClient_subscribe(client, mqtt_topic_sub, 2)) != MQTTCLIENT_SUCCESS) {
printf("rc from MQTT subscribe is %d\n", rc);
return rc;
}
printf("Subscribed\n");
return 0;
}
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 test2(struct Options options)
{
char* testname = "test2";
int subsqos = 2;
MQTTClient c;
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
int rc = 0;
char* test_topic = "C client test2";
char* topics[2] = {"test_topic", "nosubscribe"};
int qoss[2] = {2, 2};
fprintf(xml, "<testcase classname=\"test1\" name=\"bad return code from subscribe\"");
MyLog(LOGA_INFO, "Starting test 2 - bad return code from subscribe");
global_start_time = start_clock();
failures = 0;
MQTTClient_create(&c, options.connection, "multi_threaded_sample", MQTTCLIENT_PERSISTENCE_DEFAULT, NULL);
opts.keepAliveInterval = 20;
opts.cleansession = 1;
opts.MQTTVersion = 4;
if (options.haconnections != NULL)
{
opts.serverURIs = options.haconnections;
opts.serverURIcount = options.hacount;
}
rc = MQTTClient_setCallbacks(c, NULL, NULL, test2_messageArrived, test2_deliveryComplete);
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
MyLog(LOGA_DEBUG, "Connecting");
rc = MQTTClient_connect(c, &opts);
assert("Good rc from connect", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
if (rc != MQTTCLIENT_SUCCESS)
goto exit;
assert("Correct serverURI returned", strcmp(opts.returned.serverURI, options.connection) == 0, "serverURI was %s",
opts.returned.serverURI);
assert("Correct MQTTVersion returned", opts.returned.MQTTVersion == 4, "MQTTVersion was %d",
opts.returned.MQTTVersion);
assert("Correct sessionPresent returned", opts.returned.sessionPresent == 0, "sessionPresent was %d",
opts.returned.sessionPresent);
rc = MQTTClient_subscribe(c, test_topic, subsqos);
assert("Good rc from subscribe", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
rc = MQTTClient_subscribe(c, "nosubscribe", 2);
assert("0x80 from subscribe", rc == 0x80, "rc was %d", rc);
rc = MQTTClient_subscribeMany(c, 2, topics, qoss);
assert("Good rc from subscribe", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
assert("Correct returned qos from subscribe", qoss[0] == 2, "qos 0 was %d", qoss[0]);
assert("Correct returned qos from subscribe", qoss[1] == 0x80, "qos 0 was %d", qoss[0]);
rc = MQTTClient_unsubscribe(c, test_topic);
assert("Unsubscribe successful", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
rc = MQTTClient_disconnect(c, 0);
assert("Disconnect successful", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
MQTTClient_destroy(&c);
exit:
MyLog(LOGA_INFO, "%s: test %s. %d tests run, %d failures.",
(failures == 0) ? "passed" : "failed", testname, tests, failures);
write_test_result();
return failures;
}
int test2a_m(struct Options options)
{
char* testname = "test2a_m";
char* test_topic = "C client test2a_m";
int subsqos = 2;
/* TODO - usused - remove ? MQTTClient_deliveryToken* dt = NULL; */
MQTTClient c;
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
MQTTClient_willOptions wopts = MQTTClient_willOptions_initializer;
MQTTClient_SSLOptions sslopts = MQTTClient_SSLOptions_initializer;
int rc = 0;
failures = 0;
MyLog(LOGA_INFO, "Starting test 2a_m - Mutual SSL authentication - multi-threaded client using callbacks");
if (!(assert("good rc from create", (rc = MQTTClient_create(&c, options.connection, "test2a_m", MQTTCLIENT_PERSISTENCE_DEFAULT, persistenceStore)) == MQTTCLIENT_SUCCESS, "rc was %d\n", rc)))
goto exit;
opts.keepAliveInterval = 20;
opts.cleansession = 1;
opts.username = "******";
opts.password = "******";
if (options.haconnections != NULL)
{
opts.serverURIs = options.haconnections;
opts.serverURIcount = options.hacount;
}
opts.ssl = &sslopts;
if (options.server_key_file != NULL) opts.ssl->trustStore = options.server_key_file; /*file of certificates trusted by client*/
opts.ssl->keyStore = options.client_key_file; /*file of certificate for client to present to server*/
if (options.client_key_pass != NULL) opts.ssl->privateKeyPassword = options.client_key_pass;
//opts.ssl->enabledCipherSuites = "DEFAULT";
//opts.ssl->enabledServerCertAuth = 1;
if (!(assert("Good rc from setCallbacks", (rc = MQTTClient_setCallbacks(c, NULL, NULL, multiThread_messageArrived, multiThread_deliveryComplete)) == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
MyLog(LOGA_DEBUG, "Connecting");
if (!(assert("Good rc from connect", (rc = MQTTClient_connect(c, &opts)) == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
if (!(assert("Good rc from subscribe", (rc = MQTTClient_subscribe(c, test_topic, subsqos)) == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
multiThread_sendAndReceive(c, 0, test_topic);
multiThread_sendAndReceive(c, 1, test_topic);
multiThread_sendAndReceive(c, 2, test_topic);
MyLog(LOGA_DEBUG, "Stopping");
if (!(assert("Unsubscribe successful", (rc = MQTTClient_unsubscribe(c, test_topic)) == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
if (!(assert("Disconnect successful", (rc = MQTTClient_disconnect(c, 0)) == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
exit:
MQTTClient_destroy(&c);
MyLog(LOGA_INFO, "%s: test %s. %d tests run, %d failures.",
(failures == 0) ? "passed" : "failed", testname, tests, failures);
return failures;
}
MQTTAPI_HANDLE MQTTAPI_Create(const MQTTAPI_ConnectOptions* options)
{
PMQTTTAPI_HANDLE_DATA result;
/* Codes_SRS_MQTTAPI_04_011: [If any member of the parameter options is NULL or empty then MQTTAPI_Create shall return NULL.] */
if (options == NULL)
{
LogError("Invalid Argument. options cannot be NULL.\r\n")
result = NULL;
}
else if (options->deviceId == NULL || strlen(options->deviceId) <= 0)
{
LogError("Invalid Argument. Device Id cannot be NULL or Empty.\r\n")
result = NULL;
}
else if (options->deviceKey == NULL || strlen(options->deviceKey) <= 0)
{
LogError("Invalid Argument. Device Key cannot be NULL or Empty.\r\n")
result = NULL;
}
else if (options->serverURI == NULL || strlen(options->serverURI) <= 0)
{
LogError("Invalid Argument. Device Key cannot be NULL or Empty.\r\n")
result = NULL;
}
else if (options->sasTokenSr == NULL || strlen(options->sasTokenSr) <= 0)
{
LogError("Invalid Argument. sasTokenSr cannot be NULL or Empty.\r\n")
result = NULL;
}
/* Tests_SRS_MQTTAPI_04_014: [Otherwise, MQTTAPI_Create shall return a MQTTAPI_HANDLE suitable for further calls to the module.] */
else
{
result = (PMQTTTAPI_HANDLE_DATA)malloc(sizeof(MQTTTAPI_HANDLE_DATA));
if (result != NULL)
{
result->connected = false;
result->subscribed = false;
result->dcCallback = NULL;
result->maCallBack = NULL;
result->maCallbackContext = NULL;
result->subscribedTopicHandleData = NULL;
result->sasTokenLifetime = SAS_TOKEN_DEFAULT_LIFETIME;
result->sasRefreshLine = SAS_TOKEN_DEFAULT_REFRESH_LINE;
DList_InitializeListHead(&(result->messagesReceived));
DList_InitializeListHead(&(result->messagesToSend));
DList_InitializeListHead(&(result->messagesSent));
if ((result->LockHandle = Lock_Init()) == NULL)
{
LogError("Lock_Init failed\r\n");
free(result);
result = NULL;
}
/* Codes_SRS_MQTTAPI_04_012: [Parameters deviceId, deviceKey and sasTokenSr shall be saved.] */
else if ((result->device_id = STRING_construct(options->deviceId)) == NULL)
{
/* Codes_SRS_MQTTAPI_04_013: [If saving these parameters fail for any reason MQTTAPI_Create shall return NULL.] */
LogError("Could not create deviceId String.\r\n");
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
/* Codes_SRS_MQTTAPI_04_012: [Parameters deviceId, deviceKey and sasTokenSr shall be saved.] */
else if ((result->device_key = STRING_construct(options->deviceKey)) == NULL)
{
/* Codes_SRS_MQTTAPI_04_013: [If saving these parameters fail for any reason MQTTAPI_Create shall return NULL.] */
LogError("Could not create deviceId String.\r\n");
STRING_delete(result->device_id);
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
/* Codes_SRS_MQTTAPI_04_012: [Parameters deviceId, deviceKey and sasTokenSr shall be saved.] */
else if ((result->sasTokenSr = STRING_construct(options->sasTokenSr)) == NULL)
{
LogError("Could not create sasTokenSr String.\r\n");
STRING_delete(result->device_key);
STRING_delete(result->device_id);
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
else if (MQTTClient_create(&result->client, options->serverURI, STRING_c_str(result->device_id),
MQTTCLIENT_PERSISTENCE_NONE, NULL) != MQTTCLIENT_SUCCESS)
{
LogError("Could not create MQTT Client.\r\n");
STRING_delete(result->sasTokenSr);
STRING_delete(result->device_key);
STRING_delete(result->device_id);
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
/* Codes_SRS_MQTTAPI_04_004: [This function is registered when the user makes a call to MQTTAPI_SetCallbacks.] */
/* Codes_SRS_MQTTAPI_04_005: [The context parameter is a pointer to the original value passed by MQTTAPI_SetCallbacks, which contains application-specific context.] */
/* Codes_SRS_MQTTAPI_04_008: [This function is registered when the user makes a call to MQTTAPI_SetCallbacks.] */
else if (MQTTClient_setCallbacks(result->client, result, connectionLost, msgarrvd, delivered) != MQTTCLIENT_SUCCESS)
{
LogError("Could not set callbacks.\r\n");
STRING_delete(result->sasTokenSr);
STRING_delete(result->device_key);
STRING_delete(result->device_id);
MQTTClient_destroy(&result->client);
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
/* Codes_SRS_MQTTAPI_04_024: [MQTTAPI_Create shall call underlying library connection functions to establish connection with the server.] */
/* Codes_SRS_MQTTAPI_04_047: [Otherwise MQTTAPI_Create shall return a non-NULL MQTTAPI_HANDLE] */
else if (!checkAndTryToConnect(result))
{
/* Codes_SRS_MQTTAPI_04_025: [If connection fails MQTTAPI_Create shall return NULL. */
LogError("Could not Connect to MQTT Server.\r\n");
STRING_delete(result->sasTokenSr);
STRING_delete(result->device_key);
STRING_delete(result->device_id);
MQTTClient_destroy(&result->client);
Lock_Deinit(result->LockHandle);
free(result);
result = NULL;
}
}
else
{
/* Codes_SRS_MQTTAPI_04_015: [If creating instance fails for any reason, then MQTTAPI_Create shall return NULL.] */
LogError("Could not create MQTT API handle data. Memory allocation failed.\r\n");
result = NULL;
}
}
return (MQTTAPI_HANDLE)result;
}
void MQTT::connect()
{
try
{
if(_started || _client) return;
_started = true;
_connectionOptions = new MQTTClient_connectOptions(MQTTClient_connectOptions_initializer);
if(!_settings.username().empty())
{
((MQTTClient_connectOptions*)_connectionOptions)->username = _settings.username().c_str();
((MQTTClient_connectOptions*)_connectionOptions)->password = _settings.password().c_str();
}
if(_settings.enableSSL())
{
_out.printInfo("Info: Enabling SSL for MQTT.");
#ifndef OPENSSL
_out.printError("Error: MQTT library is compiled without OpenSSL support. Can't enable SSL. Aborting.");
disconnect();
return;
#endif
if(_settings.caFile().empty())
{
_out.printError("Error: SSL is enabled but \"caFile\" is not set.");
disconnect();
return;
}
if(!BaseLib::Io::fileExists(_settings.caFile()))
{
_out.printError("Error: CA certificate file does not exist or can't be opened.");
disconnect();
return;
}
if(_settings.certPath().empty())
{
_out.printError("Error: SSL is enabled but \"certPath\" is not set.");
disconnect();
return;
}
if(!BaseLib::Io::fileExists(_settings.certPath()))
{
_out.printError("Error: Client certificate file does not exist or can't be opened.");
disconnect();
return;
}
if(_settings.keyPath().empty())
{
_out.printError("Error: SSL is enabled but \"keyPath\" is not set.");
disconnect();
return;
}
if(!BaseLib::Io::fileExists(_settings.keyPath()))
{
_out.printError("Error: Client key file does not exist or can't be opened.");
disconnect();
return;
}
_sslOptions = new MQTTClient_SSLOptions({ {'M', 'Q', 'T', 'S'}, 0, _settings.caFile().c_str(), _settings.certPath().c_str(), _settings.keyPath().c_str(), nullptr, nullptr, _settings.verifyCertificate() });
((MQTTClient_connectOptions*)_connectionOptions)->ssl = (MQTTClient_SSLOptions*)_sslOptions;
}
MQTTClient_create(&_client, std::string((_settings.enableSSL() ? "ssl://" : "tcp://") + _settings.brokerHostname() + ":" + _settings.brokerPort()).c_str(), _settings.clientName().c_str(), MQTTCLIENT_PERSISTENCE_NONE, NULL);
((MQTTClient_connectOptions*)_connectionOptions)->keepAliveInterval = 10;
((MQTTClient_connectOptions*)_connectionOptions)->cleansession = 1;
MQTTClient_setCallbacks(_client, NULL, NULL, MQTTMessageArrived, NULL);
int32_t result = MQTTClient_connect(_client, (MQTTClient_connectOptions*)_connectionOptions);
if (result != MQTTCLIENT_SUCCESS)
{
disconnect();
std::string reason;
//see http://www.eclipse.org/paho/files/mqttdoc/Cclient/_m_q_t_t_client_8h.html#aaa8ae61cd65c9dc0846df10122d7bd4e
if(result == 1) reason = "Connection refused: Unacceptable protocol version";
else if(result == 2) reason = "Connection refused: Identifier rejected";
else if(result == 3) reason = "Connection refused: Server unavailable";
else if(result == 4) reason = "Connection refused: Bad user name or password";
else if(result == 5) reason = "Connection refused: Not authorized";
else reason = "Unknown reason. Check broker log for more details. A few common reasons: The broker is not running, the broker is not reachable (wrong IP address, wrong port, firewall, ...), the broker requires SSL and SSL is not enabled in Homegear's mqtt.conf.";
_out.printError("Error: Failed to connect to message broker: " + reason);
return;
}
_out.printInfo("Info: Successfully connected to message broker.");
MQTTClient_subscribe(_client, std::string("homegear/" + _settings.homegearId() + "/rpc/#").c_str(), 1);
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
int main(int argc, char* argv[])
{
//Getting input from the file for subscribing
char ADDRESS[50];
char CLIENTID[23];
char TOPIC[80];
char PORT[5];
FILE* fp = fopen("input_sub.config","r");
fscanf(fp,"%s",ADDRESS);
fscanf(fp,"%s",CLIENTID);
fscanf(fp,"%s",TOPIC);
fscanf(fp,"%s",PORT);
sprintf(ADDRESS,"%s:%s",ADDRESS,PORT);
fclose(fp);
//WiringPi setup
wiringPiSetupGpio ();
pinMode (LED_1, OUTPUT);
pinMode (LED_2, OUTPUT);
pinMode (LED_3, OUTPUT);
//pinMode (SWITCH_1, INPUT);
//pinMode (SWITCH_2, INPUT);
//pinMode (SWITCH_3, INPUT);
//Pull up input pins
pullUpDnControl (SWITCH_1, PUD_UP);
pullUpDnControl (SWITCH_2, PUD_UP);
pullUpDnControl (SWITCH_3, PUD_UP);
//Set Interrupts
wiringPiISR(SWITCH_1,INT_EDGE_BOTH,&interruptFunc_1);
wiringPiISR(SWITCH_2,INT_EDGE_BOTH,&interruptFunc_2);
wiringPiISR(SWITCH_3,INT_EDGE_BOTH,&interruptFunc_3);
//Pull down the non ground pins
pullUpDnControl (19, PUD_DOWN);
pullUpDnControl (26, PUD_DOWN);
//Lights Initialization
digitalWrite(LED_1,HIGH);
digitalWrite(LED_2,LOW);
digitalWrite(LED_3,LOW);
delay(100);
digitalWrite(LED_1,LOW);
digitalWrite(LED_2,HIGH);
digitalWrite(LED_3,LOW);
delay(100);
digitalWrite(LED_1,LOW);
digitalWrite(LED_2,LOW);
digitalWrite(LED_3,HIGH);
delay(100);
digitalWrite(LED_1, LOW);
digitalWrite(LED_2, LOW);
digitalWrite(LED_3, LOW);
//MQTT Setup for subscribing
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
int rc;
int ch;
MQTTClient_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_USER, NULL);
conn_opts.keepAliveInterval = 100;
conn_opts.cleansession = 0;
MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);
if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
{
printf("Failed to connect, return code %d\n", rc);
exit(-1);
}
printf("Subscribing to topic %s\nfor client %s using QoS %d\n\n"
"Press Q<Enter> to quit\n\n", TOPIC, CLIENTID, QOS);
MQTTClient_subscribe(client, TOPIC, QOS);
//Start the new thread
if(piThreadCreate(mqttStream) != 0)
{
printf("ERROR in creating MQTT streaming thread");
}
//Main loop
int previousBoxStatus_1,previousBoxStatus_2,previousBoxStatus_3;
previousBoxStatus_1 = boxStatus_1;
previousBoxStatus_2 = boxStatus_2;
previousBoxStatus_3 = boxStatus_3;
do
{
//if the previous mode is not the status now publish else do nothing
if(previousBoxStatus_1 != boxStatus_1){
delay(debounceDelay); //Time delay after an interrupt for the signal to be stable
publishBoxStatus(10,boxStatus_1);
previousBoxStatus_1 = boxStatus_1;
}
if(previousBoxStatus_2 != boxStatus_2){
delay(debounceDelay); //Time delay after an interrupt for the signal to be stable
publishBoxStatus(20,boxStatus_2);
previousBoxStatus_2 = boxStatus_2;
}
if(previousBoxStatus_3 != boxStatus_3){
delay(debounceDelay); //Time delay after an interrupt for the signal to be stable
publishBoxStatus(30,boxStatus_3);
previousBoxStatus_3 = boxStatus_3;
}
// ch = getchar();
} while(ch!='Q' && ch != 'q');
MQTTClient_disconnect(client, 10000);
MQTTClient_destroy(&client);
return rc;
}
void MQTTSubscriber::subscribeTopic(const std::string& topic, int qos, MQTTClient_messageArrived* mA, MQTTClient_connectionLost* cL, void* context) {
MQTTClient_setCallbacks(client , context, cL, mA, NULL);
MQTTClient_connect(client, &conn_options);
MQTTClient_subscribe(client, topic.c_str(), qos);
}
int test3a_m(struct Options options)
{
char* testname = "test3a_m";
char* test_topic = "C client test3a_m";
int subsqos = 2;
MQTTClient c;
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
MQTTClient_willOptions wopts = MQTTClient_willOptions_initializer;
MQTTClient_SSLOptions sslopts = MQTTClient_SSLOptions_initializer;
int rc = 0;
failures = 0;
MyLog(LOGA_INFO, "Starting test 3a_m - Server authentication - multi-threaded client using callbacks");
fprintf(xml, "<testcase classname=\"test3\" name=\"test 3a_m\"");
global_start_time = start_clock();
rc = MQTTClient_create(&c, options.server_auth_connection, "test3a_m", MQTTCLIENT_PERSISTENCE_DEFAULT, persistenceStore);
if (!(assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc)))
goto exit;
opts.keepAliveInterval = 20;
opts.cleansession = 1;
opts.username = "******";
opts.password = "******";
if (options.haconnections != NULL)
{
opts.serverURIs = options.haconnections;
opts.serverURIcount = options.hacount;
}
opts.ssl = &sslopts;
if (options.server_key_file != NULL)
opts.ssl->trustStore = options.server_key_file; /*file of certificates trusted by client*/
rc = MQTTClient_setCallbacks(c, NULL, NULL, multiThread_messageArrived, multiThread_deliveryComplete);
if (!(assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
MyLog(LOGA_DEBUG, "Connecting");
rc = MQTTClient_connect(c, &opts);
if (!(assert("Good rc from connect", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
rc = MQTTClient_subscribe(c, test_topic, subsqos);
if (!(assert("Good rc from subscribe", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
multiThread_sendAndReceive(c, 0, test_topic);
multiThread_sendAndReceive(c, 1, test_topic);
multiThread_sendAndReceive(c, 2, test_topic);
MyLog(LOGA_DEBUG, "Stopping\n");
rc = MQTTClient_unsubscribe(c, test_topic);
if (!(assert("Unsubscribe successful", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
rc = MQTTClient_disconnect(c, 0);
if (!(assert("Disconnect successful", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc)))
goto exit;
exit:
MQTTClient_destroy(&c);
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)
{
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;
}
