1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
|
/*
* signals.c - signals handling code
*
* 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"
/* 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];
/* 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
sigaction(sig, &act, (struct sigaction *)NULL);
#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) */
signal(sig, zhandler);
# 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;
# 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 */
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(SIG_SETMASK, &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 */
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;
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;
}
/* What flavor of waitpid/wait3/wait shall we use? */
#ifdef HAVE_WAITPID
# define WAIT(pid, statusp, options) waitpid(pid, statusp, options)
#else
# ifdef HAVE_WAIT3
# define WAIT(pid, statusp, options) wait3((void *) statusp, options, NULL)
# else
# define WAIT(pid, statusp, options) wait(statusp)
# endif
#endif
/* 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 child_suspend() */
if (do_jump)
jump_to = suspend_jmp_buf; /* Copy suspend_jmp_buf */
}
#endif
if (queueing_enabled) { /* Are we queueing signals now? */
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;
pid = WAIT(-1, &status, WNOHANG|WUNTRACED); /* reap the child process */
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);
times(&shtms);
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;
}
/* Find the process and job containing this pid and update it. */
if (findproc(pid, &jn, &pn)) {
update_process(pn, status);
update_job(jn);
} else {
/* If not found, update the shell record of time spent by
* children in sub processes anyway: otherwise, this
* will get added on to the next found process that terminates.
*/
times(&shtms);
}
}
break;
case SIGHUP:
if (sigtrapped[SIGHUP])
dotrap(SIGHUP);
else {
stopmsg = 1;
zexit(SIGHUP, 1);
}
break;
case SIGINT:
if (sigtrapped[SIGINT])
dotrap(SIGINT);
else {
if ((isset(PRIVILEGED) || isset(RESTRICTED)) &&
isset(INTERACTIVE) && noerrexit < 0)
zexit(SIGINT, 1);
if (list_pipe || chline || simple_pline) {
breaks = loops;
errflag = 1;
inerrflush();
}
}
break;
#ifdef SIGWINCH
case SIGWINCH:
adjustwinsize(1); /* check window size and adjust */
if (sigtrapped[SIGWINCH])
dotrap(SIGWINCH);
break;
#endif
case SIGALRM:
if (sigtrapped[SIGALRM]) {
int tmout;
dotrap(SIGALRM);
if ((tmout = getiparam("TMOUT")))
alarm(tmout); /* reset the alarm */
} else {
int idle = ttyidlegetfn(NULL);
int tmout = getiparam("TMOUT");
if (idle >= 0 && idle < tmout)
alarm(tmout - idle);
else {
errflag = noerrs = 0;
zwarn("timeout", NULL, 0);
stopmsg = 1;
zexit(SIGALRM, 1);
}
}
break;
default:
dotrap(sig);
break;
} /* end of switch(sig) */
signal_reset(sig);
/* This is used to make signal_suspend() race-free */
#if defined(NO_SIGNAL_BLOCKING)
if (do_jump)
signal_longjmp(jump_to, 1);
#endif
} /* handler */
/* SIGHUP any jobs left running */
/**/
void
killrunjobs(int from_signal)
{
int i, killed = 0;
if (unset(HUP))
return;
for (i = 1; i < MAXJOB; i++)
if ((from_signal || i != thisjob) && (jobtab[i].stat & STAT_LOCKED) &&
!(jobtab[i].stat & STAT_NOPRINT) &&
!(jobtab[i].stat & STAT_STOPPED)) {
if (jobtab[i].gleader != getpid() &&
killpg(jobtab[i].gleader, SIGHUP) != -1)
killed++;
}
if (killed)
zwarn("warning: %d jobs SIGHUPed", NULL, killed);
}
/* send a signal to a job (simply involves kill if monitoring is on) */
/**/
int
killjb(Job jn, int sig)
{
Process pn;
int err = 0;
if (jobbing) {
if (jn->stat & STAT_SUPERJOB) {
if (sig == SIGCONT) {
for (pn = jobtab[jn->other].procs; pn; pn = pn->next)
if (killpg(pn->pid, sig) == -1)
if (kill(pn->pid, sig) == -1 && errno != ESRCH)
err = -1;
for (pn = jn->procs; pn->next; pn = pn->next)
if (kill(pn->pid, sig) == -1 && errno != ESRCH)
err = -1;
if (!jobtab[jn->other].procs && pn)
if (kill(pn->pid, sig) == -1 && errno != ESRCH)
err = -1;
return err;
}
if (killpg(jobtab[jn->other].gleader, sig) == -1 && errno != ESRCH)
err = -1;
if (killpg(jn->gleader, sig) == -1 && errno != ESRCH)
err = -1;
return err;
}
else
return killpg(jn->gleader, sig);
}
for (pn = jn->procs; pn; pn = pn->next)
if ((err = kill(pn->pid, sig)) == -1 && errno != ESRCH && sig != 0)
return -1;
return err;
}
/*
* List for saving traps. We don't usually have that many traps
* at once, so just use a linked list.
*/
struct savetrap {
int sig, flags, local;
void *list;
};
static LinkList savetraps;
static int dontsavetrap;
/*
* Save the current trap by copying it. This does nothing to
* the existing value of sigtrapped or sigfuncs.
*/
static void
dosavetrap(int sig, int level)
{
struct savetrap *st;
st = (struct savetrap *)zalloc(sizeof(*st));
st->sig = sig;
st->local = level;
if ((st->flags = sigtrapped[sig]) & ZSIG_FUNC) {
/*
* Get the old function: this assumes we haven't added
* the new one yet.
*/
char func[20];
Shfunc shf, newshf = NULL;
sprintf(func, "TRAP%s", sigs[sig]);
if ((shf = (Shfunc)shfunctab->getnode2(shfunctab, func))) {
/* Copy the node for saving */
newshf = (Shfunc) zalloc(sizeof(*newshf));
newshf->nam = ztrdup(shf->nam);
newshf->flags = shf->flags;
newshf->funcdef = dupeprog(shf->funcdef, 0);
}
#ifdef DEBUG
else dputs("BUG: no function present with function trap flag set.");
#endif
st->list = newshf;
} else if (sigtrapped[sig]) {
st->list = sigfuncs[sig] ? dupeprog(sigfuncs[sig], 0) : NULL;
} else {
DPUTS(sigfuncs[sig], "BUG: sigfuncs not null for untrapped signal");
st->list = NULL;
}
if (!savetraps)
savetraps = znewlinklist();
/*
* Put this at the front of the list
*/
zinsertlinknode(savetraps, (LinkNode)savetraps, st);
}
/**/
mod_export int
settrap(int sig, Eprog l)
{
if (sig == -1)
return 1;
if (jobbing && (sig == SIGTTOU || sig == SIGTSTP || sig == SIGTTIN)) {
zerr("can't trap SIG%s in interactive shells", sigs[sig], 0);
return 1;
}
/*
* Call unsettrap() unconditionally, to make sure trap is saved
* if necessary.
*/
queue_signals();
unsettrap(sig);
sigfuncs[sig] = l;
if (empty_eprog(l)) {
sigtrapped[sig] = ZSIG_IGNORED;
if (sig && sig <= SIGCOUNT &&
#ifdef SIGWINCH
sig != SIGWINCH &&
#endif
sig != SIGCHLD)
signal_ignore(sig);
} else {
nsigtrapped++;
sigtrapped[sig] = ZSIG_TRAPPED;
if (sig && sig <= SIGCOUNT &&
#ifdef SIGWINCH
sig != SIGWINCH &&
#endif
sig != SIGCHLD)
install_handler(sig);
}
/*
* Note that introducing the locallevel does not affect whether
* sigtrapped[sig] is zero or not, i.e. a test without a mask
* works just the same.
*/
sigtrapped[sig] |= (locallevel << ZSIG_SHIFT);
unqueue_signals();
return 0;
}
/**/
void
unsettrap(int sig)
{
HashNode hn;
queue_signals();
hn = removetrap(sig);
if (hn)
shfunctab->freenode(hn);
unqueue_signals();
}
/**/
HashNode
removetrap(int sig)
{
int trapped;
if (sig == -1 ||
(jobbing && (sig == SIGTTOU || sig == SIGTSTP || sig == SIGTTIN)))
return NULL;
queue_signals();
trapped = sigtrapped[sig];
/*
* Note that we save the trap here even if there isn't an existing
* one, to aid in removing this one. However, if there's
* already one at the current locallevel we just overwrite it.
*/
if (!dontsavetrap && (isset(LOCALTRAPS) || sig == SIGEXIT) &&
locallevel &&
(!trapped || locallevel > (sigtrapped[sig] >> ZSIG_SHIFT)))
dosavetrap(sig, locallevel);
if (!trapped) {
unqueue_signals();
return NULL;
}
if (sigtrapped[sig] & ZSIG_TRAPPED)
nsigtrapped--;
sigtrapped[sig] = 0;
if (sig == SIGINT && interact) {
/* PWS 1995/05/16: added test for interactive, also noholdintr() *
* as subshells ignoring SIGINT have it blocked from delivery */
intr();
noholdintr();
} else if (sig == SIGHUP)
install_handler(sig);
else if (sig && sig <= SIGCOUNT &&
#ifdef SIGWINCH
sig != SIGWINCH &&
#endif
sig != SIGCHLD)
signal_default(sig);
/*
* At this point we free the appropriate structs. If we don't
* want that to happen then either the function should already have been
* removed from shfunctab, or the entry in sigfuncs should have been set
* to NULL. This is no longer necessary for saving traps as that
* copies the structures, so here we are remove the originals.
* That causes a little inefficiency, but a good deal more reliability.
*/
if (trapped & ZSIG_FUNC) {
char func[20];
HashNode node;
sprintf(func, "TRAP%s", sigs[sig]);
/*
* As in dosavetrap(), don't call removeshfuncnode() because
* that calls back into unsettrap();
*/
sigfuncs[sig] = NULL;
node = removehashnode(shfunctab, func);
unqueue_signals();
return node;
} else if (sigfuncs[sig]) {
freeeprog(sigfuncs[sig]);
sigfuncs[sig] = NULL;
}
unqueue_signals();
return NULL;
}
/**/
void
starttrapscope(void)
{
/*
* SIGEXIT needs to be restored at the current locallevel,
* so give it the next higher one. dosavetrap() is called
* automatically where necessary.
*/
if (sigtrapped[SIGEXIT]) {
locallevel++;
unsettrap(SIGEXIT);
locallevel--;
}
}
/*
* Reset traps after the end of a function: must be called after
* endparamscope() so that the locallevel has been decremented.
*/
/**/
void
endtrapscope(void)
{
LinkNode ln;
struct savetrap *st;
int exittr;
void *exitfn = NULL;
/*
* Remember the exit trap, but don't run it until
* after all the other traps have been put back.
*/
if ((exittr = sigtrapped[SIGEXIT])) {
if (exittr & ZSIG_FUNC) {
exitfn = removehashnode(shfunctab, "TRAPEXIT");
} else {
exitfn = sigfuncs[SIGEXIT];
}
sigfuncs[SIGEXIT] = NULL;
if (sigtrapped[SIGEXIT] & ZSIG_TRAPPED)
nsigtrapped--;
sigtrapped[SIGEXIT] = 0;
}
if (savetraps) {
while ((ln = firstnode(savetraps)) &&
(st = (struct savetrap *) ln->dat) &&
st->local > locallevel) {
int sig = st->sig;
remnode(savetraps, ln);
if (st->flags && (st->list != NULL)) {
Eprog prog = (st->flags & ZSIG_FUNC) ?
((Shfunc) st->list)->funcdef : (Eprog) st->list;
/* prevent settrap from saving this */
dontsavetrap++;
settrap(sig, prog);
dontsavetrap--;
/*
* counting of nsigtrapped should presumably be handled
* in settrap...
*/
DPUTS((sigtrapped[sig] ^ st->flags) & ZSIG_TRAPPED,
"BUG: settrap didn't restore correct ZSIG_TRAPPED");
if ((sigtrapped[sig] = st->flags) & ZSIG_FUNC)
shfunctab->addnode(shfunctab, ((Shfunc)st->list)->nam,
(Shfunc) st->list);
} else if (sigtrapped[sig])
unsettrap(sig);
zfree(st, sizeof(*st));
}
}
if (exittr) {
dotrapargs(SIGEXIT, &exittr, (exittr & ZSIG_FUNC) ?
((Shfunc)exitfn)->funcdef : (Eprog) exitfn);
if (exittr & ZSIG_FUNC)
shfunctab->freenode((HashNode)exitfn);
else
freeeprog(exitfn);
}
DPUTS(!locallevel && savetraps && firstnode(savetraps),
"BUG: still saved traps outside all function scope");
}
/* Execute a trap function for a given signal, possibly
* with non-standard sigtrapped & sigfuncs values
*/
/**/
void
dotrapargs(int sig, int *sigtr, void *sigfn)
{
LinkList args;
char *name, num[4];
int trapret = 0;
int obreaks = breaks;
/* if signal is being ignored or the trap function *
* is NULL, then return *
* *
* Also return if errflag is set. In fact, the code in the *
* function will test for this, but this way we keep status flags *
* intact without working too hard. Special cases (e.g. calling *
* a trap for SIGINT after the error flag was set) are handled *
* by the calling code. (PWS 1995/06/08). *
* *
* This test is now replicated in dotrap(). */
if ((*sigtr & ZSIG_IGNORED) || !sigfn || errflag)
return;
*sigtr |= ZSIG_IGNORED;
lexsave();
execsave();
breaks = 0;
runhookdef(BEFORETRAPHOOK, NULL);
if (*sigtr & ZSIG_FUNC) {
int osc = sfcontext;
args = znewlinklist();
name = (char *) zalloc(5 + strlen(sigs[sig]));
sprintf(name, "TRAP%s", sigs[sig]);
zaddlinknode(args, name);
sprintf(num, "%d", sig);
zaddlinknode(args, num);
trapreturn = -1;
sfcontext = SFC_SIGNAL;
doshfunc(name, sigfn, args, 0, 1);
sfcontext = osc;
freelinklist(args, (FreeFunc) NULL);
zsfree(name);
} else
execode(sigfn, 1, 0);
runhookdef(AFTERTRAPHOOK, NULL);
if (trapreturn > 0)
trapret = trapreturn;
else if (errflag)
trapret = 1;
execrestore();
lexrestore();
if (trapret > 0) {
breaks = loops;
errflag = 1;
} else {
breaks += obreaks;
if (breaks > loops)
breaks = loops;
}
/*
* If zle was running while the trap was executed, see if we
* need to restore the display.
*/
if (zleactive && resetneeded)
zrefresh();
if (*sigtr != ZSIG_IGNORED)
*sigtr &= ~ZSIG_IGNORED;
}
/* Standard call to execute a trap for a given signal. */
/**/
void
dotrap(int sig)
{
/* Copied from dotrapargs(). */
if ((sigtrapped[sig] & ZSIG_IGNORED) || !sigfuncs[sig] || errflag)
return;
dotrapargs(sig, sigtrapped+sig, sigfuncs[sig]);
}
|