309 lines
8.8 KiB
C
309 lines
8.8 KiB
C
/**************************************************************/
|
|
/* Multicast listener (server) */
|
|
/* */
|
|
/* Activation using: {program name} {Multicast IP} {port} */
|
|
/* {program name} - This program name */
|
|
/* {Multicast IP} - The IP address to listen to (Class D) */
|
|
/* {port} - The port hnumber to listen on */
|
|
/* {gpio} - gpio pin number for output */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* This is free software released under the GPL license. */
|
|
/* See the GNU GPL for details. */
|
|
/* */
|
|
/* (c) Juan-Mariano de Goyeneche. 1998, 1999. */
|
|
/**************************************************************/
|
|
|
|
|
|
#include <stdio.h> /* printf(), snprintf() */
|
|
#include <stdlib.h> /* strtol(), exit() */
|
|
#include <sys/types.h>
|
|
#include <errno.h> /* perror() */
|
|
#include <unistd.h> /* fork(), sleep() */
|
|
#include <sys/utsname.h> /* uname() */
|
|
#include <string.h> /* memset() */
|
|
#include <syslog.h> /* openlog(), syslog() */
|
|
#include "gpiosysfs.h"
|
|
#include <signal.h> //signal(3)
|
|
#include <sys/stat.h> //umask(3)
|
|
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <assert.h>
|
|
#include <err.h>
|
|
|
|
#include "mosquitto.h"
|
|
|
|
#define DEBUG
|
|
#define MAXLEN 1024
|
|
|
|
#ifdef DEBUG
|
|
#define LOG(...) do { printf(__VA_ARGS__); } while (0)
|
|
#else
|
|
#define LOG(...)
|
|
#endif
|
|
|
|
/* How many seconds the broker should wait between sending out
|
|
* keep-alive messages. */
|
|
#define KEEPALIVE_SECONDS 60
|
|
|
|
/* Hostname and port for the MQTT broker. */
|
|
char *mqtt_host;
|
|
int port;
|
|
char *topic;
|
|
char *pin;
|
|
int timeout;
|
|
bool debug=false;
|
|
|
|
int daemonize(char* name, char* path, char* outfile, char* errfile, char* infile , char* pidfile)
|
|
{
|
|
char filename[64];
|
|
FILE *pf;
|
|
|
|
if(!path) { path="/"; }
|
|
if(!name) { name="medaemon"; }
|
|
if(!infile) { infile="/dev/null"; }
|
|
if(!outfile) { outfile="/dev/null"; }
|
|
if(!errfile) { errfile="/dev/null"; }
|
|
if(!pidfile) {
|
|
snprintf(filename,63,"/var/run/%s.pid",name);
|
|
pidfile = filename;
|
|
}
|
|
|
|
//printf("%s %s %s %s\n",name,path,outfile,infile);
|
|
pid_t child;
|
|
//fork, detach from process group leader
|
|
if( (child=fork())<0 ) { //failed fork
|
|
fprintf(stderr,"error: failed fork\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (child>0) { //parent
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
if( setsid()<0 ) { //failed to become session leader
|
|
fprintf(stderr,"error: failed setsid\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
//catch/ignore signals
|
|
signal(SIGCHLD,SIG_IGN);
|
|
signal(SIGHUP,SIG_IGN);
|
|
|
|
//fork second time
|
|
if ( (child=fork())<0) { //failed fork
|
|
fprintf(stderr,"error: failed fork\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if( child>0 ) { //parent
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
//new file permissions
|
|
umask(0);
|
|
//change to path directory
|
|
chdir(path);
|
|
|
|
// open pid file
|
|
pf = fopen(pidfile,"w+");
|
|
if (pf == NULL) {
|
|
fprintf(stderr,"error: failed open pid file\n");
|
|
exit(EXIT_FAILURE);
|
|
} else {
|
|
fprintf(pf,"%d",getpid());
|
|
fclose(pf);
|
|
}
|
|
|
|
//Close all open file descriptors
|
|
int fd;
|
|
for( fd=sysconf(_SC_OPEN_MAX); fd>0; --fd )
|
|
{
|
|
close(fd);
|
|
}
|
|
|
|
//reopen stdin, stdout, stderr
|
|
freopen(infile,"r",stdin); //fd=0
|
|
freopen(outfile,"w+",stdout); //fd=1
|
|
freopen(errfile,"w+",stderr); //fd=2
|
|
|
|
//open syslog
|
|
openlog(name,LOG_PID,LOG_DAEMON);
|
|
|
|
syslog (LOG_DAEMON, "Program started by User %d", getuid ());
|
|
return(0);
|
|
}
|
|
|
|
void beep()
|
|
{
|
|
gpioWrite(pin,"1");
|
|
msleep(timeout);
|
|
gpioWrite(pin,"0");
|
|
msleep(timeout);
|
|
}
|
|
|
|
struct client_info {
|
|
struct mosquitto *m;
|
|
pid_t pid;
|
|
uint32_t tick_ct;
|
|
};
|
|
|
|
static void die(const char *msg);
|
|
static struct mosquitto *init(struct client_info *info);
|
|
static bool set_callbacks(struct mosquitto *m);
|
|
static bool connect(struct mosquitto *m);
|
|
static int run_loop(struct client_info *info);
|
|
|
|
/* Fail with an error message. */
|
|
static void die(const char *msg) {
|
|
fprintf(stderr, "%s", msg);
|
|
exit(1);
|
|
}
|
|
|
|
/* Initialize a mosquitto client. */
|
|
static struct mosquitto *init(struct client_info *info) {
|
|
void *udata = (void *)info;
|
|
size_t buf_sz = 32;
|
|
char buf[buf_sz];
|
|
if (buf_sz < snprintf(buf, buf_sz, "bellrecv_%d", info->pid)) {
|
|
return NULL; /* snprintf buffer failure */
|
|
}
|
|
/* Create a new mosquitto client, with the name "client_#{PID}". */
|
|
LOG("Init\n");
|
|
mosquitto_lib_init();
|
|
struct mosquitto *m = mosquitto_new(buf, true, udata);
|
|
|
|
return m;
|
|
}
|
|
|
|
/* Callback for successful connection: add subscriptions. */
|
|
static void on_connect(struct mosquitto *m, void *udata, int res) {
|
|
if (res == 0) { /* success */
|
|
LOG("connecion successfull\n");
|
|
|
|
//struct client_info *info = (struct client_info *)udata;
|
|
mosquitto_subscribe(m, NULL, topic, 0);
|
|
} else {
|
|
die("connection refused\n");
|
|
}
|
|
}
|
|
|
|
/* A message was successfully published. */
|
|
static void on_publish(struct mosquitto *m, void *udata, int m_id) {
|
|
LOG("-- published successfully\n");
|
|
}
|
|
|
|
static bool match(const char *topic, const char *key) {
|
|
return 0 == strncmp(topic, key, strlen(key));
|
|
}
|
|
|
|
/* Handle a message that just arrived via one of the subscriptions. */
|
|
static void on_message(struct mosquitto *m, void *udata,
|
|
const struct mosquitto_message *msg) {
|
|
if (msg == NULL) {
|
|
LOG("-- message NULL\n");
|
|
return;
|
|
}
|
|
LOG("-- got message @ %s: (%d, QoS %d, %s) '%s'\n",
|
|
msg->topic, msg->payloadlen, msg->qos, msg->retain ? "R" : "!r",
|
|
(char *)msg->payload);
|
|
|
|
struct client_info *info = (struct client_info *)udata;
|
|
|
|
syslog(LOG_DAEMON, "Bell message recived: '%s' -> '%s'", msg->topic, (char *)msg->payload);
|
|
if (match(msg->topic, topic)) {
|
|
if (0 == strncmp(msg->payload, "BELL:", 5)) {
|
|
LOG("%s %d\n",(char *)msg->payload, info->pid);
|
|
syslog (LOG_DAEMON, "Bell ringing by message: %s",(char *)msg->payload);
|
|
if (debug == false) beep();
|
|
} else {
|
|
LOG("invalid message: '%s' excepted 'BELL:'\n",(char *)msg->payload);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Successful subscription hook. */
|
|
static void on_subscribe(struct mosquitto *m, void *udata, int mid,
|
|
int qos_count, const int *granted_qos) {
|
|
LOG("-- subscribed successfully on topic: '%s'\n",topic);
|
|
syslog (LOG_DAEMON, "Bell subscibed on topic %s" ,topic);
|
|
}
|
|
|
|
/* Register the callbacks that the mosquitto connection will use. */
|
|
static bool set_callbacks(struct mosquitto *m) {
|
|
mosquitto_connect_callback_set(m, on_connect);
|
|
mosquitto_publish_callback_set(m, on_publish);
|
|
mosquitto_subscribe_callback_set(m, on_subscribe);
|
|
mosquitto_message_callback_set(m, on_message);
|
|
return true;
|
|
}
|
|
|
|
/* Connect to the network. */
|
|
static bool connect(struct mosquitto *m) {
|
|
int res = mosquitto_connect(m, mqtt_host, port, KEEPALIVE_SECONDS);
|
|
return res == MOSQ_ERR_SUCCESS;
|
|
}
|
|
|
|
/* Loop until it is explicitly halted or the network is lost, then clean up. */
|
|
static int run_loop(struct client_info *info) {
|
|
int res = mosquitto_loop_forever(info->m, 1000, 1000 /* unused */);
|
|
|
|
mosquitto_destroy(info->m);
|
|
(void)mosquitto_lib_cleanup();
|
|
|
|
closelog();
|
|
if (res == MOSQ_ERR_SUCCESS) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
int res;
|
|
|
|
if (argc < 6) {
|
|
fprintf(stderr, "Usage: %s mqtt_host port topic gpio seconds [debug]\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
|
|
mqtt_host = argv[1];
|
|
port = atoi(argv[2]);
|
|
topic = argv[3];
|
|
pin = argv[4];
|
|
timeout = atoi(argv[5])*1000; //To milis
|
|
|
|
if (argc == 6) {
|
|
|
|
if( (res=daemonize("bellring","/tmp",NULL,NULL,NULL,NULL)) != 0 ) {
|
|
fprintf(stderr,"error: daemonize failed\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
} else { debug = true ;};
|
|
|
|
if (debug == false) gpioSetup(pin);
|
|
|
|
pid_t pid = getpid();
|
|
|
|
struct client_info info;
|
|
memset(&info, 0, sizeof(info));
|
|
info.pid = pid;
|
|
|
|
struct mosquitto *m = init(&info);
|
|
if (m == NULL) { die("init() failure\n"); }
|
|
info.m = m;
|
|
|
|
if (!set_callbacks(m)) { die("set_callbacks() failure\n"); }
|
|
|
|
if (!connect(m)) { die("connect() failure\n"); }
|
|
|
|
return run_loop(&info);
|
|
}
|
|
|