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 client_id_generate(struct mosq_config *cfg, const char *id_base)
{
int len;
char hostname[256];
if(cfg->id_prefix) {
cfg->id = malloc(strlen(cfg->id_prefix)+10);
if(!cfg->id) {
if(!cfg->quiet) fprintf(stderr, "Error: Out of memory.\n");
mosquitto_lib_cleanup();
return 1;
}
snprintf(cfg->id, strlen(cfg->id_prefix)+10, "%s%d", cfg->id_prefix, getpid());
} else if(!cfg->id) {
hostname[0] = '\0';
gethostname(hostname, 256);
hostname[255] = '\0';
len = strlen(id_base) + strlen("/-") + 6 + strlen(hostname);
cfg->id = malloc(len);
if(!cfg->id) {
if(!cfg->quiet) fprintf(stderr, "Error: Out of memory.\n");
mosquitto_lib_cleanup();
return 1;
}
snprintf(cfg->id, len, "%s/%d-%s", id_base, getpid(), hostname);
if(strlen(cfg->id) > MOSQ_MQTT_ID_MAX_LENGTH) {
/* Enforce maximum client id length of 23 characters */
cfg->id[MOSQ_MQTT_ID_MAX_LENGTH] = '\0';
}
}
return MOSQ_ERR_SUCCESS;
}
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 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;
}
int client_connect(struct mosquitto *mosq, struct mosq_config *cfg)
{
char err[1024];
int rc;
#ifdef WITH_SRV
if(cfg->use_srv) {
rc = mosquitto_connect_srv(mosq, cfg->host, cfg->keepalive, cfg->bind_address);
} else {
rc = mosquitto_connect_bind(mosq, cfg->host, cfg->port, cfg->keepalive, cfg->bind_address);
}
#else
rc = mosquitto_connect_bind(mosq, cfg->host, cfg->port, cfg->keepalive, cfg->bind_address);
#endif
if(rc>0) {
if(!cfg->quiet) {
if(rc == MOSQ_ERR_ERRNO) {
#ifndef WIN32
strerror_r(errno, err, 1024);
#else
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errno, 0, (LPTSTR)&err, 1024, NULL);
#endif
fprintf(stderr, "Error: %s\n", err);
} else {
fprintf(stderr, "Unable to connect (%d).\n", rc);
}
}
mosquitto_lib_cleanup();
return rc;
}
return MOSQ_ERR_SUCCESS;
}
int MqttHal_Uninit()
{
mosquitto_destroy(g_mosq);
mosquitto_lib_cleanup();
return 0;
}
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 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;
}
/* Loop until it is explicitly halted or the network is lost, then clean up. */
static int run_loop(struct client_info *info) {
int res = MOSQ_ERR_SUCCESS;
int i = 0;
char buf[1024];
memset(buf, 0, sizeof(buf));
do {
res = mosquitto_loop(info->m, -1, 1 /* unused */);
if (res != MOSQ_ERR_SUCCESS) break;
sleep(5);
memset(buf, 0, sizeof(buf));
sprintf(buf, "test_msg#%d\n", i++);
res = mosquitto_publish(info->m, &mid_sent, PUBLISH_TOPIC,
strlen(buf), buf, PUBLISH_MSG_QOS, 0);
}while(res == MOSQ_ERR_SUCCESS && connected);
mosquitto_destroy(info->m);
(void)mosquitto_lib_cleanup();
if (res == MOSQ_ERR_SUCCESS) {
return 0;
} else {
return 1;
}
}
void emit_close()
{
mosquitto_disconnect(config.mosq);
mosquitto_loop_stop(config.mosq, false);
mosquitto_destroy(config.mosq);
mosquitto_lib_cleanup();
}
/* You can only call this if you _setup() succeeded all the way!. */
void mosq_cleanup(struct _squash *st)
{
event_free(st->mosq_write);
event_free(st->mosq_readidle);
mosquitto_disconnect(st->mosq);
mosquitto_destroy(st->mosq);
mosquitto_lib_cleanup();
}
static
int
mosq_lib_cleanup(lua_State *L)
{
mosquitto_lib_cleanup();
mosq_initialized = false;
return make_mosq_status_result(L, MOSQ_ERR_SUCCESS);
}
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;
}
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 fatal(void)
{
if (m) {
mosquitto_disconnect(m);
mosquitto_loop_stop(m, false);
mosquitto_lib_cleanup();
}
exit(1);
}
void mqtt_exit(mqtt_t inst) {
int rval;
mosquitto_destroy(inst->mosq);
rval = mosquitto_lib_cleanup();
if (rval != MOSQ_ERR_SUCCESS) {
error("Cannot cleanup library: '%s'", mosquitto_strerror(rval));
}
}
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 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;
}
void catcher(int sig)
{
fprintf(stderr, "Going down on signal %d\n", sig);
if (m) {
mosquitto_disconnect(m);
mosquitto_loop_stop(m, false);
mosquitto_lib_cleanup();
}
exit(1);
}
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();
}
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 client_opts_set(struct mosquitto *mosq, struct mosq_config *cfg)
{
int rc;
if(cfg->will_topic && mosquitto_will_set(mosq, cfg->will_topic,
cfg->will_payloadlen, cfg->will_payload, cfg->will_qos,
cfg->will_retain)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting will.\n");
mosquitto_lib_cleanup();
return 1;
}
if(cfg->username && mosquitto_username_pw_set(mosq, cfg->username, cfg->password)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting username and password.\n");
mosquitto_lib_cleanup();
return 1;
}
#ifdef WITH_TLS
if((cfg->cafile || cfg->capath)
&& mosquitto_tls_set(mosq, cfg->cafile, cfg->capath, cfg->certfile, cfg->keyfile, NULL)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting TLS options.\n");
mosquitto_lib_cleanup();
return 1;
}
if(cfg->insecure && mosquitto_tls_insecure_set(mosq, true)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting TLS insecure option.\n");
mosquitto_lib_cleanup();
return 1;
}
# ifdef WITH_TLS_PSK
if(cfg->psk && mosquitto_tls_psk_set(mosq, cfg->psk, cfg->psk_identity, NULL)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting TLS-PSK options.\n");
mosquitto_lib_cleanup();
return 1;
}
# endif
if(cfg->tls_version && mosquitto_tls_opts_set(mosq, 1, cfg->tls_version, cfg->ciphers)) {
if(!cfg->quiet) fprintf(stderr, "Error: Problem setting TLS options.\n");
mosquitto_lib_cleanup();
return 1;
}
#endif
mosquitto_max_inflight_messages_set(mosq, cfg->max_inflight);
#ifdef WITH_SOCKS
if(cfg->socks5_host) {
rc = mosquitto_socks5_set(mosq, cfg->socks5_host, cfg->socks5_port, cfg->socks5_username, cfg->socks5_password);
if(rc) {
mosquitto_lib_cleanup();
return rc;
}
}
#endif
mosquitto_opts_set(mosq, MOSQ_OPT_PROTOCOL_VERSION, &(cfg->protocol_version));
return MOSQ_ERR_SUCCESS;
}
void MQTT_start_receiver_process() {
int rc;
do{
rc = mosquitto_loop(MQTT_mosq, -1);
}while(rc == MOSQ_ERR_SUCCESS);
printf("[MQTT] Error :%i\n", rc);
mosquitto_destroy(MQTT_mosq);
mosquitto_lib_cleanup();
}
void /*PORT_NAME*/_start_receiver_process() {
int rc;
do{
rc = mosquitto_loop(/*PORT_NAME*/_mosq, -1);
}while(rc == MOSQ_ERR_SUCCESS);
/*TRACE_LEVEL_1*/printf("[/*PORT_NAME*/] Error :%i\n", rc);
mosquitto_destroy(/*PORT_NAME*/_mosq);
mosquitto_lib_cleanup();
}
MosquittoHandler::~MosquittoHandler()
{
if(m_mosquittoStruct) {
mosquitto_destroy(m_mosquittoStruct);
m_mosquittoStruct = NULL;
}
numOfInstances--;
if(numOfInstances == 0 && m_libInit) {
mosquitto_lib_cleanup();
}
//std::cout << "Mosquitto cleaned" << std::endl;
}
// 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 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;
}
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;
}
/**
* Handles the signal from ctrl+C. Simple close the connection and close the file.
*/
void sig_handler(int sig) {
if( SIGINT != sig ) {
CRIT("Got unexpected signal.");
}
mosquitto_disconnect(config.mosq);
mosquitto_destroy(config.mosq);
mosquitto_lib_cleanup();
fclose(config.fd);
exit(0);
}
