int main(int argc, char *argv[])
{
int daemonize = 1;
int listenq = 10;
char *pidfile = "msgcache.pid";
int lsocket;
struct sockaddr_in laddr;
struct sigaction sa;
int opt;
/* Dont save the output from errprintf() */
save_errbuf = 0;
memset(&laddr, 0, sizeof(laddr));
inet_aton("0.0.0.0", (struct in_addr *) &laddr.sin_addr.s_addr);
laddr.sin_port = htons(1984);
laddr.sin_family = AF_INET;
for (opt=1; (opt < argc); opt++) {
if (argnmatch(argv[opt], "--listen=")) {
char *locaddr, *p;
int locport;
locaddr = strchr(argv[opt], '=')+1;
p = strchr(locaddr, ':');
if (p) { locport = atoi(p+1); *p = '\0'; } else locport = 1984;
memset(&laddr, 0, sizeof(laddr));
laddr.sin_port = htons(locport);
laddr.sin_family = AF_INET;
if (inet_aton(locaddr, (struct in_addr *) &laddr.sin_addr.s_addr) == 0) {
errprintf("Invalid listen address %s\n", locaddr);
return 1;
}
}
else if (argnmatch(argv[opt], "--server=")) {
/* Who is allowed to fetch cached messages */
char *p = strchr(argv[opt], '=');
serverlist = getsenderlist(p+1);
}
else if (argnmatch(argv[opt], "--max-age=")) {
char *p = strchr(argv[opt], '=');
maxage = atoi(p+1);
}
else if (argnmatch(argv[opt], "--lqueue=")) {
char *p = strchr(argv[opt], '=');
listenq = atoi(p+1);
}
else if (strcmp(argv[opt], "--daemon") == 0) {
daemonize = 1;
}
else if (strcmp(argv[opt], "--no-daemon") == 0) {
daemonize = 0;
}
else if (argnmatch(argv[opt], "--pidfile=")) {
char *p = strchr(argv[opt], '=');
pidfile = strdup(p+1);
}
else if (argnmatch(argv[opt], "--logfile=")) {
char *p = strchr(argv[opt], '=');
logfile = strdup(p+1);
}
else if (strcmp(argv[opt], "--debug") == 0) {
debug = 1;
}
else if (strcmp(argv[opt], "--version") == 0) {
printf("xymonproxy version %s\n", VERSION);
return 0;
}
}
/* Set up a socket to listen for new connections */
lsocket = socket(AF_INET, SOCK_STREAM, 0);
if (lsocket == -1) {
errprintf("Cannot create listen socket (%s)\n", strerror(errno));
return 1;
}
opt = 1;
setsockopt(lsocket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
fcntl(lsocket, F_SETFL, O_NONBLOCK);
if (bind(lsocket, (struct sockaddr *)&laddr, sizeof(laddr)) == -1) {
errprintf("Cannot bind to listen socket (%s)\n", strerror(errno));
return 1;
}
if (listen(lsocket, listenq) == -1) {
errprintf("Cannot listen (%s)\n", strerror(errno));
return 1;
}
/* Redirect logging to the logfile, if requested */
if (logfile) {
reopen_file(logfile, "a", stdout);
reopen_file(logfile, "a", stderr);
}
errprintf("Xymon msgcache version %s starting\n", VERSION);
errprintf("Listening on %s:%d\n", inet_ntoa(laddr.sin_addr), ntohs(laddr.sin_port));
if (daemonize) {
pid_t childpid;
reopen_file("/dev/null", "r", stdin);
/* Become a daemon */
childpid = fork();
if (childpid < 0) {
/* Fork failed */
errprintf("Could not fork\n");
exit(1);
}
else if (childpid > 0) {
/* Parent - save PID and exit */
FILE *fd = fopen(pidfile, "w");
if (fd) {
fprintf(fd, "%d\n", (int)childpid);
fclose(fd);
}
exit(0);
}
/* Child (daemon) continues here */
setsid();
}
setup_signalhandler("msgcache");
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigmisc_handler;
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
do {
fd_set fdread, fdwrite;
int maxfd;
int n;
conn_t *cwalk, *cprev;
msgqueue_t *qwalk, *qprev;
time_t mintstamp;
/* Remove any finished connections */
cwalk = chead; cprev = NULL;
while (cwalk) {
conn_t *zombie;
if (cwalk->action != C_DONE) {
cprev = cwalk;
cwalk = cwalk->next;
continue;
}
/* Close the socket */
close(cwalk->sockfd);
zombie = cwalk;
if (cprev == NULL) {
chead = zombie->next;
cwalk = chead;
cprev = NULL;
}
else {
cprev->next = zombie->next;
cwalk = zombie->next;
}
freestrbuffer(zombie->msgbuf);
xfree(zombie);
}
ctail = chead;
if (ctail) { while (ctail->next) ctail = ctail->next; }
/* Remove expired messages */
qwalk = qhead; qprev = NULL;
mintstamp = getcurrenttime(NULL) - maxage;
while (qwalk) {
msgqueue_t *zombie;
if (qwalk->tstamp > mintstamp) {
/* Hasn't expired yet */
qprev = qwalk;
qwalk = qwalk->next;
continue;
}
zombie = qwalk;
if (qprev == NULL) {
qhead = zombie->next;
qwalk = qhead;
qprev = NULL;
}
else {
qprev->next = zombie->next;
qwalk = zombie->next;
}
freestrbuffer(zombie->msgbuf);
xfree(zombie);
}
qtail = qhead;
if (qtail) { while (qtail->next) qtail = qtail->next; }
/* Now we're ready to handle some data */
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
/* Add the listen socket */
FD_SET(lsocket, &fdread);
maxfd = lsocket;
for (cwalk = chead; (cwalk); cwalk = cwalk->next) {
switch (cwalk->action) {
case C_READING:
FD_SET(cwalk->sockfd, &fdread);
if (cwalk->sockfd > maxfd) maxfd = cwalk->sockfd;
break;
case C_WRITING:
FD_SET(cwalk->sockfd, &fdwrite);
if (cwalk->sockfd > maxfd) maxfd = cwalk->sockfd;
break;
case C_DONE:
break;
}
}
n = select(maxfd+1, &fdread, &fdwrite, NULL, NULL);
if (n < 0) {
if (errno == EINTR) continue;
errprintf("select failed: %s\n", strerror(errno));
return 0;
}
if (n == 0) continue; /* Timeout */
for (cwalk = chead; (cwalk); cwalk = cwalk->next) {
switch (cwalk->action) {
case C_READING:
if (FD_ISSET(cwalk->sockfd, &fdread)) grabdata(cwalk);
break;
case C_WRITING:
if (FD_ISSET(cwalk->sockfd, &fdwrite)) senddata(cwalk);
break;
case C_DONE:
break;
}
}
if (FD_ISSET(lsocket, &fdread)) {
/* New incoming connection */
conn_t *newconn;
int caddrsize;
dbgprintf("New connection\n");
newconn = calloc(1, sizeof(conn_t));
caddrsize = sizeof(newconn->caddr);
newconn->sockfd = accept(lsocket, (struct sockaddr *)&newconn->caddr, &caddrsize);
if (newconn->sockfd == -1) {
/* accept() failure. Yes, it does happen! */
dbgprintf("accept failure, ignoring connection (%s)\n", strerror(errno));
xfree(newconn);
newconn = NULL;
}
else {
fcntl(newconn->sockfd, F_SETFL, O_NONBLOCK);
newconn->action = C_READING;
newconn->msgbuf = newstrbuffer(0);
newconn->tstamp = getcurrenttime(NULL);
}
if (newconn) {
if (ctail) { ctail->next = newconn; ctail = newconn; }
else chead = ctail = newconn;
}
}
} while (keeprunning);
if (pidfile) unlink(pidfile);
return 0;
}
int main(int argc, char *argv[])
{
int argi;
struct sigaction sa;
namelist_t *hostwalk;
time_t nexttimeout;
for (argi=1; (argi < argc); argi++) {
if (argnmatch(argv[argi], "--server=")) {
char *p = strchr(argv[argi], '=');
serverip = strdup(p+1);
}
else if (argnmatch(argv[argi], "--interval=")) {
char *p = strchr(argv[argi], '=');
pollinterval = atoi(p+1);
}
else if (argnmatch(argv[argi], "--log-interval=")) {
char *p = strchr(argv[argi], '=');
errorloginterval = atoi(p+1);
}
else if (argnmatch(argv[argi], "--id=")) {
char *p = strchr(argv[argi], '=');
serverid = atoi(p+1);
}
else if (strcmp(argv[argi], "--debug") == 0) {
debug = 1;
}
}
setup_signalhandler("hobbitfetch");
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigmisc_handler;
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGUSR1, &sa, NULL); /* SIGUSR1 triggers logging of active requests */
clients = rbtNew(name_compare);
nexttimeout = time(NULL) + 60;
{
/* Seed the random number generator */
struct timeval tv;
struct timezone tz;
gettimeofday(&tv, &tz);
srandom(tv.tv_usec);
}
do {
RbtIterator handle;
conn_t *connwalk, *cprev;
fd_set fdread, fdwrite;
int n, maxfd;
struct timeval tmo;
time_t now;
now = time(NULL);
if (now > reloadtime) {
/* Time to reload the bb-hosts file */
reloadtime = now + 600;
load_hostnames(xgetenv("BBHOSTS"), NULL, get_fqdn());
for (hostwalk = first_host(); (hostwalk); hostwalk = hostwalk->next) {
char *hname;
clients_t *newclient;
if (!bbh_item(hostwalk, BBH_FLAG_PULLDATA)) continue;
hname = bbh_item(hostwalk, BBH_HOSTNAME);
handle = rbtFind(clients, hname);
if (handle == rbtEnd(clients)) {
newclient = (clients_t *)calloc(1, sizeof(clients_t));
newclient->hostname = strdup(hname);
rbtInsert(clients, newclient->hostname, newclient);
whentoqueue = now;
}
}
}
now = time(NULL);
if (now > nexttimeout) {
/* Check for connections that have timed out */
nexttimeout = now + 60;
for (connwalk = chead; (connwalk); connwalk = connwalk->next) {
if ((connwalk->tstamp + 60) < now) {
if (debug || (connwalk->client->nexterrortxt < now)) {
errprintf("Timeout while talking to %s (req %lu): Aborting session\n",
addrstring(&connwalk->caddr), connwalk->seq);
connwalk->client->nexterrortxt = now + errorloginterval;
}
flag_cleanup(connwalk);
}
}
}
if (needcleanup) {
/* Remove any finished requests */
needcleanup = 0;
connwalk = chead; cprev = NULL;
dbgprintf("Doing cleanup\n");
while (connwalk) {
conn_t *zombie;
if ((connwalk->action == C_READING) || (connwalk->action == C_WRITING)) {
/* Active connection - skip to the next conn_t record */
cprev = connwalk;
connwalk = connwalk->next;
continue;
}
if (connwalk->action == C_CLEANUP) {
if (connwalk->ctype == C_CLIENT) {
/*
* Finished getting data from a client,
* flag idle and set next poll time.
*/
connwalk->client->busy = 0;
set_polltime(connwalk->client);
}
else if (connwalk->ctype == C_SERVER) {
/* Nothing needed for server cleanups */
}
}
/* Unlink the request from the list of active connections */
zombie = connwalk;
if (cprev == NULL) {
chead = zombie->next;
connwalk = chead;
cprev = NULL;
}
else {
cprev->next = zombie->next;
connwalk = zombie->next;
}
/* Purge the zombie */
dbgprintf("Request completed: req %lu, peer %s, action was %d, type was %d\n",
zombie->seq, addrstring(&zombie->caddr),
zombie->action, zombie->ctype);
close(zombie->sockfd);
freestrbuffer(zombie->msgbuf);
xfree(zombie);
}
/* Set the tail pointer correctly */
ctail = chead;
if (ctail) { while (ctail->next) ctail = ctail->next; }
}
if (dumpsessions) {
/* Set by SIGUSR1 - dump the list of active requests */
dumpsessions = 0;
for (connwalk = chead; (connwalk); connwalk = connwalk->next) {
char *ctypestr, *actionstr;
char timestr[30];
switch (connwalk->ctype) {
case C_CLIENT: ctypestr = "client"; break;
case C_SERVER: ctypestr = "server"; break;
}
switch (connwalk->action) {
case C_READING: actionstr = "reading"; break;
case C_WRITING: actionstr = "writing"; break;
case C_CLEANUP: actionstr = "cleanup"; break;
}
strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S",
localtime(&connwalk->tstamp));
errprintf("Request %lu: state %s/%s, peer %s, started %s (%lu secs ago)\n",
connwalk->seq, ctypestr, actionstr, addrstring(&connwalk->caddr),
timestr, (now - connwalk->tstamp));
}
}
now = time(NULL);
if (now >= whentoqueue) {
/* Scan host-tree for clients we need to contact */
for (handle = rbtBegin(clients); (handle != rbtEnd(clients)); handle = rbtNext(clients, handle)) {
clients_t *clientwalk;
char msgline[100];
strbuffer_t *request;
char *pullstr, *ip;
int port;
clientwalk = (clients_t *)gettreeitem(clients, handle);
if (clientwalk->busy) continue;
if (clientwalk->nextpoll > now) continue;
/* Deleted hosts stay in our tree - but should disappear from the known hosts */
hostwalk = hostinfo(clientwalk->hostname); if (!hostwalk) continue;
pullstr = bbh_item(hostwalk, BBH_FLAG_PULLDATA); if (!pullstr) continue;
ip = strchr(pullstr, '=');
port = atoi(xgetenv("BBPORT"));
if (!ip) {
ip = strdup(bbh_item(hostwalk, BBH_IP));
}
else {
/* There is an explicit IP setting in the pulldata tag */
char *p;
ip++; /* Skip the '=' */
ip = strdup(ip);
p = strchr(ip, ':');
if (p) { *p = '\0'; port = atoi(p+1); }
if (*ip == '\0') {
/* No IP given, just a port number */
xfree(ip);
ip = strdup(bbh_item(hostwalk, BBH_IP));
}
}
if (strcmp(ip, "0.0.0.0") == 0) {
struct hostent *hent;
xfree(ip); ip = NULL;
hent = gethostbyname(clientwalk->hostname);
if (hent) {
struct in_addr addr;
memcpy(&addr, *(hent->h_addr_list), sizeof(addr));
ip = strdup(inet_ntoa(addr));
}
}
if (!ip) continue;
/*
* Build the "pullclient" request, which includes the latest
* clientdata config we got from the server. Keep the clientdata
* here - we send "pullclient" requests more often that we actually
* contact the server, but we should provide the config data always.
*/
request = newstrbuffer(0);
sprintf(msgline, "pullclient %d\n", serverid);
addtobuffer(request, msgline);
if (clientwalk->clientdata) addtobuffer(request, clientwalk->clientdata);
/* Put the request on the connection queue */
addrequest(C_CLIENT, ip, port, request, clientwalk);
clientwalk->busy = 1;
xfree(ip);
}
}
/* Handle request queue */
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
maxfd = -1;
for (connwalk = chead; (connwalk); connwalk = connwalk->next) {
switch (connwalk->action) {
case C_READING:
FD_SET(connwalk->sockfd, &fdread);
if (connwalk->sockfd > maxfd) maxfd = connwalk->sockfd;
break;
case C_WRITING:
FD_SET(connwalk->sockfd, &fdwrite);
if (connwalk->sockfd > maxfd) maxfd = connwalk->sockfd;
break;
case C_CLEANUP:
break;
}
}
/* Do select with a 1 second timeout */
tmo.tv_sec = 1;
tmo.tv_usec = 0;
n = select(maxfd+1, &fdread, &fdwrite, NULL, &tmo);
if (n == -1) {
if (errno == EINTR) continue; /* Interrupted, e.g. a SIGHUP */
/* This is a "cannot-happen" failure. Bail out */
errprintf("select failure: %s\n", strerror(errno));
return 0;
}
if (n == 0) continue; /* Timeout */
for (connwalk = chead; (connwalk); connwalk = connwalk->next) {
switch (connwalk->action) {
case C_READING:
if (FD_ISSET(connwalk->sockfd, &fdread)) grabdata(connwalk);
break;
case C_WRITING:
if (FD_ISSET(connwalk->sockfd, &fdwrite)) senddata(connwalk);
break;
case C_CLEANUP:
break;
}
}
} while (running);
return 0;
}
