/* npth-sigev.c - signal handling interface
 * Copyright (C) 2011 g10 Code GmbH
 *
 * This file is part of nPth.
 *
 * nPth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * nPth is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 * the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, see <https://www.gnu.org/licenses/>.
 */

/* This is a support interface to make it easier to handle signals.
 *
 * The interfaces here support one (and only one) thread (here called
 * "main thread") in the application to monitor several signals while
 * selecting on filedescriptors.
 *
 * First, the main thread should call npth_sigev_init.  This
 * initializes some global data structures used to record interesting
 * and pending signals.
 *
 * Then, the main thread should call npth_sigev_add for every signal
 * it is interested in observing, and finally npth_sigev_fini.  This
 * will block the signal in the main threads sigmask.  Note that these
 * signals should also be blocked in all other threads.  Since they
 * are blocked in the main thread after calling npth_sigev_add, it is
 * recommended to call npth_sigev_add in the main thread before
 * creating any threads.
 *
 * The function npth_sigev_sigmask is a convenient function that
 * returns the sigmask of the thread at time of npth_sigev_init, but
 * with all registered signals unblocked.  It is recommended to do all
 * other changes to the main thread's sigmask before calling
 * npth_sigev_init, so that the return value of npth_sigev_sigmask can
 * be used in the npth_pselect invocation.
 *
 * In any case, the main thread should invoke npth_pselect with a
 * sigmask that has all signals that should be monitored unblocked.
 *
 * After npth_pselect returns, npth_sigev_get_pending can be called in
 * a loop until it returns 0 to iterate over the list of pending
 * signals.  Each time a signal is returned by that function, its
 * status is reset to non-pending.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <signal.h>
#include <assert.h>

#include "npth.h"

/* Record events that have been noticed.  */
static sigset_t sigev_pending;

/* The signal mask during normal operation.  */
static sigset_t sigev_block;

/* The signal mask during pselect.  */
static sigset_t sigev_unblock;

/* Registered signal numbers.  Needed to iterate over sigset_t.
   Bah.  */
#define SIGEV_MAX 32
static int sigev_signum[SIGEV_MAX];
static int sigev_signum_cnt;

/* The internal handler which just sets a global flag.  */
static void
_sigev_handler (int signum)
{
  sigaddset (&sigev_pending, signum);
}


/* Start setting up signal event handling.  */
void
npth_sigev_init (void)
{
  sigemptyset (&sigev_pending);
  pthread_sigmask (SIG_SETMASK, NULL, &sigev_block);
  pthread_sigmask (SIG_SETMASK, NULL, &sigev_unblock);
}


/* Add signal SIGNUM to the list of watched signals.  */
void
npth_sigev_add (int signum)
{
  struct sigaction sa;
  sigset_t ss;

  sigemptyset(&ss);

  assert (sigev_signum_cnt < SIGEV_MAX);
  sigev_signum[sigev_signum_cnt++] = signum;

  /* Make sure we can receive it.  */
  sigdelset (&sigev_unblock, signum);
  sigaddset (&sigev_block, signum);

  sa.sa_handler = _sigev_handler;
  sa.sa_mask = ss;
  sa.sa_flags = 0; /* NOT setting SA_RESTART! */

  sigaction (signum, &sa, NULL);
}


#ifdef HAVE_PTHREAD_ATFORK
/* There is non-POSIX operating system where fork is not available to
   applications.  There, we have no pthread_atfork either.  In such a
   case, we don't call pthread_atfork.  */
static void
restore_sigmask_for_child_process (void)
{
  pthread_sigmask (SIG_SETMASK, &sigev_unblock, NULL);
}
#endif

/* Finish the list of watched signals.  This starts to block them,
   too.  */
void
npth_sigev_fini (void)
{
  /* Block the interesting signals.  */
  pthread_sigmask (SIG_SETMASK, &sigev_block, NULL);
#ifdef HAVE_PTHREAD_ATFORK
  pthread_atfork (NULL, NULL, restore_sigmask_for_child_process);
#endif
}


/* Get the sigmask as needed for pselect.  */
sigset_t *
npth_sigev_sigmask (void)
{
  return &sigev_unblock;
}


/* Return the next signal event that occured.  Returns if none are
   left, 1 on success.  */
int
npth_sigev_get_pending (int *r_signum)
{
  int i;
  for (i = 0; i < sigev_signum_cnt; i++)
    {
      int signum = sigev_signum[i];
      if (sigismember (&sigev_pending, signum))
	{
	  sigdelset (&sigev_pending, signum);
	  *r_signum = signum;
	  return 1;
	}
    }
  return 0;
}