Subversion Repositories HelenOS

/*  $NetBSD: trap.c,v 1.24 2000/05/22 10:18:47 elric Exp $  */

/*-

 * Copyright (c) 1991, 1993

 *  The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Kenneth Almquist.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *  This product includes software developed by the University of

 *  California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/cdefs.h>

#ifndef lint

#if 0

static char sccsid[] = "@(#)trap.c  8.5 (Berkeley) 6/5/95";

#else

__RCSID("$NetBSD: trap.c,v 1.24 2000/05/22 10:18:47 elric Exp $");

#endif

#endif /* not lint */

#include <signal.h>

#include <unistd.h>

#include <stdlib.h>

#include "shell.h"

#include "main.h"

#include "nodes.h"  /* for other headers */

#include "eval.h"

#include "jobs.h"

#include "show.h"

#include "options.h"

#include "syntax.h"

#include "output.h"

#include "memalloc.h"

#include "error.h"

#include "trap.h"

#include "mystring.h"

#include "mail.h"

#ifdef HETIO

#include "hetio.h"

#endif

/*

 * Sigmode records the current value of the signal handlers for the various

 * modes.  A value of zero means that the current handler is not known.

 * S_HARD_IGN indicates that the signal was ignored on entry to the shell,

 */

#define S_DFL 1         /* default signal handling (SIG_DFL) */

#define S_CATCH 2       /* signal is caught */

#define S_IGN 3         /* signal is ignored (SIG_IGN) */

#define S_HARD_IGN 4        /* signal is ignored permenantly */

#define S_RESET 5       /* temporary - to reset a hard ignored sig */

extern char nullstr[1];     /* null string */

char *trap[NSIG+1];     /* trap handler commands */

MKINIT char sigmode[NSIG];  /* current value of signal */

char gotsig[NSIG];      /* indicates specified signal received */

int pendingsigs;            /* indicates some signal received */

extern char *signal_names[];

/*

 * The trap builtin.

 */

int

trapcmd(argc, argv)

    int argc;

    char **argv;

{

    char *action;

    char **ap;

    int signo;

    if (argc <= 1) {

        for (signo = 0 ; signo <= NSIG ; signo++) {

            if (trap[signo] != NULL)

                out1fmt("%d: %s\n", signo, trap[signo]);

        }

        return 0;

    }

    ap = argv + 1;

    if (argc == 2)

        action = NULL;

    else

        action = *ap++;

    while (*ap) {

        if ((signo = decode_signal(*ap)) < 0)

            error("%s: bad trap", *ap);

        INTOFF;

        if (action) {

            if (action[0] == '-' && action[1] == '\0')

                action = NULL;

            else

                action = savestr(action);

        }

        if (trap[signo])

            ckfree(trap[signo]);

        trap[signo] = action;

        if (signo != 0)

            setsignal(signo);

        INTON;

        ap++;

    }

    return 0;

}

/*

 * Clear traps on a fork.

 */

void

clear_traps() {

    char **tp;

    for (tp = trap ; tp <= &trap[NSIG] ; tp++) {

        if (*tp && **tp) {  /* trap not NULL or SIG_IGN */

            INTOFF;

            ckfree(*tp);

            *tp = NULL;

            if (tp != &trap[0])

                setsignal(tp - trap);

            INTON;

        }

    }

}

/*

 * Set the signal handler for the specified signal.  The routine figures

 * out what it should be set to.

 */

void

setsignal(signo)

    int signo;

{

    int action;

    char *t;

    struct sigaction act;

    if ((t = trap[signo]) == NULL)

        action = S_DFL;

    else if (*t != '\0')

        action = S_CATCH;

    else

        action = S_IGN;

    if (rootshell && action == S_DFL) {

        switch (signo) {

        case SIGINT:

            if (iflag || minusc || sflag == 0)

                action = S_CATCH;

            break;

        case SIGQUIT:

#ifdef DEBUG

            {

            extern int debug;

            if (debug)

                break;

            }

#endif

            /* FALLTHROUGH */

        case SIGTERM:

            if (iflag)

                action = S_IGN;

            break;

#if JOBS

        case SIGTSTP:

        case SIGTTOU:

            if (mflag)

                action = S_IGN;

            break;

#endif

        }

    }

    t = &sigmode[signo - 1];

    if (*t == 0) {

        /*

         * current setting unknown

         */

        if (sigaction(signo, 0, &act) == -1) {

            /*

             * Pretend it worked; maybe we should give a warning

             * here, but other shells don't. We don't alter

             * sigmode, so that we retry every time.

             */

            return;

        }

        if (act.sa_handler == SIG_IGN) {

            if (mflag && (signo == SIGTSTP ||

                 signo == SIGTTIN || signo == SIGTTOU)) {

                *t = S_IGN; /* don't hard ignore these */

            } else

                *t = S_HARD_IGN;

        } else {

            *t = S_RESET;   /* force to be set */

        }

    }

    if (*t == S_HARD_IGN || *t == action)

        return;

    switch (action) {

    case S_CATCH:

        act.sa_handler = onsig;

        break;

    case S_IGN:

        act.sa_handler = SIG_IGN;

        break;

    default:

        act.sa_handler = SIG_DFL;

    }

    *t = action;

    act.sa_flags = 0;

    sigemptyset(&act.sa_mask);

    sigaction(signo, &act, 0);

}

/*

 * Ignore a signal.

 */

void

ignoresig(signo)

    int signo;

{

    if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {

        signal(signo, SIG_IGN);

    }

    sigmode[signo - 1] = S_HARD_IGN;

}

#ifdef mkinit

INCLUDE <signal.h>

INCLUDE "trap.h"

SHELLPROC {

    char *sm;

    clear_traps();

    for (sm = sigmode ; sm < sigmode + NSIG ; sm++) {

        if (*sm == S_IGN)

            *sm = S_HARD_IGN;

    }

}

#endif

/*

 * Signal handler.

 */

void

onsig(signo)

    int signo;

{

    signal(signo, onsig);

    if (signo == SIGINT && trap[SIGINT] == NULL) {

        onint();

        return;

    }

    gotsig[signo - 1] = 1;

    pendingsigs++;

}

/*

 * Called to execute a trap.  Perhaps we should avoid entering new trap

 * handlers while we are executing a trap handler.

 */

void

dotrap() {

    int i;

    int savestatus;

    for (;;) {

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

            if (gotsig[i - 1])

                break;

            if (i >= NSIG)

                goto done;

        }

        gotsig[i - 1] = 0;

        savestatus=exitstatus;

        evalstring(trap[i], 0);

        exitstatus=savestatus;

    }

done:

    pendingsigs = 0;

}

/*

 * Controls whether the shell is interactive or not.

 */

void

setinteractive(on)

    int on;

{

    static int is_interactive;

    if (on == is_interactive)

        return;

    setsignal(SIGINT);

    setsignal(SIGQUIT);

    setsignal(SIGTERM);

    chkmail(1);

    is_interactive = on;

}

/*

 * Called to exit the shell.

 */

void

exitshell(status)

    int status;

{

    struct jmploc loc1, loc2;

    char *p;

    TRACE(("exitshell(%d) pid=%d\n", status, getpid()));

#ifdef HETIO

    hetio_reset_term();

#endif

    if (setjmp(loc1.loc)) {

        goto l1;

    }

    if (setjmp(loc2.loc)) {

        goto l2;

    }

    handler = &loc1;

    if ((p = trap[0]) != NULL && *p != '\0') {

        trap[0] = NULL;

        evalstring(p, 0);

    }

l1:   handler = &loc2;          /* probably unnecessary */

    flushall();

#if JOBS

    setjobctl(0);

#endif

l2:   _exit(status);

    /* NOTREACHED */

}

int decode_signal(const char *string)

{

    int signo;

    if (is_number(string)) return atoi(string);

    for (signo=0; signo < NSIG; signo++)

        if (strcasecmp(string, signal_names[signo]) == 0 ||

            strcasecmp(string, &(signal_names[signo])[3]) == 0)

            return signo;

    return -1;

}