Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
727a69dc1d
NetBSD/bin/sh/trap.c

589 lines
12 KiB
C
Raw Normal View History

Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
/* $NetBSD: trap.c,v 1.40 2017/05/07 15:01:18 kre Exp $ */
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*-
sync with 4.4lite
1994-05-11 21:09:42 +04:00
* Copyright (c) 1991, 1993
* The Regents of the University of California. All rights reserved.
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
*
* 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.
Move UCB-licensed code from 4-clause to 3-clause licence. Patches provided by Joel Baker in PR 22249, verified by myself.
2003-08-07 13:05:01 +04:00
* 3. Neither the name of the University nor the names of its contributors
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
* 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.
*/
Fix compiler warnings.
1997-07-05 01:01:48 +04:00
#include <sys/cdefs.h>
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#ifndef lint
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
#if 0
Ignore result of sigaction when setting traps. Traps will succeed even on SIGKILL or SIGSTOP. This is what other bourne shells do. (suggested by mycroft)
1995-06-07 08:16:57 +04:00
static char sccsid[] = "@(#)trap.c 8.5 (Berkeley) 6/5/95";
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
#else
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
__RCSID("$NetBSD: trap.c,v 1.40 2017/05/07 15:01:18 kre Exp $");
convert to new RCS id conventions.
1995-03-21 12:01:59 +03:00
#endif
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#endif /* not lint */
Merge in my changes from vangogh, and fix the x=`false`; echo $? == 0 bug.
1995-05-12 01:28:33 +04:00
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
#include <stdio.h>
Merge in my changes from vangogh, and fix the x=`false`; echo $? == 0 bug.
1995-05-12 01:28:33 +04:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#include "shell.h"
#include "main.h"
#include "nodes.h" /* for other headers */
#include "eval.h"
#include "jobs.h"
Merge in my changes from vangogh, and fix the x=`false`; echo $? == 0 bug.
1995-05-12 01:28:33 +04:00
#include "show.h"
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#include "options.h"
PR/45069: Henning Petersen: Use prototypes from builtins.h .
2011-06-19 01:18:46 +04:00
#include "builtins.h"
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
#include "syntax.h"
#include "output.h"
#include "memalloc.h"
#include "error.h"
#include "trap.h"
#include "mystring.h"
PR/28940: David Laight: /bin/sh doesn't quote the output of trap.
2005-01-11 22:38:57 +03:00
#include "var.h"
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*
* 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 */
sync with 4.4lite
1994-05-11 21:09:42 +04:00
#define S_RESET 5 /* temporary - to reset a hard ignored sig */
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
char *trap[NSIG]; /* trap handler commands */
last sys_signame[] changes; shell can now be built from scratch
1994-05-13 03:55:26 +04:00
MKINIT char sigmode[NSIG]; /* current value of signal */
Process pending signals while waiting for a job: $ cat << EOF > hup.sh #!/bin/sh trap 'echo SIGHUP; exit 1' 1 sleep 10000 & wait EOF $ chmod +x ./hup.sh $ ./hup.sh & $ kill -HUP %1
2015-08-22 12:55:23 +03:00
static volatile char gotsig[NSIG];/* indicates specified signal received */
volatile int pendingsigs; /* indicates some signal received */
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
static int getsigaction(int, sig_t *);
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
STATIC const char *trap_signame(int);
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
/*
* return the signal number described by `p' (as a number or a name)
* or -1 if it isn't one
*/
static int
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
signame_to_signum(const char *p)
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
{
int i;
if (is_number(p))
return number(p);
if (strcasecmp(p, "exit") == 0 )
return 0;
if (strncasecmp(p, "sig", 3) == 0)
p += 3;
for (i = 0; i < NSIG; ++i)
if (strcasecmp (p, sys_signame[i]) == 0)
return i;
return -1;
}
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
/*
* return the name of a signal used by the "trap" command
*/
STATIC const char *
trap_signame(int signo)
{
static char nbuf[12];
const char *p = NULL;
if (signo == 0)
return "EXIT";
if (signo > 0 && signo < NSIG)
p = sys_signame[signo];
if (p != NULL)
return p;
(void)snprintf(nbuf, sizeof nbuf, "%d", signo);
return nbuf;
}
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
/*
* Print a list of valid signal names
*/
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
static void
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
printsignals(void)
{
int n;
out1str("EXIT ");
for (n = 1; n < NSIG; n++) {
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
out1fmt("%s", trap_signame(n));
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
if ((n == NSIG/2) || n == (NSIG - 1))
out1str("\n");
else
out1c(' ');
}
}
Ignore result of sigaction when setting traps. Traps will succeed even on SIGKILL or SIGSTOP. This is what other bourne shells do. (suggested by mycroft)
1995-06-07 08:16:57 +04:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*
* The trap builtin.
*/
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
int
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
trapcmd(int argc, char **argv)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
char *action;
char **ap;
int signo;
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
int errs = 0;
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
int printonly = 0;
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
ap = argv + 1;
if (argc == 2 && strcmp(*ap, "-l") == 0) {
printsignals();
return 0;
}
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
if (argc == 2 && strcmp(*ap, "-") == 0) {
for (signo = 0; signo < NSIG; signo++) {
if (trap[signo] == NULL)
continue;
INTOFF;
ckfree(trap[signo]);
trap[signo] = NULL;
if (signo != 0)
setsignal(signo, 0);
INTON;
}
return 0;
}
if (argc >= 2 && strcmp(*ap, "-p") == 0) {
printonly = 1;
ap++;
argc--;
}
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
if (argc > 1 && strcmp(*ap, "--") == 0) {
argc--;
ap++;
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (argc <= 1) {
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
int count;
if (printonly) {
for (count = 0, signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] == NULL) {
if (count == 0)
out1str("trap -- -");
out1fmt(" %s", trap_signame(signo));
/* oh! unlucky 13 */
if (++count >= 13) {
out1str("\n");
count = 0;
}
}
if (count)
out1str("\n");
}
for (count = 0, signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] != NULL && trap[signo][0] == '\0') {
if (count == 0)
out1str("trap -- ''");
out1fmt(" %s", trap_signame(signo));
/*
* the prefix is 10 bytes, with 4 byte
* signal names (common) we have room in
* the 70 bytes left on a normal line for
* 70/(4+1) signals, that's 14, but to
* allow for the occasional longer sig name
* we output one less...
*/
if (++count >= 13) {
out1str("\n");
count = 0;
}
}
if (count)
out1str("\n");
for (signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] != NULL && trap[signo][0] != '\0') {
out1str("trap -- ");
PR/28940: David Laight: /bin/sh doesn't quote the output of trap.
2005-01-11 22:38:57 +03:00
print_quoted(trap[signo]);
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
out1fmt(" %s\n", trap_signame(signo));
PR/28940: David Laight: /bin/sh doesn't quote the output of trap.
2005-01-11 22:38:57 +03:00
}
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
return 0;
}
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
action = NULL;
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
if (!printonly && !is_number(*ap)) {
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
if ((*ap)[0] == '-' && (*ap)[1] == '\0')
ap++; /* reset to default */
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
else
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
action = *ap++; /* can be '' for "ignore" */
argc--;
}
if (argc < 2) { /* there must be at least 1 condition */
out2str("Usage: trap [-l]\n"
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
" trap -p [condition ...]\n"
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
" trap action condition ...\n"
" trap N condition ...\n");
return 2;
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
}
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
while (*ap) {
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
signo = signame_to_signum(*ap);
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
if (signo < 0 || signo >= NSIG) {
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
/* This is not a fatal error, so sayeth posix */
outfmt(out2, "trap: '%s' bad condition\n", *ap);
errs = 1;
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
ap++;
continue;
}
ap++;
if (printonly) {
out1str("trap -- ");
if (trap[signo] == NULL)
out1str("-");
else
print_quoted(trap[signo]);
out1fmt(" %s\n", trap_signame(signo));
continue;
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
}
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
INTOFF;
if (action)
action = savestr(action);
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (trap[signo])
ckfree(trap[signo]);
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
trap[signo] = action;
Extended functionality of the trap builtin, which now closely follows POSIX recommendations. - trap now accepts signal names and signal numbers e.g. INT, SIGINT, 2 - added option -l that outputs a list of valid signals - added signal EXIT to list of valid signals - a `-' in the action part will reset specified signal to their default behaviour - changed standard output format to make it suitable as an input to another shell that achieves the same trapping results
2001-03-18 07:04:23 +03:00
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (signo != 0)
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
setsignal(signo, 0);
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
INTON;
}
Fix several problems with the implementation of the "trap" command (that is, with the command itself, not with the traps that are executed, if any). - "trap -- -l" is not rational, permit the (non-std) -l option only when given as the sole arg (ie: "trap -l"). - "trap --" is the same as just "trap" (and -- is ignored for below) - "trap action" generates a usage message (there must be at least one condition) - "trap N [condition...]" (the old form with a numeric first arg, to reset traps to default, instead of "trap - condition...") is properly detected. In particular while "trap 1 2 3" resets sighup sigint and siquit handlers to default, "trap hup int quit" runs the "hup" command on sigint or sigquit and does nothing to sighup at all. - actions can start with "-" (as can commands in general) - it may be unusual or even unwise, but it is not prohibited, and should work - bad conditions (signal names/numbers) are just a usage error (resulting in non-zero "exit status" (and a diagnostic on stderr)) they do not cause the script to abort (as a syntax error in a special builtin would.) (so says posix, very explicitly.) - when outputting the trap list ("trap") properly quote null actions (ignored conditions). This has the side effect of also generating an explicit null string ('') in other cases where null values are output, such as when reporting var values ("set") but that's OK, and might be better (VAR= and VAR='' mean the same, but the latter is more obvious.) We still do not properly handle traps=$(trap) (ie: it does not work at all, and should) but that's a different problem that needs fixing in another place.
2017-04-29 18:12:21 +03:00
return errs;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
/*
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
* Clear traps on a fork or vfork.
* Takes one arg vfork, to tell it to not be destructive of
* the parents variables.
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
clear_traps(int vforked)
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
char **tp;
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
for (tp = trap ; tp < &trap[NSIG] ; tp++) {
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
INTOFF;
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
if (!vforked) {
ckfree(*tp);
*tp = NULL;
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (tp != &trap[0])
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
setsignal(tp - trap, vforked);
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
INTON;
}
}
}
/*
* Set the signal handler for the specified signal. The routine figures
* out what it should be set to.
*/
Don't hard ignore signals that were ignored by our environment, because when we try to set a trap on them it will not work. Also while I am here: 1. don't change the action status if the signal system call failed. 2. don't try to sigignore it if signal failed. 3. clear the signal mask in case our parent blocked it for us.
2005-07-11 06:37:05 +04:00
sig_t
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
setsignal(int signo, int vforked)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
int action;
Don't hard ignore signals that were ignored by our environment, because when we try to set a trap on them it will not work. Also while I am here: 1. don't change the action status if the signal system call failed. 2. don't try to sigignore it if signal failed. 3. clear the signal mask in case our parent blocked it for us.
2005-07-11 06:37:05 +04:00
sig_t sigact = SIG_DFL, sig;
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
char *t, tsig;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if ((t = trap[signo]) == NULL)
action = S_DFL;
else if (*t != '\0')
action = S_CATCH;
else
action = S_IGN;
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
if (rootshell && !vforked && action == S_DFL) {
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
switch (signo) {
case SIGINT:
When we execute commands from a shell script, make sure that the signals are being caught (reported by Alexis Rosen), similar to the -c case. #!/bin/sh vi "$@" ^C when the script is running...
1999-03-27 16:46:19 +03:00
if (iflag || minusc || sflag == 0)
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
action = S_CATCH;
break;
case SIGQUIT:
#ifdef DEBUG
if (debug)
break;
#endif
/* FALLTHROUGH */
case SIGTERM:
if (iflag)
action = S_IGN;
break;
#if JOBS
case SIGTSTP:
case SIGTTOU:
sync with 4.4lite
1994-05-11 21:09:42 +04:00
if (mflag)
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
action = S_IGN;
break;
#endif
}
}
Avoid trapping SIGKILL. Pretend that we did, so that we will not keep failing trying to trap it later. This is what the other bourne shells do.
1995-06-05 18:24:33 +04:00
sync with 4.4lite
1994-05-11 21:09:42 +04:00
t = &sigmode[signo - 1];
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
tsig = *t;
if (tsig == 0) {
PR/2808: Remove trailing whitespace (from FreeBSD)
1996-10-16 19:45:03 +04:00
/*
* current setting unknown
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
*/
Ignore result of sigaction when setting traps. Traps will succeed even on SIGKILL or SIGSTOP. This is what other bourne shells do. (suggested by mycroft)
1995-06-07 08:16:57 +04:00
if (!getsigaction(signo, &sigact)) {
/*
* 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 0;
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (sigact == SIG_IGN) {
Don't hard ignore signals that were ignored by our environment, because when we try to set a trap on them it will not work. Also while I am here: 1. don't change the action status if the signal system call failed. 2. don't try to sigignore it if signal failed. 3. clear the signal mask in case our parent blocked it for us.
2005-07-11 06:37:05 +04:00
/*
Allow trap to work on ignored signals when the shell is interactive.
2005-07-15 21:23:48 +04:00
* POSIX 3.14.13 states that non-interactive shells
* should ignore trap commands for signals that were
* ignored upon entry, and leaves the behavior
* unspecified for interactive shells. On interactive
* shells, or if job control is on, and we have a job
* control related signal, we allow the trap to work.
*
* This change allows us to be POSIX compliant, and
* at the same time override the default behavior if
* we need to by setting the interactive flag.
Don't hard ignore signals that were ignored by our environment, because when we try to set a trap on them it will not work. Also while I am here: 1. don't change the action status if the signal system call failed. 2. don't try to sigignore it if signal failed. 3. clear the signal mask in case our parent blocked it for us.
2005-07-11 06:37:05 +04:00
*/
Allow trap to work on ignored signals when the shell is interactive.
2005-07-15 21:23:48 +04:00
if ((mflag && (signo == SIGTSTP ||
signo == SIGTTIN || signo == SIGTTOU)) || iflag) {
tsig = S_IGN;
} else
tsig = S_HARD_IGN;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
} else {
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
tsig = S_RESET; /* force to be set */
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
}
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
if (tsig == S_HARD_IGN || tsig == action)
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
return 0;
switch (action) {
case S_DFL: sigact = SIG_DFL; break;
case S_CATCH: sigact = onsig; break;
case S_IGN: sigact = SIG_IGN; break;
}
Don't hard ignore signals that were ignored by our environment, because when we try to set a trap on them it will not work. Also while I am here: 1. don't change the action status if the signal system call failed. 2. don't try to sigignore it if signal failed. 3. clear the signal mask in case our parent blocked it for us.
2005-07-11 06:37:05 +04:00
sig = signal(signo, sigact);
if (sig != SIG_ERR) {
sigset_t ss;
if (!vforked)
*t = action;
if (action == S_CATCH)
(void)siginterrupt(signo, 1);
/*
* If our parent accidentally blocked signals for
* us make sure we unblock them
*/
(void)sigemptyset(&ss);
(void)sigaddset(&ss, signo);
(void)sigprocmask(SIG_UNBLOCK, &ss, NULL);
}
return sig;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
sync with 4.4lite
1994-05-11 21:09:42 +04:00
/*
* Return the current setting for sig w/o changing it.
*/
Ignore result of sigaction when setting traps. Traps will succeed even on SIGKILL or SIGSTOP. This is what other bourne shells do. (suggested by mycroft)
1995-06-07 08:16:57 +04:00
static int
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
getsigaction(int signo, sig_t *sigact)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
sync with 4.4lite
1994-05-11 21:09:42 +04:00
struct sigaction sa;
if (sigaction(signo, (struct sigaction *)0, &sa) == -1)
Ignore result of sigaction when setting traps. Traps will succeed even on SIGKILL or SIGSTOP. This is what other bourne shells do. (suggested by mycroft)
1995-06-07 08:16:57 +04:00
return 0;
*sigact = (sig_t) sa.sa_handler;
return 1;
sync with 4.4lite
1994-05-11 21:09:42 +04:00
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*
* Ignore a signal.
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
ignoresig(int signo, int vforked)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
sync with 4.4lite
1994-05-11 21:09:42 +04:00
if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
signal(signo, SIG_IGN);
}
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
if (!vforked)
sigmode[signo - 1] = S_HARD_IGN;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
#ifdef mkinit
last sys_signame[] changes; shell can now be built from scratch
1994-05-13 03:55:26 +04:00
INCLUDE <signal.h>
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
INCLUDE "trap.h"
SHELLPROC {
char *sm;
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
clear_traps(0);
last sys_signame[] changes; shell can now be built from scratch
1994-05-13 03:55:26 +04:00
for (sm = sigmode ; sm < sigmode + NSIG ; sm++) {
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (*sm == S_IGN)
*sm = S_HARD_IGN;
}
}
#endif
/*
* Signal handler.
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
onsig(int signo)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
signal(signo, onsig);
if (signo == SIGINT && trap[SIGINT] == NULL) {
onint();
return;
}
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
gotsig[signo] = 1;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
pendingsigs++;
}
/*
* Called to execute a trap. Perhaps we should avoid entering new trap
* handlers while we are executing a trap handler.
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
dotrap(void)
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
int i;
int savestatus;
Deal with traps that reset the (same) trap in the trap handler (avoid referrencing memory that might have been freed). From FreeBSD (ages ago, just not committed until now...)
2017-04-27 01:41:53 +03:00
char *tr;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
for (;;) {
for (i = 1 ; ; i++) {
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
if (i >= NSIG) {
pendingsigs = 0;
return;
}
if (gotsig[i])
Use sys_signame[].
1993-08-07 01:50:14 +04:00
break;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
gotsig[i] = 0;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
savestatus=exitstatus;
Deal with traps that reset the (same) trap in the trap handler (avoid referrencing memory that might have been freed). From FreeBSD (ages ago, just not committed until now...)
2017-04-27 01:41:53 +03:00
tr = savestr(trap[i]); /* trap code may free trap[i] */
evalstring(tr, 0);
ckfree(tr);
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
exitstatus=savestatus;
}
}
report the signal that wait was interrupted by, which is not always SIGINT anymore.
2015-08-22 15:12:47 +03:00
int
lastsig(void)
{
int i;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
Enhance the trap command to make it possible to do what POSIX wants (even if no shell in existence, that I am aware of, does that). That is, POSIX says ... [of the trap command with no args] The shell shall format the output, including the proper use of quoting, so that it is suitable for re-input to the shell as commands that achieve the same trapping results. For example: save_traps=$(trap) ... eval "$save_traps" It is obvious what the intent is there. But no shell makes it work. An example using bash (as the NetBSD shell, still does not do the save_traps= stuff correctly - but that is a problem for a different time and place...) Given this script printf 'At start: '; trap printf '\n' traps=$(trap) trap 'echo hello' INT printf 'inside : '; trap printf '\n' eval "${traps}" printf 'At end : '; trap printf '\n' One would expect that (assuming no traps are set at the start, and there aren't) that the first trap will print nothing, then the inside trap will show the trap that was set, and then when we get to the end everything will be back to nothing again. But: At start: inside : trap -- 'echo hello' SIGINT At end : trap -- 'echo hello' SIGINT And of course. when you think about it, it is obvious why this happens. The first "trap" command prints nothing ... nothing has changed when we get to the "traps=$(trap)" command ... that trap command also prints nothing. So this does traps=''. When we do eval "${traps}" we are doing eval "", and it is hardly surprising that this accomplishes nothing! Now we cannot rationally change the "trap" command without args to behave in a way that would make it useful for the posix purpose (and here, what they're aiming for is good, it should be possible to accomplish that objective) so is there some other way? I think I have seen some shell (but I do not remember which one) that actually has "trap -" that resets all traps to the default, so with that, if we changed the 'eval "${traps}"' line to 'trap -; eval "${traps}"' then things would actually work - kind of - that version has race conditions, so is not really safe to use (it will work, most of the time...) But, both ksh93 and bash have a -p arg to "trap" that allows information about the current trap status of named signals to be reported. Unfortunately they don't do quite the same thing, but that's not important right now, either would be usable, and they are, but it is a lot of effort, not nearly as simple as the posix example. First, while "trap -p" (with no signals specified) works, it works just the same (in both bash and ksh93, aside from output format) as "trap". That is, that is useless. But we can to trap_int=$(trap -p int) trap_hup=$(trap -p hup) ... and then reset them all, one by one, later... (bash syntax) test -n "${trap_int}" && eval "${trap_int}" || trap - int test -n "${trap_hup}" && eval "${trap_hup}" || trap - hup (ksh93 syntax) trap "${trap_int:-}" int trap "${trap_hup:-}" hup the test (for bash) and variable with default for ksh93, is needed because they both still print nothing if the signal action is the default. So, this modification attempts to fix all of that... 1) we add trap -p, but make it always output something for every signal listed (all of the signals if none are given) even if the signal action is the default. 2) choose the bash output format for trap -p, over the ksh93 format, even though the simpler usage just above makes the ksh93 form seem better. But it isn't. Consider: ksh93$ trap -p int hup echo hello One of the two traps has "echo hello" as its action, the other is still at the default, but which? From bash... bash$ trap -p int hup trap -- 'echo hello' SIGINT And now we know! Given the bash 'trap -p' format, the following function produces ksh93 format output (for use with named signals only) instead... ksh93_trap_p() { for _ARG_ do _TRAP_=$(trap -p "${_ARG_}") || return 1 eval set -- "${_TRAP_}" printf '%s' "$3${3:+ }" done return 0 } [ It needs to be entered without the indentation, that '}"' line has to be at the margin. If the shell running that has local vars (bash does) then _ARG_ and _TRAP_ should be made local. ] So the bash format was chosen (except we do not include the "SIG" on the signal names. That's irrelevant.) If no traps are set, "trap -p" will say (on NetBSD of course)... trap -- - EXIT HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS trap -- - PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ trap -- - VTALRM PROF WINCH INFO USR1 USR2 PWR RT0 RT1 RT2 RT3 RT4 RT5 trap -- - RT6 RT7 RT8 RT9 RT10 RT11 RT12 RT13 RT14 RT15 RT16 RT17 RT18 trap -- - RT19 RT20 RT21 RT22 RT23 RT24 RT25 RT26 RT27 RT28 RT29 RT30 Obviously if traps are set, the relevant signal names will be removed from that list, and additional lines added for the trapped signals. With args, the signals names are listed, one line each, whatever the status of the trap for that signal is: $ trap -p HUP INT QUIT trap -- - HUP trap -- 'echo interrupted' INT trap -- - QUIT 3) we add "trap -" to reset all traps to default. (It is easy, and seems useful.) 4) While here, lots of generic cleanup. In particular, get rid of the NSIG+1 nonsense, and anything that ever believes a signo == NSIG is in any way rational. Before there was a bunch of confusion, as we need all the signals for traps, plus one more for the EXIT trap, which looks like we then need NSIG+1. But EXIT is 0, NSIG includes signals from 0..NSIG-1 but there is no signal 0, EXIT uses that slot, so we do not need to add and extra one, NSIG is enough. (To see the effect of this, use a /bin/sh from before this fix, and compare the output from trap '' 64 and trap '' 65 both invalid signal numbers. Then try just "trap" and watch your shell drop core...) Eventually NSIG needs to go away completely (from user apps), it is not POSIX, it isn't really useful (unless we make lots of assumptions about how signals are numbered, which are not guaranteed, so even if apps, like this sh, work on NetBSD, they're not portable,) and it isn't necessary (or will not be, soon.) But that is for another day... 5) As is kind of obvious above, when listing "all" traps, list all the ones still at their defaults, and all the ignored signals, on as few lines as possible (it could all be on one line - technically it would work as well, but it would have made this cvs log message really ugly...) Signals with a non-null action still get listed one to a line (even if several do have the exact same action.) 6) Man page updates as well. After this change, the following script: printf 'At start: '; trap printf '\n' trap -p >/tmp/out.$$ trap 'echo hello' INT printf 'inside : '; trap printf '\n' . /tmp/out.$$; rm /tmp/out.$$ printf 'At end : '; trap printf '\n' which is just the example from above, using "trap -p" instead of just "trap" to save the traps, and modified to a form that will work with the NetBSD shell today produces: At start: inside : trap -- 'echo hello' INT At end : [Do I get a prize for longest commit log message of the year?]
2017-05-07 18:01:18 +03:00
for (i = NSIG; --i > 0; )
if (gotsig[i])
report the signal that wait was interrupted by, which is not always SIGINT anymore.
2015-08-22 15:12:47 +03:00
return i;
return SIGINT; /* XXX */
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
/*
* Controls whether the shell is interactive or not.
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
setinteractive(int on)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
sync with 4.4lite
1994-05-11 21:09:42 +04:00
static int is_interactive;
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
if (on == is_interactive)
return;
VFork()ing shell: From elric@netbsd.org: Plus my changes: - walking process group fix in foregrounding a job. - reset of process group in parent shell if interrupted before the wait. - move INTON lower in the dowait so that the job structure is consistent. - error check all setpgid(), tcsetpgrp() calls. - eliminate unneeded strpgid() call. - check that we don't belong in the process group before we try to set it.
2002-09-27 22:56:50 +04:00
setsignal(SIGINT, 0);
setsignal(SIGQUIT, 0);
setsignal(SIGTERM, 0);
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
is_interactive = on;
}
/*
* Called to exit the shell.
*/
void
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
exitshell(int status)
clean up further. more patches from Jim Jegers
1994-12-05 22:07:32 +03:00
{
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
struct jmploc loc1, loc2;
char *p;
Fixes from David Laight: - ansification - format of output of jobs command (etc) - job identiers %+, %- etc - $? and $(...) - correct quoting of output of set, export -p and readonly -p - differentiation between nornal and 'posix special' builtins - correct behaviour (posix) for errors on builtins and special builtins - builtin printf and kill - set -o debug (if compiled with DEBUG) - cd src obj (as ksh - too useful to do without) - unset -e name, remove non-readonly variable from export list. (so I could unset -e PS1 before running the test shell...)
2002-11-25 01:35:38 +03:00
TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
sync with 4.4lite
1994-05-11 21:09:42 +04:00
if (setjmp(loc1.loc)) {
goto l1;
}
if (setjmp(loc2.loc)) {
goto l2;
}
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
handler = &loc1;
if ((p = trap[0]) != NULL && *p != '\0') {
trap[0] = NULL;
Fix bin/9184, bin/9194, bin/9265, bin/9266 Exitcode and negation problems (From Martin Husemann)
2000-01-28 02:39:38 +03:00
evalstring(p, 0);
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
l1: handler = &loc2; /* probably unnecessary */
flushall();
#if JOBS
setjobctl(0);
#endif
l2: _exit(status);
Delint.
1998-07-28 09:31:22 +04:00
/* NOTREACHED */
initial import of 386bsd-0.1 sources
1993-03-21 12:45:37 +03:00
}
Reference in New Issue Copy Permalink