int main(int argc, char *argv[])
{
int rc;
int tmp;
struct mosquitto *mosq;
int port = atoi(argv[1]);
mosquitto_lib_init();
mosq = mosquitto_new("prop-test", true, NULL);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_publish_callback_set(mosq, on_publish);
tmp = MQTT_PROTOCOL_V5;
mosquitto_opts_set(mosq, MOSQ_OPT_PROTOCOL_VERSION, &tmp);
rc = mosquitto_connect(mosq, "localhost", port, 60);
while(run == -1){
rc = mosquitto_loop(mosq, -1, 1);
}
mosquitto_lib_cleanup();
return run;
}
int mqPub(void)
{
int i;
char *host = "5.44.237.19";
int port = 1883;
int keepalive = 60;
bool clean_session = true;
struct mosquitto *mosq = NULL;
mosquitto_lib_init();
mosq = mosquitto_new(NULL, clean_session, NULL);
if(!mosq){
fprintf(stderr, "Error: Out of memory.\n");
return 1;
}
mosquitto_log_callback_set(mosq, my_log_callback);
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_message_callback_set(mosq, my_message_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
if(mosquitto_connect(mosq, host, port, keepalive)){
fprintf(stderr, "Unable to connect.\n");
return 1;
}
mosquitto_loop_forever(mosq, -1, 1);
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return 0;
}
bool MosquittoHandler::init(std::string id)
{
int minor, major, revision;
mosquitto_lib_version(&major, &minor, &revision);
if(numOfInstances == 0) {
mosquitto_lib_init();
}
m_libInit = true;
numOfInstances++;
void* obj = (void*) this;
m_mosquittoStruct = mosquitto_new(id.c_str(), obj);
if(!m_mosquittoStruct) {
m_lastErrorString = "Cannot create new Mosquitto instance";
return false;
}
mosquitto_log_init(m_mosquittoStruct, MOSQ_LOG_ERR || MOSQ_LOG_WARNING, MOSQ_LOG_STDOUT);
mosquitto_connect_callback_set(m_mosquittoStruct, MosquittoHandler::onConnectWrapper);
mosquitto_disconnect_callback_set(m_mosquittoStruct, MosquittoHandler::onDisconnectWrapper);
mosquitto_message_callback_set(m_mosquittoStruct, MosquittoHandler::onMessageWrapper);
return true;
}
static int mosq_init(lua_State *L)
{
if (!mosq_initialized)
mosquitto_lib_init();
return mosq__pstatus(L, MOSQ_ERR_SUCCESS);
}
int main(int argc, char *argv[])
{
int i;
char *host = "5.44.237.19";
int port = 1883;
int keepalive = 60;
bool clean_session = true;
struct mosquitto *mosq = NULL;
sprintf(mqMsg,"%s",argv[1]);
printf("And the word is >> %s <<\n", mqMsg);
mosquitto_lib_init();
mosq = mosquitto_new(NULL, clean_session, NULL);
if(!mosq){
fprintf(stderr, "Error: Out of memory.\n");
return 1;
}
mosquitto_log_callback_set(mosq, my_log_callback);
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_message_callback_set(mosq, my_message_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
if(mosquitto_connect(mosq, host, port, keepalive)){
fprintf(stderr, "Unable to connect.\n");
return 1;
}
mosquitto_loop_forever(mosq, -1, 1);
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return 0;
}
int main(int argc, char *argv[])
{
int i;
char *host = "localhost";
int port = 1883;
int keepalive = 60;
bool clean_session = false; // Note this, set it to false if you want to get offline message
struct mosquitto *mosq = NULL;
mosquitto_lib_init();
// Note this, this first argv is id, it must be set if clean_session is false
mosq = mosquitto_new("1", clean_session, NULL);
if(!mosq){
fprintf(stderr, "Error: Out of memory.\n");
return 1;
}
mosquitto_log_callback_set(mosq, my_log_callback);
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_message_callback_set(mosq, my_message_callback);
mosquitto_subscribe_callback_set(mosq, my_subscribe_callback);
if(mosquitto_connect(mosq, host, port, keepalive)){
fprintf(stderr, "Unable to connect.\n");
return 1;
}
while(!mosquitto_loop(mosq, -1, 1)){
}
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return 0;
}
int main(int argc, char *argv[])
{
int port, client_id, buffer_size;
int rc;
struct mosquitto *mosq;
void* buffer;
char line[1024];
const char *name;
//prepare arguments
if(argc < 3) {
printf("usage: %s host port [id]\n", argv[0]);
return 0;
}
port = atoi(argv[2]);
client_id = -1;
if(argc > 3) {
client_id = atoi(argv[3]);
}
pthread_mutex_init(&mutex, NULL);
name = init(client_id);
//start mosquitto stuff
mosquitto_lib_init();
mosq = mosquitto_new(name, true, NULL);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_subscribe_callback_set(mosq, on_subscribe);
mosquitto_message_callback_set(mosq, on_message);
rc = mosquitto_connect_async(mosq, argv[1], port, 60);
mosquitto_loop_start(mosq);
while(1) {
fgets(line, 1024, stdin);
pthread_mutex_lock(&mutex);
buffer = message_entered(line, &buffer_size);
pthread_mutex_unlock(&mutex);
int sent_mid = -1;
mosquitto_publish(mosq, &sent_mid, topic_name, buffer_size, buffer, 0, false);
message_sent(buffer, buffer_size);
}
mosquitto_disconnect(mosq);
mosquitto_loop_stop(mosq, false);
mosquitto_lib_cleanup();
cleanup();
return 0;
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
mosquitto_property *props = NULL;
int port = atoi(argv[1]);
mosquitto_lib_init();
mosq = mosquitto_new("publish-qos1-test", true, &run);
mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
mosquitto_connect_v5_callback_set(mosq, on_connect);
mosquitto_publish_v5_callback_set(mosq, on_publish);
rc = mosquitto_connect_bind_v5(mosq, "localhost", port, 60, NULL, NULL);
while(run == -1){
mosquitto_loop(mosq, 300, 1);
}
mosquitto_lib_cleanup();
return run;
}
int main(int argc, char *argv[])
{
struct mosquitto *mosq;
int i;
double dstart, dstop, diff;
FILE *fptr;
uint8_t *buf;
buf = malloc(MESSAGE_SIZE*MESSAGE_COUNT);
if(!buf){
printf("Error: Out of memory.\n");
return 1;
}
start.tv_sec = 0;
start.tv_usec = 0;
stop.tv_sec = 0;
stop.tv_usec = 0;
if(create_data()){
printf("Error: Unable to create random input data.\n");
return 1;
}
fptr = fopen("msgsps_pub.dat", "rb");
if(!fptr){
printf("Error: Unable to open random input data.\n");
return 1;
}
fread(buf, sizeof(uint8_t), MESSAGE_SIZE*MESSAGE_COUNT, fptr);
fclose(fptr);
mosquitto_lib_init();
mosq = mosquitto_new("perftest", true, NULL);
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_disconnect_callback_set(mosq, my_disconnect_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
mosquitto_connect(mosq, "127.0.0.1", 1884, 600);
i=0;
while(!mosquitto_loop(mosq, 1, 10) && run){
if(i<MESSAGE_COUNT){
mosquitto_publish(mosq, NULL, "perf/test", MESSAGE_SIZE, &buf[i*MESSAGE_SIZE], 0, false);
i++;
}
}
dstart = (double)start.tv_sec*1.0e6 + (double)start.tv_usec;
dstop = (double)stop.tv_sec*1.0e6 + (double)stop.tv_usec;
diff = (dstop-dstart)/1.0e6;
printf("Start: %g\nStop: %g\nDiff: %g\nMessages/s: %g\n", dstart, dstop, diff, (double)MESSAGE_COUNT/diff);
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return 0;
}
QMosquitto::QMosquitto(QObject *parent) : QObject(parent)
{
mosquitto_lib_init();
this->mosq = mosquitto_new(NULL, true, this);
if(this->mosq == NULL) throw "Error creating mosquitto object";
// Register message callback
mosquitto_message_callback_set(this->mosq, on_message);
}
static
int
mosq_lib_init(lua_State *L)
{
if (!mosq_initialized)
mosquitto_lib_init();
return make_mosq_status_result(L, MOSQ_ERR_SUCCESS);
}
static void
sol_mqtt_init(void)
{
SOL_LOG_INTERNAL_INIT_ONCE;
init_ref++;
if (init_ref == 1)
mosquitto_lib_init();
}
int MqttHal_Init()
{
int rc = 0;
//struct mosq_config mosq_cfg;
senhub_info_t *pshinfo;
g_SensorHubList = NULL;
//ADV_INFO("%s: \n", __func__);
rc = mqtt_client_config_load(&g_mosq_cfg, CLIENT_SUB, 1, NULL);
if(rc){
mqtt_client_config_cleanup(&g_mosq_cfg);
return 1;
}
mosquitto_lib_init();
if(mqtt_client_id_generate(&g_mosq_cfg, "advmqttcli")){
return 1;
}
g_mosq = mosquitto_new(g_mosq_cfg.id, g_mosq_cfg.clean_session, &g_mosq_cfg);
if(!g_mosq){
switch(errno){
case ENOMEM:
if(!g_mosq_cfg.quiet) fprintf(stderr, "Error: Out of memory.\n");
break;
case EINVAL:
if(!g_mosq_cfg.quiet) fprintf(stderr, "Error: Invalid id and/or clean_session.\n");
break;
}
mosquitto_lib_cleanup();
return 1;
}
if(mqtt_client_opts_set(g_mosq, &g_mosq_cfg)){
return 1;
}
mosquitto_connect_callback_set(g_mosq, MqttHal_Connect_Callback);
mosquitto_message_callback_set(g_mosq, MqttHal_Message_Callback);
mosquitto_disconnect_callback_set(g_mosq, MqttHal_Disconnect_Callback);
mosquitto_publish_callback_set(g_mosq, MqttHal_Publish_Callback);
// Create senhub root
pshinfo = malloc(sizeof(senhub_info_t));
memset(pshinfo, 0, sizeof(senhub_info_t));
sprintf(pshinfo->macAddress, "0000%s" , g_GWInfMAC);
pshinfo->jsonNode = NULL;
pshinfo->id = senhub_list_newId(g_SensorHubList);
//printf("%s: list add id=%d\n", __func__, pshinfo->id);
g_SensorHubList = SENHUB_LIST_ADD(g_SensorHubList, pshinfo);
return rc;
}
bool mosq_setup(struct _squash *st)
{
mosquitto_lib_init();
DLOG("mosquitto -> (re)connecting\n");
st->mosq = mosquitto_new(NULL, true, st);
mosquitto_log_callback_set(st->mosq, mosq_logger);
mosquitto_message_callback_set(st->mosq, st->msg_handler);
int rc = mosquitto_connect(st->mosq, st->mq_host, 1883, 60);
if (MOSQ_ERR_SUCCESS != rc) {
WLOG("Failed to connect: %s\n", strerror(errno));
rc = -1;
goto unwind;
}
int mosq_fd = mosquitto_socket(st->mosq);
if (evutil_make_socket_nonblocking(mosq_fd)) {
WLOG("Failed to make non-blocking: fd = %d, possibly ok\n", mosq_fd);
}
st->mosq_readidle = event_new(st->base, mosq_fd, EV_READ|EV_PERSIST, mosq_ev_io, st);
if (st->mosq_readidle == NULL) {
WLOG("Failed to create mosquitto read/idle watcher\n");
rc = -1;
goto unwind_readidle;
}
st->mosq_write = event_new(st->base, mosq_fd, EV_WRITE, mosq_ev_io, st);
if (st->mosq_write == NULL) {
WLOG("Failed to create mosquitto write watcher\n");
rc = -1;
goto unwind_write;
}
if (mosquitto_want_write(st->mosq)) {
event_add(st->mosq_write, NULL);
}
struct timeval mosq_idle_loop_time = { 0, 100 * 1000 };
if (event_add(st->mosq_readidle, &mosq_idle_loop_time) < 0) {
WLOG("Failed to activate mosquitto watcher\n");
rc = -1;
goto unwind_write;
}
goto out;
unwind_write:
event_free(st->mosq_write);
unwind_readidle:
event_free(st->mosq_readidle);
unwind:
mosquitto_destroy(st->mosq);
mosquitto_lib_cleanup();
out:
return rc == 0;
}
int main(int argc, char *argv[])
{
char clientid[24]="FcBitu'";
int rc = 0;
//int nr = 0;
struct mosquitto *mosq;
int mid;
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
mosquitto_lib_init();
mosq = mosquitto_new(clientid, true, NULL);
if(mosq){
mosquitto_connect_callback_set(mosq, connect_callback);
mosquitto_message_callback_set(mosq, message_callback);
rc = mosquitto_connect(mosq, mqtt_host, mqtt_port, 60);
mosquitto_subscribe(mosq, NULL, "coords", 0);
while(run){
rc = mosquitto_loop(mosq, 1, 1);
if(run && rc){
sleep(2);
printf ("\n run: %d rc: %d \n", run,rc);
mosquitto_reconnect(mosq);
}
printf("robot: timestamp: %d X: %d Y: %d unghi: %d\n ",coordrob[4] .timestamp,coordrob[4] .x,coordrob[4] .y,coordrob[4] .angle);
printf("0: timestamp: %d X: %d Y: %d unghi: %d\n ",coordrob[0] .timestamp,coordrob[0] .x,coordrob[0] .y,coordrob[0] .angle);
quarterback_oriented();
mosquitto_publish(mosq, &mid, idfundas, sizeof(struct control), &ctr[fundas], 0, false);
mosquitto_publish(mosq, &mid, idminge, sizeof(struct control), &ctr[0], 0, false);
//mosquitto_publish(mosq, &mid, idportar, sizeof(struct control), &ctr[ceva_portar], 0, false);
//usleep(1000);
/*if (nr >= 255) nr = 0;
ctr.right = nr; ctr.left = nr;
nr = nr + 1;
printf ("comenzi robot: ctr.right: %d ctr.left: %d timestamp: %d\n", ctr.right,ctr.left,coordrob[0].timestamp);
fflush(stdout);*/
}
mosquitto_destroy(mosq);
}
mosquitto_lib_cleanup();
return rc;
}
// establish the MQTT connection
int mqtt_loop(char *host, int port, char *username, char *password) {
struct mosquitto *mosq;
int r = 0;
mosquitto_lib_init();
if ((mosq = mosquitto_new(NULL, true, NULL)) == NULL) {
r = -1;
printf("Failed to build the MQTT object.\n" );
goto FUNCTION_END;
}
// declare the callback functions
mosquitto_connect_callback_set(mosq, mqtt_callback_connect);
mosquitto_message_callback_set(mosq, mqtt_callback_message);
mosquitto_disconnect_callback_set(mosq, mqtt_callback_disconnect);
// authentication
r = mosquitto_username_pw_set(mosq, username, password);
if (r) {
r = -2;
printf("Failed to setup the MQTT authentication - %d.\n", r);
goto FUNCTION_END;
}
// connect and wait
if (mosquitto_connect(mosq, host, port, 60) == MOSQ_ERR_SUCCESS) {
r = 0;
mosquitto_loop_forever(mosq, -1, 1);
} else {
r = -3;
printf("Failed to connect to MQTT broker.\n");
}
mosquitto_destroy(mosq);
FUNCTION_END:
mosquitto_lib_cleanup();
return r;
}
int setup_mq(const char* host) {
int mq_maj, mq_min, mq_rev;
mosquitto_lib_version(&mq_maj, &mq_min, &mq_rev);
DLOG("You've got mosquitto version major:%d, minor:%d, rev:%d\n", mq_maj, mq_min, mq_rev);
mosquitto_lib_init();
pid_t pid = getpid();
char clientid[40];
snprintf(clientid, sizeof (clientid), "rme_signed_demo_%d", pid);
mosq = mosquitto_new(clientid, NULL);
ILOG("Connecting to %s\n", host);
mosquitto_connect(mosq, host, 1883, 15, true);
return 0;
}
/* Initialize a mosquitto client. */
static struct mosquitto *init(struct client_info *info) {
void *udata = (void *)info;
size_t buf_sz = 32;
char buf[buf_sz];
if (buf_sz < snprintf(buf, buf_sz, "client_%d", info->pid)) {
return NULL; /* snprintf buffer failure */
}
mosquitto_lib_init();
/* Create a new mosquitto client, with the name "client_#{PID}". */
struct mosquitto *m = mosquitto_new(buf, true, udata);
return m;
}
int auth_mqtt_init(void)
{
mosquitto_lib_init();
auth_mqtt_mosq = mosquitto_new("auth_client_XXXXXXXXXXXX", true, NULL);
if (!auth_mqtt_mosq) {
mosquitto_lib_cleanup();
return -1;
}
mosquitto_username_pw_set(auth_mqtt_mosq, "#qmsw2..5#", "@oawifi15%");
mosquitto_connect_callback_set(auth_mqtt_mosq, connect_callback);
mosquitto_message_callback_set(auth_mqtt_mosq, message_callback);
mosquitto_connect(auth_mqtt_mosq, "127.0.0.1", 1883, 60);
return 0;
}
int main(int argc, char *argv[])
{
char *host = "5.44.237.19";
int port = 1883;
int keepalive = 60;
bool clean_session = true;
struct mosquitto *mosq = NULL;
/* argv[1] is the filename, argv[2] is the number of MAC addresses */
/* and argv[3] is the timestamp in secs since the epoch */
if(argc==4) {
macFile=argv[1];
messagesToSend=atoi(argv[2]);
if(messagesToSend==0) {
return 1;
}
timeNow=argv[3];
} else {
printf("USAGE: thingithonmq macFileName numRecords timeStamp\n Where timeStamp is in seconds, like date +\%s\n");
return 1;
}
/* Start up Mosquitto */
mosquitto_lib_init();
mosq = mosquitto_new(NULL, clean_session, NULL);
if(!mosq){
fprintf(stderr, "Error: Out of memory.\n");
return 1;
}
mosquitto_log_callback_set(mosq, my_log_callback);
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
if(mosquitto_connect(mosq, host, port, keepalive)){
fprintf(stderr, "Unable to connect.\n");
return 1;
}
mosquitto_loop_forever(mosq, -1, 1);
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return 0;
}
int emit_init()
{
char *host, *buf = strdup(config.emit_option), *bp;
int port, rc;
if ((bp = strchr(buf, '/')) == NULL) {
fprintf(stderr, "MQTT emitter option is bad (no slash)\n");
return (1);
}
*bp = 0;
port = atoi(bp+1);
host = buf;
mosquitto_lib_init();
config.mosq = mosquitto_new(NULL, true, NULL);
if (!config.mosq) {
fprintf(stderr, "Error: Out of memory.\n");
mosquitto_lib_cleanup();
return 1;
}
rc = mosquitto_connect(config.mosq, host, port, 60);
if (rc) {
if (rc == MOSQ_ERR_ERRNO) {
char err[1024];
strerror_r(errno, err, 1024);
fprintf(stderr, "Error connecting to %s:%d: %s\n", host, port, err);
} else {
fprintf(stderr, "Unable to connect (%d).\n", rc);
}
mosquitto_lib_cleanup();
return rc;
}
mosquitto_loop_start(config.mosq);
olog("[*] Connected to MQTT at %s:%d with nsid=%s (topic=%s)\n\n",
host, port, config.nsid, config.emit_topic);
free(buf);
return (0);
}
void Init_mosquitto_ext()
{
mosquitto_lib_init();
intern_call = rb_intern("call");
binary_encoding = rb_enc_find("binary");
rb_mMosquitto = rb_define_module("Mosquitto");
/*
* Message QOS specific constants
*/
rb_define_const(rb_mMosquitto, "AT_MOST_ONCE", INT2NUM(0));
rb_define_const(rb_mMosquitto, "AT_LEAST_ONCE", INT2NUM(1));
rb_define_const(rb_mMosquitto, "EXACTLY_ONCE", INT2NUM(2));
/*
* Log specific constants *
*/
rb_define_const(rb_mMosquitto, "LOG_NONE", INT2NUM(0x00));
rb_define_const(rb_mMosquitto, "LOG_INFO", INT2NUM(0x01));
rb_define_const(rb_mMosquitto, "LOG_NOTICE", INT2NUM(0x02));
rb_define_const(rb_mMosquitto, "LOG_WARNING", INT2NUM(0x04));
rb_define_const(rb_mMosquitto, "LOG_ERR", INT2NUM(0x08));
rb_define_const(rb_mMosquitto, "LOG_DEBUG", INT2NUM(0x10));
rb_define_const(rb_mMosquitto, "LOG_SUBSCRIBE", INT2NUM(0x20));
rb_define_const(rb_mMosquitto, "LOG_UNSUBSCRIBE", INT2NUM(0x40));
rb_define_const(rb_mMosquitto, "LOG_ALL", INT2NUM(0xFFFF));
/*
* TLS specific constants
*/
rb_define_const(rb_mMosquitto, "SSL_VERIFY_NONE", INT2NUM(0));
rb_define_const(rb_mMosquitto, "SSL_VERIFY_PEER", INT2NUM(1));
rb_eMosquittoError = rb_define_class_under(rb_mMosquitto, "Error", rb_eStandardError);
rb_define_module_function(rb_mMosquitto, "version", rb_mosquitto_version, 0);
rb_define_module_function(rb_mMosquitto, "cleanup", rb_mosquitto_cleanup, 0);
_init_rb_mosquitto_client();
_init_rb_mosquitto_message();
}
void ZnpActorProcess(PACTOROPTION option)
{
mosquitto_lib_init();
ZnpActorCreat(option->guid, option->psw, option->host, option->port);
if (pZnpActor == NULL)
{
mosquitto_lib_cleanup();
return;
}
while(1)
{
ActorProcessEvent(pZnpActor);
mosquitto_loop(pZnpActor->client, 0, 1);
usleep(10000);
}
mosquitto_disconnect(pZnpActor->client);
mosquitto_destroy(pZnpActor->client);
mosquitto_lib_cleanup();
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
mosquitto_lib_init();
mosq = mosquitto_new("01-unpwd-set", true, NULL);
mosquitto_username_pw_set(mosq, "uname", ";'[08gn=#");
rc = mosquitto_connect(mosq, "localhost", 1888, 60);
while(run == -1){
mosquitto_loop(mosq, -1, 1);
}
mosquitto_lib_cleanup();
return run;
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
mosquitto_lib_init();
mosq = mosquitto_new("publish-qos0-test", true, NULL);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_publish_callback_set(mosq, on_publish);
rc = mosquitto_connect(mosq, "localhost", 1888, 60);
while(run == -1){
mosquitto_loop(mosq, -1, 1);
}
mosquitto_lib_cleanup();
return run;
}
static void LedActorStart(PACTOROPTION option)
{
mosquitto_lib_init();
LedActorCreate(option->guid, option->psw, option->host, option->port);
if (pLedActor == NULL)
{
mosquitto_lib_cleanup();
return;
}
while(1)
{
ActorProcessEvent(pLedActor);
LedTransition();
mosquitto_loop(pLedActor->client, 0, 1);
usleep(10000);
}
mosquitto_disconnect(pLedActor->client);
mosquitto_destroy(pLedActor->client);
mosquitto_lib_cleanup();
}
int main(int argc, char *argv[])
{
char clientid[24]="Move Test";
struct mosquitto *mosq;
int rc = 0;
int mid;
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
mosquitto_lib_init();
mosq = mosquitto_new(clientid, true, NULL);
if(mosq) {
mosquitto_connect_callback_set(mosq, connect_callback);
mosquitto_message_callback_set(mosq, message_callback);
rc = mosquitto_connect(mosq, mqtt_host, mqtt_port, 60);
mosquitto_subscribe(mosq, NULL, "#", 0);
ctr.left=100;
ctr.right=100;
ctr.time=0;
mosquitto_publish(mosq, &mid, "in15", sizeof(ctr), &ctr, 2, false);
while(run) {
rc = mosquitto_loop(mosq, -1, 1);
if(run && rc) {
sleep(20);
mosquitto_reconnect(mosq);
}
}
mosquitto_destroy(mosq);
}
mosquitto_lib_cleanup();
return rc;
}
mqtt_t mqtt_init() {
mqtt_t inst = NULL;
int rval;
int major = 0;
int minor = 0;
int revision = 0;
(void) mosquitto_lib_version(&major, &minor, &revision);
info("Use mosquitto v%d.%d r%d", major, minor, revision);
rval = mosquitto_lib_init();
if (rval != MOSQ_ERR_SUCCESS) {
error("Cannot initialize library: '%s'", mosquitto_strerror(rval));
} else {
inst = (mqtt_t) calloc(sizeof(struct mqtt_struct_t), 1);
if (inst == NULL) {
error("Cannot allocate mqtt");
}
}
return inst;
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
mosquitto_lib_init();
mosq = mosquitto_new("08-ssl-connect-crt-auth-enc", true, NULL);
mosquitto_tls_opts_set(mosq, 1, "tlsv1", NULL);
mosquitto_tls_set(mosq, "../ssl/test-root-ca.crt", "../ssl/certs", "../ssl/client-encrypted.crt", "../ssl/client-encrypted.key", password_callback);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_disconnect_callback_set(mosq, on_disconnect);
rc = mosquitto_connect(mosq, "localhost", 1888, 60);
while(run == -1){
mosquitto_loop(mosq, -1, 1);
}
mosquitto_lib_cleanup();
return run;
}
/*
* Lib initializer
*/
LUA_API
int
luaopen_mqtt_driver(lua_State *L)
{
mosquitto_lib_init();
mosq_initialized = true;
/**
* Add metatable.__index = metatable
*/
luaL_newmetatable(L, MOSQ_LUA_UDATA_NAME);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
luaL_register(L, NULL, M);
luaL_register(L, NULL, R);
/**
* Add definitions
*/
mosq_register_defs(L, main_defs);
return 1;
}
