/*

 * Copyright (C) 2001-2003 FhG Fokus

 * Copyright (C) 2005-2006 Voice Sistem S.R.L

 *

 * This file is part of opensips, a free SIP server.

 *

 * opensips is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version

 *

 * opensips 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 *

 */

#include <sys/types.h>

#include <sys/wait.h>

#include <signal.h>

#include "dprint.h"

#include "daemonize.h"

#include "pt.h"

#include "status_report.h"

#include "shutdown.h"

#include "signals.h"

/* last signal received */

static int sig_flag = 0;

/* the initial SIGSEGV handler, provided by the OS */

static struct sigaction sa_sys_segv;

static char sa_sys_is_valid;

/**

 * Signal handler for the server.

 */

void handle_sigs(void)

{

  pid_t  chld;

  int    chld_status,overall_status=0;

  int    i;

  int    do_exit;

  switch(sig_flag){

    case 0: break; /* do nothing*/

    case SIGPIPE:

        /* SIGPIPE might be rarely received on use of

           exec module; simply ignore it

         */

    case SIGUSR1:

    case SIGUSR2:

    case SIGHUP:

        /* ignoring it*/

        break;

    case SIGINT:

    case SIGTERM:

      /* we end the program in all these cases */

      if (sig_flag==SIGINT)

        LM_DBG("SIGINT received, program terminates\n");

      else

        LM_DBG("SIGTERM received, program terminates\n");

      shutdown_opensips( 0/*status*/ );

      break;

    case SIGCHLD:

      do_exit = 0;

      while ((chld=waitpid( -1, &chld_status, WNOHANG ))>0) {

        /* is it a process we know about? */

        if ( (i=get_process_ID_by_PID( chld )) == -1 ) {

          LM_DBG("unknown child process %d ended. Ignoring\n",chld);

          continue;

        }

        if (pt[i].flags & OSS_PROC_SELFEXIT) {

          LM_NOTICE("process %d/%d did selfexit with "

            "status %d\n", i, chld,  WTERMSIG(chld_status));

          reset_process_slot(i);

          continue;

        }

        do_exit = 1;

        /* process the signal */

        overall_status |= chld_status;

        LM_DBG("OpenSIPS exit status = %d\n",overall_status);

        if (WIFEXITED(chld_status))

          LM_INFO("child process %d exited normally,"

              " status=%d\n", chld,

              WEXITSTATUS(chld_status));

        else if (WIFSIGNALED(chld_status)) {

          LM_INFO("child process %d exited by a signal"

              " %d\n", chld, WTERMSIG(chld_status));

#ifdef WCOREDUMP

          LM_INFO("core was %sgenerated\n",

               WCOREDUMP(chld_status) ?  "" : "not " );

#endif

        }else if (WIFSTOPPED(chld_status))

          LM_INFO("child process %d stopped by a"

                " signal %d\n", chld,

                 WSTOPSIG(chld_status));

        /* mark the child process as terminated / not running */

        pt[i].pid = -1;

      }

      if (!do_exit)

        break;

      LM_INFO("terminating due to SIGCHLD\n");

      /* exit */

      shutdown_opensips( overall_status );

      break;

    default:

      LM_CRIT("unhandled signal %d\n", sig_flag);

  }

  sig_flag=0;

}

static inline int restore_segv_handler(void)

{

  LM_DBG("restoring SIGSEGV handler...\n");

  if (!sa_sys_is_valid)

    return 1;

  if (sigaction(SIGSEGV, &sa_sys_segv, NULL) < 0) {

    LM_ERR("failed to restore system SIGSEGV handler\n");

    return -1;

  }

  LM_DBG("successfully restored system SIGSEGV handler\n");

  return 0;

}

/**

 * Exit regulary on a specific signal.

 * This is good for profiling which only works if exited regularly

 * and not by default signal handlers

 * \param signo The signal that should be handled

 */

static void sig_usr(int signo)

{

  int status;

  pid_t pid;

  UNUSED(pid);

  if (is_main){

    if (signo == SIGSEGV) {

      LM_CRIT("segfault in attendant (starter) process!\n");

      if (restore_segv_handler() != 0)

        exit(-1);

      return;

    }

    if (sig_flag == 0)

      sig_flag = signo;

    else /*  previous sig. not processed yet, ignoring? */

      return;

  }else{

    /* process the important signals */

    switch(signo){

      case SIGPIPE:

      case SIGINT:

      case SIGUSR1:

      case SIGUSR2:

      case SIGHUP:

          /* ignored*/

          break;

      case SIGTERM:

          /* ignore any SIGTERM if not in shutdown sequance (this 

           * is marked by the attendent process) */

          if (sr_get_core_status()!=STATE_TERMINATING)

            return;

          /* if some shutdown already in progress, ignore this one */

          if (sig_flag==0) sig_flag=signo;

          else return;

          /* do the termination */

          LM_INFO("signal %d received\n", signo);

          /* print memory stats for non-main too */

          #ifdef PKG_MALLOC

          LM_GEN1(memdump, "Memory status (pkg):\n");

          pkg_status();

          #endif

          exit(0);

          break;

      case SIGCHLD:

          while ( (pid = waitpid(-1, &status, WNOHANG))>0 );

          break;

      case SIGSEGV:

          /* looks like we ate some spicy SIP */

          LM_CRIT("segfault in process pid: %d, id: %d\n",

                  pt[process_no].pid, process_no);

          pt[process_no].flags |= OSS_PROC_DOING_DUMP;

          if (restore_segv_handler() != 0)

            exit(-1);

          pkg_status();

    }

  }

}

/**

 * Install the signal handlers.

 * \return 0 on success, -1 on error

 */

int install_sigs(void)

{

  struct sigaction act;

  memset(&act, 0, sizeof act);

  act.sa_handler = sig_usr;

  if (sigaction(SIGSEGV, &act, &sa_sys_segv) < 0) {

    LM_INFO("failed to install custom SIGSEGV handler -- corefiles must "

            "now be written within %d sec to avoid truncation!\n",

            GRACEFUL_SHUTDOWN_TIMEOUT);

  } else {

    LM_DBG("override SIGSEGV handler: success\n");

    sa_sys_is_valid = 1;

  }

  if (signal(SIGINT, sig_usr) == SIG_ERR ) {

    LM_ERR("no SIGINT signal handler can be installed\n");

    goto error;

  }

  /* if we debug and write to a pipe, we want to exit nicely too */

  if (signal(SIGPIPE, sig_usr) == SIG_ERR ) {

    LM_ERR("no SIGINT signal handler can be installed\n");

    goto error;

  }

  if (signal(SIGUSR1, sig_usr)  == SIG_ERR ) {

    LM_ERR("no SIGUSR1 signal handler can be installed\n");

    goto error;

  }

  if (signal(SIGCHLD , sig_usr)  == SIG_ERR ) {

    LM_ERR("no SIGCHLD signal handler can be installed\n");

    goto error;

  }

  if (signal(SIGTERM , sig_usr)  == SIG_ERR ) {

    LM_ERR("no SIGTERM signal handler can be installed\n");

    goto error;

  }

  if (signal(SIGHUP , sig_usr)  == SIG_ERR ) {

    LM_ERR("no SIGHUP signal handler can be installed\n");

    goto error;

  }

  if (signal(SIGUSR2 , sig_usr)  == SIG_ERR ) {

    LM_ERR("no SIGUSR2 signal handler can be installed\n");

    goto error;

  }

  return 0;

error:

  return -1;

}