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 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;
}
void
mloop(dispatch_data *dd) {
char id[30];
char *host = "130.102.128.123";
int port = 1883;
int keepalive = 60;
bool clean_session = true;
struct mosquitto *mosq = NULL;
local_dd = dd;
mosq = mosquitto_new(id, NULL);
if(!mosq){
fprintf(stderr, "Error: Out of memory.\n");
return;
}
mosq_instance=mosq;
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, clean_session)){
fprintf(stderr, "Unable to connect.\n");
return;
}
while(mosquitto_loop(mosq, -1) != -1){
}
mosquitto_destroy(mosq);
return;
}
/* {{{ Mosquitto\Client::loopForever() */
PHP_METHOD(Mosquitto_Client, loopForever)
{
mosquitto_client_object *object;
long timeout = 1000, max_packets = 1, retval = 0;
PHP_MOSQUITTO_ERROR_HANDLING();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll",
&timeout, &max_packets) == FAILURE) {
PHP_MOSQUITTO_RESTORE_ERRORS();
return;
}
PHP_MOSQUITTO_RESTORE_ERRORS();
object = (mosquitto_client_object *) mosquitto_client_object_get(getThis() TSRMLS_CC);
object->looping = 1;
while (object->looping) {
retval = mosquitto_loop(object->client, timeout, max_packets);
php_mosquitto_handle_errno(retval, errno TSRMLS_CC);
if (EG(exception)) {
break;
}
}
}
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 mosquitto_loop_forever(struct mosquitto *mosq, int timeout, int max_packets)
{
int run = 1;
int rc;
unsigned int reconnects = 0;
unsigned long reconnect_delay;
if(!mosq) return MOSQ_ERR_INVAL;
if(mosq->state == mosq_cs_connect_async){
mosquitto_reconnect(mosq);
}
while(run){
do{
rc = mosquitto_loop(mosq, timeout, max_packets);
if (reconnects !=0 && rc == MOSQ_ERR_SUCCESS){
reconnects = 0;
}
}while(rc == MOSQ_ERR_SUCCESS);
if(errno == EPROTO){
return rc;
}
pthread_mutex_lock(&mosq->state_mutex);
if(mosq->state == mosq_cs_disconnecting){
run = 0;
pthread_mutex_unlock(&mosq->state_mutex);
}else{
pthread_mutex_unlock(&mosq->state_mutex);
if(mosq->reconnect_delay > 0 && mosq->reconnect_exponential_backoff){
reconnect_delay = mosq->reconnect_delay*reconnects*reconnects;
}else{
reconnect_delay = mosq->reconnect_delay;
}
if(reconnect_delay > mosq->reconnect_delay_max){
reconnect_delay = mosq->reconnect_delay_max;
}else{
reconnects++;
}
#ifdef WIN32
Sleep(reconnect_delay*1000);
#else
sleep(reconnect_delay);
#endif
pthread_mutex_lock(&mosq->state_mutex);
if(mosq->state == mosq_cs_disconnecting){
run = 0;
pthread_mutex_unlock(&mosq->state_mutex);
}else{
pthread_mutex_unlock(&mosq->state_mutex);
mosquitto_reconnect(mosq);
}
}
}
return rc;
}
/* 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;
}
}
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;
}
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();
}
void run_tasks() {
mosquitto_loop(mosq, -1);
// anything else we like here....
time_t tt = time(NULL);
if ((long int) tt > last_message_time + 2) {
last_message_time = tt;
send_insecure_message(tt);
send_signed_message(tt, key);
}
sleep(1);
}
static int mosq_loop(lua_State *L, bool forever)
{
ctx_t *ctx = ctx_check(L, 1);
int timeout = luaL_optinteger(L, 2, -1);
int max_packets = luaL_optinteger(L, 3, 1);
int rc;
if (forever) {
rc = mosquitto_loop_forever(ctx->mosq, timeout, max_packets);
} else {
rc = mosquitto_loop(ctx->mosq, timeout, max_packets);
}
return mosq__pstatus(L, rc);
}
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;
}
bool MosquittoHandler::loop()
{
if(!m_mosquittoStruct)
{
m_lastErrorString = "Mosquitto not initialized";
return false;
}
int errorNum = mosquitto_loop(m_mosquittoStruct, 0);
if(errorNum != MOSQ_ERR_SUCCESS) {
m_lastErrorString = errorByNum(errorNum);
return false;
}
m_lastErrorString = "";
return true;
}
static bool runForever(MqttMount *mount) {
const int timeoutMs = 10;
while(1){
const int status = mosquitto_loop(mount->connection, timeoutMs, 1);
if (status == MOSQ_ERR_CONN_LOST) {
mount->connect();
} else if (status == MOSQ_ERR_SUCCESS) {
// Run MicroFlo network
for (int i=0; i<20; i++) {
mount->network->runTick();
}
} else {
LOG("mosquitto loop error: %s\n", mosquitto_strerror(status));
return false;
}
}
return true;
}
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;
}
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;
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
int port = atoi(argv[1]);
mosquitto_lib_init();
mosq = mosquitto_new("unsubscribe-test", true, NULL);
mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_disconnect_callback_set(mosq, on_disconnect);
mosquitto_unsubscribe_callback_set(mosq, on_unsubscribe);
rc = mosquitto_connect(mosq, "localhost", port, 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("08-tls-psk-pub", true, NULL);
rc = mosquitto_tls_psk_set(mosq, "deadbeef", "psk-id", NULL);
if(rc) return rc;
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_disconnect_callback_set(mosq, on_disconnect);
mosquitto_publish_callback_set(mosq, on_publish);
rc = mosquitto_connect(mosq, "localhost", 1888, 60);
if(rc) return rc;
while(run == -1){
mosquitto_loop(mosq, -1, 1);
}
mosquitto_lib_cleanup();
return run;
}
int main(int argc, char *argv[])
{
int rc;
struct mosquitto *mosq;
int port = atoi(argv[1]);
mosquitto_lib_init();
mosq = mosquitto_new("publish-qos2-test", true, &run);
mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_disconnect_callback_set(mosq, on_disconnect);
mosquitto_message_callback_set(mosq, on_message);
rc = mosquitto_connect(mosq, "localhost", port, 60);
while(run == -1){
mosquitto_loop(mosq, 100, 1);
}
mosquitto_lib_cleanup();
return run;
}
int mosquitto_loop_forever(struct mosquitto *mosq, int timeout, int max_packets)
{
int run = 1;
int rc;
unsigned int reconnects = 0;
unsigned long reconnect_delay;
if(!mosq) return MOSQ_ERR_INVAL;
if(mosq->state == mosq_cs_connect_async){
mosquitto_reconnect(mosq);
}
while(run){
do{
rc = mosquitto_loop(mosq, timeout, max_packets);
if (reconnects !=0 && rc == MOSQ_ERR_SUCCESS){
reconnects = 0;
}
}while(run && rc == MOSQ_ERR_SUCCESS);
/* Quit after fatal errors. */
switch(rc){
case MOSQ_ERR_NOMEM:
case MOSQ_ERR_PROTOCOL:
case MOSQ_ERR_INVAL:
case MOSQ_ERR_NOT_FOUND:
case MOSQ_ERR_TLS:
case MOSQ_ERR_PAYLOAD_SIZE:
case MOSQ_ERR_NOT_SUPPORTED:
case MOSQ_ERR_AUTH:
case MOSQ_ERR_ACL_DENIED:
case MOSQ_ERR_UNKNOWN:
case MOSQ_ERR_EAI:
case MOSQ_ERR_PROXY:
return rc;
case MOSQ_ERR_ERRNO:
break;
}
if(errno == EPROTO){
return rc;
}
do{
rc = MOSQ_ERR_SUCCESS;
pthread_mutex_lock(&mosq->state_mutex);
if(mosq->state == mosq_cs_disconnecting){
run = 0;
pthread_mutex_unlock(&mosq->state_mutex);
}else{
pthread_mutex_unlock(&mosq->state_mutex);
if(mosq->reconnect_delay > 0 && mosq->reconnect_exponential_backoff){
reconnect_delay = mosq->reconnect_delay*reconnects*reconnects;
}else{
reconnect_delay = mosq->reconnect_delay;
}
if(reconnect_delay > mosq->reconnect_delay_max){
reconnect_delay = mosq->reconnect_delay_max;
}else{
reconnects++;
}
#ifdef WIN32
Sleep(reconnect_delay*1000);
#else
sleep(reconnect_delay);
#endif
pthread_mutex_lock(&mosq->state_mutex);
if(mosq->state == mosq_cs_disconnecting){
run = 0;
pthread_mutex_unlock(&mosq->state_mutex);
}else{
pthread_mutex_unlock(&mosq->state_mutex);
rc = mosquitto_reconnect(mosq);
}
}
}while(run && rc != MOSQ_ERR_SUCCESS);
}
return rc;
}
int mosquittopp::loop(int timeout, int max_packets)
{
return mosquitto_loop(m_mosq, timeout, max_packets);
}
int
main(int argc, char *argv[])
{
int opt;
int rc = 0;
struct mosquitto *mosq = NULL;
luzz_mqtt_t mqtt = {
.host = "localhost",
.port = 1883,
.keepalive = 60,
.id = NULL,
.clean_session = true,
.timeout = 0,
.max_packets = 1,
.mid = NULL,
.topic = NULL,
.qos = 0,
.retain = 0,
};
luzz_ctx_t ctx = {
.mqttp = &mqtt,
.panel = 0,
.num_leds = 4,
.fps = 2,
.framep = NULL,
.rt_prio = -1,
.memlock = -1,
};
while ((opt = getopt(argc, argv, "h:p:i:n:r:P:M")) != -1) {
switch (opt) {
case 'h':
mqtt.host = optarg;
break;
case 'p':
mqtt.port = atoi(optarg);
break;
case 'i':
ctx.panel = atoi(optarg);
break;
case 'n':
ctx.num_leds = atoi(optarg);
break;
case 'r':
ctx.fps = atoi(optarg);
break;
case 'P':
ctx.rt_prio = atoi(optarg);
break;
case 'M':
ctx.memlock = 1;
break;
default:
luzz_gen_usage(&ctx);
goto finish;
}
}
struct sched_param sched = {
.sched_priority = ctx.rt_prio
};
if (ctx.rt_prio > -1 && sched_setscheduler(0, SCHED_FIFO, &sched) == -1) {
perror("rt_prio");
goto finish;
}
if (ctx.memlock > -1 && mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
perror("memlock");
goto finish;
}
int i = 0;
bool red = true;
struct timespec ts_remain;
struct timespec ts_request = {
.tv_sec = 0,
.tv_nsec = 1e9 / ctx.fps
};
ctx.framep = calloc(ctx.num_leds, sizeof(luzz_grb_t));
if (ctx.framep == NULL) {
goto oom;
}
mosquitto_lib_init();
if (uname(&ctx.uts) < 0) {
perror("uname");
goto finish;
}
if ((rc = asprintf(&mqtt.id, LUZZ_GEN_ID_TPL,
LUZZ_VERSION, ctx.uts.nodename, getpid())) < 0) {
goto oom;
}
mosq = mosquitto_new(mqtt.id, mqtt.clean_session, &ctx);
if (!mosq) {
switch (errno) {
case ENOMEM:
rc = 1;
goto oom;
case EINVAL:
fprintf(stderr, "mosq_new: Invalid id and/or clean_session.\n");
rc = 1;
goto finish;
}
}
mosquitto_connect(mosq, mqtt.host, mqtt.port, mqtt.keepalive);
if ((rc = asprintf(&mqtt.topic, LUZZ_TOPIC_TPL, ctx.panel)) < 0) {
goto oom;
}
while (true) {
((luzz_rgb_t *)ctx.framep + i++)->r = red ? 0xFF : 0x00;
if (i == ctx.num_leds - 1) {
i = 0;
red = !red;
}
mosquitto_publish(mosq, mqtt.mid, mqtt.topic, sizeof(luzz_rgb_t) * ctx.num_leds,
(const void *)ctx.framep, mqtt.qos, mqtt.retain);
while ((rc = mosquitto_loop(mosq,
mqtt.timeout, mqtt.max_packets)) != MOSQ_ERR_SUCCESS) {
switch (rc) {
case MOSQ_ERR_INVAL:
fprintf(stderr, "mosq_loop: Invalid input parameters.\n");
goto finish;
case MOSQ_ERR_NOMEM:
goto oom;
case MOSQ_ERR_PROTOCOL:
fprintf(stderr, "mosq_loop: MQTT Protocol error.\n");
goto finish;
case MOSQ_ERR_ERRNO:
perror("mosq_loop");
goto finish;
case MOSQ_ERR_NO_CONN:
fprintf(stderr, "mosq_loop: No broker connection.\n");
break;
case MOSQ_ERR_CONN_LOST:
fprintf(stderr, "mosq_loop: Connection to broker was lost.\n");
break;
}
sleep(1);
mosquitto_reconnect(mosq);
}
nanosleep(&ts_request, &ts_remain);
}
oom:
fprintf(stderr, "error: Out of memory.\n");
finish:
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
return rc;
}
int main(int argc, char *argv[])
{
struct mosq_config cfg;
char buf[1024];
struct mosquitto *mosq = NULL;
int rc;
int rc2;
rc = client_config_load(&cfg, CLIENT_PUB, argc, argv);
if(rc){
client_config_cleanup(&cfg);
if(rc == 2){
/* --help */
print_usage();
}else{
fprintf(stderr, "\nUse 'mosquitto_pub --help' to see usage.\n");
}
return 1;
}
topic = cfg.topic;
message = cfg.message;
msglen = cfg.msglen;
qos = cfg.qos;
retain = cfg.retain;
mode = cfg.pub_mode;
username = cfg.username;
password = cfg.password;
quiet = cfg.quiet;
if(cfg.pub_mode == MSGMODE_STDIN_FILE){
if(load_stdin()){
fprintf(stderr, "Error loading input from stdin.\n");
return 1;
}
}else if(cfg.file_input){
if(load_file(cfg.file_input)){
fprintf(stderr, "Error loading input file \"%s\".\n", cfg.file_input);
return 1;
}
}
if(!topic || mode == MSGMODE_NONE){
fprintf(stderr, "Error: Both topic and message must be supplied.\n");
print_usage();
return 1;
}
mosquitto_lib_init();
if(client_id_generate(&cfg, "mosqpub")){
return 1;
}
mosq = mosquitto_new(cfg.id, true, NULL);
if(!mosq){
switch(errno){
case ENOMEM:
if(!quiet) fprintf(stderr, "Error: Out of memory.\n");
break;
case EINVAL:
if(!quiet) fprintf(stderr, "Error: Invalid id.\n");
break;
}
mosquitto_lib_cleanup();
return 1;
}
if(cfg.debug){
mosquitto_log_callback_set(mosq, my_log_callback);
}
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_disconnect_callback_set(mosq, my_disconnect_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
if(client_opts_set(mosq, &cfg)){
return 1;
}
rc = client_connect(mosq, &cfg);
if(rc) return rc;
if(mode == MSGMODE_STDIN_LINE){
mosquitto_loop_start(mosq);
}
do{
if(mode == MSGMODE_STDIN_LINE){
if(status == STATUS_CONNACK_RECVD){
if(fgets(buf, 1024, stdin)){
buf[strlen(buf)-1] = '\0';
rc2 = mosquitto_publish(mosq, &mid_sent, topic, strlen(buf), buf, qos, retain);
if(rc2){
if(!quiet) fprintf(stderr, "Error: Publish returned %d, disconnecting.\n", rc2);
mosquitto_disconnect(mosq);
}
}else if(feof(stdin)){
last_mid = mid_sent;
status = STATUS_WAITING;
}
}else if(status == STATUS_WAITING){
if(last_mid_sent == last_mid && disconnect_sent == false){
mosquitto_disconnect(mosq);
disconnect_sent = true;
}
#ifdef WIN32
Sleep(100);
#else
usleep(100000);
#endif
}
rc = MOSQ_ERR_SUCCESS;
}else{
rc = mosquitto_loop(mosq, -1, 1);
}
}while(rc == MOSQ_ERR_SUCCESS && connected);
if(mode == MSGMODE_STDIN_LINE){
mosquitto_loop_stop(mosq, false);
}
if(message && mode == MSGMODE_FILE){
free(message);
}
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
if(rc){
fprintf(stderr, "Error: %s\n", mosquitto_strerror(rc));
}
return rc;
}
int main(int argc, char *argv[])
{
char *id = NULL;
char *id_prefix = NULL;
int i;
char *host = "localhost";
int port = 1883;
int keepalive = 60;
char buf[1024];
bool debug = false;
struct mosquitto *mosq = NULL;
int rc;
int rc2;
char hostname[256];
char err[1024];
int len;
char *will_payload = NULL;
long will_payloadlen = 0;
int will_qos = 0;
bool will_retain = false;
char *will_topic = NULL;
char *cafile = NULL;
char *capath = NULL;
char *certfile = NULL;
char *keyfile = NULL;
char *psk = NULL;
char *psk_identity = NULL;
for(i=1; i<argc; i++){
if(!strcmp(argv[i], "-p") || !strcmp(argv[i], "--port")){
if(i==argc-1){
fprintf(stderr, "Error: -p argument given but no port specified.\n\n");
print_usage();
return 1;
}else{
port = atoi(argv[i+1]);
if(port<1 || port>65535){
fprintf(stderr, "Error: Invalid port given: %d\n", port);
print_usage();
return 1;
}
}
i++;
}else if(!strcmp(argv[i], "--cafile")){
if(i==argc-1){
fprintf(stderr, "Error: --cafile argument given but no file specified.\n\n");
print_usage();
return 1;
}else{
cafile = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--capath")){
if(i==argc-1){
fprintf(stderr, "Error: --capath argument given but no directory specified.\n\n");
print_usage();
return 1;
}else{
capath = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--cert")){
if(i==argc-1){
fprintf(stderr, "Error: --cert argument given but no file specified.\n\n");
print_usage();
return 1;
}else{
certfile = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")){
debug = true;
}else if(!strcmp(argv[i], "-f") || !strcmp(argv[i], "--file")){
if(mode != MSGMODE_NONE){
fprintf(stderr, "Error: Only one type of message can be sent at once.\n\n");
print_usage();
return 1;
}else if(i==argc-1){
fprintf(stderr, "Error: -f argument given but no file specified.\n\n");
print_usage();
return 1;
}else{
if(load_file(argv[i+1])) return 1;
}
i++;
}else if(!strcmp(argv[i], "--help")){
print_usage();
return 0;
}else if(!strcmp(argv[i], "-h") || !strcmp(argv[i], "--host")){
if(i==argc-1){
fprintf(stderr, "Error: -h argument given but no host specified.\n\n");
print_usage();
return 1;
}else{
host = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-i") || !strcmp(argv[i], "--id")){
if(id_prefix){
fprintf(stderr, "Error: -i and -I argument cannot be used together.\n\n");
print_usage();
return 1;
}
if(i==argc-1){
fprintf(stderr, "Error: -i argument given but no id specified.\n\n");
print_usage();
return 1;
}else{
id = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-I") || !strcmp(argv[i], "--id-prefix")){
if(id){
fprintf(stderr, "Error: -i and -I argument cannot be used together.\n\n");
print_usage();
return 1;
}
if(i==argc-1){
fprintf(stderr, "Error: -I argument given but no id prefix specified.\n\n");
print_usage();
return 1;
}else{
id_prefix = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--key")){
if(i==argc-1){
fprintf(stderr, "Error: --key argument given but no file specified.\n\n");
print_usage();
return 1;
}else{
keyfile = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-l") || !strcmp(argv[i], "--stdin-line")){
if(mode != MSGMODE_NONE){
fprintf(stderr, "Error: Only one type of message can be sent at once.\n\n");
print_usage();
return 1;
}else{
mode = MSGMODE_STDIN_LINE;
}
}else if(!strcmp(argv[i], "-m") || !strcmp(argv[i], "--message")){
if(mode != MSGMODE_NONE){
fprintf(stderr, "Error: Only one type of message can be sent at once.\n\n");
print_usage();
return 1;
}else if(i==argc-1){
fprintf(stderr, "Error: -m argument given but no message specified.\n\n");
print_usage();
return 1;
}else{
message = argv[i+1];
msglen = strlen(message);
mode = MSGMODE_CMD;
}
i++;
}else if(!strcmp(argv[i], "-n") || !strcmp(argv[i], "--null-message")){
if(mode != MSGMODE_NONE){
fprintf(stderr, "Error: Only one type of message can be sent at once.\n\n");
print_usage();
return 1;
}else{
mode = MSGMODE_NULL;
}
}else if(!strcmp(argv[i], "--psk")){
if(i==argc-1){
fprintf(stderr, "Error: --psk argument given but no key specified.\n\n");
print_usage();
return 1;
}else{
psk = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--psk-identity")){
if(i==argc-1){
fprintf(stderr, "Error: --psk-identity argument given but no identity specified.\n\n");
print_usage();
return 1;
}else{
psk_identity = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-q") || !strcmp(argv[i], "--qos")){
if(i==argc-1){
fprintf(stderr, "Error: -q argument given but no QoS specified.\n\n");
print_usage();
return 1;
}else{
qos = atoi(argv[i+1]);
if(qos<0 || qos>2){
fprintf(stderr, "Error: Invalid QoS given: %d\n", qos);
print_usage();
return 1;
}
}
i++;
}else if(!strcmp(argv[i], "--quiet")){
quiet = true;
}else if(!strcmp(argv[i], "-r") || !strcmp(argv[i], "--retain")){
retain = 1;
}else if(!strcmp(argv[i], "-s") || !strcmp(argv[i], "--stdin-file")){
if(mode != MSGMODE_NONE){
fprintf(stderr, "Error: Only one type of message can be sent at once.\n\n");
print_usage();
return 1;
}else{
if(load_stdin()) return 1;
}
}else if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--topic")){
if(i==argc-1){
fprintf(stderr, "Error: -t argument given but no topic specified.\n\n");
print_usage();
return 1;
}else{
topic = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-u") || !strcmp(argv[i], "--username")){
if(i==argc-1){
fprintf(stderr, "Error: -u argument given but no username specified.\n\n");
print_usage();
return 1;
}else{
username = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "-P") || !strcmp(argv[i], "--pw")){
if(i==argc-1){
fprintf(stderr, "Error: -P argument given but no password specified.\n\n");
print_usage();
return 1;
}else{
password = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--will-payload")){
if(i==argc-1){
fprintf(stderr, "Error: --will-payload argument given but no will payload specified.\n\n");
print_usage();
return 1;
}else{
will_payload = argv[i+1];
will_payloadlen = strlen(will_payload);
}
i++;
}else if(!strcmp(argv[i], "--will-qos")){
if(i==argc-1){
fprintf(stderr, "Error: --will-qos argument given but no will QoS specified.\n\n");
print_usage();
return 1;
}else{
will_qos = atoi(argv[i+1]);
if(will_qos < 0 || will_qos > 2){
fprintf(stderr, "Error: Invalid will QoS %d.\n\n", will_qos);
return 1;
}
}
i++;
}else if(!strcmp(argv[i], "--will-retain")){
will_retain = true;
}else if(!strcmp(argv[i], "--will-topic")){
if(i==argc-1){
fprintf(stderr, "Error: --will-topic argument given but no will topic specified.\n\n");
print_usage();
return 1;
}else{
will_topic = argv[i+1];
}
i++;
}else{
fprintf(stderr, "Error: Unknown option '%s'.\n",argv[i]);
print_usage();
return 1;
}
}
if(!topic || mode == MSGMODE_NONE){
fprintf(stderr, "Error: Both topic and message must be supplied.\n");
print_usage();
return 1;
}
if(will_payload && !will_topic){
fprintf(stderr, "Error: Will payload given, but no will topic given.\n");
print_usage();
return 1;
}
if(will_retain && !will_topic){
fprintf(stderr, "Error: Will retain given, but no will topic given.\n");
print_usage();
return 1;
}
if(password && !username){
if(!quiet) fprintf(stderr, "Warning: Not using password since username not set.\n");
}
if((certfile && !keyfile) || (keyfile && !certfile)){
fprintf(stderr, "Error: Both certfile and keyfile must be provided if one of them is.\n");
print_usage();
return 1;
}
if((cafile || capath) && psk){
if(!quiet) fprintf(stderr, "Error: Only one of --psk or --cafile/--capath may be used at once.\n");
return 1;
}
if(psk && !psk_identity){
if(!quiet) fprintf(stderr, "Error: --psk-identity required if --psk used.\n");
return 1;
}
mosquitto_lib_init();
if(id_prefix){
id = malloc(strlen(id_prefix)+10);
if(!id){
if(!quiet) fprintf(stderr, "Error: Out of memory.\n");
mosquitto_lib_cleanup();
return 1;
}
snprintf(id, strlen(id_prefix)+10, "%s%d", id_prefix, getpid());
}else if(!id){
hostname[0] = '\0';
gethostname(hostname, 256);
hostname[255] = '\0';
len = strlen("mosqpub/-") + 6 + strlen(hostname);
id = malloc(len);
if(!id){
if(!quiet) fprintf(stderr, "Error: Out of memory.\n");
mosquitto_lib_cleanup();
return 1;
}
snprintf(id, len, "mosqpub/%d-%s", getpid(), hostname);
if(strlen(id) > MOSQ_MQTT_ID_MAX_LENGTH){
/* Enforce maximum client id length of 23 characters */
id[MOSQ_MQTT_ID_MAX_LENGTH] = '\0';
}
}
mosq = mosquitto_new(id, true, NULL);
if(!mosq){
switch(errno){
case ENOMEM:
if(!quiet) fprintf(stderr, "Error: Out of memory.\n");
break;
case EINVAL:
if(!quiet) fprintf(stderr, "Error: Invalid id.\n");
break;
}
mosquitto_lib_cleanup();
return 1;
}
if(debug){
mosquitto_log_callback_set(mosq, my_log_callback);
}
if(will_topic && mosquitto_will_set(mosq, will_topic, will_payloadlen, will_payload, will_qos, will_retain)){
if(!quiet) fprintf(stderr, "Error: Problem setting will.\n");
mosquitto_lib_cleanup();
return 1;
}
if(username && mosquitto_username_pw_set(mosq, username, password)){
if(!quiet) fprintf(stderr, "Error: Problem setting username and password.\n");
mosquitto_lib_cleanup();
return 1;
}
if((cafile || capath) && mosquitto_tls_set(mosq, cafile, capath, certfile, keyfile, NULL)){
if(!quiet) fprintf(stderr, "Error: Problem setting TLS options.\n");
mosquitto_lib_cleanup();
return 1;
}
if(psk && mosquitto_tls_psk_set(mosq, psk, psk_identity, NULL)){
if(!quiet) fprintf(stderr, "Error: Problem setting TLS-PSK options.\n");
mosquitto_lib_cleanup();
return 1;
}
mosquitto_connect_callback_set(mosq, my_connect_callback);
mosquitto_disconnect_callback_set(mosq, my_disconnect_callback);
mosquitto_publish_callback_set(mosq, my_publish_callback);
rc = mosquitto_connect(mosq, host, port, keepalive);
if(rc){
if(!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;
}
if(mode == MSGMODE_STDIN_LINE){
mosquitto_loop_start(mosq);
}
do{
if(mode == MSGMODE_STDIN_LINE){
if(status == STATUS_CONNACK_RECVD){
if(fgets(buf, 1024, stdin)){
buf[strlen(buf)-1] = '\0';
rc2 = mosquitto_publish(mosq, &mid_sent, topic, strlen(buf), buf, qos, retain);
if(rc2){
if(!quiet) fprintf(stderr, "Error: Publish returned %d, disconnecting.\n", rc2);
mosquitto_disconnect(mosq);
}
}else if(feof(stdin)){
last_mid = mid_sent;
status = STATUS_WAITING;
}
}else if(status == STATUS_WAITING){
#ifdef WIN32
Sleep(1000);
#else
usleep(1000000);
#endif
}
rc = MOSQ_ERR_SUCCESS;
}else{
rc = mosquitto_loop(mosq, -1, 1);
}
}while(rc == MOSQ_ERR_SUCCESS && connected);
if(mode == MSGMODE_STDIN_LINE){
mosquitto_loop_stop(mosq, false);
}
if(message && mode == MSGMODE_FILE){
free(message);
}
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
if(rc){
if(rc == MOSQ_ERR_ERRNO){
fprintf(stderr, "Error: %s\n", strerror(errno));
}else{
fprintf(stderr, "Error: %s\n", mosquitto_strerror(rc));
}
}
return rc;
}
int mosquitto_loop_forever(struct mosquitto *mosq, int timeout, int max_packets)
{
int run = 1;
int rc;
if(!mosq) return MOSQ_ERR_INVAL;
if(mosq->state == mosq_cs_connect_async) {
mosquitto_reconnect(mosq);
}
while(run) {
do {
rc = mosquitto_loop(mosq, timeout, max_packets);
} while(rc == MOSQ_ERR_SUCCESS);
if(errno == EPROTO) {
return rc;
}
if(mosq->state == mosq_cs_disconnecting) {
run = 0;
} else {
#ifdef WIN32
Sleep(1000);
#else
sleep(1);
#endif
mosquitto_reconnect(mosq);
}
}
return rc;
}
