Exemplo n.º 1
0
Arquivo: mqtt.c Projeto: dsmrd/dsmrd
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;
    }
}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
0
/* {{{ Mosquitto\Client::getSocket() */
PHP_METHOD(Mosquitto_Client, getSocket)
{
	mosquitto_client_object *object;

	PHP_MOSQUITTO_ERROR_HANDLING();
	if (zend_parse_parameters_none()  == FAILURE) {
		PHP_MOSQUITTO_RESTORE_ERRORS();
		return;
	}
	PHP_MOSQUITTO_RESTORE_ERRORS();

	object = (mosquitto_client_object *) mosquitto_client_object_get(getThis() TSRMLS_CC);
	RETURN_LONG(mosquitto_socket(object->client));
}
bool MosquittoHandler::getSocket(int &socket)
{
    if(!m_mosquittoStruct) {
        m_lastErrorString = "Mosquitto not initialized";
        return false;
    }
    int sock = mosquitto_socket(m_mosquittoStruct);
    if(sock == -1) {
        m_lastErrorString = "Socket error";
        return false;
    }
    socket = sock;
    return true;
}
Exemplo n.º 5
0
static int ctx_socket(lua_State *L)
{
	ctx_t *ctx = ctx_check(L, 1);

	int fd = mosquitto_socket(ctx->mosq);
	switch (fd) {
		case -1:
			lua_pushboolean(L, false);
			break;
		default:
			lua_pushinteger(L, fd);
			break;
	}

	return 1;
}
Exemplo n.º 6
0
Arquivo: mqtt.c Projeto: dsmrd/dsmrd
int mqtt_open(mqtt_t inst, dispatch_t d, const char* name, const char* host, int port, int keepalive) {
    int rval = -1;
    int fd;

    inst->mosq = mosquitto_new(name, true, inst);
    if (inst->mosq == NULL) {
        error("Cannot create mqtt");
    } else {
        inst->dispatch = d;

        mosquitto_log_callback_set(inst->mosq, on_log);
        mosquitto_connect_callback_set(inst->mosq, on_connect);
        mosquitto_disconnect_callback_set(inst->mosq, on_disconnect);
        mosquitto_publish_callback_set(inst->mosq, on_publish);
        mosquitto_message_callback_set(inst->mosq, on_message);
        mosquitto_subscribe_callback_set(inst->mosq, on_subscribe);
        mosquitto_unsubscribe_callback_set(inst->mosq, on_unsubscribe);

        inst->timer = dispatch_create_timer(d, 2000000, mqtt_misc, inst);
        if (inst->timer == NULL) {
            error("Cannot create timer");
        }

        rval = mosquitto_connect(inst->mosq, host, port, keepalive);
        if (rval != MOSQ_ERR_SUCCESS) {
            error("Cannot connect mqtt");
        } else {
            fd = mosquitto_socket(inst->mosq);

            rval = dispatch_register(d, fd, mqtt_read, mqtt_write, NULL, mqtt_close, inst);
            if (rval != 0) {
                error("Cannot register mqtt");
            }
        }
    }

    return rval;
}
Exemplo n.º 7
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;
}
Exemplo n.º 8
0
int mosquittopp::socket()
{
	return mosquitto_socket(m_mosq);
}
Exemplo n.º 9
0
int auth_mqtt_fd(void)
{
	if (auth_mqtt_mosq)
		return mosquitto_socket(auth_mqtt_mosq);
	return -1;
}
Exemplo n.º 10
0
int run_subscriber(int argc, char* const argv[])
//int main(int argc, char* const argv[])
{
  mosquitto_lib_init();
#if 0
  {
    int major, minor, revision;
    mosquitto_lib_version(&major, &minor, &revision);
    std::cout << "Mosquitto library version - " << major << "." << minor << "." << revision << std::endl;
  }
#endif
  std::cout << "Rx Measurement test program" << std::endl;


  std::string hostname("localhost");
  std::list<std::string> topics;
  int qos = 0; // Cheap.
  int port = 1883;
  bool use_json = false;
  int num_threads = 1;

  enum {
    HELP_OPTION = '?',
    HOST_OPTION = 'h',
    TOPIC_OPTION = 't',
    QOS_OPTION = 'q',
    PORT_OPTION = 'p',
    JSON_MSG_OPTION = 'j',
    BINARY_MSG_OPTION = 'B',
    PARALLEL_OPTION = 'P',
  };
  struct option options[] = {
    {"help", 0, nullptr, HELP_OPTION},
    {"mqtt-host", 1, nullptr, HOST_OPTION},
    {"topic", 1, nullptr, TOPIC_OPTION},
    {"qos", 1, nullptr, QOS_OPTION},
    {"mqtt-port", 1, nullptr, PORT_OPTION},
    {"json", 0, nullptr, JSON_MSG_OPTION},
    {"binary", 0, nullptr, BINARY_MSG_OPTION},
    {"parallel", 1, nullptr, PARALLEL_OPTION},
    {0}
  };

  bool more_options = true;
  while (more_options) {
    int status = getopt_long(argc, argv, "h:t:q:p:j", options, nullptr);

    switch (status) {
    case HOST_OPTION:
      hostname = optarg;
      break;

    case TOPIC_OPTION:
      topics.push_back(optarg);
      break;

    case HELP_OPTION:
      exit(EXIT_FAILURE);
      break;

    case QOS_OPTION:
      qos = atoi(optarg);
      break;

    case PORT_OPTION:
      port = atoi(optarg);
      break;

    case JSON_MSG_OPTION:
      use_json = true;
      break;

    case BINARY_MSG_OPTION:
      use_json = false;
      break;

    case PARALLEL_OPTION:
      num_threads = atoi(optarg);
      break;

    default:
      more_options = false;
      break;
    }
  }

  std::cout << "Connect to host " << hostname << " on port " << port << std::endl;
  for (auto& topic : topics) {
    std::cout << "Subscribe under topic " << topic << std::endl;
  }
  std::cout << "Subscribe with quality of service of " << qos << std::endl;

  {
    std::list<struct mosquitto*> mosq_list;
    
    ReceiveStats data_obj;
    get_timestamp(data_obj.base_nsec);
    data_obj.last_report_nsec = data_obj.base_nsec;

    for (int i = 0; i < num_threads; i++) {
      struct mosquitto *mosq = mosquitto_new(nullptr, /*clean_session=*/true, &data_obj);
      int code = mosquitto_connect(mosq, hostname.c_str(), port, /*keepalive=*/-1);
      if (code != MOSQ_ERR_SUCCESS) {
	switch (code) {
	case MOSQ_ERR_INVAL:
	  std::cerr << "Mosquitto connect failure - invalid input parameters" << std::endl;
	  break;
	case MOSQ_ERR_ERRNO:
	  std::cerr << "Mosquitto connect failure - " << strerror(errno) << std::endl;
	  break;
	default:
	  std::cerr << "Mosquitto connect failure - unknown error" << std::endl;
	  break;
	}
	exit(EXIT_FAILURE);
      }
      mosq_list.push_back(mosq);
    }

#if DISABLE_NAGLE
    for (auto mosq : mosq_list) {
      int sock = mosquitto_socket(mosq);
      if (sock >= 0) {
	int flag = 1;
	int result = setsockopt(sock,
				IPPROTO_TCP,
				TCP_NODELAY,
				(char *) &flag,
				sizeof(flag));
	if (result < 0) {
	  std::cerr << "Unable to disable Nagle algorithm on Misquitto socket, " << strerror(errno) << std::endl;
	}
	else {
	  std::cout << "Disabled Nagle algorithm on Misquitto socket" << std::endl;
	}
      }
      else {
	  std::cerr << "Unable to disable Nagle algorithm on Misquitto, no socket" << std::endl;
      }
    }
#endif

    for (auto mosq : mosq_list) {
      if (use_json) {
	mosquitto_message_callback_set(mosq, &message_callback_json);
      }
      else {
	mosquitto_message_callback_set(mosq, &message_callback_binary);
      }
      mosquitto_subscribe_callback_set(mosq, &subscribe_callback);
    }

    for (auto mosq : mosq_list) {
      int code = mosquitto_loop_start(mosq);
      if (code != MOSQ_ERR_SUCCESS) {
	switch (code) {
	case MOSQ_ERR_INVAL:
	  std::cerr << "Mosquitto loop start failure - invalid input parameters" << std::endl;
	  break;
	case MOSQ_ERR_NOT_SUPPORTED:
	  std::cerr << "Mosquitto loop start failure - not supported" << std::endl;
	  break;
	default:
	  std::cerr << "Mosquitto loop start failure - unknown error" << std::endl;
	  break;
	}
	exit(EXIT_FAILURE);
      }
    }

    for (auto& topic : topics) {
      int mid;
      struct mosquitto* mosq = mosq_list.front();

      // Transfer to back of list.
      mosq_list.pop_front();
      mosq_list.push_back(mosq);
      
      int code = mosquitto_subscribe(mosq, &mid, topic.c_str(), qos);
      if (code != MOSQ_ERR_SUCCESS) {
	switch (code) {
	case MOSQ_ERR_INVAL:
	  std::cerr << "Mosquitto subscribe failure - invalid input parameters" << std::endl;
	  break;
	case MOSQ_ERR_NOMEM:
	  std::cerr << "Mosquitto subscribe failure - out of memory" << std::endl;
	  break;
	case MOSQ_ERR_NO_CONN:
	  std::cerr << "Mosquitto subscribe failure - no connection" << std::endl;
	  break;
	default:
	  std::cerr << "Mosquitto subscribe failure - unknown error" << std::endl;
	  break;
	}
	exit(EXIT_FAILURE);
      }
      std::cout << "Subscribing to topic " << topic << " with mid " << mid << std::endl;
    }

    for (auto mosq : mosq_list) {
      //      mosquitto_disconnect(mosq);
      mosquitto_loop_stop(mosq, false);
      mosquitto_destroy(mosq);
    }
  }

  mosquitto_lib_cleanup();
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
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;
}