1 files changed, 44 insertions, 3 deletions

diff --git a/shell/hush.c b/shell/hush.c
index bced388bf..357a354e2 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -988,6 +988,10 @@ struct globals {
 # define G_fatal_sig_mask 0
 #endif
 #if ENABLE_HUSH_TRAP
+        int pre_trap_exitcode;
+# if ENABLE_HUSH_FUNCTIONS
+        int return_exitcode;
+# endif
         char **traps; /* char *traps[NSIG] */
 # define G_traps G.traps
 #else
@@ -2097,25 +2101,35 @@ static int check_and_run_traps(void)
                 } while (sig < NSIG);
                 break;
  got_sig:
+#if ENABLE_HUSH_TRAP
                 if (G_traps && G_traps[sig]) {
                         debug_printf_exec("%s: sig:%d handler:'%s'\n", __func__, sig, G.traps[sig]);
                         if (G_traps[sig][0]) {
                                 /* We have user-defined handler */
                                 smalluint save_rcode;
+                                int save_pre;
                                 char *argv[3];
                                 /* argv[0] is unused */
                                 argv[1] = xstrdup(G_traps[sig]);
                                 /* why strdup? trap can modify itself: trap 'trap "echo oops" INT' INT */
                                 argv[2] = NULL;
-                                save_rcode = G.last_exitcode;
+                                save_pre = G.pre_trap_exitcode;
+                                G.pre_trap_exitcode = save_rcode = G.last_exitcode;
                                 builtin_eval(argv);
                                 free(argv[1]);
-//FIXME: shouldn't it be set to 128 + sig instead?
+                                G.pre_trap_exitcode = save_pre;
                                 G.last_exitcode = save_rcode;
+# if ENABLE_HUSH_FUNCTIONS
+                                if (G.return_exitcode >= 0) {
+                                        debug_printf_exec("trap exitcode:%d\n", G.return_exitcode);
+                                        G.last_exitcode = G.return_exitcode;
+                                }
+# endif
                                 last_sig = sig;
                         } /* else: "" trap, ignoring signal */
                         continue;
                 }
+#endif
                 /* not a trap: special action */
                 switch (sig) {
                 case SIGINT:
@@ -8127,6 +8141,10 @@ static int run_function(const struct function *funcp, char **argv)
         IF_HUSH_LOCAL(leave_var_nest_level();)
 
         G_flag_return_in_progress = sv_flg;
+# if ENABLE_HUSH_TRAP
+        debug_printf_exec("G.return_exitcode=-1\n");
+        G.return_exitcode = -1; /* invalidate stashed return value */
+# endif
 
         restore_G_args(&sv, argv);
 
@@ -9628,6 +9646,9 @@ static int run_list(struct pipe *pi)
                         debug_printf_exec(": builtin/func exitcode %d\n", rcode);
                         G.last_exitcode = rcode;
                         check_and_run_traps();
+#if ENABLE_HUSH_TRAP && ENABLE_HUSH_FUNCTIONS
+                        rcode = G.last_exitcode; /* "return" in trap can change it, read back */
+#endif
 #if ENABLE_HUSH_LOOPS
                         /* Was it "break" or "continue"? */
                         if (G.flag_break_continue) {
@@ -9684,6 +9705,9 @@ static int run_list(struct pipe *pi)
  check_traps:
                         G.last_exitcode = rcode;
                         check_and_run_traps();
+#if ENABLE_HUSH_TRAP && ENABLE_HUSH_FUNCTIONS
+                        rcode = G.last_exitcode; /* "return" in trap can change it, read back */
+#endif
                 }
 
                 /* Handle "set -e" */
@@ -9907,6 +9931,12 @@ int hush_main(int argc, char **argv)
         INIT_G();
         if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
                 G.last_exitcode = EXIT_SUCCESS;
+#if ENABLE_HUSH_TRAP
+# if ENABLE_HUSH_FUNCTIONS
+        G.return_exitcode = -1;
+# endif
+        G.pre_trap_exitcode = -1;
+#endif
 
 #if ENABLE_HUSH_FAST
         G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
@@ -10552,8 +10582,13 @@ static int FAST_FUNC builtin_exit(char **argv)
 
         /* note: EXIT trap is run by hush_exit */
         argv = skip_dash_dash(argv);
-        if (argv[0] == NULL)
+        if (argv[0] == NULL) {
+#if ENABLE_HUSH_TRAP
+                if (G.pre_trap_exitcode >= 0) /* "exit" in trap uses $? from before the trap */
+                        hush_exit(G.pre_trap_exitcode);
+#endif
                 hush_exit(G.last_exitcode);
+        }
         /* mimic bash: exit 123abc == exit 255 + error msg */
         xfunc_error_retval = 255;
         /* bash: exit -2 == exit 254, no error msg */
@@ -11745,6 +11780,12 @@ static int FAST_FUNC builtin_return(char **argv)
          * 255  <== we also do this
          */
         rc = parse_numeric_argv1(argv, G.last_exitcode, 0);
+# if ENABLE_HUSH_TRAP
+        if (argv[1]) { /* "return ARG" inside a running trap sets $? */
+                debug_printf_exec("G.return_exitcode=%d\n", rc);
+                G.return_exitcode = rc;
+        }
+# endif
         return rc;
 }
 #endif