static int ctx_loop_misc(lua_State *L) { ctx_t *ctx = ctx_check(L, 1); int rc = mosquitto_loop_misc(ctx->mosq); return mosq__pstatus(L, rc); }
static void mosq_ev_io(evutil_socket_t fd, short what, void *arg) { (void)fd; int rc; struct _squash *st = arg; if (what & EV_READ) { rc = mosquitto_loop_read(st->mosq, 1); if (MOSQ_ERR_SUCCESS != rc) { mosq_reconnect(st); return; } } if (what & EV_TIMEOUT) { rc = mosquitto_loop_misc(st->mosq); if (MOSQ_ERR_SUCCESS != rc) { mosq_reconnect(st); return; } } if (what & EV_WRITE) { rc = mosquitto_loop_write(st->mosq, 1); if (MOSQ_ERR_SUCCESS != rc) { mosq_reconnect(st); return; } } /* Only get to here if the other routines passed ok */ if (mosquitto_want_write(st->mosq)) { event_add(st->mosq_write, NULL); } }
static void mqtt_misc(void* userdata) { mqtt_t inst = (mqtt_t) userdata; int rval; int fd; if (inst->connected == 0) { inst->reconnect_timer++; inst->reconnect_timer %= 20; if (inst->reconnect_timer == 0) { rval = mosquitto_reconnect(inst->mosq); if (rval != MOSQ_ERR_SUCCESS) { error("Cannot reconnect mosquitto: %s", mosquitto_strerror(rval)); } else { fd = mosquitto_socket(inst->mosq); assert(fd != 0); rval = dispatch_register(inst->dispatch, fd, mqtt_read, mqtt_write, NULL, mqtt_close, inst); assert(rval == 0); } } } rval = mosquitto_loop_misc(inst->mosq); switch (rval) { case MOSQ_ERR_SUCCESS: break; case MOSQ_ERR_NO_CONN: //debug("mosquitto_loop_misc: No connection"); break; case MOSQ_ERR_INVAL: default: error("mosquitto_loop_misc: %s", mosquitto_strerror(rval)); break; } }
void auth_mqtt_select_loop(void) { int ret = mosquitto_loop_misc(auth_mqtt_mosq); if (ret) { mosquitto_reconnect(auth_mqtt_mosq); } }
static void mqtt_timeout_cb(struct ev_loop *loop, struct ev_io *w, int revents) { ev_timer_helper_t *watcher = (ev_timer_helper_t *)w; mqtt_context_t *mqttctx = (mqtt_context_t *)watcher->userdata; if (EV_TIMEOUT & revents) { if (mqttctx->connected) { if (MOSQ_ERR_SUCCESS != mosquitto_loop_misc(mqttctx->mosq)) { LOG_ERROR("mosquitto_loop_misc fail"); mqtt_disconnect(mqttctx); } #if LIBMOSQUITTO_VERSION_NUMBER > 1000000 if (mosquitto_want_write(mqttctx->mosq)) #endif ev_io_start(g_srvctx.loop, &mqttctx->write_watcher.io); } } }
static int mosq_poll_one_ctx(mosq_t *ctx, int revents, size_t timeout, int max_packets) { /** XXX * I'm confused: socket < 0 means MOSQ_ERR_NO_CONN */ int rc = MOSQ_ERR_NO_CONN; int fd = mosquitto_socket(ctx->mosq); if (fd >= 0) { /** Wait until event */ revents = coio_wait(fd, revents, timeout); if (revents != 0) { if (revents & COIO_READ) rc = mosquitto_loop_read(ctx->mosq, max_packets); if (revents & COIO_WRITE) rc = mosquitto_loop_write(ctx->mosq, max_packets); } /** * mosquitto_loop_miss * This function deals with handling PINGs and checking * whether messages need to be retried, * so should be called fairly _frequently_(!). * */ if (ctx->next_misc_timeout < fiber_time64()) { rc = mosquitto_loop_misc(ctx->mosq); ctx->next_misc_timeout = fiber_time64() + 1200; } } return rc; }
int mosquitto_loop(struct mosquitto *mosq, int timeout, int max_packets) { #ifdef HAVE_PSELECT struct timespec local_timeout; #else struct timeval local_timeout; #endif fd_set readfds, writefds; int fdcount; int rc; char pairbuf; int maxfd = 0; if(!mosq || max_packets < 1) return MOSQ_ERR_INVAL; #ifndef WIN32 if(mosq->sock >= FD_SETSIZE || mosq->sockpairR >= FD_SETSIZE){ return MOSQ_ERR_INVAL; } #endif FD_ZERO(&readfds); FD_ZERO(&writefds); if(mosq->sock != INVALID_SOCKET){ maxfd = mosq->sock; FD_SET(mosq->sock, &readfds); pthread_mutex_lock(&mosq->current_out_packet_mutex); pthread_mutex_lock(&mosq->out_packet_mutex); if(mosq->out_packet || mosq->current_out_packet){ FD_SET(mosq->sock, &writefds); } #ifdef WITH_TLS if(mosq->ssl){ if(mosq->want_write){ FD_SET(mosq->sock, &writefds); mosq->want_write = false; }else if(mosq->want_connect){ /* Remove possible FD_SET from above, we don't want to check * for writing if we are still connecting, unless want_write is * definitely set. The presence of outgoing packets does not * matter yet. */ FD_CLR(mosq->sock, &writefds); } } #endif pthread_mutex_unlock(&mosq->out_packet_mutex); pthread_mutex_unlock(&mosq->current_out_packet_mutex); }else{ #ifdef WITH_SRV if(mosq->achan){ pthread_mutex_lock(&mosq->state_mutex); if(mosq->state == mosq_cs_connect_srv){ rc = ares_fds(mosq->achan, &readfds, &writefds); if(rc > maxfd){ maxfd = rc; } }else{ pthread_mutex_unlock(&mosq->state_mutex); return MOSQ_ERR_NO_CONN; } pthread_mutex_unlock(&mosq->state_mutex); } #else return MOSQ_ERR_NO_CONN; #endif } if(mosq->sockpairR != INVALID_SOCKET){ /* sockpairR is used to break out of select() before the timeout, on a * call to publish() etc. */ FD_SET(mosq->sockpairR, &readfds); if(mosq->sockpairR > maxfd){ maxfd = mosq->sockpairR; } } if(timeout >= 0){ local_timeout.tv_sec = timeout/1000; #ifdef HAVE_PSELECT local_timeout.tv_nsec = (timeout-local_timeout.tv_sec*1000)*1e6; #else local_timeout.tv_usec = (timeout-local_timeout.tv_sec*1000)*1000; #endif }else{ local_timeout.tv_sec = 1; #ifdef HAVE_PSELECT local_timeout.tv_nsec = 0; #else local_timeout.tv_usec = 0; #endif } #ifdef HAVE_PSELECT fdcount = pselect(maxfd+1, &readfds, &writefds, NULL, &local_timeout, NULL); #else fdcount = select(maxfd+1, &readfds, &writefds, NULL, &local_timeout); #endif if(fdcount == -1){ #ifdef WIN32 errno = WSAGetLastError(); #endif if(errno == EINTR){ return MOSQ_ERR_SUCCESS; }else{ return MOSQ_ERR_ERRNO; } }else{ if(mosq->sock != INVALID_SOCKET){ if(FD_ISSET(mosq->sock, &readfds)){ #ifdef WITH_TLS if(mosq->want_connect){ rc = mosquitto__socket_connect_tls(mosq); if(rc) return rc; }else #endif { do{ rc = mosquitto_loop_read(mosq, max_packets); if(rc || mosq->sock == INVALID_SOCKET){ return rc; } }while(SSL_DATA_PENDING(mosq)); } } if(mosq->sockpairR != INVALID_SOCKET && FD_ISSET(mosq->sockpairR, &readfds)){ #ifndef WIN32 if(read(mosq->sockpairR, &pairbuf, 1) == 0){ } #else recv(mosq->sockpairR, &pairbuf, 1, 0); #endif /* Fake write possible, to stimulate output write even though * we didn't ask for it, because at that point the publish or * other command wasn't present. */ FD_SET(mosq->sock, &writefds); } if(FD_ISSET(mosq->sock, &writefds)){ #ifdef WITH_TLS if(mosq->want_connect){ rc = mosquitto__socket_connect_tls(mosq); if(rc) return rc; }else #endif { rc = mosquitto_loop_write(mosq, max_packets); if(rc || mosq->sock == INVALID_SOCKET){ return rc; } } } } #ifdef WITH_SRV if(mosq->achan){ ares_process(mosq->achan, &readfds, &writefds); } #endif } return mosquitto_loop_misc(mosq); }
int mosquittopp::loop_misc() { return mosquitto_loop_misc(m_mosq); }
int mosquitto_loop(struct mosquitto *mosq, int timeout, int max_packets) { #ifdef HAVE_PSELECT struct timespec local_timeout; #else struct timeval local_timeout; #endif fd_set readfds, writefds; int fdcount; int rc; if(!mosq || max_packets < 1) return MOSQ_ERR_INVAL; if(mosq->sock == INVALID_SOCKET) return MOSQ_ERR_NO_CONN; FD_ZERO(&readfds); FD_SET(mosq->sock, &readfds); FD_ZERO(&writefds); pthread_mutex_lock(&mosq->out_packet_mutex); if(mosq->out_packet || mosq->current_out_packet) { FD_SET(mosq->sock, &writefds); #ifdef WITH_TLS } else if(mosq->ssl && mosq->want_write) { FD_SET(mosq->sock, &writefds); #endif } pthread_mutex_unlock(&mosq->out_packet_mutex); if(timeout >= 0) { local_timeout.tv_sec = timeout/1000; #ifdef HAVE_PSELECT local_timeout.tv_nsec = (timeout-local_timeout.tv_sec*1000)*1e6; #else local_timeout.tv_usec = (int)(timeout-local_timeout.tv_sec*1000)*1000; #endif } else { local_timeout.tv_sec = 1; #ifdef HAVE_PSELECT local_timeout.tv_nsec = 0; #else local_timeout.tv_usec = 0; #endif } #ifdef HAVE_PSELECT fdcount = pselect(mosq->sock+1, &readfds, &writefds, NULL, &local_timeout, NULL); #else fdcount = select(mosq->sock+1, &readfds, &writefds, NULL, &local_timeout); #endif if(fdcount == -1) { #ifdef WIN32 errno = WSAGetLastError(); #endif if(errno == EINTR) { return MOSQ_ERR_SUCCESS; } else { return MOSQ_ERR_ERRNO; } } else { if(FD_ISSET(mosq->sock, &readfds)) { rc = mosquitto_loop_read(mosq, max_packets); if(rc || mosq->sock == INVALID_SOCKET) { return rc; } } if(FD_ISSET(mosq->sock, &writefds)) { rc = mosquitto_loop_write(mosq, max_packets); if(rc || mosq->sock == INVALID_SOCKET) { return rc; } } } return mosquitto_loop_misc(mosq); }
int main(int argc, char *argv[]) { int pid, opt, ret, running, keepalive; int baudrate; bool clean_session; struct mosquitto *mosq = NULL; char uart[MAX_BUFFER]; char broker[MAX_BUFFER]; clean_session = true; running = 1; clean_session = true; background = 0; keepalive = 5; baudrate = 9600; memset(topic, 0, sizeof(topic)); memset(broker, 0, sizeof(broker)); memcpy(broker, mqtt_broker_host, strlen(mqtt_broker_host)); while ((opt = getopt(argc, argv, "b:d:s:t:fh?")) != -1) { switch (opt) { case 'd': strncpy(uart, optarg, sizeof(uart) - 1); break; case 's': baudrate = atoi(optarg); break; case 'b': strncpy(broker, optarg, sizeof(broker) - 1); break; case 't': strncpy(topic, optarg, sizeof(topic) - 1); break; case 'f': background = 1; break; case 'h': case '?': print_usage(basename(argv[0])); exit(EXIT_SUCCESS); break; default: fprintf(stderr, "Unknown option %c\n", opt); print_usage(basename(argv[0])); exit(EXIT_FAILURE); } } mosquitto_lib_init(); mosq = mosquitto_new(NULL, clean_session, NULL); if (!mosq) { fprintf(stderr, "Error: Out of memory.\n"); return (EXIT_FAILURE); } /* daemonize the process if requested */ if (background) { /* fork off the parent process */ pid = fork(); if (pid < 0) { exit(EXIT_FAILURE); } /* if we got a good PID, then we can exit the parent process */ if (pid > 0) { printf("Going into background ...\n"); exit(EXIT_SUCCESS); } } snprintf(topic_in, MAX_BUFFER - 3, "%s/in", topic); pfd[1].fd = openDevice(uart, serial_speed(baudrate)); if (pfd[1].fd <= 0) exit(EXIT_FAILURE); printf("open serial device fd : %d\n", pfd[1].fd); mosquitto_connect_callback_set(mosq, mqtt_cb_connect); mosquitto_message_callback_set(mosq, mqtt_cb_msg); mosquitto_subscribe_callback_set(mosq, mqtt_cb_subscribe); mosquitto_disconnect_callback_set(mosq, mqtt_cb_disconnect); if (!background) mosquitto_log_callback_set(mosq, mqtt_cb_log); // we try until we succeed, or we killed while (running) { if (mosquitto_connect(mosq, broker, mqtt_broker_port, keepalive)) { printf("Unable to connect, host: %s, port: %d\n", broker, mqtt_broker_port); sleep(2); continue; } break; } // pfd[0] is for the mosquitto socket, pfd[1] is for UART, or any // other file descriptor we need to handle // pfd[1].fd = 0; pfd[1].events = POLLIN; //these 2 won't change, so enough to set it once const int nfds = sizeof(pfd) / sizeof(struct pollfd); while (running) { // this might change (when reconnecting for example) // so better check it always int mosq_fd = mosquitto_socket(mosq); pfd[0].fd = mosq_fd; pfd[0].events = POLLIN; // we check whether libmosquitto wants to write, and if yes, we // also register the POLLOUT event for poll, so it will return // when it's possible to write to the socket. if (mosquitto_want_write(mosq)) { printf("Set POLLOUT\n"); pfd[0].events |= POLLOUT; } // we set the poll()-s timeout here to the half // of libmosquitto's keepalive value, to stay on the safe side if (poll(pfd, nfds, keepalive / 2 * 1000) < 0) { printf("Poll() failed with <%s>, exiting", strerror(errno)); return EXIT_FAILURE; } // first checking the mosquitto socket // if we supposed to write: if (pfd[0].revents & POLLOUT) { mosquitto_loop_write(mosq, 1); } // or read: if (pfd[0].revents & POLLIN) { ret = mosquitto_loop_read(mosq, 1); if (ret == MOSQ_ERR_CONN_LOST) { printf("reconnect...\n"); mosquitto_reconnect(mosq); } } // we call the misc() funtion in both cases mosquitto_loop_misc(mosq); // checking if there is data on the UART, if yes, reading it // and publish if (pfd[1].revents & POLLIN) { char input[64]; memset(input, 0, sizeof(input)); ret = read(pfd[1].fd, input, 64); if (ret < 0) { fprintf(stderr, "%s: read_error\n", __func__); exit(EXIT_FAILURE); } printf("%s: %s", uart, input); mosquitto_publish(mosq, NULL, topic_in, strlen(input), input, 0, false); } } mosquitto_destroy(mosq); mosquitto_lib_cleanup(); printf("bye\n"); return EXIT_SUCCESS; }
int mosquitto_loop(struct mosquitto *mosq, int timeout) { #ifdef HAVE_PSELECT struct timespec local_timeout; #else struct timeval local_timeout; #endif fd_set readfds, writefds; int fdcount; int rc; if(!mosq) return MOSQ_ERR_INVAL; if(mosq->sock == INVALID_SOCKET) return MOSQ_ERR_NO_CONN; FD_ZERO(&readfds); FD_SET(mosq->sock, &readfds); FD_ZERO(&writefds); if(mosq->out_packet){ FD_SET(mosq->sock, &writefds); #ifdef WITH_SSL }else if(mosq->ssl && mosq->ssl->want_write){ FD_SET(mosq->sock, &writefds); #endif } if(timeout >= 0){ local_timeout.tv_sec = timeout/1000; #ifdef HAVE_PSELECT local_timeout.tv_nsec = (timeout-local_timeout.tv_sec*1000)*1e6; #else local_timeout.tv_usec = (timeout-local_timeout.tv_sec*1000)*1000; #endif }else{ local_timeout.tv_sec = 1; #ifdef HAVE_PSELECT local_timeout.tv_nsec = 0; #else local_timeout.tv_usec = 0; #endif } #ifdef HAVE_PSELECT fdcount = pselect(mosq->sock+1, &readfds, &writefds, NULL, &local_timeout, NULL); #else fdcount = select(mosq->sock+1, &readfds, &writefds, NULL, &local_timeout); #endif if(fdcount == -1){ #ifdef WIN32 errno = WSAGetLastError(); #endif return MOSQ_ERR_ERRNO; }else{ if(FD_ISSET(mosq->sock, &readfds)){ rc = mosquitto_loop_read(mosq); if(rc){ _mosquitto_socket_close(mosq); if(mosq->state == mosq_cs_disconnecting){ rc = MOSQ_ERR_SUCCESS; } if(mosq->on_disconnect){ mosq->in_callback = true; mosq->on_disconnect(mosq->obj); mosq->in_callback = false; } return rc; } } if(FD_ISSET(mosq->sock, &writefds)){ rc = mosquitto_loop_write(mosq); if(rc){ _mosquitto_socket_close(mosq); if(mosq->state == mosq_cs_disconnecting){ rc = MOSQ_ERR_SUCCESS; } if(mosq->on_disconnect){ mosq->in_callback = true; mosq->on_disconnect(mosq->obj); mosq->in_callback = false; } return rc; } } } mosquitto_loop_misc(mosq); return MOSQ_ERR_SUCCESS; }
int main( int argc, char* argv[] ) { setbuf(stdout, NULL); INFO("%s v1.0\n", argv[0]); config_t cfg; global_data_t state; struct mosquitto *mosq = NULL; config_init(&cfg); loadDefaults(&cfg); loadSerialDefaults(&cfg); if(parseArgs(argc, argv, &cfg)) { exit(1); } if(parseSerialArgs(argc, argv, &cfg)) { exit(1); } //config_write(&cfg, stderr); port_t serial; loadSerial(&cfg, &serial); if(serial.name == NULL) { ERR("Could not load serial configuration\n"); exit(2); } if(!strlen(serial.name)) { ERR("You must specify the serial port\n"); exit(2); } DBG("Setting up serial port..."); state.arduino_fd = setupSerial(serial.name, serial.speed); if(state.arduino_fd < 0) { ERR("Failed to setup serial port %s @ %d\n", serial.name, serial.speed); exit(2); } INFO("listening for event on %s\n", serial.name); mosquitto_lib_init(); mqttserver_t mqtt; loadMQTT(&cfg, &mqtt); char hostname[BUF_MAX]; gethostname(hostname, BUF_MAX); asprintf(&state.client_id, "%s.%s", hostname, (char *) strlaststr(serial.name, "/")); mosq = mosquitto_new(state.client_id, true, &state.arduino_fd); //use port name as client id if(!mosq) { ERR("Couldn't create a new mosquitto client instance\n"); exit(3); } //TODO setup callbacks mosquitto_log_callback_set(mosq, log_callback); mosquitto_disconnect_callback_set(mosq, disconnect_callback); mosquitto_connect_callback_set(mosq, connect_callback); mosquitto_message_callback_set(mosq, message_callback); INFO("Connecting to %s:%d ... ", mqtt.servername, mqtt.port); if(mosquitto_connect(mosq, mqtt.servername, mqtt.port, mqtt.keepalive)){ ERR("\nUnable to connect to %s:%d.\n", mqtt.servername, mqtt.port); exit(3); } INFO("done\n"); int mosq_fd = mosquitto_socket(mosq); fd_set active_fd_set, read_fd_set; /* Initialize the set of active sockets. */ FD_ZERO (&active_fd_set); FD_SET (state.arduino_fd, &active_fd_set); FD_SET (mosq_fd, &active_fd_set); char buf[BUF_MAX]; bzero(buf,BUF_MAX); int retries = 0; //TODO setup syscall to stop process while(1) { /* Block until input arrives on one or more active sockets. */ read_fd_set = active_fd_set; if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0) { ERR("Error in select\n"); sleep(BACKOFF); int r = mosquitto_reconnect(mosq); retries++; if(r != MOSQ_ERR_SUCCESS) { ERR("Could not reconnect to broker: %s\n", strerror(r)); if(retries > MAX_RETRIES) { /* Cleanup */ mosquitto_destroy(mosq); mosquitto_lib_cleanup(); exit (EXIT_FAILURE); } } else { retries = 0; continue; } } /* Service all the sockets with input pending. */ int i; for (i = 0; i < FD_SETSIZE; ++i) if (FD_ISSET (i, &read_fd_set)) { if(i == state.arduino_fd) { if(!readSerial(state.arduino_fd, buf, BUF_MAX, serial.timeout)) { arduinoEvent(buf, &cfg, mosq); bzero(buf,BUF_MAX); } } else if(i == mosq_fd) { mosquitto_loop_read(mosq, 1); mosquitto_loop_write(mosq, 1); mosquitto_loop_misc(mosq); } } }; return EXIT_SUCCESS; }