[moira.git] / server / mr_main.c

/* $Id$
 *
 * Moira server process.
 *
 * Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
 * For copying and distribution information, please see the file
 * <mit-copyright.h>.
 *
 */

#include <mit-copyright.h>
#include "mr_server.h"

#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/wait.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <krb.h>

RCSID("$Header$");

extern char *krb_get_lrealm(char *, int);

client *cur_client;

char *whoami;
char *takedown;
FILE *journal;

time_t now;

char *host;
char krb_realm[REALM_SZ];

/* Client array and associated data. This needs to be global for _list_users */
client **clients;
int nclients, clientssize;

int dormant;

void reapchild(int x);
void godormant(int x);
void gowakeup(int x);
void clist_append(client *cp);
void mr_setup_signals(void);

/*
 * Main Moira server loop.
 *
 * Initialize the world, then start accepting connections and
 * making progress on current connections.
 */

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

  krb_get_lrealm(krb_realm, 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.
   */
  if (!(listener = mr_listen(port)))
    {
      com_err(whoami, status, "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");
	  if (!inc_running || now - inc_started > INC_TIMEOUT)
	    next_incremental();
	  continue;
	}

      if (takedown)
	break;
      time(&now);
      if (!inc_running || now - inc_started > INC_TIMEOUT)
	next_incremental();
      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;
	  struct sockaddr_in addr;
	  client *cp;

	  newconn = mr_accept(listener, &addr);
	  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));

	      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);
		  /* Now that we're done writing we can read again */
		  FD_SET(clients[i]->con, &xreadfds);
		}
	      clients[i]->last_time_used = now;
	    }

	  if (FD_ISSET(clients[i]->con, &readfds))
	    {
	      client_read(clients[i]);
	      if (clients[i]->ntuples)
		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]->done = 1;
	    }

	  if (clients[i]->done)
	    {
	      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);
	      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;
}

void reapchild(int x)
{
  int status, pid;

  while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
    {
      if (pid == inc_pid)
	inc_running = 0;
      if (!takedown && (WTERMSIG(status) != 0 || WEXITSTATUS(status) != 0))
	{
	  critical_alert("moirad", "%d: child exits with signal %d status %d",
			 pid, WTERMSIG(status), WEXITSTATUS(status));
	}
    }
}


void godormant(int x)
{
  switch (dormant)
    {
    case AWAKE:
    case GROGGY:
      com_err(whoami, 0, "requested to go dormant");
      break;
    case ASLEEP:
      com_err(whoami, 0, "already asleep");
      break;
    case SLEEPY:
      break;
    }
  dormant = SLEEPY;
}


void gowakeup(int x)
{
  switch (dormant)
    {
    case ASLEEP:
    case SLEEPY:
      com_err(whoami, 0, "Good morning");
      break;
    case AWAKE:
      com_err(whoami, 0, "already awake");
      break;
    case GROGGY:
      break;
    }
  dormant = GROGGY;
}


void mr_setup_signals(void)
{
  struct sigaction action;

  action.sa_flags = 0;
  sigemptyset(&action.sa_mask);

  /* There should probably be a few more of these. */

  action.sa_handler = sigshut;
  if ((sigaction(SIGTERM, &action, NULL) < 0) ||
      (sigaction(SIGINT, &action, NULL) < 0) ||
      (sigaction(SIGHUP, &action, NULL) < 0))
    {
      com_err(whoami, errno, "Unable to establish signal handlers.");
      exit(1);
    }

  action.sa_handler = godormant;
  if (sigaction(SIGUSR1, &action, NULL) < 0)
    {
      com_err(whoami, errno, "Unable to establish signal handlers.");
      exit(1);
    }

  action.sa_handler = gowakeup;
  if (sigaction(SIGUSR2, &action, NULL) < 0)
    {
      com_err(whoami, errno, "Unable to establish signal handlers.");
      exit(1);
    }

  action.sa_handler = SIG_IGN;
  if (sigaction(SIGPIPE, &action, NULL) < 0)
    {
      com_err(whoami, errno, "Unable to establish signal handlers.");
      exit(1);
    }

  action.sa_handler = reapchild;
  sigaddset(&action.sa_mask, SIGCHLD);
  if (sigaction(SIGCHLD, &action, NULL) < 0)
    {
      com_err(whoami, errno, "Unable to establish signal handlers.");
      exit(1);
    }
}
Commit	Line	Data
7ac48069	1	/* $Id$
0fa91a0a	2	*
7ac48069	3	* Moira server process.
0fa91a0a	4	*
7ac48069	5	* Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
	6	* For copying and distribution information, please see the file
	7	* <mit-copyright.h>.
5eaef520	8	*
0fa91a0a	9	*/
0fa91a0a	10
c801de4c	11	#include <mit-copyright.h>
7ac48069	12	#include "mr_server.h"
	13
	14	#include <sys/socket.h>
	15	#include <sys/stat.h>
589993be	16	#include <sys/types.h>
7ac48069	17	#include <sys/utsname.h>
554776b1	18	#include <sys/wait.h>
7ac48069	19
7ac48069	20	#include <netinet/in.h>
03c05291	21	#include <arpa/inet.h>
70d54e43	22
7ac48069	23	#include <ctype.h>
	24	#include <errno.h>
	25	#include <signal.h>
	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <unistd.h>
	30
85330553	31	#include <krb.h>
85330553	32
7ac48069	33	RCSID("$Header$");
	34
	35	extern char krb_get_lrealm(char , int);
	36
85330553	37	client *cur_client;
0fa91a0a	38
85330553	39	char *whoami;
	40	char *takedown;
	41	FILE *journal;
0fa91a0a	42
85330553	43	time_t now;
0fa91a0a	44
85330553	45	char *host;
85330553	46	char krb_realm[REALM_SZ];
70d54e43	47
85330553	48	/* Client array and associated data. This needs to be global for _list_users */
	49	client **clients;
	50	int nclients, clientssize;
0eb9f52f	51
85330553	52	int dormant;
3d0d0f07	53
7ac48069	54	void reapchild(int x);
	55	void godormant(int x);
	56	void gowakeup(int x);
03c05291	57	void clist_append(client *cp);
03c05291	58	void mr_setup_signals(void);
e448f08d	59
0ec57336	60	/*
59ec8dae	61	* Main Moira server loop.
0ec57336	62	*
	63	* Initialize the world, then start accepting connections and
	64	* making progress on current connections.
	65	*/
0fa91a0a	66
5eaef520	67	int main(int argc, char **argv)
0fa91a0a	68	{
85330553	69	int status, i, listener;
5eaef520	70	time_t tardy;
	71	char port, p;
	72	extern char *database;
	73	struct stat stbuf;
7ac48069	74	struct utsname uts;
85330553	75	fd_set readfds, writefds, xreadfds, xwritefds;
85330553	76	int nfds, counter = 0;
5eaef520	77
	78	whoami = argv[0];
	79	/*
	80	* Error handler init.
	81	*/
85330553	82	mr_init();
5eaef520	83	set_com_err_hook(mr_com_err);
	84	setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
	85
	86	port = strchr(MOIRA_SERVER, ':') + 1;
	87
	88	for (i = 1; i < argc; i++)
	89	{
	90	if (!strcmp(argv[i], "-db") && i + 1 < argc)
	91	{
	92	database = argv[i + 1];
	93	i++;
5dbd09a0	94	}
5eaef520	95	else if (!strcmp(argv[i], "-p") && i + 1 < argc)
	96	{
	97	port = argv[i + 1];
	98	i++;
f6cc38de	99	}
5eaef520	100	else
	101	{
	102	com_err(whoami, 0, "Usage: moirad [-db database][-p port]");
3d0d0f07	103	exit(1);
3d0d0f07	104	}
5eaef520	105	}
5eaef520	106
5eaef520	107	krb_get_lrealm(krb_realm, 1);
	108
	109	/*
	110	* Database initialization. Only init if database should be open.
	111	*/
	112
	113	if (stat(MOIRA_MOTD_FILE, &stbuf) != 0)
	114	{
	115	if ((status = mr_open_database()))
	116	{
85330553	117	com_err(whoami, status, "trying to open database.");
5eaef520	118	exit(1);
2f4ff9cd	119	}
5eaef520	120	sanity_check_database();
	121	}
	122	else
	123	{
	124	dormant = ASLEEP;
	125	com_err(whoami, 0, "sleeping, not opening database");
	126	}
2f4ff9cd	127
5eaef520	128	sanity_check_queries();
	129
	130	/*
	131	* Get moira server hostname for authentication
	132	*/
7ac48069	133	if (uname(&uts) < 0)
5eaef520	134	{
	135	com_err(whoami, errno, "Unable to get local hostname");
	136	exit(1);
	137	}
e688520a	138	host = canonicalize_hostname(xstrdup(uts.nodename));
5eaef520	139	for (p = host; p && p != '.'; p++)
	140	{
	141	if (isupper(*p))
	142	p = tolower(p);
	143	}
	144	*p = '\0';
	145
	146	/*
	147	* Set up client array handler.
	148	*/
	149	nclients = 0;
85330553	150	clientssize = 10;
e688520a	151	clients = xmalloc(clientssize * sizeof(client *));
5eaef520	152
	153	mr_setup_signals();
	154
	155	journal = fopen(JOURNAL, "a");
	156	if (!journal)
	157	{
85330553	158	com_err(whoami, errno, "opening journal file");
5eaef520	159	exit(1);
	160	}
	161
	162	/*
	163	* Establish template connection.
	164	*/
85330553	165	if (!(listener = mr_listen(port)))
5eaef520	166	{
85330553	167	com_err(whoami, status, "trying to create listening connection");
5eaef520	168	exit(1);
5eaef520	169	}
85330553	170	FD_ZERO(&xreadfds);
	171	FD_ZERO(&xwritefds);
	172	FD_SET(listener, &xreadfds);
	173	nfds = listener + 1;
5eaef520	174
5eaef520	175	com_err(whoami, 0, "started (pid %d)", getpid());
7ac48069	176	com_err(whoami, 0, rcsid);
5eaef520	177	if (dormant != ASLEEP)
	178	send_zgram("MOIRA", "server started");
	179	else
	180	send_zgram("MOIRA", "server started, but database closed");
	181
	182	/*
	183	* Run until shut down.
	184	*/
	185	while (!takedown)
	186	{
44d12d58	187	int i;
9294e804	188	struct timeval timeout = {60, 0}; /* 1 minute */
85330553	189
85330553	190	/* If we're supposed to go down and we can, do it */
59ad5a76	191	if (((dormant == AWAKE) && (nclients == 0) &&
	192	(stat(MOIRA_MOTD_FILE, &stbuf) == 0)) \|\|
	193	(dormant == SLEEPY))
5eaef520	194	{
	195	mr_close_database();
	196	com_err(whoami, 0, "database closed");
	197	mr_setup_signals();
	198	send_zgram("MOIRA", "database closed");
	199	dormant = ASLEEP;
	200	}
589993be	201
85330553	202	/* Block until something happens. */
	203	memcpy(&readfds, &xreadfds, sizeof(readfds));
	204	memcpy(&writefds, &xwritefds, sizeof(writefds));
9294e804	205	if (select(nfds, &readfds, &writefds, NULL, &timeout) == -1)
5eaef520	206	{
5eaef520	207	if (errno != EINTR)
85330553	208	com_err(whoami, errno, "in select");
5eaef520	209	if (!inc_running \|\| now - inc_started > INC_TIMEOUT)
	210	next_incremental();
	211	continue;
	212	}
85330553	213
5eaef520	214	if (takedown)
	215	break;
	216	time(&now);
	217	if (!inc_running \|\| now - inc_started > INC_TIMEOUT)
	218	next_incremental();
85330553	219	tardy = now - 30 * 60;
	220
	221	/* If we're asleep and we should wake up, do it */
	222	if ((dormant == ASLEEP) && (stat(MOIRA_MOTD_FILE, &stbuf) == -1) &&
	223	(errno == ENOENT))
	224	{
	225	mr_open_database();
	226	com_err(whoami, 0, "database open");
	227	mr_setup_signals();
	228	send_zgram("MOIRA", "database open again");
	229	dormant = AWAKE;
	230	}
5eaef520	231
85330553	232	/* Handle any new connections */
85330553	233	if (FD_ISSET(listener, &readfds))
5eaef520	234	{
85330553	235	int newconn;
	236	struct sockaddr_in addr;
	237	client *cp;
	238
	239	newconn = mr_accept(listener, &addr);
	240	if (newconn == -1)
	241	com_err(whoami, errno, "accepting new connection");
	242	else if (newconn > 0)
5eaef520	243	{
85330553	244	if (newconn + 1 > nfds)
	245	nfds = newconn + 1;
	246	FD_SET(newconn, &xreadfds);
	247
	248	/* Add a new client to the array */
	249	nclients++;
	250	if (nclients > clientssize)
5eaef520	251	{
85330553	252	clientssize = 2 * clientssize;
85330553	253	clients = xrealloc(clients, clientssize * sizeof(client *));
0fa91a0a	254	}
85330553	255
	256	clients[nclients - 1] = cp = xmalloc(sizeof(client));
	257	memset(cp, 0, sizeof(client));
	258	cp->con = newconn;
	259	cp->id = counter++;
	260	cp->last_time_used = now;
	261	cp->haddr = addr;
	262	cp->tuplessize = 1;
	263	cp->tuples = xmalloc(sizeof(mr_params));
	264	memset(cp->tuples, 0, sizeof(mr_params));
	265
	266	cur_client = cp;
	267	com_err(whoami, 0,
	268	"New connection from %s port %d (now %d client%s)",
	269	inet_ntoa(cp->haddr.sin_addr),
	270	(int)ntohs(cp->haddr.sin_port),
	271	nclients, nclients != 1 ? "s" : "");
5eaef520	272	}
0fa91a0a	273	}
5eaef520	274
85330553	275	/* Handle any existing connections. */
5eaef520	276	for (i = 0; i < nclients; i++)
	277	{
	278	cur_client = clients[i];
85330553	279
	280	if (FD_ISSET(clients[i]->con, &writefds))
	281	{
	282	client_write(clients[i]);
	283	if (!clients[i]->ntuples)
	284	{
	285	FD_CLR(clients[i]->con, &xwritefds);
	286	/* Now that we're done writing we can read again */
	287	FD_SET(clients[i]->con, &xreadfds);
	288	}
	289	clients[i]->last_time_used = now;
	290	}
	291
	292	if (FD_ISSET(clients[i]->con, &readfds))
5eaef520	293	{
85330553	294	client_read(clients[i]);
	295	if (clients[i]->ntuples)
	296	FD_SET(clients[i]->con, &xwritefds);
	297	clients[i]->last_time_used = now;
5eaef520	298	}
85330553	299
85330553	300	if (clients[i]->last_time_used < tardy)
5eaef520	301	{
5eaef520	302	com_err(whoami, 0, "Shutting down connection due to inactivity");
85330553	303	clients[i]->done = 1;
	304	}
	305
	306	if (clients[i]->done)
	307	{
	308	client *old;
	309
	310	com_err(whoami, 0, "Closed connection (now %d client%s, "
	311	"%d queries)", nclients - 1, nclients != 2 ? "s" : "",
	312	newqueries);
	313
	314	shutdown(clients[i]->con, 2);
	315	close(clients[i]->con);
	316	FD_CLR(clients[i]->con, &xreadfds);
	317	FD_CLR(clients[i]->con, &xwritefds);
92ced3ed	318	free_rtn_tuples(clients[i]);
85330553	319	free(clients[i]->tuples);
	320	old = clients[i];
	321	clients[i] = clients[--nclients];
	322	free(old);
5eaef520	323	}
85330553	324
5eaef520	325	cur_client = NULL;
	326	if (takedown)
	327	break;
	328	}
	329	}
85330553	330
5eaef520	331	com_err(whoami, 0, "%s", takedown);
	332	if (dormant != ASLEEP)
	333	mr_close_database();
	334	send_zgram("MOIRA", takedown);
	335	return 0;
70d54e43	336	}
70d54e43	337
5eaef520	338	void reapchild(int x)
554776b1	339	{
5eaef520	340	int status, pid;
	341
	342	while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
	343	{
	344	if (pid == inc_pid)
	345	inc_running = 0;
	346	if (!takedown && (WTERMSIG(status) != 0 \|\| WEXITSTATUS(status) != 0))
71c89283	347	{
e4342467	348	critical_alert("moirad", "%d: child exits with signal %d status %d",
71c89283	349	pid, WTERMSIG(status), WEXITSTATUS(status));
71c89283	350	}
554776b1	351	}
554776b1	352	}
589993be	353
589993be	354
5eaef520	355	void godormant(int x)
589993be	356	{
5eaef520	357	switch (dormant)
5eaef520	358	{
589993be	359	case AWAKE:
589993be	360	case GROGGY:
5eaef520	361	com_err(whoami, 0, "requested to go dormant");
5eaef520	362	break;
589993be	363	case ASLEEP:
5eaef520	364	com_err(whoami, 0, "already asleep");
5eaef520	365	break;
589993be	366	case SLEEPY:
5eaef520	367	break;
589993be	368	}
5eaef520	369	dormant = SLEEPY;
589993be	370	}
	371
	372
5eaef520	373	void gowakeup(int x)
589993be	374	{
5eaef520	375	switch (dormant)
5eaef520	376	{
589993be	377	case ASLEEP:
589993be	378	case SLEEPY:
5eaef520	379	com_err(whoami, 0, "Good morning");
5eaef520	380	break;
589993be	381	case AWAKE:
5eaef520	382	com_err(whoami, 0, "already awake");
5eaef520	383	break;
589993be	384	case GROGGY:
5eaef520	385	break;
589993be	386	}
5eaef520	387	dormant = GROGGY;
589993be	388	}
083a6e94	389
5eaef520	390
03c05291	391	void mr_setup_signals(void)
083a6e94	392	{
5eaef520	393	struct sigaction action;
	394
	395	action.sa_flags = 0;
	396	sigemptyset(&action.sa_mask);
03c05291	397
5eaef520	398	/* There should probably be a few more of these. */
03c05291	399
5eaef520	400	action.sa_handler = sigshut;
	401	if ((sigaction(SIGTERM, &action, NULL) < 0) \|\|
	402	(sigaction(SIGINT, &action, NULL) < 0) \|\|
	403	(sigaction(SIGHUP, &action, NULL) < 0))
	404	{
03c05291	405	com_err(whoami, errno, "Unable to establish signal handlers.");
03c05291	406	exit(1);
083a6e94	407	}
e448f08d	408
5eaef520	409	action.sa_handler = godormant;
	410	if (sigaction(SIGUSR1, &action, NULL) < 0)
	411	{
03c05291	412	com_err(whoami, errno, "Unable to establish signal handlers.");
	413	exit(1);
	414	}
e448f08d	415
5eaef520	416	action.sa_handler = gowakeup;
	417	if (sigaction(SIGUSR2, &action, NULL) < 0)
	418	{
03c05291	419	com_err(whoami, errno, "Unable to establish signal handlers.");
	420	exit(1);
	421	}
e448f08d	422
44762a3f	423	action.sa_handler = SIG_IGN;
	424	if (sigaction(SIGPIPE, &action, NULL) < 0)
	425	{
	426	com_err(whoami, errno, "Unable to establish signal handlers.");
	427	exit(1);
	428	}
	429
5eaef520	430	action.sa_handler = reapchild;
	431	sigaddset(&action.sa_mask, SIGCHLD);
	432	if (sigaction(SIGCHLD, &action, NULL) < 0)
	433	{
03c05291	434	com_err(whoami, errno, "Unable to establish signal handlers.");
	435	exit(1);
	436	}
	437	}