#define _GNU_SOURCE /* for GLIBC */
#define _POSIX_PTHREAD_SEMANTICS /* for Solaris threads */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
#include <signal.h>
#include <locale.h>
#include <libintl.h>
#include <pthread.h>

static int pid_is_written = 0;
static pthread_mutex_t mutex_pid = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_pid = PTHREAD_COND_INITIALIZER;

/* Thread for handling signals */
static void *
sig_handler (void *v_param)
{
  struct flock lock;
  sigset_t sigs_to_catch;
  int caught;

  printf ("Pid of sig_handler=%d\n", getpid ());

  /* Signal the main thread that we have the pid printed */
  pthread_mutex_lock(&mutex_pid);
  pid_is_written = 1;
  pthread_cond_broadcast(&cond_pid);
  pthread_mutex_unlock(&mutex_pid);

  sigemptyset (&sigs_to_catch);
  sigaddset (&sigs_to_catch, SIGCHLD);
  sigaddset (&sigs_to_catch, SIGTERM);
  sigaddset (&sigs_to_catch, SIGINT);
  sigaddset (&sigs_to_catch, SIGQUIT);
  sigaddset (&sigs_to_catch, SIGSEGV);
  sigaddset (&sigs_to_catch, SIGHUP);

  while (1)
    {
      sigwait (&sigs_to_catch, &caught);
      switch (caught)
	{
	case SIGCHLD:
	  printf ("SIGCHLD arrived, what should I do ?\n");
	  break;
	case SIGTERM:
	case SIGINT:
	case SIGQUIT:
	case SIGSEGV:
	  /* Clean up if we quit the program. */
	  printf ("Signal (%d) for quitting program arrived.\n", caught);
	  exit (0);
	  break;
	case SIGHUP:
	  /* Reload config file */
	  printf ("SIGHUP arrived, reloading config file.\n");
	  break;
	default:
	  printf ("Unknown signal: %d\n", caught);
	  break;
	}
    }
}

int
main (int argc, char **argv)
{
  sigset_t sigs_to_block;
  pthread_t sig_thread;

  sigemptyset (&sigs_to_block);
  sigaddset (&sigs_to_block, SIGCHLD);
  sigaddset (&sigs_to_block, SIGTERM);
  sigaddset (&sigs_to_block, SIGINT);
  sigaddset (&sigs_to_block, SIGQUIT);
  sigaddset (&sigs_to_block, SIGSEGV);
  sigaddset (&sigs_to_block, SIGHUP);
  if (pthread_sigmask (SIG_BLOCK, &sigs_to_block, NULL) != 0)
    {
      printf ("Could not block signals.\n");
      exit (1);
    }

  pthread_create (&sig_thread, NULL, &sig_handler, NULL);

  /* wait until signal thread has created the pid file */
  pthread_mutex_lock(&mutex_pid);
  while (pid_is_written < 1)
    {
      pthread_cond_wait(&cond_pid, &mutex_pid);
    }
  pthread_mutex_unlock(&mutex_pid);

  while (1)
    sleep (5);

  return 1;
}