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;
}
