1 /* $OpenBSD: jobs.c,v 1.43 2015/09/10 22:48:58 nicm Exp $ */
2
3 /*-
4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011,
5 * 2012, 2013, 2014, 2015, 2016, 2018
6 * mirabilos <m@mirbsd.org>
7 *
8 * Provided that these terms and disclaimer and all copyright notices
9 * are retained or reproduced in an accompanying document, permission
10 * is granted to deal in this work without restriction, including un-
11 * limited rights to use, publicly perform, distribute, sell, modify,
12 * merge, give away, or sublicence.
13 *
14 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
15 * the utmost extent permitted by applicable law, neither express nor
16 * implied; without malicious intent or gross negligence. In no event
17 * may a licensor, author or contributor be held liable for indirect,
18 * direct, other damage, loss, or other issues arising in any way out
19 * of dealing in the work, even if advised of the possibility of such
20 * damage or existence of a defect, except proven that it results out
21 * of said person's immediate fault when using the work as intended.
22 */
23
24 #include "sh.h"
25
26 __RCSID("$MirOS: src/bin/mksh/jobs.c,v 1.125 2018/01/05 20:08:34 tg Exp $");
27
28 #if HAVE_KILLPG
29 #define mksh_killpg killpg
30 #else
31 /* cross fingers and hope kill is killpg-endowed */
32 #define mksh_killpg(p,s) kill(-(p), (s))
33 #endif
34
35 /* Order important! */
36 #define PRUNNING 0
37 #define PEXITED 1
38 #define PSIGNALLED 2
39 #define PSTOPPED 3
40
41 typedef struct proc Proc;
42 /* to take alignment into consideration */
43 struct proc_dummy {
44 Proc *next;
45 pid_t pid;
46 int state;
47 int status;
48 char command[128];
49 };
50 /* real structure */
51 struct proc {
52 /* next process in pipeline (if any) */
53 Proc *next;
54 /* process id of this Unix process in the job */
55 pid_t pid;
56 /* one of the four P… above */
57 int state;
58 /* wait status */
59 int status;
60 /* process command string from vistree */
61 char command[256 - (ALLOC_OVERHEAD +
62 offsetof(struct proc_dummy, command[0]))];
63 };
64
65 /* Notify/print flag - j_print() argument */
66 #define JP_SHORT 1 /* print signals processes were killed by */
67 #define JP_MEDIUM 2 /* print [job-num] -/+ command */
68 #define JP_LONG 3 /* print [job-num] -/+ pid command */
69 #define JP_PGRP 4 /* print pgrp */
70
71 /* put_job() flags */
72 #define PJ_ON_FRONT 0 /* at very front */
73 #define PJ_PAST_STOPPED 1 /* just past any stopped jobs */
74
75 /* Job.flags values */
76 #define JF_STARTED 0x001 /* set when all processes in job are started */
77 #define JF_WAITING 0x002 /* set if j_waitj() is waiting on job */
78 #define JF_W_ASYNCNOTIFY 0x004 /* set if waiting and async notification ok */
79 #define JF_XXCOM 0x008 /* set for $(command) jobs */
80 #define JF_FG 0x010 /* running in foreground (also has tty pgrp) */
81 #define JF_SAVEDTTY 0x020 /* j->ttystat is valid */
82 #define JF_CHANGED 0x040 /* process has changed state */
83 #define JF_KNOWN 0x080 /* $! referenced */
84 #define JF_ZOMBIE 0x100 /* known, unwaited process */
85 #define JF_REMOVE 0x200 /* flagged for removal (j_jobs()/j_noityf()) */
86 #define JF_USETTYMODE 0x400 /* tty mode saved if process exits normally */
87 #define JF_SAVEDTTYPGRP 0x800 /* j->saved_ttypgrp is valid */
88
89 typedef struct job Job;
90 struct job {
91 Job *next; /* next job in list */
92 Proc *proc_list; /* process list */
93 Proc *last_proc; /* last process in list */
94 struct timeval systime; /* system time used by job */
95 struct timeval usrtime; /* user time used by job */
96 pid_t pgrp; /* process group of job */
97 pid_t ppid; /* pid of process that forked job */
98 int job; /* job number: %n */
99 int flags; /* see JF_* */
100 volatile int state; /* job state */
101 int status; /* exit status of last process */
102 int age; /* number of jobs started */
103 Coproc_id coproc_id; /* 0 or id of coprocess output pipe */
104 #ifndef MKSH_UNEMPLOYED
105 mksh_ttyst ttystat; /* saved tty state for stopped jobs */
106 pid_t saved_ttypgrp; /* saved tty process group for stopped jobs */
107 #endif
108 };
109
110 /* Flags for j_waitj() */
111 #define JW_NONE 0x00
112 #define JW_INTERRUPT 0x01 /* ^C will stop the wait */
113 #define JW_ASYNCNOTIFY 0x02 /* asynchronous notification during wait ok */
114 #define JW_STOPPEDWAIT 0x04 /* wait even if job stopped */
115 #define JW_PIPEST 0x08 /* want PIPESTATUS */
116
117 /* Error codes for j_lookup() */
118 #define JL_NOSUCH 0 /* no such job */
119 #define JL_AMBIG 1 /* %foo or %?foo is ambiguous */
120 #define JL_INVALID 2 /* non-pid, non-% job id */
121
122 static const char * const lookup_msgs[] = {
123 "no such job",
124 "ambiguous",
125 "argument must be %job or process id"
126 };
127
128 static Job *job_list; /* job list */
129 static Job *last_job;
130 static Job *async_job;
131 static pid_t async_pid;
132
133 static int nzombie; /* # of zombies owned by this process */
134 static int njobs; /* # of jobs started */
135
136 #ifndef CHILD_MAX
137 #define CHILD_MAX 25
138 #endif
139
140 #ifndef MKSH_NOPROSPECTOFWORK
141 /* held_sigchld is set if sigchld occurs before a job is completely started */
142 static volatile sig_atomic_t held_sigchld;
143 #endif
144
145 #ifndef MKSH_UNEMPLOYED
146 static struct shf *shl_j;
147 static bool ttypgrp_ok; /* set if can use tty pgrps */
148 static pid_t restore_ttypgrp = -1;
149 static int const tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU };
150 #endif
151
152 static void j_set_async(Job *);
153 static void j_startjob(Job *);
154 static int j_waitj(Job *, int, const char *);
155 static void j_sigchld(int);
156 static void j_print(Job *, int, struct shf *);
157 static Job *j_lookup(const char *, int *);
158 static Job *new_job(void);
159 static Proc *new_proc(void);
160 static void check_job(Job *);
161 static void put_job(Job *, int);
162 static void remove_job(Job *, const char *);
163 static int kill_job(Job *, int);
164
165 static void tty_init_talking(void);
166 static void tty_init_state(void);
167
168 /* initialise job control */
169 void
j_init(void)170 j_init(void)
171 {
172 #ifndef MKSH_UNEMPLOYED
173 bool mflagset = Flag(FMONITOR) != 127;
174
175 Flag(FMONITOR) = 0;
176 #endif
177
178 #ifndef MKSH_NOPROSPECTOFWORK
179 (void)sigemptyset(&sm_default);
180 sigprocmask(SIG_SETMASK, &sm_default, NULL);
181
182 (void)sigemptyset(&sm_sigchld);
183 (void)sigaddset(&sm_sigchld, SIGCHLD);
184
185 setsig(&sigtraps[SIGCHLD], j_sigchld,
186 SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
187 #else
188 /* Make sure SIGCHLD isn't ignored - can do odd things under SYSV */
189 setsig(&sigtraps[SIGCHLD], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE);
190 #endif
191
192 #ifndef MKSH_UNEMPLOYED
193 if (!mflagset && Flag(FTALKING))
194 Flag(FMONITOR) = 1;
195
196 /*
197 * shl_j is used to do asynchronous notification (used in
198 * an interrupt handler, so need a distinct shf)
199 */
200 shl_j = shf_fdopen(2, SHF_WR, NULL);
201
202 if (Flag(FMONITOR) || Flag(FTALKING)) {
203 int i;
204
205 /*
206 * the TF_SHELL_USES test is a kludge that lets us know if
207 * if the signals have been changed by the shell.
208 */
209 for (i = NELEM(tt_sigs); --i >= 0; ) {
210 sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES;
211 /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */
212 setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
213 SS_RESTORE_IGN|SS_FORCE);
214 }
215 }
216
217 /* j_change() calls tty_init_talking() and tty_init_state() */
218 if (Flag(FMONITOR))
219 j_change();
220 else
221 #endif
222 if (Flag(FTALKING)) {
223 tty_init_talking();
224 tty_init_state();
225 }
226 }
227
228 static int
proc_errorlevel(Proc * p)229 proc_errorlevel(Proc *p)
230 {
231 switch (p->state) {
232 case PEXITED:
233 return ((WEXITSTATUS(p->status)) & 255);
234 case PSIGNALLED:
235 return (ksh_sigmask(WTERMSIG(p->status)));
236 default:
237 return (0);
238 }
239 }
240
241 #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID
242 /* suspend the shell */
243 void
j_suspend(void)244 j_suspend(void)
245 {
246 struct sigaction sa, osa;
247
248 /* Restore tty and pgrp. */
249 if (ttypgrp_ok) {
250 if (tty_hasstate)
251 mksh_tcset(tty_fd, &tty_state);
252 if (restore_ttypgrp >= 0) {
253 if (tcsetpgrp(tty_fd, restore_ttypgrp) < 0) {
254 warningf(false, Tf_ssfaileds,
255 Tj_suspend, "tcsetpgrp", cstrerror(errno));
256 } else if (setpgid(0, restore_ttypgrp) < 0) {
257 warningf(false, Tf_ssfaileds,
258 Tj_suspend, "setpgid", cstrerror(errno));
259 }
260 }
261 }
262
263 /* Suspend the shell. */
264 memset(&sa, 0, sizeof(sa));
265 sigemptyset(&sa.sa_mask);
266 sa.sa_handler = SIG_DFL;
267 sigaction(SIGTSTP, &sa, &osa);
268 kill(0, SIGTSTP);
269
270 /* Back from suspend, reset signals, pgrp and tty. */
271 sigaction(SIGTSTP, &osa, NULL);
272 if (ttypgrp_ok) {
273 if (restore_ttypgrp >= 0) {
274 if (setpgid(0, kshpid) < 0) {
275 warningf(false, Tf_ssfaileds,
276 Tj_suspend, "setpgid", cstrerror(errno));
277 ttypgrp_ok = false;
278 } else if (tcsetpgrp(tty_fd, kshpid) < 0) {
279 warningf(false, Tf_ssfaileds,
280 Tj_suspend, "tcsetpgrp", cstrerror(errno));
281 ttypgrp_ok = false;
282 }
283 }
284 tty_init_state();
285 }
286 }
287 #endif
288
289 /* job cleanup before shell exit */
290 void
j_exit(void)291 j_exit(void)
292 {
293 /* kill stopped, and possibly running, jobs */
294 Job *j;
295 bool killed = false;
296
297 for (j = job_list; j != NULL; j = j->next) {
298 if (j->ppid == procpid &&
299 (j->state == PSTOPPED ||
300 (j->state == PRUNNING &&
301 ((j->flags & JF_FG) ||
302 (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) {
303 killed = true;
304 if (j->pgrp == 0)
305 kill_job(j, SIGHUP);
306 else
307 mksh_killpg(j->pgrp, SIGHUP);
308 #ifndef MKSH_UNEMPLOYED
309 if (j->state == PSTOPPED) {
310 if (j->pgrp == 0)
311 kill_job(j, SIGCONT);
312 else
313 mksh_killpg(j->pgrp, SIGCONT);
314 }
315 #endif
316 }
317 }
318 if (killed)
319 sleep(1);
320 j_notify();
321
322 #ifndef MKSH_UNEMPLOYED
323 if (kshpid == procpid && restore_ttypgrp >= 0) {
324 /*
325 * Need to restore the tty pgrp to what it was when the
326 * shell started up, so that the process that started us
327 * will be able to access the tty when we are done.
328 * Also need to restore our process group in case we are
329 * about to do an exec so that both our parent and the
330 * process we are to become will be able to access the tty.
331 */
332 tcsetpgrp(tty_fd, restore_ttypgrp);
333 setpgid(0, restore_ttypgrp);
334 }
335 if (Flag(FMONITOR)) {
336 Flag(FMONITOR) = 0;
337 j_change();
338 }
339 #endif
340 }
341
342 #ifndef MKSH_UNEMPLOYED
343 /* turn job control on or off according to Flag(FMONITOR) */
344 void
j_change(void)345 j_change(void)
346 {
347 int i;
348
349 if (Flag(FMONITOR)) {
350 bool use_tty = Flag(FTALKING);
351
352 /* don't call mksh_tcget until we own the tty process group */
353 if (use_tty)
354 tty_init_talking();
355
356 /* no controlling tty, no SIGT* */
357 if ((ttypgrp_ok = (use_tty && tty_fd >= 0 && tty_devtty))) {
358 setsig(&sigtraps[SIGTTIN], SIG_DFL,
359 SS_RESTORE_ORIG|SS_FORCE);
360 /* wait to be given tty (POSIX.1, B.2, job control) */
361 while (/* CONSTCOND */ 1) {
362 pid_t ttypgrp;
363
364 if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) {
365 warningf(false, Tf_ssfaileds,
366 "j_init", "tcgetpgrp",
367 cstrerror(errno));
368 ttypgrp_ok = false;
369 break;
370 }
371 if (ttypgrp == kshpgrp)
372 break;
373 kill(0, SIGTTIN);
374 }
375 }
376 for (i = NELEM(tt_sigs); --i >= 0; )
377 setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
378 SS_RESTORE_DFL|SS_FORCE);
379 if (ttypgrp_ok && kshpgrp != kshpid) {
380 if (setpgid(0, kshpid) < 0) {
381 warningf(false, Tf_ssfaileds,
382 "j_init", "setpgid", cstrerror(errno));
383 ttypgrp_ok = false;
384 } else {
385 if (tcsetpgrp(tty_fd, kshpid) < 0) {
386 warningf(false, Tf_ssfaileds,
387 "j_init", "tcsetpgrp",
388 cstrerror(errno));
389 ttypgrp_ok = false;
390 } else
391 restore_ttypgrp = kshpgrp;
392 kshpgrp = kshpid;
393 }
394 }
395 #ifndef MKSH_DISABLE_TTY_WARNING
396 if (use_tty && !ttypgrp_ok)
397 warningf(false, Tf_sD_s, "warning",
398 "won't have full job control");
399 #endif
400 } else {
401 ttypgrp_ok = false;
402 if (Flag(FTALKING))
403 for (i = NELEM(tt_sigs); --i >= 0; )
404 setsig(&sigtraps[tt_sigs[i]], SIG_IGN,
405 SS_RESTORE_IGN|SS_FORCE);
406 else
407 for (i = NELEM(tt_sigs); --i >= 0; ) {
408 if (sigtraps[tt_sigs[i]].flags &
409 (TF_ORIG_IGN | TF_ORIG_DFL))
410 setsig(&sigtraps[tt_sigs[i]],
411 (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ?
412 SIG_IGN : SIG_DFL,
413 SS_RESTORE_ORIG|SS_FORCE);
414 }
415 }
416 tty_init_state();
417 }
418 #endif
419
420 #if HAVE_NICE
421 /* run nice(3) and ignore the result */
422 static void
ksh_nice(int ness)423 ksh_nice(int ness)
424 {
425 #if defined(__USE_FORTIFY_LEVEL) && (__USE_FORTIFY_LEVEL > 0)
426 int eno;
427
428 errno = 0;
429 /* this is gonna annoy users; complain to your distro, people! */
430 if (nice(ness) == -1 && (eno = errno) != 0)
431 warningf(false, Tf_sD_s, "bgnice", cstrerror(eno));
432 #else
433 (void)nice(ness);
434 #endif
435 }
436 #endif
437
438 /* execute tree in child subprocess */
439 int
exchild(struct op * t,int flags,volatile int * xerrok,int close_fd)440 exchild(struct op *t, int flags,
441 volatile int *xerrok,
442 /* used if XPCLOSE or XCCLOSE */
443 int close_fd)
444 {
445 /* for pipelines */
446 static Proc *last_proc;
447
448 int rv = 0, forksleep, jwflags = JW_NONE;
449 #ifndef MKSH_NOPROSPECTOFWORK
450 sigset_t omask;
451 #endif
452 Proc *p;
453 Job *j;
454 pid_t cldpid;
455
456 if (flags & XPIPEST) {
457 flags &= ~XPIPEST;
458 jwflags |= JW_PIPEST;
459 }
460
461 if (flags & XEXEC)
462 /*
463 * Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND
464 * (also done in another execute() below)
465 */
466 return (execute(t, flags & (XEXEC | XERROK), xerrok));
467
468 #ifndef MKSH_NOPROSPECTOFWORK
469 /* no SIGCHLDs while messing with job and process lists */
470 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
471 #endif
472
473 p = new_proc();
474 p->next = NULL;
475 p->state = PRUNNING;
476 p->status = 0;
477 p->pid = 0;
478
479 /* link process into jobs list */
480 if (flags & XPIPEI) {
481 /* continuing with a pipe */
482 if (!last_job)
483 internal_errorf("exchild: XPIPEI and no last_job - pid %d",
484 (int)procpid);
485 j = last_job;
486 if (last_proc)
487 last_proc->next = p;
488 last_proc = p;
489 } else {
490 /* fills in j->job */
491 j = new_job();
492 /*
493 * we don't consider XXCOMs foreground since they don't get
494 * tty process group and we don't save or restore tty modes.
495 */
496 j->flags = (flags & XXCOM) ? JF_XXCOM :
497 ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE));
498 timerclear(&j->usrtime);
499 timerclear(&j->systime);
500 j->state = PRUNNING;
501 j->pgrp = 0;
502 j->ppid = procpid;
503 j->age = ++njobs;
504 j->proc_list = p;
505 j->coproc_id = 0;
506 last_job = j;
507 last_proc = p;
508 put_job(j, PJ_PAST_STOPPED);
509 }
510
511 vistree(p->command, sizeof(p->command), t);
512
513 /* create child process */
514 forksleep = 1;
515 while ((cldpid = fork()) < 0 && errno == EAGAIN && forksleep < 32) {
516 if (intrsig)
517 /* allow user to ^C out... */
518 break;
519 sleep(forksleep);
520 forksleep <<= 1;
521 }
522 /* ensure $RANDOM changes between parent and child */
523 rndset((unsigned long)cldpid);
524 /* fork failed? */
525 if (cldpid < 0) {
526 kill_job(j, SIGKILL);
527 remove_job(j, "fork failed");
528 #ifndef MKSH_NOPROSPECTOFWORK
529 sigprocmask(SIG_SETMASK, &omask, NULL);
530 #endif
531 errorf("can't fork - try again");
532 }
533 p->pid = cldpid ? cldpid : (procpid = getpid());
534
535 #ifndef MKSH_UNEMPLOYED
536 /* job control set up */
537 if (Flag(FMONITOR) && !(flags&XXCOM)) {
538 bool dotty = false;
539
540 if (j->pgrp == 0) {
541 /* First process */
542 j->pgrp = p->pid;
543 dotty = true;
544 }
545
546 /*
547 * set pgrp in both parent and child to deal with race
548 * condition
549 */
550 setpgid(p->pid, j->pgrp);
551 if (ttypgrp_ok && dotty && !(flags & XBGND))
552 tcsetpgrp(tty_fd, j->pgrp);
553 }
554 #endif
555
556 /* used to close pipe input fd */
557 if (close_fd >= 0 && (((flags & XPCLOSE) && cldpid) ||
558 ((flags & XCCLOSE) && !cldpid)))
559 close(close_fd);
560 if (!cldpid) {
561 /* child */
562
563 /* Do this before restoring signal */
564 if (flags & XCOPROC)
565 coproc_cleanup(false);
566 cleanup_parents_env();
567 #ifndef MKSH_UNEMPLOYED
568 /*
569 * If FMONITOR or FTALKING is set, these signals are ignored,
570 * if neither FMONITOR nor FTALKING are set, the signals have
571 * their inherited values.
572 */
573 if (Flag(FMONITOR) && !(flags & XXCOM)) {
574 for (forksleep = NELEM(tt_sigs); --forksleep >= 0; )
575 setsig(&sigtraps[tt_sigs[forksleep]], SIG_DFL,
576 SS_RESTORE_DFL|SS_FORCE);
577 }
578 #endif
579 #if HAVE_NICE
580 if (Flag(FBGNICE) && (flags & XBGND))
581 ksh_nice(4);
582 #endif
583 if ((flags & XBGND)
584 #ifndef MKSH_UNEMPLOYED
585 && !Flag(FMONITOR)
586 #endif
587 ) {
588 setsig(&sigtraps[SIGINT], SIG_IGN,
589 SS_RESTORE_IGN|SS_FORCE);
590 setsig(&sigtraps[SIGQUIT], SIG_IGN,
591 SS_RESTORE_IGN|SS_FORCE);
592 if ((!(flags & (XPIPEI | XCOPROC))) &&
593 ((forksleep = open("/dev/null", 0)) > 0)) {
594 (void)ksh_dup2(forksleep, 0, true);
595 close(forksleep);
596 }
597 }
598 /* in case of $(jobs) command */
599 remove_job(j, "child");
600 #ifndef MKSH_NOPROSPECTOFWORK
601 /* remove_job needs SIGCHLD blocked still */
602 sigprocmask(SIG_SETMASK, &omask, NULL);
603 #endif
604 nzombie = 0;
605 #ifndef MKSH_UNEMPLOYED
606 ttypgrp_ok = false;
607 Flag(FMONITOR) = 0;
608 #endif
609 Flag(FTALKING) = 0;
610 cleartraps();
611 /* no return */
612 execute(t, (flags & XERROK) | XEXEC, NULL);
613 #ifndef MKSH_SMALL
614 if (t->type == TPIPE)
615 unwind(LLEAVE);
616 internal_warningf("%s: execute() returned", "exchild");
617 fptreef(shl_out, 8, "%s: tried to execute {\n\t%T\n}\n",
618 "exchild", t);
619 shf_flush(shl_out);
620 #endif
621 unwind(LLEAVE);
622 /* NOTREACHED */
623 }
624
625 /* shell (parent) stuff */
626 if (!(flags & XPIPEO)) {
627 /* last process in a job */
628 j_startjob(j);
629 if (flags & XCOPROC) {
630 j->coproc_id = coproc.id;
631 /* n jobs using co-process output */
632 coproc.njobs++;
633 /* j using co-process input */
634 coproc.job = (void *)j;
635 }
636 if (flags & XBGND) {
637 j_set_async(j);
638 if (Flag(FTALKING)) {
639 shf_fprintf(shl_out, "[%d]", j->job);
640 for (p = j->proc_list; p; p = p->next)
641 shf_fprintf(shl_out, Tf__d,
642 (int)p->pid);
643 shf_putchar('\n', shl_out);
644 shf_flush(shl_out);
645 }
646 } else
647 rv = j_waitj(j, jwflags, "jw:last proc");
648 }
649
650 #ifndef MKSH_NOPROSPECTOFWORK
651 sigprocmask(SIG_SETMASK, &omask, NULL);
652 #endif
653
654 return (rv);
655 }
656
657 /* start the last job: only used for $(command) jobs */
658 void
startlast(void)659 startlast(void)
660 {
661 #ifndef MKSH_NOPROSPECTOFWORK
662 sigset_t omask;
663
664 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
665 #endif
666
667 /* no need to report error - waitlast() will do it */
668 if (last_job) {
669 /* ensure it isn't removed by check_job() */
670 last_job->flags |= JF_WAITING;
671 j_startjob(last_job);
672 }
673 #ifndef MKSH_NOPROSPECTOFWORK
674 sigprocmask(SIG_SETMASK, &omask, NULL);
675 #endif
676 }
677
678 /* wait for last job: only used for $(command) jobs */
679 int
waitlast(void)680 waitlast(void)
681 {
682 int rv;
683 Job *j;
684 #ifndef MKSH_NOPROSPECTOFWORK
685 sigset_t omask;
686
687 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
688 #endif
689
690 j = last_job;
691 if (!j || !(j->flags & JF_STARTED)) {
692 if (!j)
693 warningf(true, Tf_sD_s, "waitlast", "no last job");
694 else
695 internal_warningf(Tf_sD_s, "waitlast", Tnot_started);
696 #ifndef MKSH_NOPROSPECTOFWORK
697 sigprocmask(SIG_SETMASK, &omask, NULL);
698 #endif
699 /* not so arbitrary, non-zero value */
700 return (125);
701 }
702
703 rv = j_waitj(j, JW_NONE, "waitlast");
704
705 #ifndef MKSH_NOPROSPECTOFWORK
706 sigprocmask(SIG_SETMASK, &omask, NULL);
707 #endif
708
709 return (rv);
710 }
711
712 /* wait for child, interruptable. */
713 int
waitfor(const char * cp,int * sigp)714 waitfor(const char *cp, int *sigp)
715 {
716 int rv, ecode, flags = JW_INTERRUPT|JW_ASYNCNOTIFY;
717 Job *j;
718 #ifndef MKSH_NOPROSPECTOFWORK
719 sigset_t omask;
720
721 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
722 #endif
723
724 *sigp = 0;
725
726 if (cp == NULL) {
727 /*
728 * wait for an unspecified job - always returns 0, so
729 * don't have to worry about exited/signaled jobs
730 */
731 for (j = job_list; j; j = j->next)
732 /* AT&T ksh will wait for stopped jobs - we don't */
733 if (j->ppid == procpid && j->state == PRUNNING)
734 break;
735 if (!j) {
736 #ifndef MKSH_NOPROSPECTOFWORK
737 sigprocmask(SIG_SETMASK, &omask, NULL);
738 #endif
739 return (-1);
740 }
741 } else if ((j = j_lookup(cp, &ecode))) {
742 /* don't report normal job completion */
743 flags &= ~JW_ASYNCNOTIFY;
744 if (j->ppid != procpid) {
745 #ifndef MKSH_NOPROSPECTOFWORK
746 sigprocmask(SIG_SETMASK, &omask, NULL);
747 #endif
748 return (-1);
749 }
750 } else {
751 #ifndef MKSH_NOPROSPECTOFWORK
752 sigprocmask(SIG_SETMASK, &omask, NULL);
753 #endif
754 if (ecode != JL_NOSUCH)
755 bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]);
756 return (-1);
757 }
758
759 /* AT&T ksh will wait for stopped jobs - we don't */
760 rv = j_waitj(j, flags, "jw:waitfor");
761
762 #ifndef MKSH_NOPROSPECTOFWORK
763 sigprocmask(SIG_SETMASK, &omask, NULL);
764 #endif
765
766 if (rv < 0)
767 /* we were interrupted */
768 *sigp = ksh_sigmask(-rv);
769
770 return (rv);
771 }
772
773 /* kill (built-in) a job */
774 int
j_kill(const char * cp,int sig)775 j_kill(const char *cp, int sig)
776 {
777 Job *j;
778 int rv = 0, ecode;
779 #ifndef MKSH_NOPROSPECTOFWORK
780 sigset_t omask;
781
782 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
783 #endif
784
785 if ((j = j_lookup(cp, &ecode)) == NULL) {
786 #ifndef MKSH_NOPROSPECTOFWORK
787 sigprocmask(SIG_SETMASK, &omask, NULL);
788 #endif
789 bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]);
790 return (1);
791 }
792
793 if (j->pgrp == 0) {
794 /* started when !Flag(FMONITOR) */
795 if (kill_job(j, sig) < 0) {
796 bi_errorf(Tf_sD_s, cp, cstrerror(errno));
797 rv = 1;
798 }
799 } else {
800 #ifndef MKSH_UNEMPLOYED
801 if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP))
802 mksh_killpg(j->pgrp, SIGCONT);
803 #endif
804 if (mksh_killpg(j->pgrp, sig) < 0) {
805 bi_errorf(Tf_sD_s, cp, cstrerror(errno));
806 rv = 1;
807 }
808 }
809
810 #ifndef MKSH_NOPROSPECTOFWORK
811 sigprocmask(SIG_SETMASK, &omask, NULL);
812 #endif
813
814 return (rv);
815 }
816
817 #ifndef MKSH_UNEMPLOYED
818 /* fg and bg built-ins: called only if Flag(FMONITOR) set */
819 int
j_resume(const char * cp,int bg)820 j_resume(const char *cp, int bg)
821 {
822 Job *j;
823 Proc *p;
824 int ecode, rv = 0;
825 bool running;
826 sigset_t omask;
827
828 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
829
830 if ((j = j_lookup(cp, &ecode)) == NULL) {
831 sigprocmask(SIG_SETMASK, &omask, NULL);
832 bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]);
833 return (1);
834 }
835
836 if (j->pgrp == 0) {
837 sigprocmask(SIG_SETMASK, &omask, NULL);
838 bi_errorf("job not job-controlled");
839 return (1);
840 }
841
842 if (bg)
843 shprintf("[%d] ", j->job);
844
845 running = false;
846 for (p = j->proc_list; p != NULL; p = p->next) {
847 if (p->state == PSTOPPED) {
848 p->state = PRUNNING;
849 p->status = 0;
850 running = true;
851 }
852 shf_puts(p->command, shl_stdout);
853 if (p->next)
854 shf_puts("| ", shl_stdout);
855 }
856 shf_putc('\n', shl_stdout);
857 shf_flush(shl_stdout);
858 if (running)
859 j->state = PRUNNING;
860
861 put_job(j, PJ_PAST_STOPPED);
862 if (bg)
863 j_set_async(j);
864 else {
865 /* attach tty to job */
866 if (j->state == PRUNNING) {
867 if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
868 mksh_tcset(tty_fd, &j->ttystat);
869 /* See comment in j_waitj regarding saved_ttypgrp. */
870 if (ttypgrp_ok &&
871 tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ?
872 j->saved_ttypgrp : j->pgrp) < 0) {
873 rv = errno;
874 if (j->flags & JF_SAVEDTTY)
875 mksh_tcset(tty_fd, &tty_state);
876 sigprocmask(SIG_SETMASK, &omask, NULL);
877 bi_errorf(Tf_ldfailed,
878 "fg: 1st", "tcsetpgrp", tty_fd,
879 (long)((j->flags & JF_SAVEDTTYPGRP) ?
880 j->saved_ttypgrp : j->pgrp),
881 cstrerror(rv));
882 return (1);
883 }
884 }
885 j->flags |= JF_FG;
886 j->flags &= ~JF_KNOWN;
887 if (j == async_job)
888 async_job = NULL;
889 }
890
891 if (j->state == PRUNNING && mksh_killpg(j->pgrp, SIGCONT) < 0) {
892 int eno = errno;
893
894 if (!bg) {
895 j->flags &= ~JF_FG;
896 if (ttypgrp_ok && (j->flags & JF_SAVEDTTY))
897 mksh_tcset(tty_fd, &tty_state);
898 if (ttypgrp_ok && tcsetpgrp(tty_fd, kshpgrp) < 0)
899 warningf(true, Tf_ldfailed,
900 "fg: 2nd", "tcsetpgrp", tty_fd,
901 (long)kshpgrp, cstrerror(errno));
902 }
903 sigprocmask(SIG_SETMASK, &omask, NULL);
904 bi_errorf(Tf_s_sD_s, "can't continue job",
905 cp, cstrerror(eno));
906 return (1);
907 }
908 if (!bg) {
909 if (ttypgrp_ok) {
910 j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP);
911 }
912 rv = j_waitj(j, JW_NONE, "jw:resume");
913 }
914 sigprocmask(SIG_SETMASK, &omask, NULL);
915 return (rv);
916 }
917 #endif
918
919 /* are there any running or stopped jobs ? */
920 int
j_stopped_running(void)921 j_stopped_running(void)
922 {
923 Job *j;
924 int which = 0;
925
926 for (j = job_list; j != NULL; j = j->next) {
927 #ifndef MKSH_UNEMPLOYED
928 if (j->ppid == procpid && j->state == PSTOPPED)
929 which |= 1;
930 #endif
931 if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid &&
932 j->ppid == procpid && j->state == PRUNNING)
933 which |= 2;
934 }
935 if (which) {
936 shellf("You have %s%s%s jobs\n",
937 which & 1 ? "stopped" : "",
938 which == 3 ? " and " : "",
939 which & 2 ? "running" : "");
940 return (1);
941 }
942
943 return (0);
944 }
945
946
947 /* list jobs for jobs built-in */
948 int
j_jobs(const char * cp,int slp,int nflag)949 j_jobs(const char *cp, int slp,
950 /* 0: short, 1: long, 2: pgrp */
951 int nflag)
952 {
953 Job *j, *tmp;
954 int how, zflag = 0;
955 #ifndef MKSH_NOPROSPECTOFWORK
956 sigset_t omask;
957
958 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
959 #endif
960
961 if (nflag < 0) {
962 /* kludge: print zombies */
963 nflag = 0;
964 zflag = 1;
965 }
966 if (cp) {
967 int ecode;
968
969 if ((j = j_lookup(cp, &ecode)) == NULL) {
970 #ifndef MKSH_NOPROSPECTOFWORK
971 sigprocmask(SIG_SETMASK, &omask, NULL);
972 #endif
973 bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]);
974 return (1);
975 }
976 } else
977 j = job_list;
978 how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP);
979 for (; j; j = j->next) {
980 if ((!(j->flags & JF_ZOMBIE) || zflag) &&
981 (!nflag || (j->flags & JF_CHANGED))) {
982 j_print(j, how, shl_stdout);
983 if (j->state == PEXITED || j->state == PSIGNALLED)
984 j->flags |= JF_REMOVE;
985 }
986 if (cp)
987 break;
988 }
989 /* Remove jobs after printing so there won't be multiple + or - jobs */
990 for (j = job_list; j; j = tmp) {
991 tmp = j->next;
992 if (j->flags & JF_REMOVE)
993 remove_job(j, Tjobs);
994 }
995 #ifndef MKSH_NOPROSPECTOFWORK
996 sigprocmask(SIG_SETMASK, &omask, NULL);
997 #endif
998 return (0);
999 }
1000
1001 /* list jobs for top-level notification */
1002 void
j_notify(void)1003 j_notify(void)
1004 {
1005 Job *j, *tmp;
1006 #ifndef MKSH_NOPROSPECTOFWORK
1007 sigset_t omask;
1008
1009 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
1010 #endif
1011 for (j = job_list; j; j = j->next) {
1012 #ifndef MKSH_UNEMPLOYED
1013 if (Flag(FMONITOR) && (j->flags & JF_CHANGED))
1014 j_print(j, JP_MEDIUM, shl_out);
1015 #endif
1016 /*
1017 * Remove job after doing reports so there aren't
1018 * multiple +/- jobs.
1019 */
1020 if (j->state == PEXITED || j->state == PSIGNALLED)
1021 j->flags |= JF_REMOVE;
1022 }
1023 for (j = job_list; j; j = tmp) {
1024 tmp = j->next;
1025 if (j->flags & JF_REMOVE) {
1026 if (j == async_job || (j->flags & JF_KNOWN)) {
1027 j->flags = (j->flags & ~JF_REMOVE) | JF_ZOMBIE;
1028 j->job = -1;
1029 nzombie++;
1030 } else
1031 remove_job(j, "notify");
1032 }
1033 }
1034 shf_flush(shl_out);
1035 #ifndef MKSH_NOPROSPECTOFWORK
1036 sigprocmask(SIG_SETMASK, &omask, NULL);
1037 #endif
1038 }
1039
1040 /* Return pid of last process in last asynchronous job */
1041 pid_t
j_async(void)1042 j_async(void)
1043 {
1044 #ifndef MKSH_NOPROSPECTOFWORK
1045 sigset_t omask;
1046
1047 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
1048 #endif
1049
1050 if (async_job)
1051 async_job->flags |= JF_KNOWN;
1052
1053 #ifndef MKSH_NOPROSPECTOFWORK
1054 sigprocmask(SIG_SETMASK, &omask, NULL);
1055 #endif
1056
1057 return (async_pid);
1058 }
1059
1060 /*
1061 * Make j the last async process
1062 *
1063 * If jobs are compiled in then this routine expects sigchld to be blocked.
1064 */
1065 static void
j_set_async(Job * j)1066 j_set_async(Job *j)
1067 {
1068 Job *jl, *oldest;
1069
1070 if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE)
1071 remove_job(async_job, "async");
1072 if (!(j->flags & JF_STARTED)) {
1073 internal_warningf(Tf_sD_s, "j_async", Tjob_not_started);
1074 return;
1075 }
1076 async_job = j;
1077 async_pid = j->last_proc->pid;
1078 while (nzombie > CHILD_MAX) {
1079 oldest = NULL;
1080 for (jl = job_list; jl; jl = jl->next)
1081 if (jl != async_job && (jl->flags & JF_ZOMBIE) &&
1082 (!oldest || jl->age < oldest->age))
1083 oldest = jl;
1084 if (!oldest) {
1085 /* XXX debugging */
1086 if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) {
1087 internal_warningf("%s: bad nzombie (%d)",
1088 "j_async", nzombie);
1089 nzombie = 0;
1090 }
1091 break;
1092 }
1093 remove_job(oldest, "zombie");
1094 }
1095 }
1096
1097 /*
1098 * Start a job: set STARTED, check for held signals and set j->last_proc
1099 *
1100 * If jobs are compiled in then this routine expects sigchld to be blocked.
1101 */
1102 static void
j_startjob(Job * j)1103 j_startjob(Job *j)
1104 {
1105 Proc *p;
1106
1107 j->flags |= JF_STARTED;
1108 for (p = j->proc_list; p->next; p = p->next)
1109 ;
1110 j->last_proc = p;
1111
1112 #ifndef MKSH_NOPROSPECTOFWORK
1113 if (held_sigchld) {
1114 held_sigchld = 0;
1115 /* Don't call j_sigchld() as it may remove job... */
1116 kill(procpid, SIGCHLD);
1117 }
1118 #endif
1119 }
1120
1121 /*
1122 * wait for job to complete or change state
1123 *
1124 * If jobs are compiled in then this routine expects sigchld to be blocked.
1125 */
1126 static int
j_waitj(Job * j,int flags,const char * where)1127 j_waitj(Job *j,
1128 /* see JW_* */
1129 int flags,
1130 const char *where)
1131 {
1132 Proc *p;
1133 int rv;
1134 #ifdef MKSH_NO_SIGSUSPEND
1135 sigset_t omask;
1136 #endif
1137
1138 /*
1139 * No auto-notify on the job we are waiting on.
1140 */
1141 j->flags |= JF_WAITING;
1142 if (flags & JW_ASYNCNOTIFY)
1143 j->flags |= JF_W_ASYNCNOTIFY;
1144
1145 #ifndef MKSH_UNEMPLOYED
1146 if (!Flag(FMONITOR))
1147 #endif
1148 flags |= JW_STOPPEDWAIT;
1149
1150 while (j->state == PRUNNING ||
1151 ((flags & JW_STOPPEDWAIT) && j->state == PSTOPPED)) {
1152 #ifndef MKSH_NOPROSPECTOFWORK
1153 #ifdef MKSH_NO_SIGSUSPEND
1154 sigprocmask(SIG_SETMASK, &sm_default, &omask);
1155 pause();
1156 /* note that handlers may run here so they need to know */
1157 sigprocmask(SIG_SETMASK, &omask, NULL);
1158 #else
1159 sigsuspend(&sm_default);
1160 #endif
1161 #else
1162 j_sigchld(SIGCHLD);
1163 #endif
1164 if (fatal_trap) {
1165 int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY);
1166 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1167 runtraps(TF_FATAL);
1168 /* not reached... */
1169 j->flags |= oldf;
1170 }
1171 if ((flags & JW_INTERRUPT) && (rv = trap_pending())) {
1172 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1173 return (-rv);
1174 }
1175 }
1176 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY);
1177
1178 if (j->flags & JF_FG) {
1179 j->flags &= ~JF_FG;
1180 #ifndef MKSH_UNEMPLOYED
1181 if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) {
1182 /*
1183 * Save the tty's current pgrp so it can be restored
1184 * when the job is foregrounded. This is to
1185 * deal with things like the GNU su which does
1186 * a fork/exec instead of an exec (the fork means
1187 * the execed shell gets a different pid from its
1188 * pgrp, so naturally it sets its pgrp and gets hosed
1189 * when it gets foregrounded by the parent shell which
1190 * has restored the tty's pgrp to that of the su
1191 * process).
1192 */
1193 if (j->state == PSTOPPED &&
1194 (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0)
1195 j->flags |= JF_SAVEDTTYPGRP;
1196 if (tcsetpgrp(tty_fd, kshpgrp) < 0)
1197 warningf(true, Tf_ldfailed,
1198 "j_waitj:", "tcsetpgrp", tty_fd,
1199 (long)kshpgrp, cstrerror(errno));
1200 if (j->state == PSTOPPED) {
1201 j->flags |= JF_SAVEDTTY;
1202 mksh_tcget(tty_fd, &j->ttystat);
1203 }
1204 }
1205 #endif
1206 if (tty_hasstate) {
1207 /*
1208 * Only restore tty settings if job was originally
1209 * started in the foreground. Problems can be
1210 * caused by things like 'more foobar &' which will
1211 * typically get and save the shell's vi/emacs tty
1212 * settings before setting up the tty for itself;
1213 * when more exits, it restores the 'original'
1214 * settings, and things go down hill from there...
1215 */
1216 if (j->state == PEXITED && j->status == 0 &&
1217 (j->flags & JF_USETTYMODE)) {
1218 mksh_tcget(tty_fd, &tty_state);
1219 } else {
1220 mksh_tcset(tty_fd, &tty_state);
1221 /*-
1222 * Don't use tty mode if job is stopped and
1223 * later restarted and exits. Consider
1224 * the sequence:
1225 * vi foo (stopped)
1226 * ...
1227 * stty something
1228 * ...
1229 * fg (vi; ZZ)
1230 * mode should be that of the stty, not what
1231 * was before the vi started.
1232 */
1233 if (j->state == PSTOPPED)
1234 j->flags &= ~JF_USETTYMODE;
1235 }
1236 }
1237 #ifndef MKSH_UNEMPLOYED
1238 /*
1239 * If it looks like user hit ^C to kill a job, pretend we got
1240 * one too to break out of for loops, etc. (AT&T ksh does this
1241 * even when not monitoring, but this doesn't make sense since
1242 * a tty generated ^C goes to the whole process group)
1243 */
1244 if (Flag(FMONITOR) && j->state == PSIGNALLED &&
1245 WIFSIGNALED(j->last_proc->status)) {
1246 int termsig;
1247
1248 if ((termsig = WTERMSIG(j->last_proc->status)) > 0 &&
1249 termsig < ksh_NSIG &&
1250 (sigtraps[termsig].flags & TF_TTY_INTR))
1251 trapsig(termsig);
1252 }
1253 #endif
1254 }
1255
1256 j_usrtime = j->usrtime;
1257 j_systime = j->systime;
1258 rv = j->status;
1259
1260 if (!(p = j->proc_list)) {
1261 ; /* nothing */
1262 } else if (flags & JW_PIPEST) {
1263 uint32_t num = 0;
1264 struct tbl *vp;
1265
1266 unset(vp_pipest, 1);
1267 vp = vp_pipest;
1268 vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U;
1269 goto got_array;
1270
1271 while (p != NULL) {
1272 {
1273 struct tbl *vq;
1274
1275 /* strlen(vp_pipest->name) == 10 */
1276 vq = alloc(offsetof(struct tbl, name[0]) + 11,
1277 vp_pipest->areap);
1278 memset(vq, 0, offsetof(struct tbl, name[0]));
1279 memcpy(vq->name, vp_pipest->name, 11);
1280 vp->u.array = vq;
1281 vp = vq;
1282 }
1283 vp->areap = vp_pipest->areap;
1284 vp->ua.index = ++num;
1285 vp->flag = DEFINED | ISSET | INTEGER | RDONLY |
1286 ARRAY | INT_U | AINDEX;
1287 got_array:
1288 vp->val.i = proc_errorlevel(p);
1289 if (Flag(FPIPEFAIL) && vp->val.i)
1290 rv = vp->val.i;
1291 p = p->next;
1292 }
1293 } else if (Flag(FPIPEFAIL)) {
1294 do {
1295 const int i = proc_errorlevel(p);
1296
1297 if (i)
1298 rv = i;
1299 } while ((p = p->next));
1300 }
1301
1302 if (!(flags & JW_ASYNCNOTIFY)
1303 #ifndef MKSH_UNEMPLOYED
1304 && (!Flag(FMONITOR) || j->state != PSTOPPED)
1305 #endif
1306 ) {
1307 j_print(j, JP_SHORT, shl_out);
1308 shf_flush(shl_out);
1309 }
1310 if (j->state != PSTOPPED
1311 #ifndef MKSH_UNEMPLOYED
1312 && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY))
1313 #endif
1314 )
1315 remove_job(j, where);
1316
1317 return (rv);
1318 }
1319
1320 /*
1321 * SIGCHLD handler to reap children and update job states
1322 *
1323 * If jobs are compiled in then this routine expects sigchld to be blocked.
1324 */
1325 /* ARGSUSED */
1326 static void
j_sigchld(int sig MKSH_A_UNUSED)1327 j_sigchld(int sig MKSH_A_UNUSED)
1328 {
1329 int saved_errno = errno;
1330 Job *j;
1331 Proc *p = NULL;
1332 pid_t pid;
1333 int status;
1334 struct rusage ru0, ru1;
1335 #ifdef MKSH_NO_SIGSUSPEND
1336 sigset_t omask;
1337
1338 /* this handler can run while SIGCHLD is not blocked, so block it now */
1339 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
1340 #endif
1341
1342 #ifndef MKSH_NOPROSPECTOFWORK
1343 /*
1344 * Don't wait for any processes if a job is partially started.
1345 * This is so we don't do away with the process group leader
1346 * before all the processes in a pipe line are started (so the
1347 * setpgid() won't fail)
1348 */
1349 for (j = job_list; j; j = j->next)
1350 if (j->ppid == procpid && !(j->flags & JF_STARTED)) {
1351 held_sigchld = 1;
1352 goto j_sigchld_out;
1353 }
1354 #endif
1355
1356 getrusage(RUSAGE_CHILDREN, &ru0);
1357 do {
1358 #ifndef MKSH_NOPROSPECTOFWORK
1359 pid = waitpid(-1, &status, (WNOHANG |
1360 #if defined(WCONTINUED) && defined(WIFCONTINUED)
1361 WCONTINUED |
1362 #endif
1363 WUNTRACED));
1364 #else
1365 pid = wait(&status);
1366 #endif
1367
1368 /*
1369 * return if this would block (0) or no children
1370 * or interrupted (-1)
1371 */
1372 if (pid <= 0)
1373 goto j_sigchld_out;
1374
1375 getrusage(RUSAGE_CHILDREN, &ru1);
1376
1377 /* find job and process structures for this pid */
1378 for (j = job_list; j != NULL; j = j->next)
1379 for (p = j->proc_list; p != NULL; p = p->next)
1380 if (p->pid == pid)
1381 goto found;
1382 found:
1383 if (j == NULL) {
1384 /* Can occur if process has kids, then execs shell
1385 warningf(true, "bad process waited for (pid = %d)",
1386 pid);
1387 */
1388 ru0 = ru1;
1389 continue;
1390 }
1391
1392 timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime);
1393 timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime);
1394 timeradd(&j->systime, &ru1.ru_stime, &j->systime);
1395 timersub(&j->systime, &ru0.ru_stime, &j->systime);
1396 ru0 = ru1;
1397 p->status = status;
1398 #ifndef MKSH_UNEMPLOYED
1399 if (WIFSTOPPED(status))
1400 p->state = PSTOPPED;
1401 else
1402 #if defined(WCONTINUED) && defined(WIFCONTINUED)
1403 if (WIFCONTINUED(status)) {
1404 p->state = j->state = PRUNNING;
1405 /* skip check_job(), no-op in this case */
1406 continue;
1407 } else
1408 #endif
1409 #endif
1410 if (WIFSIGNALED(status))
1411 p->state = PSIGNALLED;
1412 else
1413 p->state = PEXITED;
1414
1415 /* check to see if entire job is done */
1416 check_job(j);
1417 }
1418 #ifndef MKSH_NOPROSPECTOFWORK
1419 while (/* CONSTCOND */ 1);
1420 #else
1421 while (/* CONSTCOND */ 0);
1422 #endif
1423
1424 j_sigchld_out:
1425 #ifdef MKSH_NO_SIGSUSPEND
1426 sigprocmask(SIG_SETMASK, &omask, NULL);
1427 #endif
1428 errno = saved_errno;
1429 }
1430
1431 /*
1432 * Called only when a process in j has exited/stopped (ie, called only
1433 * from j_sigchld()). If no processes are running, the job status
1434 * and state are updated, asynchronous job notification is done and,
1435 * if unneeded, the job is removed.
1436 *
1437 * If jobs are compiled in then this routine expects sigchld to be blocked.
1438 */
1439 static void
check_job(Job * j)1440 check_job(Job *j)
1441 {
1442 int jstate;
1443 Proc *p;
1444
1445 /* XXX debugging (nasty - interrupt routine using shl_out) */
1446 if (!(j->flags & JF_STARTED)) {
1447 internal_warningf("check_job: job started (flags 0x%X)",
1448 (unsigned int)j->flags);
1449 return;
1450 }
1451
1452 jstate = PRUNNING;
1453 for (p=j->proc_list; p != NULL; p = p->next) {
1454 if (p->state == PRUNNING)
1455 /* some processes still running */
1456 return;
1457 if (p->state > jstate)
1458 jstate = p->state;
1459 }
1460 j->state = jstate;
1461 j->status = proc_errorlevel(j->last_proc);
1462
1463 /*
1464 * Note when co-process dies: can't be done in j_wait() nor
1465 * remove_job() since neither may be called for non-interactive
1466 * shells.
1467 */
1468 if (j->state == PEXITED || j->state == PSIGNALLED) {
1469 /*
1470 * No need to keep co-process input any more
1471 * (at least, this is what ksh93d thinks)
1472 */
1473 if (coproc.job == j) {
1474 coproc.job = NULL;
1475 /*
1476 * XXX would be nice to get the closes out of here
1477 * so they aren't done in the signal handler.
1478 * Would mean a check in coproc_getfd() to
1479 * do "if job == 0 && write >= 0, close write".
1480 */
1481 coproc_write_close(coproc.write);
1482 }
1483 /* Do we need to keep the output? */
1484 if (j->coproc_id && j->coproc_id == coproc.id &&
1485 --coproc.njobs == 0)
1486 coproc_readw_close(coproc.read);
1487 }
1488
1489 j->flags |= JF_CHANGED;
1490 #ifndef MKSH_UNEMPLOYED
1491 if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) {
1492 /*
1493 * Only put stopped jobs at the front to avoid confusing
1494 * the user (don't want finished jobs effecting %+ or %-)
1495 */
1496 if (j->state == PSTOPPED)
1497 put_job(j, PJ_ON_FRONT);
1498 if (Flag(FNOTIFY) &&
1499 (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) {
1500 /* Look for the real file descriptor 2 */
1501 {
1502 struct env *ep;
1503 int fd = 2;
1504
1505 for (ep = e; ep; ep = ep->oenv)
1506 if (ep->savefd && ep->savefd[2])
1507 fd = ep->savefd[2];
1508 shf_reopen(fd, SHF_WR, shl_j);
1509 }
1510 /*
1511 * Can't call j_notify() as it removes jobs. The job
1512 * must stay in the job list as j_waitj() may be
1513 * running with this job.
1514 */
1515 j_print(j, JP_MEDIUM, shl_j);
1516 shf_flush(shl_j);
1517 if (!(j->flags & JF_WAITING) && j->state != PSTOPPED)
1518 remove_job(j, "notify");
1519 }
1520 }
1521 #endif
1522 if (
1523 #ifndef MKSH_UNEMPLOYED
1524 !Flag(FMONITOR) &&
1525 #endif
1526 !(j->flags & (JF_WAITING|JF_FG)) &&
1527 j->state != PSTOPPED) {
1528 if (j == async_job || (j->flags & JF_KNOWN)) {
1529 j->flags |= JF_ZOMBIE;
1530 j->job = -1;
1531 nzombie++;
1532 } else
1533 remove_job(j, "checkjob");
1534 }
1535 }
1536
1537 /*
1538 * Print job status in either short, medium or long format.
1539 *
1540 * If jobs are compiled in then this routine expects sigchld to be blocked.
1541 */
1542 static void
j_print(Job * j,int how,struct shf * shf)1543 j_print(Job *j, int how, struct shf *shf)
1544 {
1545 Proc *p;
1546 int state;
1547 int status;
1548 #ifdef WCOREDUMP
1549 bool coredumped;
1550 #endif
1551 char jobchar = ' ';
1552 char buf[64];
1553 const char *filler;
1554 int output = 0;
1555
1556 if (how == JP_PGRP) {
1557 /*
1558 * POSIX doesn't say what to do it there is no process
1559 * group leader (ie, !FMONITOR). We arbitrarily return
1560 * last pid (which is what $! returns).
1561 */
1562 shf_fprintf(shf, Tf_dN, (int)(j->pgrp ? j->pgrp :
1563 (j->last_proc ? j->last_proc->pid : 0)));
1564 return;
1565 }
1566 j->flags &= ~JF_CHANGED;
1567 filler = j->job > 10 ? "\n " : "\n ";
1568 if (j == job_list)
1569 jobchar = '+';
1570 else if (j == job_list->next)
1571 jobchar = '-';
1572
1573 for (p = j->proc_list; p != NULL;) {
1574 #ifdef WCOREDUMP
1575 coredumped = false;
1576 #endif
1577 switch (p->state) {
1578 case PRUNNING:
1579 memcpy(buf, "Running", 8);
1580 break;
1581 case PSTOPPED: {
1582 int stopsig = WSTOPSIG(p->status);
1583
1584 strlcpy(buf, stopsig > 0 && stopsig < ksh_NSIG ?
1585 sigtraps[stopsig].mess : "Stopped", sizeof(buf));
1586 break;
1587 }
1588 case PEXITED: {
1589 int exitstatus = (WEXITSTATUS(p->status)) & 255;
1590
1591 if (how == JP_SHORT)
1592 buf[0] = '\0';
1593 else if (exitstatus == 0)
1594 memcpy(buf, "Done", 5);
1595 else
1596 shf_snprintf(buf, sizeof(buf), "Done (%d)",
1597 exitstatus);
1598 break;
1599 }
1600 case PSIGNALLED: {
1601 int termsig = WTERMSIG(p->status);
1602 #ifdef WCOREDUMP
1603 if (WCOREDUMP(p->status))
1604 coredumped = true;
1605 #endif
1606 /*
1607 * kludge for not reporting 'normal termination
1608 * signals' (i.e. SIGINT, SIGPIPE)
1609 */
1610 if (how == JP_SHORT &&
1611 #ifdef WCOREDUMP
1612 !coredumped &&
1613 #endif
1614 (termsig == SIGINT || termsig == SIGPIPE)) {
1615 buf[0] = '\0';
1616 } else
1617 strlcpy(buf, termsig > 0 && termsig < ksh_NSIG ?
1618 sigtraps[termsig].mess : "Signalled",
1619 sizeof(buf));
1620 break;
1621 }
1622 default:
1623 buf[0] = '\0';
1624 }
1625
1626 if (how != JP_SHORT) {
1627 if (p == j->proc_list)
1628 shf_fprintf(shf, "[%d] %c ", j->job, jobchar);
1629 else
1630 shf_puts(filler, shf);
1631 }
1632
1633 if (how == JP_LONG)
1634 shf_fprintf(shf, "%5d ", (int)p->pid);
1635
1636 if (how == JP_SHORT) {
1637 if (buf[0]) {
1638 output = 1;
1639 #ifdef WCOREDUMP
1640 shf_fprintf(shf, "%s%s ",
1641 buf, coredumped ? " (core dumped)" : null);
1642 #else
1643 shf_puts(buf, shf);
1644 shf_putchar(' ', shf);
1645 #endif
1646 }
1647 } else {
1648 output = 1;
1649 shf_fprintf(shf, "%-20s %s%s%s", buf, p->command,
1650 p->next ? "|" : null,
1651 #ifdef WCOREDUMP
1652 coredumped ? " (core dumped)" :
1653 #endif
1654 null);
1655 }
1656
1657 state = p->state;
1658 status = p->status;
1659 p = p->next;
1660 while (p && p->state == state && p->status == status) {
1661 if (how == JP_LONG)
1662 shf_fprintf(shf, "%s%5d %-20s %s%s", filler,
1663 (int)p->pid, T1space, p->command,
1664 p->next ? "|" : null);
1665 else if (how == JP_MEDIUM)
1666 shf_fprintf(shf, Tf__ss, p->command,
1667 p->next ? "|" : null);
1668 p = p->next;
1669 }
1670 }
1671 if (output)
1672 shf_putc('\n', shf);
1673 }
1674
1675 /*
1676 * Convert % sequence to job
1677 *
1678 * If jobs are compiled in then this routine expects sigchld to be blocked.
1679 */
1680 static Job *
j_lookup(const char * cp,int * ecodep)1681 j_lookup(const char *cp, int *ecodep)
1682 {
1683 Job *j, *last_match;
1684 Proc *p;
1685 size_t len;
1686 int job = 0;
1687
1688 if (ctype(*cp, C_DIGIT) && getn(cp, &job)) {
1689 /* Look for last_proc->pid (what $! returns) first... */
1690 for (j = job_list; j != NULL; j = j->next)
1691 if (j->last_proc && j->last_proc->pid == job)
1692 return (j);
1693 /*
1694 * ...then look for process group (this is non-POSIX,
1695 * but should not break anything
1696 */
1697 for (j = job_list; j != NULL; j = j->next)
1698 if (j->pgrp && j->pgrp == job)
1699 return (j);
1700 goto j_lookup_nosuch;
1701 }
1702 if (*cp != '%') {
1703 j_lookup_invalid:
1704 if (ecodep)
1705 *ecodep = JL_INVALID;
1706 return (NULL);
1707 }
1708 switch (*++cp) {
1709 case '\0': /* non-standard */
1710 case '+':
1711 case '%':
1712 if (job_list != NULL)
1713 return (job_list);
1714 break;
1715
1716 case '-':
1717 if (job_list != NULL && job_list->next)
1718 return (job_list->next);
1719 break;
1720
1721 case '0': case '1': case '2': case '3': case '4':
1722 case '5': case '6': case '7': case '8': case '9':
1723 if (!getn(cp, &job))
1724 goto j_lookup_invalid;
1725 for (j = job_list; j != NULL; j = j->next)
1726 if (j->job == job)
1727 return (j);
1728 break;
1729
1730 /* %?string */
1731 case '?':
1732 last_match = NULL;
1733 for (j = job_list; j != NULL; j = j->next)
1734 for (p = j->proc_list; p != NULL; p = p->next)
1735 if (strstr(p->command, cp+1) != NULL) {
1736 if (last_match) {
1737 if (ecodep)
1738 *ecodep = JL_AMBIG;
1739 return (NULL);
1740 }
1741 last_match = j;
1742 }
1743 if (last_match)
1744 return (last_match);
1745 break;
1746
1747 /* %string */
1748 default:
1749 len = strlen(cp);
1750 last_match = NULL;
1751 for (j = job_list; j != NULL; j = j->next)
1752 if (strncmp(cp, j->proc_list->command, len) == 0) {
1753 if (last_match) {
1754 if (ecodep)
1755 *ecodep = JL_AMBIG;
1756 return (NULL);
1757 }
1758 last_match = j;
1759 }
1760 if (last_match)
1761 return (last_match);
1762 break;
1763 }
1764 j_lookup_nosuch:
1765 if (ecodep)
1766 *ecodep = JL_NOSUCH;
1767 return (NULL);
1768 }
1769
1770 static Job *free_jobs;
1771 static Proc *free_procs;
1772
1773 /*
1774 * allocate a new job and fill in the job number.
1775 *
1776 * If jobs are compiled in then this routine expects sigchld to be blocked.
1777 */
1778 static Job *
new_job(void)1779 new_job(void)
1780 {
1781 int i;
1782 Job *newj, *j;
1783
1784 if (free_jobs != NULL) {
1785 newj = free_jobs;
1786 free_jobs = free_jobs->next;
1787 } else
1788 newj = alloc(sizeof(Job), APERM);
1789
1790 /* brute force method */
1791 for (i = 1; ; i++) {
1792 for (j = job_list; j && j->job != i; j = j->next)
1793 ;
1794 if (j == NULL)
1795 break;
1796 }
1797 newj->job = i;
1798
1799 return (newj);
1800 }
1801
1802 /*
1803 * Allocate new process struct
1804 *
1805 * If jobs are compiled in then this routine expects sigchld to be blocked.
1806 */
1807 static Proc *
new_proc(void)1808 new_proc(void)
1809 {
1810 Proc *p;
1811
1812 if (free_procs != NULL) {
1813 p = free_procs;
1814 free_procs = free_procs->next;
1815 } else
1816 p = alloc(sizeof(Proc), APERM);
1817
1818 return (p);
1819 }
1820
1821 /*
1822 * Take job out of job_list and put old structures into free list.
1823 * Keeps nzombies, last_job and async_job up to date.
1824 *
1825 * If jobs are compiled in then this routine expects sigchld to be blocked.
1826 */
1827 static void
remove_job(Job * j,const char * where)1828 remove_job(Job *j, const char *where)
1829 {
1830 Proc *p, *tmp;
1831 Job **prev, *curr;
1832
1833 prev = &job_list;
1834 curr = job_list;
1835 while (curr && curr != j) {
1836 prev = &curr->next;
1837 curr = *prev;
1838 }
1839 if (curr != j) {
1840 internal_warningf("remove_job: job %s (%s)", Tnot_found, where);
1841 return;
1842 }
1843 *prev = curr->next;
1844
1845 /* free up proc structures */
1846 for (p = j->proc_list; p != NULL; ) {
1847 tmp = p;
1848 p = p->next;
1849 tmp->next = free_procs;
1850 free_procs = tmp;
1851 }
1852
1853 if ((j->flags & JF_ZOMBIE) && j->ppid == procpid)
1854 --nzombie;
1855 j->next = free_jobs;
1856 free_jobs = j;
1857
1858 if (j == last_job)
1859 last_job = NULL;
1860 if (j == async_job)
1861 async_job = NULL;
1862 }
1863
1864 /*
1865 * put j in a particular location (taking it out job_list if it is there
1866 * already)
1867 *
1868 * If jobs are compiled in then this routine expects sigchld to be blocked.
1869 */
1870 static void
put_job(Job * j,int where)1871 put_job(Job *j, int where)
1872 {
1873 Job **prev, *curr;
1874
1875 /* Remove job from list (if there) */
1876 prev = &job_list;
1877 curr = job_list;
1878 while (curr && curr != j) {
1879 prev = &curr->next;
1880 curr = *prev;
1881 }
1882 if (curr == j)
1883 *prev = curr->next;
1884
1885 switch (where) {
1886 case PJ_ON_FRONT:
1887 j->next = job_list;
1888 job_list = j;
1889 break;
1890
1891 case PJ_PAST_STOPPED:
1892 prev = &job_list;
1893 curr = job_list;
1894 for (; curr && curr->state == PSTOPPED; prev = &curr->next,
1895 curr = *prev)
1896 ;
1897 j->next = curr;
1898 *prev = j;
1899 break;
1900 }
1901 }
1902
1903 /*
1904 * nuke a job (called when unable to start full job).
1905 *
1906 * If jobs are compiled in then this routine expects sigchld to be blocked.
1907 */
1908 static int
kill_job(Job * j,int sig)1909 kill_job(Job *j, int sig)
1910 {
1911 Proc *p;
1912 int rval = 0;
1913
1914 for (p = j->proc_list; p != NULL; p = p->next)
1915 if (p->pid != 0)
1916 if (kill(p->pid, sig) < 0)
1917 rval = -1;
1918 return (rval);
1919 }
1920
1921 static void
tty_init_talking(void)1922 tty_init_talking(void)
1923 {
1924 switch (tty_init_fd()) {
1925 case 0:
1926 break;
1927 case 1:
1928 #ifndef MKSH_DISABLE_TTY_WARNING
1929 warningf(false, Tf_sD_s_sD_s,
1930 "No controlling tty", Topen, T_devtty, cstrerror(errno));
1931 #endif
1932 break;
1933 case 2:
1934 #ifndef MKSH_DISABLE_TTY_WARNING
1935 warningf(false, Tf_sD_s_s, Tcant_find, Ttty_fd,
1936 cstrerror(errno));
1937 #endif
1938 break;
1939 case 3:
1940 warningf(false, Tf_ssfaileds, "j_ttyinit",
1941 Ttty_fd_dupof, cstrerror(errno));
1942 break;
1943 case 4:
1944 warningf(false, Tf_sD_sD_s, "j_ttyinit",
1945 "can't set close-on-exec flag", cstrerror(errno));
1946 break;
1947 }
1948 }
1949
1950 static void
tty_init_state(void)1951 tty_init_state(void)
1952 {
1953 if (tty_fd >= 0) {
1954 mksh_tcget(tty_fd, &tty_state);
1955 tty_hasstate = true;
1956 }
1957 }
1958