Return to trap.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / korn

Annotation of coherent/a/usr/bob/korn/trap.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * signal handling
                      3:  */
                      4: 
                      5: #include <stddef.h>
                      6: #include <stdlib.h>
                      7: #include <stdio.h>
                      8: #include <string.h>
                      9: #include <errno.h>
                     10: #include <signal.h>
                     11: #include <setjmp.h>
                     12: #include "sh.h"
                     13: #include "lex.h"
                     14: 
                     15: Trap sigtraps [SIGNALS] = {
                     16:        {0,     "EXIT", "Signal 0"}, /* todo: belongs in e.loc->exit */
                     17:        {SIGHUP, "HUP", "Hangup"},
                     18:        {SIGINT, "INT", "Interrupt"},
                     19:        {SIGQUIT, "QUIT", "Quit"},
                     20: #if !COHERENT
                     21:        {SIGILL, "ILL", "Illegal instruction"},
                     22: #endif
                     23:        {SIGTRAP, "TRAP", "Trace trap"},
                     24: #if !COHERENT
                     25:        {SIGIOT, "IOT", "Abort"},
                     26:        {SIGEMT, "EMT", "EMT trap"},
                     27:        {SIGFPE, "FPE", "Floating exception"},
                     28: #endif
                     29:        {SIGKILL, "KILL", "Killed"},
                     30: #if !COHERENT
                     31:        {SIGBUS, "BUS", "Bus error"},
                     32: #endif
                     33:        {SIGSEGV, "SEGV", "Memory fault"},
                     34:        {SIGSYS, "SYS", "Bad system call"},
                     35:        {SIGPIPE, "PIPE", "Broken pipe"},
                     36:        {SIGALRM, "ALRM", "Alarm clock"},
                     37:        {SIGTERM, "TERM", "Terminated"},
                     38: #if JOBS                       /* todo: need to be more portable */
                     39:        {SIGURG, "URG", "Urgent condition"}, /* BSDism */
                     40:        {SIGSTOP, "STOP", "Stop (signal)"},
                     41:        {SIGTSTP, "TSTP", "Stop"},
                     42:        {SIGCONT, "CONT", "Continue"},
                     43:        {SIGCHLD, "CHLD", "Waiting children"},
                     44:        {SIGTTIN, "TTIN", "Stop (tty input)"},
                     45:        {SIGTTOU, "TTOU", "Stop (tty output)"},
                     46: #endif
                     47: };
                     48: 
                     49: /*
                     50:  * compare two strings, mapping the case of the first string in
                     51:  * case the second string was lower case.
                     52:  */
                     53: int
                     54: namecmp(s1, s2)
                     55: char   *s1, *s2;
                     56: {
                     57:        while (*s1) {
                     58:                if (*s1 != *s2 && (!isalpha(*s1) || tolower(*s1) != *s2))
                     59:                        break;
                     60:                ++s1; ++s2;
                     61:        }
                     62:        return (*s1 - *s2);
                     63: }
                     64: 
                     65: Trap *
                     66: gettrap(name)
                     67:        char *name;
                     68: {
                     69:        int i;
                     70:        register Trap *p;
                     71: 
                     72:        if (digit(*name)) {
                     73:                i = getn(name);
                     74:                return (0 <= i && i < SIGNALS) ? &sigtraps[i] : NULL;
                     75:        }
                     76: #if 0
                     77:        if (strcmp("ERR", name) == 0)
                     78:                return &e.loc->err;
                     79:        if (strcmp("EXIT", name) == 0)
                     80:                return &e.loc->exit;
                     81: #endif
                     82:        for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
                     83:                if (namecmp(p->name, name) == 0)
                     84:                        return p;
                     85:        return NULL;
                     86: }
                     87: 
                     88: /*
                     89:  * trap signal handler
                     90:  */
                     91: void
                     92: trapsig(i)
                     93:        int i;
                     94: {
                     95:        trap = sigtraps[i].set = 1;
                     96: 
                     97:        if (i == SIGINT && e.type == E_PARSE) {
                     98:                if (source && source->type == STTY)
                     99:                        source->str = null;
                    100:                /* dangerous but necessary to deal with BSD silly signals */
                    101:                longjmp(e.jbuf, 1);
                    102:        }
                    103:        (void) signal(i, trapsig); /* todo: use sigact */
                    104: }
                    105: 
                    106: /*
                    107:  * run any pending traps
                    108:  */
                    109: runtraps()
                    110: {
                    111:        int i;
                    112:        register Trap *p;
                    113: 
                    114:        for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
                    115:                if (p->set)
                    116:                        runtrap(p);
                    117:        trap = 0;
                    118: }
                    119: 
                    120: runtrap(p)
                    121:        Trap *p;
                    122: {
                    123:        char *trapstr;
                    124: 
                    125:        p->set = 0;
                    126:        if ((trapstr = p->trap) == NULL)
                    127:                if (p->signal == SIGINT)
                    128:                        unwind();       /* return to shell() */
                    129:                else
                    130:                        return;
                    131:        if (p->signal == 0)     /* ??? */
                    132:                p->trap = 0;
                    133:        command(trapstr);
                    134: }
                    135:  
                    136: /* restore signals for children */
                    137: cleartraps()
                    138: {
                    139:        int i;
                    140:        register Trap *p;
                    141: 
                    142:        for (i = SIGNALS, p = sigtraps; --i >= 0; p++) {
                    143:                p->set = 0;
                    144:                if (p->ourtrap && signal(p->signal, SIG_IGN) != SIG_IGN)
                    145:                        (void) signal(p->signal, SIG_DFL);
                    146:        }
                    147: }
                    148: 
                    149: ignoresig(i)
                    150:        int i;
                    151: {
                    152:        if (signal(i, SIG_IGN) != SIG_IGN)
                    153:                sigtraps[i].sig_dfl = 1;
                    154: }
                    155: 
                    156: restoresigs()
                    157: {
                    158:        int i;
                    159:        register Trap *p;
                    160: 
                    161:        for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
                    162:                if (p->sig_dfl) {
                    163:                        p->sig_dfl = 0;
                    164:                        (void) signal(p->signal, SIG_DFL);
                    165:                }
                    166: }
                    167: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.