void critical_alert(char *whoami, char *instance, char *msg, ...)
{
FILE *crit;
char *buf;
va_list ap;
long start;
/* Log message to critical file */
if ((crit = fopen(CRITERRLOG, "a")))
{
time_t t;
char *time_s;
time(&t);
time_s = ctime(&t) + 4;
time_s[strlen(time_s) - 6] = '\0';
fprintf(crit, "%s <%ld>", time_s, (long)getpid());
start = ftell(crit);
va_start(ap, msg);
vfprintf(crit, msg, ap);
va_end(ap);
fprintf(crit, "\n");
buf = malloc(ftell(crit) - start);
fclose(crit);
if (buf)
{
va_start(ap, msg);
vsprintf(buf, msg, ap);
va_end(ap);
send_zgram(instance, buf);
com_err(whoami, 0, "%s", buf);
free(buf);
}
}
if (!crit || !buf)
{
send_zgram(instance, "Couldn't format critical syslog!");
com_err(whoami, 0, "Couldn't format critical syslog!");
}
}
int main(int argc, char **argv)
{
int status, i, listener;
time_t tardy;
char *port, *p;
extern char *database;
struct stat stbuf;
struct utsname uts;
fd_set readfds, writefds, xreadfds, xwritefds;
int nfds, counter = 0;
whoami = argv[0];
/*
* Error handler init.
*/
mr_init();
set_com_err_hook(mr_com_err);
setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
port = strchr(MOIRA_SERVER, ':') + 1;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-db") && i + 1 < argc)
{
database = argv[i + 1];
i++;
}
else if (!strcmp(argv[i], "-p") && i + 1 < argc)
{
port = argv[i + 1];
i++;
}
else
{
com_err(whoami, 0, "Usage: moirad [-db database][-p port]");
exit(1);
}
}
status = krb5_init_context(&context);
if (status)
{
com_err(whoami, status, "Initializing krb5 context.");
exit(1);
}
status = krb5_get_default_realm(context, &krb_realm);
if (status)
{
com_err(whoami, status, "Getting default Kerberos realm.");
exit(1);
}
/*
* Database initialization. Only init if database should be open.
*/
if (stat(MOIRA_MOTD_FILE, &stbuf) != 0)
{
if ((status = mr_open_database()))
{
com_err(whoami, status, "trying to open database.");
exit(1);
}
sanity_check_database();
}
else
{
dormant = ASLEEP;
com_err(whoami, 0, "sleeping, not opening database");
}
sanity_check_queries();
/*
* Get moira server hostname for authentication
*/
if (uname(&uts) < 0)
{
com_err(whoami, errno, "Unable to get local hostname");
exit(1);
}
host = canonicalize_hostname(xstrdup(uts.nodename));
for (p = host; *p && *p != '.'; p++)
{
if (isupper(*p))
*p = tolower(*p);
}
*p = '\0';
/*
* Set up client array handler.
*/
nclients = 0;
clientssize = 10;
clients = xmalloc(clientssize * sizeof(client *));
mr_setup_signals();
journal = fopen(JOURNAL, "a");
if (!journal)
{
com_err(whoami, errno, "opening journal file");
exit(1);
}
/*
* Establish template connection.
*/
listener = mr_listen(port);
if (listener == -1)
{
com_err(whoami, MR_ABORTED, "trying to create listening connection");
exit(1);
}
FD_ZERO(&xreadfds);
FD_ZERO(&xwritefds);
FD_SET(listener, &xreadfds);
nfds = listener + 1;
com_err(whoami, 0, "started (pid %d)", getpid());
com_err(whoami, 0, rcsid);
if (dormant != ASLEEP)
send_zgram("MOIRA", "server started");
else
send_zgram("MOIRA", "server started, but database closed");
/*
* Run until shut down.
*/
while (!takedown)
{
int i;
struct timeval timeout = {60, 0}; /* 1 minute */
/* If we're supposed to go down and we can, do it */
if (((dormant == AWAKE) && (nclients == 0) &&
(stat(MOIRA_MOTD_FILE, &stbuf) == 0)) ||
(dormant == SLEEPY))
{
mr_close_database();
com_err(whoami, 0, "database closed");
mr_setup_signals();
send_zgram("MOIRA", "database closed");
dormant = ASLEEP;
}
/* Block until something happens. */
memcpy(&readfds, &xreadfds, sizeof(readfds));
memcpy(&writefds, &xwritefds, sizeof(writefds));
if (select(nfds, &readfds, &writefds, NULL, &timeout) == -1)
{
if (errno != EINTR)
com_err(whoami, errno, "in select");
continue;
}
if (takedown)
break;
if (child_exited_abnormally)
{
critical_alert(whoami, "moirad", "%d: child exits with signal %d status %d",
child_pid, child_signal, child_status);
child_exited_abnormally = 0;
}
time(&now);
tardy = now - 30 * 60;
/* If we're asleep and we should wake up, do it */
if ((dormant == ASLEEP) && (stat(MOIRA_MOTD_FILE, &stbuf) == -1) &&
(errno == ENOENT))
{
mr_open_database();
com_err(whoami, 0, "database open");
mr_setup_signals();
send_zgram("MOIRA", "database open again");
dormant = AWAKE;
}
/* Handle any new connections */
if (FD_ISSET(listener, &readfds))
{
int newconn, addrlen = sizeof(struct sockaddr_in);
struct sockaddr_in addr;
client *cp;
newconn = accept(listener, (struct sockaddr *)&addr, &addrlen);
if (newconn == -1)
com_err(whoami, errno, "accepting new connection");
else if (newconn > 0)
{
if (newconn + 1 > nfds)
nfds = newconn + 1;
FD_SET(newconn, &xreadfds);
/* Add a new client to the array */
nclients++;
if (nclients > clientssize)
{
clientssize = 2 * clientssize;
clients = xrealloc(clients, clientssize * sizeof(client *));
}
clients[nclients - 1] = cp = xmalloc(sizeof(client));
memset(cp, 0, sizeof(client));
cp->con = newconn;
cp->id = counter++;
cp->last_time_used = now;
cp->haddr = addr;
cp->tuplessize = 1;
cp->tuples = xmalloc(sizeof(mr_params));
memset(cp->tuples, 0, sizeof(mr_params));
cp->state = CL_ACCEPTING;
cp->version = 2;
cur_client = cp;
com_err(whoami, 0,
"New connection from %s port %d (now %d client%s)",
inet_ntoa(cp->haddr.sin_addr),
(int)ntohs(cp->haddr.sin_port),
nclients, nclients != 1 ? "s" : "");
}
}
/* Handle any existing connections. */
for (i = 0; i < nclients; i++)
{
cur_client = clients[i];
if (FD_ISSET(clients[i]->con, &writefds))
{
client_write(clients[i]);
if (!clients[i]->ntuples)
{
FD_CLR(clients[i]->con, &xwritefds);
FD_SET(clients[i]->con, &xreadfds);
}
clients[i]->last_time_used = now;
}
if (FD_ISSET(clients[i]->con, &readfds))
{
if (clients[i]->state == CL_ACCEPTING)
{
switch(mr_cont_accept(clients[i]->con,
&clients[i]->hsbuf,
&clients[i]->hslen))
{
case -1:
break;
case 0:
clients[i]->state = CL_CLOSING;
break;
default:
clients[i]->state = CL_ACTIVE;
clients[i]->hsbuf = NULL;
break;
}
}
else
{
client_read(clients[i]);
if (clients[i]->ntuples)
{
FD_CLR(clients[i]->con, &xreadfds);
FD_SET(clients[i]->con, &xwritefds);
}
clients[i]->last_time_used = now;
}
}
if (clients[i]->last_time_used < tardy)
{
com_err(whoami, 0, "Shutting down connection due to inactivity");
clients[i]->state = CL_CLOSING;
}
if (clients[i]->state == CL_CLOSING)
{
client *old;
com_err(whoami, 0, "Closed connection (now %d client%s, "
"%d queries)", nclients - 1, nclients != 2 ? "s" : "",
newqueries);
shutdown(clients[i]->con, 2);
close(clients[i]->con);
FD_CLR(clients[i]->con, &xreadfds);
FD_CLR(clients[i]->con, &xwritefds);
free_rtn_tuples(clients[i]);
free(clients[i]->tuples);
if (clients[i]->hsbuf)
free(clients[i]->hsbuf);
old = clients[i];
clients[i] = clients[--nclients];
free(old);
}
cur_client = NULL;
if (takedown)
break;
}
}
com_err(whoami, 0, "%s", takedown);
if (dormant != ASLEEP)
mr_close_database();
send_zgram("MOIRA", takedown);
return 0;
}
