#pragma prototyped
#include "defs.h"
#include <fcin.h>
#include "io.h"
#include "history.h"
#include "shnodes.h"
#include "variables.h"
#include "jobs.h"
#include "path.h"
#define abortsig(sig) (sig==SIGABRT || sig==SIGBUS || sig==SIGILL || sig==SIGSEGV)
static char indone;
#if !_std_malloc
# include <vmalloc.h>
#endif
#if defined(VMFL) && (VMALLOC_VERSION>=20031205L)
static int malloc_done(Vmalloc_t* vm, int type, Void_t* val, Vmdisc_t* dp)
{
dp->exceptf = 0;
sh_exit(SH_EXITSIG);
return(0);
}
#endif
void sh_fault(register int sig)
{
register Shell_t *shp = sh_getinterp();
register int flag=0;
register char *trap;
register struct checkpt *pp = (struct checkpt*)shp->jmplist;
int action=0;
if(!(sig&SH_TRAP))
signal(sig, sh_fault);
sig &= ~SH_TRAP;
#ifdef SIGWINCH
if(sig==SIGWINCH)
{
int rows=0, cols=0;
int32_t v;
astwinsize(2,&rows,&cols);
if(v = cols)
nv_putval(COLUMNS, (char*)&v, NV_INT32);
if(v = rows)
nv_putval(LINES, (char*)&v, NV_INT32);
}
#endif
if(shp->savesig)
{
shp->savesig = sig;
return;
}
if((trap=shp->st.trapcom[sig]) && *trap==0)
return;
flag = shp->sigflag[sig]&~SH_SIGOFF;
if(!trap)
{
if(flag&SH_SIGIGNORE)
return;
if(flag&SH_SIGDONE)
{
void *ptr=0;
if((flag&SH_SIGINTERACTIVE) && sh_isstate(SH_INTERACTIVE) && !sh_isstate(SH_FORKED) && ! shp->subshell)
{
if(sig==SIGTERM && job.in_critical)
shp->trapnote |= SH_SIGTERM;
return;
}
shp->lastsig = sig;
sigrelease(sig);
if(pp->mode < SH_JMPFUN)
pp->mode = SH_JMPFUN;
else
pp->mode = SH_JMPEXIT;
if(sig==SIGABRT || (abortsig(sig) && (ptr = malloc(1))))
{
if(ptr)
free(ptr);
if(!shp->subshell)
sh_done(sig);
sh_exit(SH_EXITSIG);
}
shp->trapnote |= SH_SIGSET;
if(sig < shp->sigmax)
shp->sigflag[sig] |= SH_SIGSET;
#if defined(VMFL) && (VMALLOC_VERSION>=20031205L)
if(abortsig(sig))
{
Vmdisc_t* dp = vmdisc(Vmregion,0);
if(dp)
dp->exceptf = malloc_done;
}
#endif
return;
}
}
errno = 0;
if(pp->mode==SH_JMPCMD)
shp->lastsig = sig;
if(trap)
{
if(sig==SIGHUP && job.curpgid)
killpg(job.curpgid,SIGHUP);
flag = SH_SIGTRAP;
}
else
{
shp->lastsig = sig;
flag = SH_SIGSET;
#ifdef SIGTSTP
if(sig==SIGTSTP)
{
shp->trapnote |= SH_SIGTSTP;
if(pp->mode==SH_JMPCMD && sh_isstate(SH_STOPOK))
{
sigrelease(sig);
sh_exit(SH_EXITSIG);
flag = 0;
}
}
#endif
}
#ifdef ERROR_NOTIFY
if((error_info.flags&ERROR_NOTIFY) && shp->bltinfun)
action = (*shp->bltinfun)(-sig,(char**)0,(void*)0);
if(action>0)
return;
#endif
if(shp->bltinfun && shp->bltindata.notify)
{
shp->bltindata.sigset = 1;
return;
}
shp->trapnote |= flag;
if(sig < shp->sigmax)
shp->sigflag[sig] |= flag;
if(pp->mode==SH_JMPCMD && sh_isstate(SH_STOPOK))
{
if(action<0)
return;
sigrelease(sig);
sh_exit(SH_EXITSIG);
}
}
void sh_siginit(void)
{
register int sig, n=SIGTERM+1;
register const struct shtable2 *tp = shtab_signals;
sig_begin();
while(*tp->sh_name)
{
if((sig=tp->sh_number&((1<<SH_SIGBITS)-1))>n && sig<SH_TRAP)
n = sig;
tp++;
}
#if defined(_SC_SIGRT_MAX) && defined(_SIGRTMAX)
if((sig=SIGRTMAX+1)>n && sig<SH_TRAP)
n = sig;
#endif
sh.sigmax = n;
sh.st.trapcom = (char**)calloc(n,sizeof(char*));
sh.sigflag = (unsigned char*)calloc(n,1);
sh.sigmsg = (char**)calloc(n,sizeof(char*));
for(tp=shtab_signals; sig=tp->sh_number; tp++)
{
n = (sig>>SH_SIGBITS);
if((sig &= ((1<<SH_SIGBITS)-1)) > sh.sigmax)
continue;
sig--;
#if defined(_SC_SIGRT_MIN) && defined(_SIGRTMIN)
if(sig==_SIGRTMIN)
sig = SIGRTMIN;
#endif
#if defined(_SC_SIGRT_MAX) && defined(_SIGRTMAX)
if(sig==_SIGRTMAX)
sig = SIGRTMAX;
#endif
if(sig>=0)
{
sh.sigflag[sig] = n;
if(*tp->sh_name)
sh.sigmsg[sig] = (char*)tp->sh_value;
}
}
}
void sh_sigtrap(register int sig)
{
register int flag;
void (*fun)(int);
sh.st.otrapcom = 0;
if(sig==0)
sh_sigdone();
else if(!((flag=sh.sigflag[sig])&(SH_SIGFAULT|SH_SIGOFF)))
{
if((fun=signal(sig,sh_fault))==SIG_IGN)
{
signal(sig,SIG_IGN);
flag |= SH_SIGOFF;
}
else
{
flag |= SH_SIGFAULT;
if(sig==SIGALRM && fun!=SIG_DFL && fun!=sh_fault)
signal(sig,fun);
}
flag &= ~(SH_SIGSET|SH_SIGTRAP);
sh.sigflag[sig] = flag;
}
}
void sh_sigdone(void)
{
register int flag, sig = sh.sigmax;
sh.sigflag[0] |= SH_SIGFAULT;
while(--sig>0)
{
flag = sh.sigflag[sig];
if((flag&(SH_SIGDONE|SH_SIGIGNORE|SH_SIGINTERACTIVE)) && !(flag&(SH_SIGFAULT|SH_SIGOFF)))
sh_sigtrap(sig);
}
}
void sh_sigreset(register int mode)
{
register char *trap;
register int flag, sig=sh.st.trapmax;
while(sig-- > 0)
{
if(trap=sh.st.trapcom[sig])
{
flag = sh.sigflag[sig]&~(SH_SIGTRAP|SH_SIGSET);
if(*trap)
{
if(mode)
free(trap);
sh.st.trapcom[sig] = 0;
}
else if(sig && mode>1)
{
signal(sig,SIG_IGN);
flag &= ~SH_SIGFAULT;
flag |= SH_SIGOFF;
}
sh.sigflag[sig] = flag;
}
}
for(sig=SH_DEBUGTRAP;sig>=0;sig--)
{
if(trap=sh.st.trap[sig])
{
if(mode)
free(trap);
sh.st.trap[sig] = 0;
}
}
sh.st.trapcom[0] = 0;
if(mode)
sh.st.trapmax = 0;
sh.trapnote=0;
}
void sh_sigclear(register int sig)
{
register int flag = sh.sigflag[sig];
register char *trap;
sh.st.otrapcom=0;
if(!(flag&SH_SIGFAULT))
return;
flag &= ~(SH_SIGTRAP|SH_SIGSET);
if(trap=sh.st.trapcom[sig])
{
free(trap);
sh.st.trapcom[sig]=0;
}
sh.sigflag[sig] = flag;
}
void sh_chktrap(void)
{
register int sig=sh.st.trapmax;
register char *trap;
if(!sh.trapnote)
sig=0;
sh.trapnote &= ~SH_SIGTRAP;
if(sh_isstate(SH_ERREXIT) && sh.exitval)
{
int sav_trapnote = sh.trapnote;
sh.trapnote &= ~SH_SIGSET;
if(sh.st.trap[SH_ERRTRAP])
{
trap = sh.st.trap[SH_ERRTRAP];
sh.st.trap[SH_ERRTRAP] = 0;
sh_trap(trap,0);
sh.st.trap[SH_ERRTRAP] = trap;
}
sh.trapnote = sav_trapnote;
if(sh_isoption(SH_ERREXIT))
{
struct checkpt *pp = (struct checkpt*)sh.jmplist;
pp->mode = SH_JMPEXIT;
sh_exit(sh.exitval);
}
}
if(sh.sigflag[SIGALRM]&SH_SIGALRM)
sh_timetraps();
while(--sig>=0)
{
if(sh.sigflag[sig]&SH_SIGTRAP)
{
sh.sigflag[sig] &= ~SH_SIGTRAP;
if(trap=sh.st.trapcom[sig])
sh_trap(trap,0);
}
}
}
int sh_trap(const char *trap, int mode)
{
int jmpval, savxit = sh.exitval;
int was_history = sh_isstate(SH_HISTORY);
int was_verbose = sh_isstate(SH_VERBOSE);
int staktop = staktell();
char *savptr = stakfreeze(0);
struct checkpt buff;
Fcin_t savefc;
fcsave(&savefc);
sh_offstate(SH_HISTORY);
sh_offstate(SH_VERBOSE);
sh.intrap++;
sh_pushcontext(&buff,SH_JMPTRAP);
jmpval = sigsetjmp(buff.buff,0);
if(jmpval == 0)
{
if(mode==2)
sh_exec((Shnode_t*)trap,sh_isstate(SH_ERREXIT));
else
{
Sfio_t *sp;
if(mode)
sp = (Sfio_t*)trap;
else
sp = sfopen(NIL(Sfio_t*),trap,"s");
sh_eval(sp,0);
}
}
else if(indone)
{
if(jmpval==SH_JMPSCRIPT)
indone=0;
else
{
if(jmpval==SH_JMPEXIT)
savxit = sh.exitval;
jmpval=SH_JMPTRAP;
}
}
sh_popcontext(&buff);
sh.intrap--;
sfsync(sh.outpool);
if(jmpval!=SH_JMPEXIT && jmpval!=SH_JMPFUN)
sh.exitval=savxit;
stakset(savptr,staktop);
fcrestore(&savefc);
if(was_history)
sh_onstate(SH_HISTORY);
if(was_verbose)
sh_onstate(SH_VERBOSE);
exitset();
if(jmpval>SH_JMPTRAP)
siglongjmp(*sh.jmplist,jmpval);
return(sh.exitval);
}
void sh_exit(register int xno)
{
register struct checkpt *pp = (struct checkpt*)sh.jmplist;
register int sig=0;
register Sfio_t* pool;
sh.exitval=xno;
if(xno==SH_EXITSIG)
sh.exitval |= (sig=sh.lastsig);
#ifdef SIGTSTP
if(sh.trapnote&SH_SIGTSTP)
{
sh.trapnote = 0;
sh.sigflag[SIGTSTP] = 0;
if(!sh.subshell && sh_isstate(SH_MONITOR) && !sh_isstate(SH_STOPOK))
return;
if(sh_isstate(SH_TIMING))
return;
sh.lastsig = 0;
sh_onstate(SH_MONITOR);
sh_offstate(SH_STOPOK);
sh.trapnote = 0;
if(!sh.subshell && (sig=sh_fork(0,NIL(int*))))
{
job.curpgid = 0;
job.parent = (pid_t)-1;
job_wait(sig);
job.parent = 0;
sh.sigflag[SIGTSTP] = 0;
sh.exitval = (SH_EXITSIG|SIGTSTP);
pp->mode = SH_JMPERREXIT;
}
else
{
if(sh.subshell)
sh_subfork();
sh_offstate(SH_STOPOK);
sh_offstate(SH_MONITOR);
sh.sigflag[SIGTSTP] = 0;
killpg(job.curpgid,SIGTSTP);
job_clear();
sh.forked = 1;
sh.exitval = (xno&SH_EXITMASK);
return;
}
}
#endif
sh_offstate(SH_NOTRACK);
if(!(pool=sfpool(NIL(Sfio_t*),sh.outpool,SF_WRITE)))
pool = sh.outpool;
sfclrlock(pool);
#ifdef SIGPIPE
if(sh.lastsig==SIGPIPE)
sfpurge(pool);
#endif
sfclrlock(sfstdin);
if(!pp)
sh_done(sig);
sh.prefix = 0;
if(pp->mode == SH_JMPSCRIPT && !pp->prev)
sh_done(sig);
siglongjmp(pp->buff,pp->mode);
}
void sh_done(register int sig)
{
register char *t;
register int savxit = sh.exitval;
sh.trapnote = 0;
indone=1;
if(sig==0)
sig = sh.lastsig;
if(sh.userinit)
(*sh.userinit)(-1);
if(t=sh.st.trapcom[0])
{
sh.st.trapcom[0]=0;
sh.oldexit = savxit;
sh_trap(t,0);
savxit = sh.exitval;
}
else
{
sh_offstate(SH_ERREXIT);
sh_chktrap();
}
sh_freeup();
#if SHOPT_ACCT
sh_accend();
#endif
#if SHOPT_VSH || SHOPT_ESH
if(sh_isoption(SH_EMACS)||sh_isoption(SH_VI)||sh_isoption(SH_GMACS))
tty_cooked(-1);
#endif
#ifdef JOBS
if((sh_isoption(SH_INTERACTIVE) && sh.login_sh) || (!sh_isoption(SH_INTERACTIVE) && (sig==SIGHUP)))
job_walk(sfstderr,job_terminate,SIGHUP,NIL(char**));
#endif
job_close();
if(nv_search("VMTRACE", sh.var_tree,0))
strmatch((char*)0,(char*)0);
sfsync((Sfio_t*)sfstdin);
sfsync((Sfio_t*)sh.outpool);
sfsync((Sfio_t*)sfstdout);
if(sig)
{
signal(sig,SIG_DFL);
sigrelease(sig);
kill(getpid(),sig);
pause();
}
#if SHOPT_KIA
if(sh_isoption(SH_NOEXEC))
kiaclose();
#endif
exit(savxit&SH_EXITMASK);
}