// signals.c - signals handling code

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1992-1997 Paul Falstad

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Paul Falstad or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Paul Falstad and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Paul Falstad and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Paul Falstad and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "signals.pro"

#ifdef __SYMBIAN32__

#include "dummy.h"

#endif //__SYMBIAN32__

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* Array describing the state of each signal: an element contains *

 * 0 for the default action or some ZSIG_* flags ored together.   */

/**/

mod_export int sigtrapped[VSIGCOUNT];

/* trap functions for each signal */

/**/

mod_export Eprog sigfuncs[VSIGCOUNT];

/* Total count of trapped signals */

/**/

mod_export int nsigtrapped;

/* Variables used by signal queueing */

/**/

mod_export int queueing_enabled, queue_front, queue_rear;

/**/

mod_export int signal_queue[MAX_QUEUE_SIZE];

/**/

mod_export sigset_t signal_mask_queue[MAX_QUEUE_SIZE];

/* Variables used by trap queueing */

/**/

mod_export int trap_queueing_enabled, trap_queue_front, trap_queue_rear;

/**/

mod_export int trap_queue[MAX_QUEUE_SIZE];

/* This is only used on machines that don't understand signal sets.  *

 * On SYSV machines this will represent the signals that are blocked *

 * (held) using sighold.  On machines which can't block signals at   *

 * all, we will simulate this by ignoring them and remembering them  *

 * in this variable.                                                 */

#if !defined(POSIX_SIGNALS) && !defined(BSD_SIGNALS)

static sigset_t blocked_set;

#endif

#ifdef POSIX_SIGNALS

# define signal_jmp_buf       sigjmp_buf

# define signal_setjmp(b)     sigsetjmp((b),1)

# define signal_longjmp(b,n)  siglongjmp((b),(n))

#else

# define signal_jmp_buf       jmp_buf

# define signal_setjmp(b)     setjmp(b)

# define signal_longjmp(b,n)  longjmp((b),(n))

#endif

#ifdef NO_SIGNAL_BLOCKING

# define signal_process(sig)  signal_ignore(sig)

# define signal_reset(sig)    install_handler(sig)

#else

# define signal_process(sig)  ;

# define signal_reset(sig)    ;

#endif

/* Install signal handler for given signal.           *

 * If possible, we want to make sure that interrupted *

 * system calls are not restarted.                    */

/**/

mod_export void

install_handler(int sig)

{

#ifdef POSIX_SIGNALS

    struct sigaction act;

    act.sa_handler = (SIGNAL_HANDTYPE) zhandler;

    sigemptyset(&act.sa_mask);        /* only block sig while in handler */

    act.sa_flags = 0;

# ifdef SA_INTERRUPT                  /* SunOS 4.x */

    if (interact)

        act.sa_flags |= SA_INTERRUPT; /* make sure system calls are not restarted */

# endif

#ifndef __SYMBIAN32__

    sigaction(sig, &act, (struct sigaction *)NULL);

#endif    

#else

# ifdef BSD_SIGNALS

    struct sigvec vec;

    vec.sv_handler = (SIGNAL_HANDTYPE) zhandler;

    vec.sv_mask = sigmask(sig);    /* mask out this signal while in handler    */

#  ifdef SV_INTERRUPT

    vec.sv_flags = SV_INTERRUPT;   /* make sure system calls are not restarted */

#  endif

    sigvec(sig, &vec, (struct sigvec *)NULL);

# else

#  ifdef SYSV_SIGNALS

    /* we want sigset rather than signal because it will   *

     * block sig while in handler.  signal usually doesn't */

    sigset(sig, zhandler);

#  else  /* NO_SIGNAL_BLOCKING (bummer) */

#ifndef __SYMBIAN32__

    signal(sig, zhandler); 

#endif

#  endif /* SYSV_SIGNALS  */

# endif  /* BSD_SIGNALS   */

#endif   /* POSIX_SIGNALS */

}

/* enable ^C interrupts */

/**/

mod_export void

intr(void)

{

    if (interact)

        install_handler(SIGINT);

}

/* disable ^C interrupts */

#if 0 /**/

void

nointr(void)

{

    if (interact)

        signal_ignore(SIGINT);

}

#endif

/* temporarily block ^C interrupts */

/**/

mod_export void

holdintr(void)

{

    if (interact)

        signal_block(signal_mask(SIGINT));

}

/* release ^C interrupts */

/**/

mod_export void

noholdintr(void)

{

    if (interact)

        signal_unblock(signal_mask(SIGINT));

}

/* create a signal mask containing *

 * only the given signal           */

/**/

sigset_t

signal_mask(int sig)

{

    sigset_t set;

    sigemptyset(&set);

    if (sig)

        sigaddset(&set, sig);

    return set;

}

/* Block the signals in the given signal *

 * set. Return the old signal set.       */

/**/

#ifdef POSIX_SIGNALS

/**/

mod_export sigset_t dummy_sigset1, dummy_sigset2;

/**/

#else

/**/

#ifndef BSD_SIGNALS

sigset_t

signal_block(sigset_t set)

{

    sigset_t oset;

#ifdef SYSV_SIGNALS

    int i;

    oset = blocked_set;

    for (i = 1; i <= NSIG; ++i) {

        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {

            sigaddset(&blocked_set, i);

            sighold(i);

        }

    }

#else  /* NO_SIGNAL_BLOCKING */

/* We will just ignore signals if the system doesn't have *

 * the ability to block them.                             */

    int i;

    oset = blocked_set;

    for (i = 1; i <= NSIG; ++i) {

        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {

            sigaddset(&blocked_set, i);

            signal_ignore(i);

        }

   }

#endif /* SYSV_SIGNALS  */

    return oset;

}

/**/

#endif /* BSD_SIGNALS */

/**/

#endif /* POSIX_SIGNALS */

/* Unblock the signals in the given signal *

 * set. Return the old signal set.         */

#ifndef POSIX_SIGNALS

sigset_t

signal_unblock(sigset_t set)

{

    sigset_t oset;

#ifndef __SYMBIAN32__

# ifdef BSD_SIGNALS

    sigfillset(&oset);

    oset = sigsetmask(oset);

    sigsetmask(oset & ~set);

# else

#  ifdef SYSV_SIGNALS

    int i;

    oset = blocked_set;

    for (i = 1; i <= NSIG; ++i) {

        if (sigismember(&set, i) && sigismember(&blocked_set, i)) {

            sigdelset(&blocked_set, i);

            sigrelse(i);

        }

    }

#  else  /* NO_SIGNAL_BLOCKING */

/* On systems that can't block signals, we are just ignoring them.  So *

 * to unblock signals, we just reenable the signal handler for them.   */

    int i;

    oset = blocked_set;

    for (i = 1; i <= NSIG; ++i) {

        if (sigismember(&set, i) && sigismember(&blocked_set, i)) {

            sigdelset(&blocked_set, i);

            install_handler(i);

        }

   }

#  endif /* SYSV_SIGNALS  */

# endif  /* BSD_SIGNALS   */

#endif //__SYMBIAN32__

    return oset;

}

#endif   /* POSIX_SIGNALS */

/* set the process signal mask to *

 * be the given signal mask       */

/**/

mod_export sigset_t

signal_setmask(sigset_t set)

{

    sigset_t oset;

#ifdef POSIX_SIGNALS

    sigprocmask(35, &set, &oset);

#else

# ifdef BSD_SIGNALS

    oset = sigsetmask(set);

# else

#  ifdef SYSV_SIGNALS

    int i;

    oset = blocked_set;

    for (i = 1; i <= NSIG; ++i) {

        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {

            sigaddset(&blocked_set, i);

            sighold(i);

        } else if (!sigismember(&set, i) && sigismember(&blocked_set, i)) {

            sigdelset(&blocked_set, i);

            sigrelse(i);

        }

    }

#  else  /* NO_SIGNAL_BLOCKING */

    int i;

    oset = blocked_set;

    for (i = 1; i < NSIG; ++i) {

        if (sigismember(&set, i) && !sigismember(&blocked_set, i)) {

            sigaddset(&blocked_set, i);

            signal_ignore(i);

        } else if (!sigismember(&set, i) && sigismember(&blocked_set, i)) {

            sigdelset(&blocked_set, i);

            install_handler(i);

        }

    }

#  endif /* SYSV_SIGNALS  */

# endif  /* BSD_SIGNALS   */

#endif   /* POSIX_SIGNALS */

    return oset;

}

#if defined(NO_SIGNAL_BLOCKING)

static int suspend_longjmp = 0;

static signal_jmp_buf suspend_jmp_buf;

#endif

/**/

int

signal_suspend(int sig, int sig2)

{

    int ret;

#ifdef POSIX_SIGNALS

    sigset_t set;

#ifdef BROKEN_POSIX_SIGSUSPEND

    sigset_t oset;

#endif /* BROKEN_POSIX_SIGSUSPEND */

    if (isset(TRAPSASYNC)) {

	sigemptyset(&set);

    } else {

	sigfillset(&set);

	sigdelset(&set, sig);

	sigdelset(&set, SIGHUP);  /* still don't know why we add this? */

	if (sig2)

	    sigdelset(&set, sig2);

    }

#ifdef BROKEN_POSIX_SIGSUSPEND

    sigprocmask(SIG_SETMASK, &set, &oset);

    pause();

    sigprocmask(SIG_SETMASK, &oset, NULL);

#else /* not BROKEN_POSIX_SIGSUSPEND */

    ret = sigsuspend(&set);

#endif /* BROKEN_POSIX_SIGSUSPEND */

#else /* not POSIX_SIGNALS */

# ifdef BSD_SIGNALS

    sigset_t set;

    if (isset(TRAPSASYNC)) {

	sigemptyset(&set);

    } else {

	sigfillset(&set);

	sigdelset(&set, sig);

	if (sig2)

	    sigdelset(&set, sig2);

	ret = sigpause(set);

    }

# else

#  ifdef SYSV_SIGNALS

    ret = sigpause(sig);

#  else  /* NO_SIGNAL_BLOCKING */

    /* need to use signal_longjmp to make this race-free *

     * between the child_unblock() and pause()           */

    if (signal_setjmp(suspend_jmp_buf) == 0) {

        suspend_longjmp = 1;   /* we want to signal_longjmp after catching signal */

        child_unblock();       /* do we need to unblock sig2 as well?             */

        ret = pause();

    }

    suspend_longjmp = 0;       /* turn off using signal_longjmp since we are past *

                                * the pause() function.                           */

#  endif /* SYSV_SIGNALS  */

# endif  /* BSD_SIGNALS   */

#endif   /* POSIX_SIGNALS */

    return ret;

}

/* the signal handler */

/**/

mod_export RETSIGTYPE

zhandler(int sig)

{

    sigset_t newmask, oldmask;

#if defined(NO_SIGNAL_BLOCKING)

    int do_jump;

    signal_jmp_buf jump_to;

#endif

    signal_process(sig);

    sigfillset(&newmask);

    oldmask = signal_block(newmask);        /* Block all signals temporarily           */

#if defined(NO_SIGNAL_BLOCKING)

    do_jump = suspend_longjmp;              /* do we need to longjmp to signal_suspend */

    suspend_longjmp = 0;                    /* In case a SIGCHLD somehow arrives       */

    if (sig == SIGCHLD) {                   /* Traps can cause nested signal_suspend()  */

        if (do_jump)

            jump_to = suspend_jmp_buf;      /* Copy suspend_jmp_buf                    */

    }

#endif

    /* Are we queueing signals now?      */

    if (queueing_enabled) {

        int temp_rear = ++queue_rear % MAX_QUEUE_SIZE;

	DPUTS(temp_rear == queue_front, "BUG: signal queue full");

        if (temp_rear != queue_front) { /* Make sure it's not full (extremely unlikely) */

            queue_rear = temp_rear;                  /* ok, not full, so add to queue   */

            signal_queue[queue_rear] = sig;          /* save signal caught              */

            signal_mask_queue[queue_rear] = oldmask; /* save current signal mask        */

        }

        signal_reset(sig);

        return;

    }

    signal_setmask(oldmask);          /* Reset signal mask, signal traps ok now */

    switch (sig) {

    case SIGCHLD:

	/* keep WAITING until no more child processes to reap */

	for (;;)

	  cont: {

            int old_errno = errno; /* save the errno, since WAIT may change it */

	    int status;

	    Job jn;

	    Process pn;

            pid_t pid;

	    pid_t *procsubpid = &cmdoutpid;

	    int *procsubval = &cmdoutval;

	    struct execstack *es = exstack;

	    /*

	     * Reap the child process.

	     * If we want usage information, we need to use wait3.

	     */

#ifdef HAVE_WAIT3

# ifdef HAVE_GETRUSAGE

	    struct rusage ru;

	    pid = wait3((void *)&status, WNOHANG|WUNTRACED, &ru); 

# else

	    pid = wait3((void *)&status, WNOHANG|WUNTRACED, NULL);

# endif

#else

# ifdef HAVE_WAITPID

	    pid = waitpid(-1, &status, WNOHANG|WUNTRACED);

# else

	    pid = wait(&status);

# endif

#endif

            if (!pid)  /* no more children to reap */

                break;

	    /* check if child returned was from process substitution */

	    for (;;) {

		if (pid == *procsubpid) {

		    *procsubpid = 0;

		    if (WIFSIGNALED(status))

			*procsubval = (0200 | WTERMSIG(status));

		    else

			*procsubval = WEXITSTATUS(status);

		    get_usage();

		    goto cont;

		}

		if (!es)

		    break;

		procsubpid = &es->cmdoutpid;

		procsubval = &es->cmdoutval;

		es = es->next;

	    }

	    /* check for WAIT error */

            if (pid == -1) {

                if (errno != ECHILD)

                    zerr("wait failed: %e", NULL, errno);

                errno = old_errno;    /* WAIT changed errno, so restore the original */

                break;

            }