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
})
/* 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 */
#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
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 */
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;
#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)
}
}
+#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.
*
if (signo < 0) {
int c;
- while ((c = nextopt("ls:")) != '\0')
+ while ((c = nextopt("ls:")) != '\0') {
switch (c) {
default:
#if DEBUG
}
break;
}
+ }
argv = argptr;
} else
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)
{
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
return col;
}
-#if JOBS
-static void
-showjob(FILE *out, struct job *jp, int mode)
-{
- struct procstat *ps;
- struct procstat *psend;
- int col;
- int indent;
- char s[80];
-
- ps = jp->ps;
-
- if (mode & SHOW_PGID) {
- /* just output process (group) id of pipeline */
- fprintf(out, "%d\n", ps->pid);
- return;
- }
-
- col = fmtstr(s, 16, "[%d] ", jobno(jp));
- indent = col;
-
- if (jp == curjob)
- s[col - 2] = '+';
- else if (curjob && jp == curjob->prev_job)
+/*
+ * 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)
+{
+ struct procstat *ps;
+ struct procstat *psend;
+ int col;
+ int indent;
+ char s[80];
+
+ ps = jp->ps;
+
+ if (mode & SHOW_PGID) {
+ /* just output process (group) id of pipeline */
+ fprintf(out, "%d\n", ps->pid);
+ return;
+ }
+
+ col = fmtstr(s, 16, "[%d] ", jobno(jp));
+ indent = col;
+
+ if (jp == curjob)
+ s[col - 2] = '+';
+ else if (curjob && jp == curjob->prev_job)
s[col - 2] = '-';
if (mode & SHOW_PID)
}
}
-
static int
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.
}
#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)
{
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.
jp->used = 1;
jp->ps = &jp->ps0;
if (nprocs > 1) {
- jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
- }
- TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
- jobno(jp)));
- 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);
+ jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
+ }
+ TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
+ jobno(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.
*
* 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;
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) {
return pid;
}
-
/*
* Wait for job to finish.
*
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;
cmdtxt(n);
name = stackblock();
TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
- name, cmdnextc, cmdnextc));
+ name, cmdnextc, cmdnextc));
return ckstrdup(name);
}
*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 */
/* 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 */
/*
/*
- * 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.
*/
#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(
"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)
{
* 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;
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;
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;
}
-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";
#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;
}
}
-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"
* - 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
#define NUMPTR (*numstackptr)
-static int tok_have_assign(operator op)
+static int
+tok_have_assign(operator op)
{
operator prec = PREC(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;
else is variable name */
} v_n_t;
-
typedef struct CHK_VAR_RECURSIVE_LOOPED {
const char *var;
struct CHK_VAR_RECURSIVE_LOOPED *next;
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);
/* "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;
}
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 {
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;
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 ? */
}
/* 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-- */
return -1;
}
-/* longest must first */
+/* longest must be first */
static const char op_tokens[] = {
'<','<','=',0, TOK_LSHIFT_ASSIGN,
'>','>','=',0, TOK_RSHIFT_ASSIGN,
#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;
* 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;
/* from var.c: */
{
char **envp;
- char ppid[32];
+ char ppid[sizeof(int)*3 + 1];
const char *p;
struct stat st1, st2;
}
}
- snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
+ snprintf(ppid, sizeof(ppid), "%u", (unsigned) getppid());
setvar("PPID", ppid, 0);
p = lookupvar("PWD");
projects / platform / upstream / busybox.git / commitdiff