ash: cleanup part 5

1 files changed, 439 insertions, 464 deletions

diff --git a/shell/ash.c b/shell/ash.c
index 7ffecf43d..54fc8ea48 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -175,6 +175,18 @@ static int exsig;
 static volatile sig_atomic_t pendingsigs;
 
 /*
+ * 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 */
+#define S_RESET 5               /* temporary - to reset a hard ignored sig */
+
+/*
  * These macros allow the user to suspend the handling of interrupt signals
  * over a period of time.  This is similar to SIGHOLD to or sigblock, but
  * much more efficient and portable.  (But hacking the kernel is so much
@@ -285,6 +297,34 @@ force_int_on(void)
         })
 /* EXSIG is turned off by evalbltin(). */
 
+/*
+ * Ignore a signal. Only one usage site - in forkchild()
+ */
+static void
+ignoresig(int signo)
+{
+        if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
+                signal(signo, SIG_IGN);
+        }
+        sigmode[signo - 1] = S_HARD_IGN;
+}
+
+/*
+ * Signal handler. Only one usage site - in setsignal()
+ */
+static void
+onsig(int signo)
+{
+        gotsig[signo - 1] = 1;
+        pendingsigs = signo;
+
+        if (exsig || (signo == SIGINT && !trap[SIGINT])) {
+                if (!suppressint)
+                        raise_interrupt();
+                intpending = 1;
+        }
+}
+
 
 /* ============ stdout/stderr output */
 
@@ -3244,10 +3284,10 @@ static void unsetfunc(const char *);
 
 #if ENABLE_ASH_MATH_SUPPORT_64
 typedef int64_t arith_t;
-#define arith_t_type (long long)
+#define arith_t_type long long
 #else
 typedef long arith_t;
-#define arith_t_type (long)
+#define arith_t_type long
 #endif
 
 #if ENABLE_ASH_MATH_SUPPORT
@@ -3341,7 +3381,6 @@ static int jobctl;              /* true if doing job control */
 static struct job *makejob(union node *, int);
 static int forkshell(struct job *, union node *, int);
 static int waitforjob(struct job *);
-static int stoppedjobs(void);
 
 #if ! JOBS
 #define setjobctl(on)   /* do nothing */
@@ -3384,8 +3423,6 @@ static int redirectsafe(union node *, int);
 
 static void clear_traps(void);
 static void setsignal(int);
-static void ignoresig(int);
-static void onsig(int);
 static int dotrap(void);
 static void setinteractive(int);
 static void exitshell(void) ATTRIBUTE_NORETURN;
@@ -7226,38 +7263,26 @@ closescript(void)
 #define DOWAIT_NORMAL 0
 #define DOWAIT_BLOCK 1
 
-/* array of jobs */
-static struct job *jobtab;
-/* size of array */
-static unsigned njobs;
 #if JOBS
 /* pgrp of shell on invocation */
 static int initialpgrp;
 static int ttyfd = -1;
 #endif
+/* array of jobs */
+static struct job *jobtab;
+/* size of array */
+static unsigned njobs;
 /* current job */
 static struct job *curjob;
 /* number of presumed living untracked jobs */
 static int jobless;
 
-static void set_curjob(struct job *, unsigned);
 #if JOBS
-static int restartjob(struct job *, int);
-static void xtcsetpgrp(int, pid_t);
 static char *commandtext(union node *);
 static void cmdlist(union node *, int);
 static void cmdtxt(union node *);
 static void cmdputs(const char *);
-static void showpipe(struct job *, FILE *);
 #endif
-static int sprint_status(char *, int, int);
-static void freejob(struct job *);
-static struct job *getjob(const char *, int);
-static struct job *growjobtab(void);
-static void forkchild(struct job *, union node *, int);
-static void forkparent(struct job *, union node *, int, pid_t);
-static int dowait(int, struct job *);
-static int getstatus(struct job *);
 
 static void
 set_curjob(struct job *jp, unsigned mode)
@@ -7307,7 +7332,126 @@ set_curjob(struct job *jp, unsigned mode)
         }
 }
 
+#if JOBS || DEBUG
+static int
+jobno(const struct job *jp)
+{
+        return jp - jobtab + 1;
+}
+#endif
+
+/*
+ * Convert a job name to a job structure.
+ */
+static struct job *
+getjob(const char *name, int getctl)
+{
+        struct job *jp;
+        struct job *found;
+        const char *err_msg = "No such job: %s";
+        unsigned num;
+        int c;
+        const char *p;
+        char *(*match)(const char *, const char *);
+
+        jp = curjob;
+        p = name;
+        if (!p)
+                goto currentjob;
+
+        if (*p != '%')
+                goto err;
+
+        c = *++p;
+        if (!c)
+                goto currentjob;
+
+        if (!p[1]) {
+                if (c == '+' || c == '%') {
+ currentjob:
+                        err_msg = "No current job";
+                        goto check;
+                }
+                if (c == '-') {
+                        if (jp)
+                                jp = jp->prev_job;
+                        err_msg = "No previous job";
+ check:
+                        if (!jp)
+                                goto err;
+                        goto gotit;
+                }
+        }
+
+        if (is_number(p)) {
+                num = atoi(p);
+                if (num < njobs) {
+                        jp = jobtab + num - 1;
+                        if (jp->used)
+                                goto gotit;
+                        goto err;
+                }
+        }
+
+        match = prefix;
+        if (*p == '?') {
+                match = strstr;
+                p++;
+        }
+
+        found = 0;
+        while (1) {
+                if (!jp)
+                        goto err;
+                if (match(jp->ps[0].cmd, p)) {
+                        if (found)
+                                goto err;
+                        found = jp;
+                        err_msg = "%s: ambiguous";
+                }
+                jp = jp->prev_job;
+        }
+
+ gotit:
+#if JOBS
+        err_msg = "job %s not created under job control";
+        if (getctl && jp->jobctl == 0)
+                goto err;
+#endif
+        return jp;
+ err:
+        ash_msg_and_raise_error(err_msg, name);
+}
+
+/*
+ * Mark a job structure as unused.
+ */
+static void
+freejob(struct job *jp)
+{
+        struct procstat *ps;
+        int i;
+
+        INT_OFF;
+        for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
+                if (ps->cmd != nullstr)
+                        free(ps->cmd);
+        }
+        if (jp->ps != &jp->ps0)
+                free(jp->ps);
+        jp->used = 0;
+        set_curjob(jp, CUR_DELETE);
+        INT_ON;
+}
+
 #if JOBS
+static void
+xtcsetpgrp(int fd, pid_t pgrp)
+{
+        if (tcsetpgrp(fd, pgrp))
+                ash_msg_and_raise_error("Cannot set tty process group (%m)");
+}
+
 /*
  * Turn job control on and off.
  *
@@ -7401,7 +7545,7 @@ killcmd(int argc, char **argv)
                 if (signo < 0) {
                         int c;
 
-                        while ((c = nextopt("ls:")) != '\0')
+                        while ((c = nextopt("ls:")) != '\0') {
                                 switch (c) {
                                 default:
 #if DEBUG
@@ -7420,6 +7564,7 @@ killcmd(int argc, char **argv)
                                         }
                                         break;
                                 }
+                        }
                         argv = argptr;
                 } else
                         argv++;
@@ -7467,42 +7612,21 @@ killcmd(int argc, char **argv)
 
         return i;
 }
-#endif /* JOBS */
-
-#if JOBS || DEBUG
-static int
-jobno(const struct job *jp)
-{
-        return jp - jobtab + 1;
-}
-#endif
 
-#if JOBS
-static int
-fg_bgcmd(int argc, char **argv)
+static void
+showpipe(struct job *jp, FILE *out)
 {
-        struct job *jp;
-        FILE *out;
-        int mode;
-        int retval;
+        struct procstat *sp;
+        struct procstat *spend;
 
-        mode = (**argv == 'f') ? FORK_FG : FORK_BG;
-        nextopt(nullstr);
-        argv = argptr;
-        out = stdout;
-        do {
-                jp = getjob(*argv, 1);
-                if (mode == FORK_BG) {
-                        set_curjob(jp, CUR_RUNNING);
-                        fprintf(out, "[%d] ", jobno(jp));
-                }
-                outstr(jp->ps->cmd, out);
-                showpipe(jp, out);
-                retval = restartjob(jp, mode);
-        } while (*argv && *++argv);
-        return retval;
+        spend = jp->ps + jp->nprocs;
+        for (sp = jp->ps + 1; sp < spend; sp++)
+                fprintf(out, " | %s", sp->cmd);
+        outcslow('\n', out);
+        flush_stdout_stderr();
 }
 
+
 static int
 restartjob(struct job *jp, int mode)
 {
@@ -7531,6 +7655,31 @@ restartjob(struct job *jp, int mode)
         INT_ON;
         return status;
 }
+
+static int
+fg_bgcmd(int argc, char **argv)
+{
+        struct job *jp;
+        FILE *out;
+        int mode;
+        int retval;
+
+        mode = (**argv == 'f') ? FORK_FG : FORK_BG;
+        nextopt(nullstr);
+        argv = argptr;
+        out = stdout;
+        do {
+                jp = getjob(*argv, 1);
+                if (mode == FORK_BG) {
+                        set_curjob(jp, CUR_RUNNING);
+                        fprintf(out, "[%d] ", jobno(jp));
+                }
+                outstr(jp->ps->cmd, out);
+                showpipe(jp, out);
+                retval = restartjob(jp, mode);
+        } while (*argv && *++argv);
+        return retval;
+}
 #endif
 
 static int
@@ -7571,6 +7720,137 @@ sprint_status(char *s, int status, int sigonly)
         return col;
 }
 
+/*
+ * Do a wait system call.  If job control is compiled in, we accept
+ * stopped processes.  If block is zero, we return a value of zero
+ * rather than blocking.
+ *
+ * System V doesn't have a non-blocking wait system call.  It does
+ * have a SIGCLD signal that is sent to a process when one of it's
+ * children dies.  The obvious way to use SIGCLD would be to install
+ * a handler for SIGCLD which simply bumped a counter when a SIGCLD
+ * was received, and have waitproc bump another counter when it got
+ * the status of a process.  Waitproc would then know that a wait
+ * system call would not block if the two counters were different.
+ * This approach doesn't work because if a process has children that
+ * have not been waited for, System V will send it a SIGCLD when it
+ * installs a signal handler for SIGCLD.  What this means is that when
+ * a child exits, the shell will be sent SIGCLD signals continuously
+ * until is runs out of stack space, unless it does a wait call before
+ * restoring the signal handler.  The code below takes advantage of
+ * this (mis)feature by installing a signal handler for SIGCLD and
+ * then checking to see whether it was called.  If there are any
+ * children to be waited for, it will be.
+ *
+ * If neither SYSV nor BSD is defined, we don't implement nonblocking
+ * waits at all.  In this case, the user will not be informed when
+ * a background process until the next time she runs a real program
+ * (as opposed to running a builtin command or just typing return),
+ * and the jobs command may give out of date information.
+ */
+static int
+waitproc(int block, int *status)
+{
+        int flags = 0;
+
+#if JOBS
+        if (jobctl)
+                flags |= WUNTRACED;
+#endif
+        if (block == 0)
+                flags |= WNOHANG;
+        return wait3(status, flags, (struct rusage *)NULL);
+}
+
+/*
+ * Wait for a process to terminate.
+ */
+static int
+dowait(int block, struct job *job)
+{
+        int pid;
+        int status;
+        struct job *jp;
+        struct job *thisjob;
+        int state;
+
+        TRACE(("dowait(%d) called\n", block));
+        pid = waitproc(block, &status);
+        TRACE(("wait returns pid %d, status=%d\n", pid, status));
+        if (pid <= 0)
+                return pid;
+        INT_OFF;
+        thisjob = NULL;
+        for (jp = curjob; jp; jp = jp->prev_job) {
+                struct procstat *sp;
+                struct procstat *spend;
+                if (jp->state == JOBDONE)
+                        continue;
+                state = JOBDONE;
+                spend = jp->ps + jp->nprocs;
+                sp = jp->ps;
+                do {
+                        if (sp->pid == pid) {
+                                TRACE(("Job %d: changing status of proc %d "
+                                        "from 0x%x to 0x%x\n",
+                                        jobno(jp), pid, sp->status, status));
+                                sp->status = status;
+                                thisjob = jp;
+                        }
+                        if (sp->status == -1)
+                                state = JOBRUNNING;
+#if JOBS
+                        if (state == JOBRUNNING)
+                                continue;
+                        if (WIFSTOPPED(sp->status)) {
+                                jp->stopstatus = sp->status;
+                                state = JOBSTOPPED;
+                        }
+#endif
+                } while (++sp < spend);
+                if (thisjob)
+                        goto gotjob;
+        }
+#if JOBS
+        if (!WIFSTOPPED(status))
+#endif
+
+                jobless--;
+        goto out;
+
+ gotjob:
+        if (state != JOBRUNNING) {
+                thisjob->changed = 1;
+
+                if (thisjob->state != state) {
+                        TRACE(("Job %d: changing state from %d to %d\n",
+                                jobno(thisjob), thisjob->state, state));
+                        thisjob->state = state;
+#if JOBS
+                        if (state == JOBSTOPPED) {
+                                set_curjob(thisjob, CUR_STOPPED);
+                        }
+#endif
+                }
+        }
+
+ out:
+        INT_ON;
+
+        if (thisjob && thisjob == job) {
+                char s[48 + 1];
+                int len;
+
+                len = sprint_status(s, status, 1);
+                if (len) {
+                        s[len] = '\n';
+                        s[len + 1] = 0;
+                        out2str(s);
+                }
+        }
+        return pid;
+}
+
 #if JOBS
 static void
 showjob(FILE *out, struct job *jp, int mode)
@@ -7641,7 +7921,6 @@ showjob(FILE *out, struct job *jp, int mode)
         }
 }
 
-
 static int
 jobscmd(int argc, char **argv)
 {
@@ -7668,7 +7947,6 @@ jobscmd(int argc, char **argv)
         return 0;
 }
 
-
 /*
  * Print a list of jobs.  If "change" is nonzero, only print jobs whose
  * statuses have changed since the last call to showjobs.
@@ -7691,29 +7969,34 @@ showjobs(FILE *out, int mode)
 }
 #endif /* JOBS */
 
-
-/*
- * Mark a job structure as unused.
- */
-static void
-freejob(struct job *jp)
+static int
+getstatus(struct job *job)
 {
-        struct procstat *ps;
-        int i;
+        int status;
+        int retval;
 
-        INT_OFF;
-        for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
-                if (ps->cmd != nullstr)
-                        free(ps->cmd);
+        status = job->ps[job->nprocs - 1].status;
+        retval = WEXITSTATUS(status);
+        if (!WIFEXITED(status)) {
+#if JOBS
+                retval = WSTOPSIG(status);
+                if (!WIFSTOPPED(status))
+#endif
+                {
+                        /* XXX: limits number of signals */
+                        retval = WTERMSIG(status);
+#if JOBS
+                        if (retval == SIGINT)
+                                job->sigint = 1;
+#endif
+                }
+                retval += 128;
         }
-        if (jp->ps != &jp->ps0)
-                free(jp->ps);
-        jp->used = 0;
-        set_curjob(jp, CUR_DELETE);
-        INT_ON;
+        TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
+                jobno(job), job->nprocs, status, retval));
+        return retval;
 }
 
-
 static int
 waitcmd(int argc, char **argv)
 {
@@ -7774,91 +8057,49 @@ waitcmd(int argc, char **argv)
         return retval;
 }
 
-
-/*
- * Convert a job name to a job structure.
- */
 static struct job *
-getjob(const char *name, int getctl)
+growjobtab(void)
 {
-        struct job *jp;
-        struct job *found;
-        const char *err_msg = "No such job: %s";
-        unsigned num;
-        int c;
-        const char *p;
-        char *(*match)(const char *, const char *);
-
-        jp = curjob;
-        p = name;
-        if (!p)
-                goto currentjob;
-
-        if (*p != '%')
-                goto err;
-
-        c = *++p;
-        if (!c)
-                goto currentjob;
-
-        if (!p[1]) {
-                if (c == '+' || c == '%') {
- currentjob:
-                        err_msg = "No current job";
-                        goto check;
-                }
-                if (c == '-') {
-                        if (jp)
-                                jp = jp->prev_job;
-                        err_msg = "No previous job";
- check:
-                        if (!jp)
-                                goto err;
-                        goto gotit;
-                }
-        }
+        size_t len;
+        ptrdiff_t offset;
+        struct job *jp, *jq;
 
-        if (is_number(p)) {
-                num = atoi(p);
-                if (num < njobs) {
-                        jp = jobtab + num - 1;
-                        if (jp->used)
-                                goto gotit;
-                        goto err;
-                }
-        }
+        len = njobs * sizeof(*jp);
+        jq = jobtab;
+        jp = ckrealloc(jq, len + 4 * sizeof(*jp));
 
-        match = prefix;
-        if (*p == '?') {
-                match = strstr;
-                p++;
-        }
+        offset = (char *)jp - (char *)jq;
+        if (offset) {
+                /* Relocate pointers */
+                size_t l = len;
 
-        found = 0;
-        while (1) {
-                if (!jp)
-                        goto err;
-                if (match(jp->ps[0].cmd, p)) {
-                        if (found)
-                                goto err;
-                        found = jp;
-                        err_msg = "%s: ambiguous";
+                jq = (struct job *)((char *)jq + l);
+                while (l) {
+                        l -= sizeof(*jp);
+                        jq--;
+#define joff(p) ((struct job *)((char *)(p) + l))
+#define jmove(p) (p) = (void *)((char *)(p) + offset)
+                        if (xlikely(joff(jp)->ps == &jq->ps0))
+                                jmove(joff(jp)->ps);
+                        if (joff(jp)->prev_job)
+                                jmove(joff(jp)->prev_job);
                 }
-                jp = jp->prev_job;
+                if (curjob)
+                        jmove(curjob);
+#undef joff
+#undef jmove
         }
 
- gotit:
-#if JOBS
-        err_msg = "job %s not created under job control";
-        if (getctl && jp->jobctl == 0)
-                goto err;
-#endif
+        njobs += 4;
+        jobtab = jp;
+        jp = (struct job *)((char *)jp + len);
+        jq = jp + 3;
+        do {
+                jq->used = 0;
+        } while (--jq >= jp);
         return jp;
- err:
-        ash_msg_and_raise_error(err_msg, name);
 }
 
-
 /*
  * Return a new job structure.
  * Called with interrupts off.
@@ -7902,50 +8143,6 @@ makejob(union node *node, int nprocs)
         return jp;
 }
 
-static struct job *
-growjobtab(void)
-{
-        size_t len;
-        ptrdiff_t offset;
-        struct job *jp, *jq;
-
-        len = njobs * sizeof(*jp);
-        jq = jobtab;
-        jp = ckrealloc(jq, len + 4 * sizeof(*jp));
-
-        offset = (char *)jp - (char *)jq;
-        if (offset) {
-                /* Relocate pointers */
-                size_t l = len;
-
-                jq = (struct job *)((char *)jq + l);
-                while (l) {
-                        l -= sizeof(*jp);
-                        jq--;
-#define joff(p) ((struct job *)((char *)(p) + l))
-#define jmove(p) (p) = (void *)((char *)(p) + offset)
-                        if (xlikely(joff(jp)->ps == &jq->ps0))
-                                jmove(joff(jp)->ps);
-                        if (joff(jp)->prev_job)
-                                jmove(joff(jp)->prev_job);
-                }
-                if (curjob)
-                        jmove(curjob);
-#undef joff
-#undef jmove
-        }
-
-        njobs += 4;
-        jobtab = jp;
-        jp = (struct job *)((char *)jp + len);
-        jq = jp + 3;
-        do {
-                jq->used = 0;
-        } while (--jq >= jp);
-        return jp;
-}
-
-
 /*
  * Fork off a subshell.  If we are doing job control, give the subshell its
  * own process group.  Jp is a job structure that the job is to be added to.
@@ -7962,7 +8159,8 @@ growjobtab(void)
  *
  * Called with interrupts off.
  */
-static void forkchild(struct job *jp, union node *n, int mode)
+static void
+forkchild(struct job *jp, union node *n, int mode)
 {
         int oldlvl;
 
@@ -8009,7 +8207,8 @@ static void forkchild(struct job *jp, union node *n, int mode)
         jobless = 0;
 }
 
-static void forkparent(struct job *jp, union node *n, int mode, pid_t pid)
+static void
+forkparent(struct job *jp, union node *n, int mode, pid_t pid)
 {
         TRACE(("In parent shell: child = %d\n", pid));
         if (!jp) {
@@ -8065,7 +8264,6 @@ forkshell(struct job *jp, union node *n, int mode)
         return pid;
 }
 
-
 /*
  * Wait for job to finish.
  *
@@ -8116,144 +8314,10 @@ waitforjob(struct job *jp)
         return st;
 }
 
-
-/*
- * Do a wait system call.  If job control is compiled in, we accept
- * stopped processes.  If block is zero, we return a value of zero
- * rather than blocking.
- *
- * System V doesn't have a non-blocking wait system call.  It does
- * have a SIGCLD signal that is sent to a process when one of it's
- * children dies.  The obvious way to use SIGCLD would be to install
- * a handler for SIGCLD which simply bumped a counter when a SIGCLD
- * was received, and have waitproc bump another counter when it got
- * the status of a process.  Waitproc would then know that a wait
- * system call would not block if the two counters were different.
- * This approach doesn't work because if a process has children that
- * have not been waited for, System V will send it a SIGCLD when it
- * installs a signal handler for SIGCLD.  What this means is that when
- * a child exits, the shell will be sent SIGCLD signals continuously
- * until is runs out of stack space, unless it does a wait call before
- * restoring the signal handler.  The code below takes advantage of
- * this (mis)feature by installing a signal handler for SIGCLD and
- * then checking to see whether it was called.  If there are any
- * children to be waited for, it will be.
- *
- * If neither SYSV nor BSD is defined, we don't implement nonblocking
- * waits at all.  In this case, the user will not be informed when
- * a background process until the next time she runs a real program
- * (as opposed to running a builtin command or just typing return),
- * and the jobs command may give out of date information.
- */
-static int
-waitproc(int block, int *status)
-{
-        int flags = 0;
-
-#if JOBS
-        if (jobctl)
-                flags |= WUNTRACED;
-#endif
-        if (block == 0)
-                flags |= WNOHANG;
-        return wait3(status, flags, (struct rusage *)NULL);
-}
-
-
-/*
- * Wait for a process to terminate.
- */
-static int
-dowait(int block, struct job *job)
-{
-        int pid;
-        int status;
-        struct job *jp;
-        struct job *thisjob;
-        int state;
-
-        TRACE(("dowait(%d) called\n", block));
-        pid = waitproc(block, &status);
-        TRACE(("wait returns pid %d, status=%d\n", pid, status));
-        if (pid <= 0)
-                return pid;
-        INT_OFF;
-        thisjob = NULL;
-        for (jp = curjob; jp; jp = jp->prev_job) {
-                struct procstat *sp;
-                struct procstat *spend;
-                if (jp->state == JOBDONE)
-                        continue;
-                state = JOBDONE;
-                spend = jp->ps + jp->nprocs;
-                sp = jp->ps;
-                do {
-                        if (sp->pid == pid) {
-                                TRACE(("Job %d: changing status of proc %d "
-                                        "from 0x%x to 0x%x\n",
-                                        jobno(jp), pid, sp->status, status));
-                                sp->status = status;
-                                thisjob = jp;
-                        }
-                        if (sp->status == -1)
-                                state = JOBRUNNING;
-#if JOBS
-                        if (state == JOBRUNNING)
-                                continue;
-                        if (WIFSTOPPED(sp->status)) {
-                                jp->stopstatus = sp->status;
-                                state = JOBSTOPPED;
-                        }
-#endif
-                } while (++sp < spend);
-                if (thisjob)
-                        goto gotjob;
-        }
-#if JOBS
-        if (!WIFSTOPPED(status))
-#endif
-
-                jobless--;
-        goto out;
-
- gotjob:
-        if (state != JOBRUNNING) {
-                thisjob->changed = 1;
-
-                if (thisjob->state != state) {
-                        TRACE(("Job %d: changing state from %d to %d\n",
-                                jobno(thisjob), thisjob->state, state));
-                        thisjob->state = state;
-#if JOBS
-                        if (state == JOBSTOPPED) {
-                                set_curjob(thisjob, CUR_STOPPED);
-                        }
-#endif
-                }
-        }
-
- out:
-        INT_ON;
-
-        if (thisjob && thisjob == job) {
-                char s[48 + 1];
-                int len;
-
-                len = sprint_status(s, status, 1);
-                if (len) {
-                        s[len] = '\n';
-                        s[len + 1] = 0;
-                        out2str(s);
-                }
-        }
-        return pid;
-}
-
-
 /*
  * return 1 if there are stopped jobs, otherwise 0
  */
-int
+static int
 stoppedjobs(void)
 {
         struct job *jp;
@@ -8289,7 +8353,7 @@ commandtext(union node *n)
         cmdtxt(n);
         name = stackblock();
         TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
-                name, cmdnextc, cmdnextc));
+                        name, cmdnextc, cmdnextc));
         return ckstrdup(name);
 }
 
@@ -8550,57 +8614,8 @@ cmdputs(const char *s)
         *nextc = 0;
         cmdnextc = nextc;
 }
-
-
-static void
-showpipe(struct job *jp, FILE *out)
-{
-        struct procstat *sp;
-        struct procstat *spend;
-
-        spend = jp->ps + jp->nprocs;
-        for (sp = jp->ps + 1; sp < spend; sp++)
-                fprintf(out, " | %s", sp->cmd);
-        outcslow('\n', out);
-        flush_stdout_stderr();
-}
-
-static void
-xtcsetpgrp(int fd, pid_t pgrp)
-{
-        if (tcsetpgrp(fd, pgrp))
-                ash_msg_and_raise_error("Cannot set tty process group (%m)");
-}
 #endif /* JOBS */
 
-static int
-getstatus(struct job *job)
-{
-        int status;
-        int retval;
-
-        status = job->ps[job->nprocs - 1].status;
-        retval = WEXITSTATUS(status);
-        if (!WIFEXITED(status)) {
-#if JOBS
-                retval = WSTOPSIG(status);
-                if (!WIFSTOPPED(status))
-#endif
-                {
-                        /* XXX: limits number of signals */
-                        retval = WTERMSIG(status);
-#if JOBS
-                        if (retval == SIGINT)
-                                job->sigint = 1;
-#endif
-                }
-                retval += 128;
-        }
-        TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
-                jobno(job), job->nprocs, status, retval));
-        return retval;
-}
-
 #if ENABLE_ASH_MAIL
 /*      mail.c       */
 
@@ -11333,17 +11348,6 @@ redirectsafe(union node *redir, int flags)
 
 /*      trap.c       */
 
-/*
- * 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 */
-#define S_RESET 5               /* temporary - to reset a hard ignored sig */
 
 
 /*
@@ -11507,36 +11511,6 @@ setsignal(int signo)
 
 
 /*
- * Ignore a signal.
- */
-static void
-ignoresig(int signo)
-{
-        if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
-                signal(signo, SIG_IGN);
-        }
-        sigmode[signo - 1] = S_HARD_IGN;
-}
-
-
-/*
- * Signal handler.
- */
-static void
-onsig(int signo)
-{
-        gotsig[signo - 1] = 1;
-        pendingsigs = signo;
-
-        if (exsig || (signo == SIGINT && !trap[SIGINT])) {
-                if (!suppressint)
-                        raise_interrupt();
-                intpending = 1;
-        }
-}
-
-
-/*
  * Called to execute a trap.  Perhaps we should avoid entering new trap
  * handlers while we are executing a trap handler.
  */
@@ -11587,7 +11561,7 @@ setinteractive(int on)
 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
         if (is_interactive > 1) {
                 /* Looks like they want an interactive shell */
-                static int do_banner;
+                static smallint do_banner;
 
                 if (!do_banner) {
                         out1fmt(
@@ -11596,15 +11570,16 @@ setinteractive(int on)
                                 "Enter 'help' for a list of built-in commands."
                                 "\n\n",
                                 BB_BANNER);
-                        do_banner++;
+                        do_banner = 1;
                 }
         }
 #endif
 }
 
 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
-/*** List the available builtins ***/
-
+/*
+ * Lists available builtins
+ */
 static int
 helpcmd(int argc, char **argv)
 {
@@ -11711,7 +11686,8 @@ exportcmd(int argc, char **argv)
  * will be restored when the shell function returns.  We handle the name
  * "-" as a special case.
  */
-static void mklocal(char *name)
+static void
+mklocal(char *name)
 {
         struct localvar *lvp;
         struct var **vpp;
@@ -11811,9 +11787,10 @@ static const unsigned char timescmd_str[] = {
         0
 };
 
-static int timescmd(int ac, char **av)
+static int
+timescmd(int ac, char **av)
 {
-        long int clk_tck, s, t;
+        long clk_tck, s, t;
         const unsigned char *p;
         struct tms buf;
 
@@ -11845,12 +11822,11 @@ dash_arith(const char *s)
         if (errcode < 0) {
                 if (errcode == -3)
                         ash_msg_and_raise_error("exponent less than 0");
-                else if (errcode == -2)
+                if (errcode == -2)
                         ash_msg_and_raise_error("divide by zero");
-                else if (errcode == -5)
+                if (errcode == -5)
                         ash_msg_and_raise_error("expression recursion loop detected");
-                else
-                        raise_error_syntax(s);
+                raise_error_syntax(s);
         }
         INT_ON;
 
@@ -12083,7 +12059,8 @@ readcmd(int argc, char **argv)
 }
 
 
-static int umaskcmd(int argc, char **argv)
+static int
+umaskcmd(int argc, char **argv)
 {
         static const char permuser[3] = "ugo";
         static const char permmode[3] = "rwx";
@@ -12201,12 +12178,13 @@ static const struct limits limits[] = {
 #ifdef RLIMIT_LOCKS
         { "locks",                      RLIMIT_LOCKS,      1, 'w' },
 #endif
-        { (char *) 0,                   0,                 0,  '\0' }
+        { NULL,                         0,                 0,  '\0' }
 };
 
 enum limtype { SOFT = 0x1, HARD = 0x2 };
 
-static void printlim(enum limtype how, const struct rlimit *limit,
+static void
+printlim(enum limtype how, const struct rlimit *limit,
                         const struct limits *l)
 {
         rlim_t val;
@@ -12223,16 +12201,16 @@ static void printlim(enum limtype how, const struct rlimit *limit,
         }
 }
 
-int
+static int
 ulimitcmd(int argc, char **argv)
 {
-        int     c;
+        int c;
         rlim_t val = 0;
         enum limtype how = SOFT | HARD;
-        const struct limits     *l;
-        int             set, all = 0;
-        int             optc, what;
-        struct rlimit   limit;
+        const struct limits *l;
+        int set, all = 0;
+        int optc, what;
+        struct rlimit limit;
 
         what = 'f';
         while ((optc = nextopt("HSa"
@@ -12428,11 +12406,9 @@ ulimitcmd(int argc, char **argv)
  * - always use special isspace(), see comment from bash ;-)
  */
 
-
 #define arith_isspace(arithval) \
         (arithval == ' ' || arithval == '\n' || arithval == '\t')
 
-
 typedef unsigned char operator;
 
 /* An operator's token id is a bit of a bitfield. The lower 5 bits are the
@@ -12524,7 +12500,8 @@ typedef unsigned char operator;
 
 #define NUMPTR (*numstackptr)
 
-static int tok_have_assign(operator op)
+static int
+tok_have_assign(operator op)
 {
         operator prec = PREC(op);
 
@@ -12533,13 +12510,13 @@ static int tok_have_assign(operator op)
                         prec == PREC_PRE || prec == PREC_POST);
 }
 
-static int is_right_associativity(operator prec)
+static int
+is_right_associativity(operator prec)
 {
         return (prec == PREC(TOK_ASSIGN) || prec == PREC(TOK_EXPONENT)
                 || prec == PREC(TOK_CONDITIONAL));
 }
 
-
 typedef struct ARITCH_VAR_NUM {
         arith_t val;
         arith_t contidional_second_val;
@@ -12548,7 +12525,6 @@ typedef struct ARITCH_VAR_NUM {
                            else is variable name */
 } v_n_t;
 
-
 typedef struct CHK_VAR_RECURSIVE_LOOPED {
         const char *var;
         struct CHK_VAR_RECURSIVE_LOOPED *next;
@@ -12556,8 +12532,8 @@ typedef struct CHK_VAR_RECURSIVE_LOOPED {
 
 static chk_var_recursive_looped_t *prev_chk_var_recursive;
 
-
-static int arith_lookup_val(v_n_t *t)
+static int
+arith_lookup_val(v_n_t *t)
 {
         if (t->var) {
                 const char * p = lookupvar(t->var);
@@ -12595,7 +12571,8 @@ static int arith_lookup_val(v_n_t *t)
 /* "applying" a token means performing it on the top elements on the integer
  * stack. For a unary operator it will only change the top element, but a
  * binary operator will pop two arguments and push a result */
-static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
+static int
+arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
 {
         v_n_t *numptr_m1;
         arith_t numptr_val, rez;
@@ -12692,12 +12669,10 @@ static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
                         }
                         numptr_m1->contidional_second_val_initialized = op;
                         numptr_m1->contidional_second_val = numptr_val;
-                }
-                else if (op == TOK_CONDITIONAL) {
+                } else if (op == TOK_CONDITIONAL) {
                         rez = rez ?
                                 numptr_val : numptr_m1->contidional_second_val;
-                }
-                else if (op == TOK_EXPONENT) {
+                } else if (op == TOK_EXPONENT) {
                         if (numptr_val < 0)
                                 return -3;      /* exponent less than 0 */
                         else {
@@ -12708,8 +12683,7 @@ static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
                                                 c *= rez;
                                 rez = c;
                         }
-                }
-                else if (numptr_val==0)          /* zero divisor check */
+                } else if (numptr_val==0)          /* zero divisor check */
                         return -2;
                 else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
                         rez /= numptr_val;
@@ -12717,7 +12691,7 @@ static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
                         rez %= numptr_val;
         }
         if (tok_have_assign(op)) {
-                char buf[32];
+                char buf[sizeof(arith_t_type)*3 + 2];
 
                 if (numptr_m1->var == NULL) {
                         /* Hmm, 1=2 ? */
@@ -12725,9 +12699,9 @@ static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
                 }
                 /* save to shell variable */
 #if ENABLE_ASH_MATH_SUPPORT_64
-                snprintf(buf, sizeof(buf), "%lld", arith_t_type rez);
+                snprintf(buf, sizeof(buf), "%lld", (arith_t_type) rez);
 #else
-                snprintf(buf, sizeof(buf), "%ld", arith_t_type rez);
+                snprintf(buf, sizeof(buf), "%ld", (arith_t_type) rez);
 #endif
                 setvar(numptr_m1->var, buf, 0);
                 /* after saving, make previous value for v++ or v-- */
@@ -12744,7 +12718,7 @@ static int arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
         return -1;
 }
 
-/* longest must first */
+/* longest must be first */
 static const char op_tokens[] = {
         '<','<','=',0, TOK_LSHIFT_ASSIGN,
         '>','>','=',0, TOK_RSHIFT_ASSIGN,
@@ -12792,7 +12766,8 @@ static const char op_tokens[] = {
 #define endexpression &op_tokens[sizeof(op_tokens)-7]
 
 
-static arith_t arith(const char *expr, int *perrcode)
+static arith_t
+arith(const char *expr, int *perrcode)
 {
         char arithval; /* Current character under analysis */
         operator lasttok, op;
@@ -12990,8 +12965,8 @@ static arith_t arith(const char *expr, int *perrcode)
  * exception occurs.  When an exception occurs the variable "state"
  * is used to figure out how far we had gotten.
  */
-
-static void init(void)
+static void
+init(void)
 {
         /* from input.c: */
         basepf.nextc = basepf.buf = basebuf;
@@ -13002,7 +12977,7 @@ static void init(void)
         /* from var.c: */
         {
                 char **envp;
-                char ppid[32];
+                char ppid[sizeof(int)*3 + 1];
                 const char *p;
                 struct stat st1, st2;
 
@@ -13013,7 +12988,7 @@ static void init(void)
                         }
                 }
 
-                snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
+                snprintf(ppid, sizeof(ppid), "%u", (unsigned) getppid());
                 setvar("PPID", ppid, 0);
 
                 p = lookupvar("PWD");