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 int ctx_loop_write(lua_State *L) { ctx_t *ctx = ctx_check(L, 1); int max_packets = luaL_optinteger(L, 2, 1); int rc = mosquitto_loop_write(ctx->mosq, max_packets); return mosq__pstatus(L, rc); }
int main(int argc, char *argv[]) { struct mosquitto *mosq; int fd; bool clean_session = true; int keepalive = 60; mosq = mosquitto_new("packetgen", NULL); if(!mosq){ fprintf(stderr, "Error: Out of memory.\n"); return 1; } /* CONNECT */ fd = open("mqtt.connect", O_CREAT|O_WRONLY, 00644); if(fd<0){ fprintf(stderr, "Error: Unable to open mqtt.connect for writing.\n"); return 1; } mosq->core.sock = fd; printf("_mosquitto_send_connect(): %d\n", _mosquitto_send_connect(mosq, keepalive, clean_session)); printf("loop: %d\n", mosquitto_loop_write(mosq)); close(fd); /* SUBSCRIBE */ fd = open("mqtt.subscribe", O_CREAT|O_WRONLY, 00644); if(fd<0){ fprintf(stderr, "Error: Unable to open mqtt.subscribe for writing.\n"); return 1; } mosq->core.sock = fd; printf("_mosquitto_send_subscribe(): %d\n", _mosquitto_send_subscribe(mosq, NULL, false, "subscribe/topic", 2)); printf("loop: %d\n", mosquitto_loop_write(mosq)); close(fd); mosquitto_destroy(mosq); return 0; }
bool MosquittoHandler::loopWrite() { if(!m_mosquittoStruct) { m_lastErrorString = "Mosquitto not initialized"; return false; } int errorNum = mosquitto_loop_write(m_mosquittoStruct); if(errorNum != MOSQ_ERR_SUCCESS) { m_lastErrorString = errorByNum(errorNum); return false; } m_lastErrorString = ""; return true; }
void auth_mqtt_select_handle(fd_set *read_set, fd_set *write_set) { int fd = auth_mqtt_fd(); if (fd != INVALID_SOCKET) { if (FD_ISSET(fd, read_set)) { if (mosquitto_loop_read(auth_mqtt_mosq, 1) != 0) return; } if (FD_ISSET(fd, write_set)) { if (mosquitto_loop_write(auth_mqtt_mosq, 1) != 0) return; } } }
static int mqtt_write(void* userdata) { mqtt_t inst = (mqtt_t) userdata; int rval; rval = mosquitto_loop_write(inst->mosq, 1); switch (rval) { case MOSQ_ERR_SUCCESS: break; case MOSQ_ERR_NO_CONN: case MOSQ_ERR_CONN_LOST: break; case MOSQ_ERR_INVAL: case MOSQ_ERR_NOMEM: case MOSQ_ERR_PROTOCOL: case MOSQ_ERR_ERRNO: default: error("mosquitto_loop_write: %s", mosquitto_strerror(rval)); break; } return 0; }
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; }
static void mqtt_ev_cb(struct ev_loop *loop, ev_io *w, int revents) { ev_io_helper_t *watcher = (ev_io_helper_t *)w; mqtt_context_t *mqttctx = (mqtt_context_t *)watcher->userdata; if (EV_READ & revents) { if (MOSQ_ERR_SUCCESS != mosquitto_loop_read(mqttctx->mosq #if LIBMOSQUITTO_VERSION_NUMBER > 1000000 , 1 #endif )) { LOG_ERROR("read fail"); mqtt_disconnect(mqttctx); } } if (EV_WRITE & revents) { if (MOSQ_ERR_SUCCESS != mosquitto_loop_write(mqttctx->mosq #if LIBMOSQUITTO_VERSION_NUMBER > 1000000 , 1 #endif )) { LOG_ERROR("write fail"); mqtt_disconnect(mqttctx); } #if LIBMOSQUITTO_VERSION_NUMBER > 1000000 if (!mosquitto_want_write(mqttctx->mosq)) #endif ev_io_stop(g_srvctx.loop, &mqttctx->write_watcher.io); } }
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_write(int max_packets) { return mosquitto_loop_write(m_mosq, max_packets); }
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 mosquittopp::loop_write() { return mosquitto_loop_write(mosq); }
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; }