1 /*
2 * sh.proc.c: Job manipulations
3 */
4 /*-
5 * Copyright (c) 1980, 1991 The Regents of the University of California.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32 #include "sh.h"
33 #include "ed.h"
34 #include "tc.h"
35 #include "tc.wait.h"
36
37 #ifdef WINNT_NATIVE
38 #undef POSIX
39 #define POSIX
40 #endif /* WINNT_NATIVE */
41 #ifdef aiws
42 # undef HZ
43 # define HZ 16
44 #endif /* aiws */
45
46 #if defined(_BSD) || (defined(IRIS4D) && __STDC__) || defined(__lucid)
47 # define BSDWAIT
48 #endif /* _BSD || (IRIS4D && __STDC__) || __lucid */
49 #ifndef WTERMSIG
50 # define WTERMSIG(w) (((union wait *) &(w))->w_termsig)
51 # ifndef BSDWAIT
52 # define BSDWAIT
53 # endif /* !BSDWAIT */
54 #endif /* !WTERMSIG */
55 #ifndef WEXITSTATUS
56 # define WEXITSTATUS(w) (((union wait *) &(w))->w_retcode)
57 #endif /* !WEXITSTATUS */
58 #ifndef WSTOPSIG
59 # define WSTOPSIG(w) (((union wait *) &(w))->w_stopsig)
60 #endif /* !WSTOPSIG */
61
62 #ifdef __osf__
63 # ifndef WCOREDUMP
64 # define WCOREDUMP(x) (_W_INT(x) & WCOREFLAG)
65 # endif
66 #endif
67
68 #ifndef WCOREDUMP
69 # ifdef BSDWAIT
70 # define WCOREDUMP(w) (((union wait *) &(w))->w_coredump)
71 # else /* !BSDWAIT */
72 # define WCOREDUMP(w) ((w) & 0200)
73 # endif /* !BSDWAIT */
74 #endif /* !WCOREDUMP */
75
76 #ifndef JOBDEBUG
77 # define jobdebug_xprintf(x) (void)0
78 # define jobdebug_flush() (void)0
79 #else
80 # define jobdebug_xprintf(s) xprintf s
81 # define jobdebug_flush() flush()
82 #endif
83
84 /*
85 * C Shell - functions that manage processes, handling hanging, termination
86 */
87
88 #define BIGINDEX 9 /* largest desirable job index */
89
90 #ifdef BSDTIMES
91 # ifdef convex
92 /* use 'cvxrusage' to get parallel statistics */
93 static struct cvxrusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L,
94 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
95 {0L, 0L}, 0LL, 0LL, 0LL, 0LL, 0L, 0L, 0L,
96 0LL, 0LL, {0L, 0L, 0L, 0L, 0L}};
97 # else
98 static struct rusage zru;
99 # endif /* convex */
100 #else /* !BSDTIMES */
101 # ifdef _SEQUENT_
102 static struct process_stats zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0,
103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
104 # else /* !_SEQUENT_ */
105 # ifdef _SX
106 static struct tms zru = {0, 0, 0, 0}, lru = {0, 0, 0, 0};
107 # else /* !_SX */
108 static struct tms zru = {0L, 0L, 0L, 0L}, lru = {0L, 0L, 0L, 0L};
109 # endif /* !_SX */
110 # endif /* !_SEQUENT_ */
111 #endif /* !BSDTIMES */
112
113 #ifndef BSDTIMES
114 static int timesdone; /* shtimes buffer full ? */
115 #endif /* BSDTIMES */
116
117 #ifndef RUSAGE_CHILDREN
118 # define RUSAGE_CHILDREN -1
119 #endif /* RUSAGE_CHILDREN */
120
121 static void pflushall (void);
122 static void pflush (struct process *);
123 static void pfree (struct process *);
124 static void pclrcurr (struct process *);
125 static void morecommand (size_t);
126 static void padd (struct command *);
127 static int pprint (struct process *, int);
128 static void ptprint (struct process *);
129 static void pads (Char *);
130 static void pkill (Char **, int);
131 static struct process *pgetcurr (struct process *);
132 static void okpcntl (void);
133 static void setttypgrp (int);
134
135 /*
136 * pchild - call queued by the SIGCHLD signal
137 * indicating that at least one child has terminated or stopped
138 * thus at least one wait system call will definitely return a
139 * childs status. Top level routines (like pwait) must be sure
140 * to mask interrupts when playing with the proclist data structures!
141 */
142 void
pchild(void)143 pchild(void)
144 {
145 struct process *pp;
146 struct process *fp;
147 pid_t pid;
148 #ifdef BSDWAIT
149 union wait w;
150 #else /* !BSDWAIT */
151 int w;
152 #endif /* !BSDWAIT */
153 int jobflags;
154 #ifdef BSDTIMES
155 struct sysrusage ru;
156 #else /* !BSDTIMES */
157 # ifdef _SEQUENT_
158 struct process_stats ru;
159 struct process_stats cpst1, cpst2;
160 timeval_t tv;
161 # else /* !_SEQUENT_ */
162 struct tms proctimes;
163
164 if (!timesdone) {
165 timesdone++;
166 (void) times(&shtimes);
167 }
168 # endif /* !_SEQUENT_ */
169 #endif /* !BSDTIMES */
170
171 jobdebug_xprintf(("pchild()\n"));
172
173 loop:
174 jobdebug_xprintf(("Waiting...\n"));
175 jobdebug_flush();
176 errno = 0; /* reset, just in case */
177
178 #ifndef WINNT_NATIVE
179 # ifdef BSDJOBS
180 # ifdef BSDTIMES
181 # ifdef convex
182 /* use 'cvxwait' to get parallel statistics */
183 pid = cvxwait(&w,
184 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
185 # else
186 /* both a wait3 and rusage */
187 # if !defined(BSDWAIT) || defined(NeXT) || defined(MACH) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (defined(IRIS4D) && SYSVREL <= 3) || defined(__lucid) || defined(__osf__)
188 #ifdef __ANDROID__ /* no wait3, only wait4 */
189 pid = wait4(-1, &w,
190 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
191 #else
192 pid = wait3(&w,
193 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
194 #endif /* __ANDROID__ */
195 # else /* BSDWAIT */
196 pid = wait3(&w.w_status,
197 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
198 # endif /* BSDWAIT */
199 # endif /* convex */
200 # else /* !BSDTIMES */
201 # ifdef _SEQUENT_
202 (void) get_process_stats(&tv, PS_SELF, 0, &cpst1);
203 pid = waitpid(-1, &w,
204 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
205 (void) get_process_stats(&tv, PS_SELF, 0, &cpst2);
206 pr_stat_sub(&cpst2, &cpst1, &ru);
207 # else /* !_SEQUENT_ */
208 # ifndef POSIX
209 /* we have a wait3, but no rusage stuff */
210 pid = wait3(&w.w_status,
211 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
212 # else /* POSIX */
213 pid = waitpid(-1, &w,
214 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
215 # endif /* POSIX */
216 # endif /* !_SEQUENT_ */
217 # endif /* !BSDTIMES */
218 # else /* !BSDJOBS */
219 # ifdef BSDTIMES
220 # define HAVEwait3
221 /* both a wait3 and rusage */
222 # ifdef hpux
223 pid = wait3(&w.w_status, WNOHANG, 0);
224 # else /* !hpux */
225 # ifndef BSDWAIT
226 pid = wait3(&w, WNOHANG, &ru);
227 # else
228 pid = wait3(&w.w_status, WNOHANG, &ru);
229 # endif /* BSDWAIT */
230 # endif /* !hpux */
231 # else /* !BSDTIMES */
232 # ifdef ODT /* For Sco Unix 3.2.0 or ODT 1.0 */
233 # define HAVEwait3
234 pid = waitpid(-1, &w,
235 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
236 # endif /* ODT */
237 # if defined(aiws) || defined(uts)
238 # define HAVEwait3
239 pid = wait3(&w.w_status,
240 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
241 # endif /* aiws || uts */
242 # ifndef HAVEwait3
243 # ifndef BSDWAIT
244 /* no wait3, therefore no rusage */
245 /* on Sys V, this may hang. I hope it's not going to be a problem */
246 pid = wait(&w);
247 # else /* BSDWAIT */
248 /*
249 * XXX: for greater than 3 we should use waitpid().
250 * but then again, SVR4 falls into the POSIX/BSDJOBS category.
251 */
252 pid = wait(&w.w_status);
253 # endif /* BSDWAIT */
254 # endif /* !HAVEwait3 */
255 # endif /* !BSDTIMES */
256 # endif /* !BSDJOBS */
257 #else /* WINNT_NATIVE */
258 pid = waitpid(-1, &w,
259 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
260 #endif /* WINNT_NATIVE */
261
262 jobdebug_xprintf(("parent %d pid %d, retval %x termsig %x retcode %x\n",
263 (int)getpid(), (int)pid, w, WTERMSIG(w),
264 WEXITSTATUS(w)));
265 jobdebug_flush();
266
267 if ((pid == 0) || (pid == -1)) {
268 (void)handle_pending_signals();
269 jobdebug_xprintf(("errno == %d\n", errno));
270 if (errno == EINTR)
271 goto loop;
272 goto end;
273 }
274 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
275 if (pid == pp->p_procid)
276 goto found;
277 #if !defined(BSDJOBS) && !defined(WINNT_NATIVE)
278 /* this should never have happened */
279 stderror(ERR_SYNC, pid);
280 xexit(0);
281 #else /* BSDJOBS || WINNT_NATIVE */
282 goto loop;
283 #endif /* !BSDJOBS && !WINNT_NATIVE */
284 found:
285 pp->p_flags &= ~(PRUNNING | PSTOPPED | PREPORTED);
286 if (WIFSTOPPED(w)) {
287 pp->p_flags |= PSTOPPED;
288 pp->p_reason = WSTOPSIG(w);
289 }
290 else {
291 if (pp->p_flags & (PTIME | PPTIME) || adrof(STRtime))
292 #ifndef BSDTIMES
293 # ifdef _SEQUENT_
294 (void) get_process_stats(&pp->p_etime, PS_SELF, NULL, NULL);
295 # else /* !_SEQUENT_ */
296 pp->p_etime = times(&proctimes);
297 # endif /* !_SEQUENT_ */
298 #else /* BSDTIMES */
299 (void) gettimeofday(&pp->p_etime, NULL);
300 #endif /* BSDTIMES */
301
302
303 #if defined(BSDTIMES) || defined(_SEQUENT_)
304 pp->p_rusage = ru;
305 #else /* !BSDTIMES && !_SEQUENT_ */
306 (void) times(&proctimes);
307 pp->p_utime = proctimes.tms_cutime - shtimes.tms_cutime;
308 pp->p_stime = proctimes.tms_cstime - shtimes.tms_cstime;
309 shtimes = proctimes;
310 #endif /* !BSDTIMES && !_SEQUENT_ */
311 if (WIFSIGNALED(w)) {
312 if (WTERMSIG(w) == SIGINT)
313 pp->p_flags |= PINTERRUPTED;
314 else
315 pp->p_flags |= PSIGNALED;
316 if (WCOREDUMP(w))
317 pp->p_flags |= PDUMPED;
318 pp->p_reason = WTERMSIG(w);
319 }
320 else {
321 pp->p_reason = WEXITSTATUS(w);
322 if (pp->p_reason != 0)
323 pp->p_flags |= PAEXITED;
324 else
325 pp->p_flags |= PNEXITED;
326 }
327 }
328 jobflags = 0;
329 fp = pp;
330 do {
331 if ((fp->p_flags & (PPTIME | PRUNNING | PSTOPPED)) == 0 &&
332 !child && adrof(STRtime) &&
333 #ifdef BSDTIMES
334 fp->p_rusage.ru_utime.tv_sec + fp->p_rusage.ru_stime.tv_sec
335 #else /* !BSDTIMES */
336 # ifdef _SEQUENT_
337 fp->p_rusage.ps_utime.tv_sec + fp->p_rusage.ps_stime.tv_sec
338 # else /* !_SEQUENT_ */
339 # ifndef POSIX
340 (fp->p_utime + fp->p_stime) / HZ
341 # else /* POSIX */
342 (fp->p_utime + fp->p_stime) / clk_tck
343 # endif /* POSIX */
344 # endif /* !_SEQUENT_ */
345 #endif /* !BSDTIMES */
346 >= atoi(short2str(varval(STRtime))))
347 fp->p_flags |= PTIME;
348 jobflags |= fp->p_flags;
349 } while ((fp = fp->p_friends) != pp);
350 pp->p_flags &= ~PFOREGND;
351 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
352 pp->p_flags &= ~PPTIME;
353 pp->p_flags |= PTIME;
354 }
355 if ((jobflags & (PRUNNING | PREPORTED)) == 0) {
356 fp = pp;
357 do {
358 if (fp->p_flags & PSTOPPED)
359 fp->p_flags |= PREPORTED;
360 } while ((fp = fp->p_friends) != pp);
361 while (fp->p_procid != fp->p_jobid)
362 fp = fp->p_friends;
363 if (jobflags & PSTOPPED) {
364 if (pcurrent && pcurrent != fp)
365 pprevious = pcurrent;
366 pcurrent = fp;
367 }
368 else
369 pclrcurr(fp);
370 if (jobflags & PFOREGND) {
371 if (!(jobflags & (PSIGNALED | PSTOPPED | PPTIME) ||
372 #ifdef notdef
373 jobflags & PAEXITED ||
374 #endif /* notdef */
375 fp->p_cwd == NULL ||
376 !eq(dcwd->di_name, fp->p_cwd->di_name))) {
377 /* PWP: print a newline after ^C */
378 if (jobflags & PINTERRUPTED) {
379 xputchar('\r' | QUOTE);
380 xputchar('\n');
381 }
382 #ifdef notdef
383 else if ((jobflags & (PTIME|PSTOPPED)) == PTIME)
384 ptprint(fp);
385 #endif /* notdef */
386 }
387 }
388 else {
389 if (jobflags & PNOTIFY || adrof(STRnotify)) {
390 xputchar('\r' | QUOTE);
391 xputchar('\n');
392 (void) pprint(pp, NUMBER | NAME | REASON);
393 if ((jobflags & PSTOPPED) == 0)
394 pflush(pp);
395 if (GettingInput) {
396 errno = 0;
397 (void) Rawmode();
398 #ifdef notdef
399 /*
400 * don't really want to do that, because it
401 * will erase our message in case of multi-line
402 * input
403 */
404 ClearLines();
405 #endif /* notdef */
406 ClearDisp();
407 Refresh();
408 }
409 }
410 else {
411 fp->p_flags |= PNEEDNOTE;
412 neednote = 1;
413 }
414 }
415 }
416 #if defined(BSDJOBS) || defined(HAVEwait3) ||defined(WINNT_NATIVE)
417 goto loop;
418 #endif /* BSDJOBS || HAVEwait3 */
419 end:
420 ;
421 }
422
423 void
pnote(void)424 pnote(void)
425 {
426 struct process *pp;
427 int flags;
428
429 neednote = 0;
430 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) {
431 if (pp->p_flags & PNEEDNOTE) {
432 pchild_disabled++;
433 cleanup_push(&pchild_disabled, disabled_cleanup);
434 pp->p_flags &= ~PNEEDNOTE;
435 flags = pprint(pp, NUMBER | NAME | REASON);
436 if ((flags & (PRUNNING | PSTOPPED)) == 0)
437 pflush(pp);
438 cleanup_until(&pchild_disabled);
439 }
440 }
441 }
442
443
444 static void
pfree(struct process * pp)445 pfree(struct process *pp)
446 {
447 xfree(pp->p_command);
448 if (pp->p_cwd && --pp->p_cwd->di_count == 0)
449 if (pp->p_cwd->di_next == 0)
450 dfree(pp->p_cwd);
451 xfree(pp);
452 }
453
454
455 /*
456 * pwait - wait for current job to terminate, maintaining integrity
457 * of current and previous job indicators.
458 */
459 void
pwait(void)460 pwait(void)
461 {
462 struct process *fp, *pp;
463
464 /*
465 * Here's where dead procs get flushed.
466 */
467 for (pp = (fp = &proclist)->p_next; pp != NULL; pp = (fp = pp)->p_next)
468 if (pp->p_procid == 0) {
469 fp->p_next = pp->p_next;
470 pfree(pp);
471 pp = fp;
472 }
473 pjwait(pcurrjob);
474 }
475
476
477 /*
478 * pjwait - wait for a job to finish or become stopped
479 * It is assumed to be in the foreground state (PFOREGND)
480 */
481 void
pjwait(struct process * pp)482 pjwait(struct process *pp)
483 {
484 struct process *fp;
485 int jobflags, reason;
486 sigset_t oset, set, pause_mask;
487 Char *reason_str;
488
489 while (pp->p_procid != pp->p_jobid)
490 pp = pp->p_friends;
491 fp = pp;
492
493 do {
494 if ((fp->p_flags & (PFOREGND | PRUNNING)) == PRUNNING)
495 xprintf("%s", CGETS(17, 1, "BUG: waiting for background job!\n"));
496 } while ((fp = fp->p_friends) != pp);
497 /*
498 * Now keep pausing as long as we are not interrupted (SIGINT), and the
499 * target process, or any of its friends, are running
500 */
501 fp = pp;
502 sigemptyset(&set);
503 sigaddset(&set, SIGINT);
504 sigaddset(&set, SIGCHLD);
505 (void)sigprocmask(SIG_BLOCK, &set, &oset);
506 cleanup_push(&oset, sigprocmask_cleanup);
507 pause_mask = oset;
508 sigdelset(&pause_mask, SIGCHLD);
509 sigaddset(&pause_mask, SIGINT);
510 for (;;) {
511 (void)handle_pending_signals();
512 jobflags = 0;
513 do
514 jobflags |= fp->p_flags;
515 while ((fp = (fp->p_friends)) != pp);
516 if ((jobflags & PRUNNING) == 0)
517 break;
518 jobdebug_xprintf(("%d starting to sigsuspend for SIGCHLD on %d\n",
519 getpid(), fp->p_procid));
520 sigsuspend(&pause_mask);
521 }
522 cleanup_until(&oset);
523 jobdebug_xprintf(("%d returned from sigsuspend loop\n", getpid()));
524 #ifdef BSDJOBS
525 if (tpgrp > 0) /* get tty back */
526 (void) tcsetpgrp(FSHTTY, tpgrp);
527 #endif /* BSDJOBS */
528 if ((jobflags & (PSIGNALED | PSTOPPED | PTIME)) ||
529 fp->p_cwd == NULL || !eq(dcwd->di_name, fp->p_cwd->di_name)) {
530 if (jobflags & PSTOPPED) {
531 xputchar('\n');
532 if (adrof(STRlistjobs)) {
533 Char *jobcommand[3];
534
535 jobcommand[0] = STRjobs;
536 if (eq(varval(STRlistjobs), STRlong))
537 jobcommand[1] = STRml;
538 else
539 jobcommand[1] = NULL;
540 jobcommand[2] = NULL;
541
542 dojobs(jobcommand, NULL);
543 (void) pprint(pp, SHELLDIR);
544 }
545 else
546 (void) pprint(pp, AREASON | SHELLDIR);
547 }
548 else
549 (void) pprint(pp, AREASON | SHELLDIR);
550 }
551 if ((jobflags & (PINTERRUPTED | PSTOPPED)) && setintr &&
552 (!gointr || !eq(gointr, STRminus))) {
553 if ((jobflags & PSTOPPED) == 0)
554 pflush(pp);
555 pintr1(0);
556 /* NOTREACHED */
557 }
558 reason = 0;
559 fp = pp;
560 do {
561 /* In case of pipelines only the result of the last
562 * command should be taken in account */
563 if (!anyerror && !(fp->p_flags & PBRACE)
564 && ((fp->p_flags & PPOU) || (fp->p_flags & PBACKQ)))
565 continue;
566 if (fp->p_reason)
567 reason = fp->p_flags & (PSIGNALED | PINTERRUPTED) ?
568 fp->p_reason | META : fp->p_reason;
569 } while ((fp = fp->p_friends) != pp);
570 /*
571 * Don't report on backquoted jobs, cause it will mess up
572 * their output.
573 */
574 if ((reason != 0) && (adrof(STRprintexitvalue)) &&
575 (pp->p_flags & PBACKQ) == 0)
576 xprintf(CGETS(17, 2, "Exit %d\n"), reason);
577 reason_str = putn((tcsh_number_t)reason);
578 cleanup_push(reason_str, xfree);
579 setstrstatus(reason_str);
580 cleanup_ignore(reason_str);
581 cleanup_until(reason_str);
582 if (reason && exiterr)
583 exitstat();
584 pflush(pp);
585 }
586
587 /*
588 * dowait - wait for all processes to finish
589 */
590
591 /*ARGSUSED*/
592 void
dowait(Char ** v,struct command * c)593 dowait(Char **v, struct command *c)
594 {
595 struct process *pp;
596
597 /* the current block mask to be able to restore */
598 sigset_t old_mask;
599
600 /* block mask for critical section: OLD_MASK U {SIGCHLD} */
601 sigset_t block_mask;
602
603 /* ignore those during blocking sigsuspend:
604 OLD_MASK / {SIGCHLD, possibly(SIGINT)} */
605 sigset_t pause_mask;
606
607 int opintr_disabled, gotsig;
608
609 USE(c);
610 USE(v);
611 pjobs++;
612
613 sigprocmask(SIG_BLOCK, NULL, &pause_mask);
614 sigdelset(&pause_mask, SIGCHLD);
615 if (setintr)
616 sigdelset(&pause_mask, SIGINT);
617
618 /* critical section, block also SIGCHLD */
619 sigprocmask(SIG_BLOCK, NULL, &block_mask);
620 sigaddset(&block_mask, SIGCHLD);
621 sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
622
623 /* detect older SIGCHLDs and remove PRUNNING flag from proclist */
624 (void)handle_pending_signals();
625
626 loop:
627 for (pp = proclist.p_next; pp; pp = pp->p_next)
628 if (pp->p_procid && /* pp->p_procid == pp->p_jobid && */
629 pp->p_flags & PRUNNING) {
630 /* wait for (or pick up alredy blocked) SIGCHLD */
631 sigsuspend(&pause_mask);
632
633 /* make the 'wait' interuptable by CTRL-C */
634 opintr_disabled = pintr_disabled;
635 pintr_disabled = 0;
636 gotsig = handle_pending_signals();
637 pintr_disabled = opintr_disabled;
638 if (gotsig)
639 break;
640 goto loop;
641 }
642 pjobs = 0;
643
644 sigprocmask(SIG_SETMASK, &old_mask, NULL);
645 }
646
647 /*
648 * pflushall - flush all jobs from list (e.g. at fork())
649 */
650 static void
pflushall(void)651 pflushall(void)
652 {
653 struct process *pp;
654
655 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
656 if (pp->p_procid)
657 pflush(pp);
658 }
659
660 /*
661 * pflush - flag all process structures in the same job as the
662 * the argument process for deletion. The actual free of the
663 * space is not done here since pflush is called at interrupt level.
664 */
665 static void
pflush(struct process * pp)666 pflush(struct process *pp)
667 {
668 struct process *np;
669 int idx;
670
671 if (pp->p_procid == 0) {
672 xprintf("%s", CGETS(17, 3, "BUG: process flushed twice"));
673 return;
674 }
675 while (pp->p_procid != pp->p_jobid)
676 pp = pp->p_friends;
677 pclrcurr(pp);
678 if (pp == pcurrjob)
679 pcurrjob = 0;
680 idx = pp->p_index;
681 np = pp;
682 do {
683 np->p_index = np->p_procid = 0;
684 np->p_flags &= ~PNEEDNOTE;
685 } while ((np = np->p_friends) != pp);
686 if (idx == pmaxindex) {
687 for (np = proclist.p_next, idx = 0; np; np = np->p_next)
688 if (np->p_index > idx)
689 idx = np->p_index;
690 pmaxindex = idx;
691 }
692 }
693
694 /*
695 * pclrcurr - make sure the given job is not the current or previous job;
696 * pp MUST be the job leader
697 */
698 static void
pclrcurr(struct process * pp)699 pclrcurr(struct process *pp)
700 {
701 if (pp == pcurrent) {
702 if (pprevious != NULL) {
703 pcurrent = pprevious;
704 pprevious = pgetcurr(pp);
705 }
706 else {
707 pcurrent = pgetcurr(pp);
708 pprevious = pgetcurr(pp);
709 }
710 }
711 else if (pp == pprevious)
712 pprevious = pgetcurr(pp);
713 }
714
715 /* +4 here is 1 for '\0', 1 ea for << >& >> */
716 static Char *cmdstr;
717 static size_t cmdmax;
718 static size_t cmdlen;
719 static Char *cmdp;
720 #define CMD_INIT 1024
721 #define CMD_INCR 64
722
723 static void
morecommand(size_t s)724 morecommand(size_t s)
725 {
726 Char *ncmdstr;
727 ptrdiff_t d;
728
729 cmdmax += s;
730 ncmdstr = xrealloc(cmdstr, cmdmax * sizeof(*cmdstr));
731 d = ncmdstr - cmdstr;
732 cmdstr = ncmdstr;
733 cmdp += d;
734 }
735
736 /* GrP
737 * unparse - Export padd() functionality
738 */
739 Char *
unparse(struct command * t)740 unparse(struct command *t)
741 {
742 if (cmdmax == 0)
743 morecommand(CMD_INIT);
744 cmdp = cmdstr;
745 cmdlen = 0;
746 padd(t);
747 *cmdp++ = '\0';
748 return Strsave(cmdstr);
749 }
750
751
752 /*
753 * palloc - allocate a process structure and fill it up.
754 * an important assumption is made that the process is running.
755 */
756 void
palloc(pid_t pid,struct command * t)757 palloc(pid_t pid, struct command *t)
758 {
759 struct process *pp;
760 int i;
761
762 pp = xcalloc(1, sizeof(struct process));
763 pp->p_procid = pid;
764 pp->p_parentid = shpgrp;
765 pp->p_flags = ((t->t_dflg & F_AMPERSAND) ? 0 : PFOREGND) | PRUNNING;
766 if (t->t_dflg & F_TIME)
767 pp->p_flags |= PPTIME;
768 if (t->t_dflg & F_BACKQ)
769 pp->p_flags |= PBACKQ;
770 if (t->t_dflg & F_HUP)
771 pp->p_flags |= PHUP;
772 if (t->t_dcom && t->t_dcom[0] && (*t->t_dcom[0] == '{'))
773 pp->p_flags |= PBRACE;
774 if (cmdmax == 0)
775 morecommand(CMD_INIT);
776 cmdp = cmdstr;
777 cmdlen = 0;
778 padd(t);
779 *cmdp++ = 0;
780 if (t->t_dflg & F_PIPEOUT) {
781 pp->p_flags |= PPOU;
782 if (t->t_dflg & F_STDERR)
783 pp->p_flags |= PDIAG;
784 }
785 pp->p_command = Strsave(cmdstr);
786 if (pcurrjob) {
787 struct process *fp;
788
789 /* careful here with interrupt level */
790 pp->p_cwd = 0;
791 pp->p_index = pcurrjob->p_index;
792 pp->p_friends = pcurrjob;
793 pp->p_jobid = pcurrjob->p_procid;
794 for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends)
795 continue;
796 fp->p_friends = pp;
797 }
798 else {
799 pcurrjob = pp;
800 pp->p_jobid = pid;
801 pp->p_friends = pp;
802 pp->p_cwd = dcwd;
803 dcwd->di_count++;
804 if (pmaxindex < BIGINDEX)
805 pp->p_index = ++pmaxindex;
806 else {
807 struct process *np;
808
809 for (i = 1;; i++) {
810 for (np = proclist.p_next; np; np = np->p_next)
811 if (np->p_index == i)
812 goto tryagain;
813 pp->p_index = i;
814 if (i > pmaxindex)
815 pmaxindex = i;
816 break;
817 tryagain:;
818 }
819 }
820 if (pcurrent == NULL)
821 pcurrent = pp;
822 else if (pprevious == NULL)
823 pprevious = pp;
824 }
825 pp->p_next = proclist.p_next;
826 proclist.p_next = pp;
827 #ifdef BSDTIMES
828 (void) gettimeofday(&pp->p_btime, NULL);
829 #else /* !BSDTIMES */
830 # ifdef _SEQUENT_
831 (void) get_process_stats(&pp->p_btime, PS_SELF, NULL, NULL);
832 # else /* !_SEQUENT_ */
833 {
834 struct tms tmptimes;
835
836 pp->p_btime = times(&tmptimes);
837 }
838 # endif /* !_SEQUENT_ */
839 #endif /* !BSDTIMES */
840 }
841
842 static void
padd(struct command * t)843 padd(struct command *t)
844 {
845 Char **argp;
846
847 if (t == 0)
848 return;
849 switch (t->t_dtyp) {
850
851 case NODE_PAREN:
852 pads(STRLparensp);
853 padd(t->t_dspr);
854 pads(STRspRparen);
855 break;
856
857 case NODE_COMMAND:
858 for (argp = t->t_dcom; *argp; argp++) {
859 pads(*argp);
860 if (argp[1])
861 pads(STRspace);
862 }
863 break;
864
865 case NODE_OR:
866 case NODE_AND:
867 case NODE_PIPE:
868 case NODE_LIST:
869 padd(t->t_dcar);
870 switch (t->t_dtyp) {
871 case NODE_OR:
872 pads(STRspor2sp);
873 break;
874 case NODE_AND:
875 pads(STRspand2sp);
876 break;
877 case NODE_PIPE:
878 pads(STRsporsp);
879 break;
880 case NODE_LIST:
881 pads(STRsemisp);
882 break;
883 default:
884 break;
885 }
886 padd(t->t_dcdr);
887 return;
888
889 default:
890 break;
891 }
892 if ((t->t_dflg & F_PIPEIN) == 0 && t->t_dlef) {
893 pads((t->t_dflg & F_READ) ? STRspLarrow2sp : STRspLarrowsp);
894 pads(t->t_dlef);
895 }
896 if ((t->t_dflg & F_PIPEOUT) == 0 && t->t_drit) {
897 pads((t->t_dflg & F_APPEND) ? STRspRarrow2 : STRspRarrow);
898 if (t->t_dflg & F_STDERR)
899 pads(STRand);
900 pads(STRspace);
901 pads(t->t_drit);
902 }
903 }
904
905 static void
pads(Char * cp)906 pads(Char *cp)
907 {
908 size_t i, len;
909
910 /*
911 * Avoid the Quoted Space alias hack! Reported by:
912 * sam@john-bigboote.ICS.UCI.EDU (Sam Horrocks)
913 */
914 if (cp[0] == STRQNULL[0])
915 cp++;
916
917 i = Strlen(cp);
918
919 len = cmdlen + i + CMD_INCR;
920 if (len >= cmdmax)
921 morecommand(len);
922 (void) Strcpy(cmdp, cp);
923 cmdp += i;
924 cmdlen += i;
925 }
926
927 /*
928 * psavejob - temporarily save the current job on a one level stack
929 * so another job can be created. Used for { } in exp6
930 * and `` in globbing.
931 */
932 void
psavejob(void)933 psavejob(void)
934 {
935 pholdjob = pcurrjob;
936 pcurrjob = NULL;
937 }
938
939 void
psavejob_cleanup(void * dummy)940 psavejob_cleanup(void *dummy)
941 {
942 USE(dummy);
943 pcurrjob = pholdjob;
944 pholdjob = NULL;
945 }
946
947 /*
948 * pendjob - indicate that a job (set of commands) has been completed
949 * or is about to begin.
950 */
951 void
pendjob(void)952 pendjob(void)
953 {
954 struct process *pp, *tp;
955
956 if (pcurrjob && (pcurrjob->p_flags & (PFOREGND | PSTOPPED)) == 0) {
957 pp = pcurrjob;
958 pcurrjob = NULL;
959 while (pp->p_procid != pp->p_jobid)
960 pp = pp->p_friends;
961 xprintf("[%d]", pp->p_index);
962 tp = pp;
963 do {
964 xprintf(" %d", pp->p_procid);
965 pp = pp->p_friends;
966 } while (pp != tp);
967 xputchar('\n');
968 }
969 pholdjob = pcurrjob = 0;
970 }
971
972 /*
973 * pprint - print a job
974 */
975
976 /*
977 * Hacks have been added for SVR4 to deal with pipe's being spawned in
978 * reverse order
979 *
980 * David Dawes (dawes@physics.su.oz.au) Oct 1991
981 */
982
983 static int
pprint(struct process * pp,int flag)984 pprint(struct process *pp, int flag)
985 {
986 int status, reason;
987 struct process *tp;
988 int jobflags, pstatus, pcond;
989 const char *format;
990 int ohaderr;
991
992 #ifdef BACKPIPE
993 struct process *pipehead = NULL, *pipetail = NULL, *pmarker = NULL;
994 int inpipe = 0;
995 #endif /* BACKPIPE */
996
997 while (pp->p_procid != pp->p_jobid)
998 pp = pp->p_friends;
999 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
1000 pp->p_flags &= ~PPTIME;
1001 pp->p_flags |= PTIME;
1002 }
1003 tp = pp;
1004 status = reason = -1;
1005 jobflags = 0;
1006 ohaderr = haderr;
1007 /* Print status to stderr, except for jobs built-in */
1008 haderr = !(flag & JOBLIST);
1009 do {
1010 #ifdef BACKPIPE
1011 /*
1012 * The pipeline is reversed, so locate the real head of the pipeline
1013 * if pp is at the tail of a pipe (and not already in a pipeline)
1014 */
1015 if ((pp->p_friends->p_flags & PPOU) && !inpipe && (flag & NAME)) {
1016 inpipe = 1;
1017 pipetail = pp;
1018 do
1019 pp = pp->p_friends;
1020 while (pp->p_friends->p_flags & PPOU);
1021 pipehead = pp;
1022 pmarker = pp;
1023 /*
1024 * pmarker is used to hold the place of the proc being processed, so
1025 * we can search for the next one downstream later.
1026 */
1027 }
1028 pcond = (tp != pp || (inpipe && tp == pp));
1029 #else /* !BACKPIPE */
1030 pcond = (tp != pp);
1031 #endif /* BACKPIPE */
1032
1033 jobflags |= pp->p_flags;
1034 pstatus = (int) (pp->p_flags & PALLSTATES);
1035 if (pcond && linp != linbuf && !(flag & FANCY) &&
1036 ((pstatus == status && pp->p_reason == reason) ||
1037 !(flag & REASON)))
1038 xputchar(' ');
1039 else {
1040 if (pcond && linp != linbuf)
1041 xputchar('\n');
1042 if (flag & NUMBER) {
1043 #ifdef BACKPIPE
1044 pcond = ((pp == tp && !inpipe) ||
1045 (inpipe && pipetail == tp && pp == pipehead));
1046 #else /* BACKPIPE */
1047 pcond = (pp == tp);
1048 #endif /* BACKPIPE */
1049 if (pcond)
1050 xprintf("[%d]%s %c ", pp->p_index,
1051 pp->p_index < 10 ? " " : "",
1052 pp == pcurrent ? '+' :
1053 (pp == pprevious ? '-' : ' '));
1054 else
1055 xprintf(" ");
1056 }
1057 if (flag & FANCY) {
1058 xprintf("%5d ", pp->p_procid);
1059 #ifdef TCF
1060 xprintf("%11s ", sitename(pp->p_procid));
1061 #endif /* TCF */
1062 }
1063 if (flag & (REASON | AREASON)) {
1064 if (flag & NAME)
1065 format = "%-30s";
1066 else
1067 format = "%s";
1068 if (pstatus == status) {
1069 if (pp->p_reason == reason) {
1070 xprintf(format, "");
1071 goto prcomd;
1072 }
1073 else
1074 reason = (int) pp->p_reason;
1075 }
1076 else {
1077 status = pstatus;
1078 reason = (int) pp->p_reason;
1079 }
1080 switch (status) {
1081
1082 case PRUNNING:
1083 xprintf(format, CGETS(17, 4, "Running "));
1084 break;
1085
1086 case PINTERRUPTED:
1087 case PSTOPPED:
1088 case PSIGNALED:
1089 /*
1090 * tell what happened to the background job
1091 * From: Michael Schroeder
1092 * <mlschroe@immd4.informatik.uni-erlangen.de>
1093 */
1094 if ((flag & REASON)
1095 || ((flag & AREASON)
1096 && reason != SIGINT
1097 && (reason != SIGPIPE
1098 || (pp->p_flags & PPOU) == 0))) {
1099 char *ptr;
1100 int free_ptr;
1101
1102 free_ptr = 0;
1103 ptr = (char *)(intptr_t)mesg[pp->p_reason & 0177].pname;
1104 if (ptr == NULL) {
1105 ptr = xasprintf("%s %d", CGETS(17, 5, "Signal"),
1106 pp->p_reason & 0177);
1107 cleanup_push(ptr, xfree);
1108 free_ptr = 1;
1109 }
1110 xprintf(format, ptr);
1111 if (free_ptr != 0)
1112 cleanup_until(ptr);
1113 }
1114 else
1115 reason = -1;
1116 break;
1117
1118 case PNEXITED:
1119 case PAEXITED:
1120 if (flag & REASON) {
1121 if (pp->p_reason)
1122 xprintf(CGETS(17, 6, "Exit %-25d"), pp->p_reason);
1123 else
1124 xprintf(format, CGETS(17, 7, "Done"));
1125 }
1126 break;
1127
1128 default:
1129 xprintf(CGETS(17, 8, "BUG: status=%-9o"),
1130 status);
1131 }
1132 }
1133 }
1134 prcomd:
1135 if (flag & NAME) {
1136 xprintf("%" TCSH_S, pp->p_command);
1137 if (pp->p_flags & PPOU)
1138 xprintf(" |");
1139 if (pp->p_flags & PDIAG)
1140 xprintf("&");
1141 }
1142 if (flag & (REASON | AREASON) && pp->p_flags & PDUMPED)
1143 xprintf("%s", CGETS(17, 9, " (core dumped)"));
1144 if (tp == pp->p_friends) {
1145 if (flag & AMPERSAND)
1146 xprintf(" &");
1147 if (flag & JOBDIR &&
1148 !eq(tp->p_cwd->di_name, dcwd->di_name)) {
1149 xprintf("%s", CGETS(17, 10, " (wd: "));
1150 dtildepr(tp->p_cwd->di_name);
1151 xprintf(")");
1152 }
1153 }
1154 if (pp->p_flags & PPTIME && !(status & (PSTOPPED | PRUNNING))) {
1155 if (linp != linbuf)
1156 xprintf("\n\t");
1157 #if defined(BSDTIMES) || defined(_SEQUENT_)
1158 prusage(&zru, &pp->p_rusage, &pp->p_etime,
1159 &pp->p_btime);
1160 #else /* !BSDTIMES && !SEQUENT */
1161 lru.tms_utime = pp->p_utime;
1162 lru.tms_stime = pp->p_stime;
1163 lru.tms_cutime = 0;
1164 lru.tms_cstime = 0;
1165 prusage(&zru, &lru, pp->p_etime,
1166 pp->p_btime);
1167 #endif /* !BSDTIMES && !SEQUENT */
1168
1169 }
1170 #ifdef BACKPIPE
1171 pcond = ((tp == pp->p_friends && !inpipe) ||
1172 (inpipe && pipehead->p_friends == tp && pp == pipetail));
1173 #else /* !BACKPIPE */
1174 pcond = (tp == pp->p_friends);
1175 #endif /* BACKPIPE */
1176 if (pcond) {
1177 if (linp != linbuf)
1178 xputchar('\n');
1179 if (flag & SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) {
1180 xprintf("%s", CGETS(17, 11, "(wd now: "));
1181 dtildepr(dcwd->di_name);
1182 xprintf(")\n");
1183 }
1184 }
1185 #ifdef BACKPIPE
1186 if (inpipe) {
1187 /*
1188 * if pmaker == pipetail, we are finished that pipeline, and
1189 * can now skip to past the head
1190 */
1191 if (pmarker == pipetail) {
1192 inpipe = 0;
1193 pp = pipehead;
1194 }
1195 else {
1196 /*
1197 * set pp to one before the one we want next, so the while below
1198 * increments to the correct spot.
1199 */
1200 do
1201 pp = pp->p_friends;
1202 while (pp->p_friends->p_friends != pmarker);
1203 pmarker = pp->p_friends;
1204 }
1205 }
1206 pcond = ((pp = pp->p_friends) != tp || inpipe);
1207 #else /* !BACKPIPE */
1208 pcond = ((pp = pp->p_friends) != tp);
1209 #endif /* BACKPIPE */
1210 } while (pcond);
1211
1212 if (jobflags & PTIME && (jobflags & (PSTOPPED | PRUNNING)) == 0) {
1213 if (jobflags & NUMBER)
1214 xprintf(" ");
1215 ptprint(tp);
1216 }
1217 haderr = ohaderr;
1218 return (jobflags);
1219 }
1220
1221 /*
1222 * All 4.3 BSD derived implementations are buggy and I've had enough.
1223 * The following implementation produces similar code and works in all
1224 * cases. The 4.3BSD one works only for <, >, !=
1225 */
1226 # undef timercmp
1227 # define timercmp(tvp, uvp, cmp) \
1228 (((tvp)->tv_sec == (uvp)->tv_sec) ? \
1229 ((tvp)->tv_usec cmp (uvp)->tv_usec) : \
1230 ((tvp)->tv_sec cmp (uvp)->tv_sec))
1231
1232 static void
ptprint(struct process * tp)1233 ptprint(struct process *tp)
1234 {
1235 #ifdef BSDTIMES
1236 struct timeval tetime, diff;
1237 static struct timeval ztime;
1238 struct sysrusage ru;
1239 struct process *pp = tp;
1240
1241 ru = zru;
1242 tetime = ztime;
1243 do {
1244 ruadd(&ru, &pp->p_rusage);
1245 tvsub(&diff, &pp->p_etime, &pp->p_btime);
1246 if (timercmp(&diff, &tetime, >))
1247 tetime = diff;
1248 } while ((pp = pp->p_friends) != tp);
1249 prusage(&zru, &ru, &tetime, &ztime);
1250 #else /* !BSDTIMES */
1251 # ifdef _SEQUENT_
1252 timeval_t tetime, diff;
1253 static timeval_t ztime;
1254 struct process_stats ru;
1255 struct process *pp = tp;
1256
1257 ru = zru;
1258 tetime = ztime;
1259 do {
1260 ruadd(&ru, &pp->p_rusage);
1261 tvsub(&diff, &pp->p_etime, &pp->p_btime);
1262 if (timercmp(&diff, &tetime, >))
1263 tetime = diff;
1264 } while ((pp = pp->p_friends) != tp);
1265 prusage(&zru, &ru, &tetime, &ztime);
1266 # else /* !_SEQUENT_ */
1267 # ifndef POSIX
1268 static time_t ztime = 0;
1269 static time_t zu_time = 0;
1270 static time_t zs_time = 0;
1271 time_t tetime, diff;
1272 time_t u_time, s_time;
1273
1274 # else /* POSIX */
1275 static clock_t ztime = 0;
1276 static clock_t zu_time = 0;
1277 static clock_t zs_time = 0;
1278 clock_t tetime, diff;
1279 clock_t u_time, s_time;
1280
1281 # endif /* POSIX */
1282 struct tms zts, rts;
1283 struct process *pp = tp;
1284
1285 u_time = zu_time;
1286 s_time = zs_time;
1287 tetime = ztime;
1288 do {
1289 u_time += pp->p_utime;
1290 s_time += pp->p_stime;
1291 diff = pp->p_etime - pp->p_btime;
1292 if (diff > tetime)
1293 tetime = diff;
1294 } while ((pp = pp->p_friends) != tp);
1295 zts.tms_utime = zu_time;
1296 zts.tms_stime = zs_time;
1297 zts.tms_cutime = 0;
1298 zts.tms_cstime = 0;
1299 rts.tms_utime = u_time;
1300 rts.tms_stime = s_time;
1301 rts.tms_cutime = 0;
1302 rts.tms_cstime = 0;
1303 prusage(&zts, &rts, tetime, ztime);
1304 # endif /* !_SEQUENT_ */
1305 #endif /* !BSDTIMES */
1306 }
1307
1308 /*
1309 * dojobs - print all jobs
1310 */
1311 /*ARGSUSED*/
1312 void
dojobs(Char ** v,struct command * c)1313 dojobs(Char **v, struct command *c)
1314 {
1315 struct process *pp;
1316 int flag = NUMBER | NAME | REASON | JOBLIST;
1317 int i;
1318
1319 USE(c);
1320 if (chkstop)
1321 chkstop = 2;
1322 if (*++v) {
1323 if (v[1]) {
1324 if (eq(*v, STRml)) {
1325 flag |= FANCY | JOBDIR;
1326 } else if (eq(*v, STRmZ)) {
1327 #ifdef HAVE_SETPROCTITLE
1328 if (v[1] && v[1][0]) {
1329 setproctitle("%s", short2str(v[1]));
1330 } else {
1331 setproctitle(NULL);
1332 }
1333 #endif
1334 return;
1335 } else {
1336 stderror(ERR_JOBS);
1337 }
1338 }
1339 flag |= FANCY | JOBDIR;
1340 }
1341 for (i = 1; i <= pmaxindex; i++)
1342 for (pp = proclist.p_next; pp; pp = pp->p_next)
1343 if (pp->p_index == i && pp->p_procid == pp->p_jobid) {
1344 pp->p_flags &= ~PNEEDNOTE;
1345 if (!(pprint(pp, flag) & (PRUNNING | PSTOPPED)))
1346 pflush(pp);
1347 break;
1348 }
1349 }
1350
1351 /*
1352 * dofg - builtin - put the job into the foreground
1353 */
1354 /*ARGSUSED*/
1355 void
dofg(Char ** v,struct command * c)1356 dofg(Char **v, struct command *c)
1357 {
1358 struct process *pp;
1359
1360 USE(c);
1361 okpcntl();
1362 ++v;
1363 do {
1364 pp = pfind(*v);
1365 if (!pstart(pp, 1)) {
1366 pp->p_procid = 0;
1367 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1368 continue;
1369 }
1370 pjwait(pp);
1371 } while (*v && *++v);
1372 }
1373
1374 /*
1375 * %... - builtin - put the job into the foreground
1376 */
1377 /*ARGSUSED*/
1378 void
dofg1(Char ** v,struct command * c)1379 dofg1(Char **v, struct command *c)
1380 {
1381 struct process *pp;
1382
1383 USE(c);
1384 okpcntl();
1385 pp = pfind(v[0]);
1386 if (!pstart(pp, 1)) {
1387 pp->p_procid = 0;
1388 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1389 return;
1390 }
1391 pjwait(pp);
1392 }
1393
1394 /*
1395 * dobg - builtin - put the job into the background
1396 */
1397 /*ARGSUSED*/
1398 void
dobg(Char ** v,struct command * c)1399 dobg(Char **v, struct command *c)
1400 {
1401 struct process *pp;
1402
1403 USE(c);
1404 okpcntl();
1405 ++v;
1406 do {
1407 pp = pfind(*v);
1408 if (!pstart(pp, 0)) {
1409 pp->p_procid = 0;
1410 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1411 }
1412 } while (*v && *++v);
1413 }
1414
1415 /*
1416 * %... & - builtin - put the job into the background
1417 */
1418 /*ARGSUSED*/
1419 void
dobg1(Char ** v,struct command * c)1420 dobg1(Char **v, struct command *c)
1421 {
1422 struct process *pp;
1423
1424 USE(c);
1425 pp = pfind(v[0]);
1426 if (!pstart(pp, 0)) {
1427 pp->p_procid = 0;
1428 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1429 }
1430 }
1431
1432 /*
1433 * dostop - builtin - stop the job
1434 */
1435 /*ARGSUSED*/
1436 void
dostop(Char ** v,struct command * c)1437 dostop(Char **v, struct command *c)
1438 {
1439 USE(c);
1440 #ifdef BSDJOBS
1441 pkill(++v, SIGSTOP);
1442 #endif /* BSDJOBS */
1443 }
1444
1445 /*
1446 * dokill - builtin - superset of kill (1)
1447 */
1448 /*ARGSUSED*/
1449 void
dokill(Char ** v,struct command * c)1450 dokill(Char **v, struct command *c)
1451 {
1452 int signum, len = 0;
1453 const char *name;
1454 Char *sigptr;
1455
1456 USE(c);
1457 v++;
1458 if (v[0] && v[0][0] == '-') {
1459 if (v[0][1] == 'l') {
1460 for (signum = 0; signum <= nsig; signum++) {
1461 if ((name = mesg[signum].iname) != NULL) {
1462 len += strlen(name) + 1;
1463 if (len >= TermH - 1) {
1464 xputchar('\n');
1465 len = strlen(name) + 1;
1466 }
1467 xprintf("%s ", name);
1468 }
1469 }
1470 xputchar('\n');
1471 return;
1472 }
1473 sigptr = &v[0][1];
1474 if (v[0][1] == 's') {
1475 if (v[1]) {
1476 v++;
1477 sigptr = &v[0][0];
1478 } else {
1479 stderror(ERR_NAME | ERR_TOOFEW);
1480 }
1481 }
1482 if (Isdigit(*sigptr)) {
1483 char *ep;
1484 signum = strtoul(short2str(sigptr), &ep, 0);
1485 if (*ep || signum < 0 || signum > (MAXSIG-1))
1486 stderror(ERR_NAME | ERR_BADSIG);
1487 }
1488 else {
1489 for (signum = 0; signum <= nsig; signum++)
1490 if (mesg[signum].iname &&
1491 eq(sigptr, str2short(mesg[signum].iname)))
1492 goto gotsig;
1493 setname(short2str(sigptr));
1494 stderror(ERR_NAME | ERR_UNKSIG);
1495 }
1496 gotsig:
1497 v++;
1498 }
1499 else
1500 signum = SIGTERM;
1501 pkill(v, signum);
1502 }
1503
1504 static void
pkill(Char ** v,int signum)1505 pkill(Char **v, int signum)
1506 {
1507 struct process *pp, *np;
1508 int jobflags = 0, err1 = 0;
1509 pid_t pid;
1510 Char *cp, **vp, **globbed;
1511
1512 /* Avoid globbing %?x patterns */
1513 for (vp = v; vp && *vp; vp++)
1514 if (**vp == '%')
1515 (void) quote(*vp);
1516
1517 v = glob_all_or_error(v);
1518 globbed = v;
1519 cleanup_push(globbed, blk_cleanup);
1520
1521 pchild_disabled++;
1522 cleanup_push(&pchild_disabled, disabled_cleanup);
1523 if (setintr) {
1524 pintr_disabled++;
1525 cleanup_push(&pintr_disabled, disabled_cleanup);
1526 }
1527
1528 while (v && (cp = *v)) {
1529 if (*cp == '%') {
1530 np = pp = pfind(cp);
1531 do
1532 jobflags |= np->p_flags;
1533 while ((np = np->p_friends) != pp);
1534 #ifdef BSDJOBS
1535 switch (signum) {
1536
1537 case SIGSTOP:
1538 case SIGTSTP:
1539 case SIGTTIN:
1540 case SIGTTOU:
1541 if ((jobflags & PRUNNING) == 0) {
1542 # ifdef SUSPENDED
1543 xprintf(CGETS(17, 12, "%" TCSH_S ": Already suspended\n"),
1544 cp);
1545 # else /* !SUSPENDED */
1546 xprintf(CGETS(17, 13, "%" TCSH_S ": Already stopped\n"),
1547 cp);
1548 # endif /* !SUSPENDED */
1549 err1++;
1550 goto cont;
1551 }
1552 break;
1553 /*
1554 * suspend a process, kill -CONT %, then type jobs; the shell
1555 * says it is suspended, but it is running; thanks jaap..
1556 */
1557 case SIGCONT:
1558 if (!pstart(pp, 0)) {
1559 pp->p_procid = 0;
1560 stderror(ERR_NAME|ERR_BADJOB, pp->p_command,
1561 strerror(errno));
1562 }
1563 goto cont;
1564 default:
1565 break;
1566 }
1567 #endif /* BSDJOBS */
1568 if (killpg(pp->p_jobid, signum) < 0) {
1569 xprintf("%" TCSH_S ": %s\n", cp, strerror(errno));
1570 err1++;
1571 }
1572 #ifdef BSDJOBS
1573 if (signum == SIGTERM || signum == SIGHUP)
1574 (void) killpg(pp->p_jobid, SIGCONT);
1575 #endif /* BSDJOBS */
1576 }
1577 else if (!(Isdigit(*cp) || *cp == '-'))
1578 stderror(ERR_NAME | ERR_JOBARGS);
1579 else {
1580 char *ep;
1581 #ifndef WINNT_NATIVE
1582 pid = strtol(short2str(cp), &ep, 10);
1583 #else
1584 pid = strtoul(short2str(cp), &ep, 0);
1585 #endif /* WINNT_NATIVE */
1586 if (*ep)
1587 stderror(ERR_NAME | ERR_JOBARGS);
1588 else if (kill(pid, signum) < 0) {
1589 xprintf("%d: %s\n", pid, strerror(errno));
1590 err1++;
1591 goto cont;
1592 }
1593 #ifdef BSDJOBS
1594 if (signum == SIGTERM || signum == SIGHUP)
1595 (void) kill(pid, SIGCONT);
1596 #endif /* BSDJOBS */
1597 }
1598 cont:
1599 v++;
1600 }
1601 cleanup_until(&pchild_disabled);
1602 if (err1)
1603 stderror(ERR_SILENT);
1604 }
1605
1606 /*
1607 * pstart - start the job in foreground/background
1608 */
1609 int
pstart(struct process * pp,int foregnd)1610 pstart(struct process *pp, int foregnd)
1611 {
1612 int rv = 0;
1613 struct process *np;
1614 /* We don't use jobflags in this function right now (see below) */
1615 /* long jobflags = 0; */
1616
1617 pchild_disabled++;
1618 cleanup_push(&pchild_disabled, disabled_cleanup);
1619 np = pp;
1620 do {
1621 /* We don't use jobflags in this function right now (see below) */
1622 /* jobflags |= np->p_flags; */
1623 if (np->p_flags & (PRUNNING | PSTOPPED)) {
1624 np->p_flags |= PRUNNING;
1625 np->p_flags &= ~PSTOPPED;
1626 if (foregnd)
1627 np->p_flags |= PFOREGND;
1628 else
1629 np->p_flags &= ~PFOREGND;
1630 }
1631 } while ((np = np->p_friends) != pp);
1632 if (!foregnd)
1633 pclrcurr(pp);
1634 (void) pprint(pp, foregnd ? NAME | JOBDIR : NUMBER | NAME | AMPERSAND);
1635
1636 /* GrP run jobcmd hook if foregrounding */
1637 if (foregnd) {
1638 job_cmd(pp->p_command);
1639 }
1640
1641 #ifdef BSDJOBS
1642 if (foregnd) {
1643 rv = tcsetpgrp(FSHTTY, pp->p_jobid);
1644 }
1645 /*
1646 * 1. child process of csh (shell script) receives SIGTTIN/SIGTTOU
1647 * 2. parent process (csh) receives SIGCHLD
1648 * 3. The "csh" signal handling function pchild() is invoked
1649 * with a SIGCHLD signal.
1650 * 4. pchild() calls wait3(WNOHANG) which returns 0.
1651 * The child process is NOT ready to be waited for at this time.
1652 * pchild() returns without picking-up the correct status
1653 * for the child process which generated the SIGCHLD.
1654 * 5. CONSEQUENCE : csh is UNaware that the process is stopped
1655 * 6. THIS LINE HAS BEEN COMMENTED OUT : if (jobflags&PSTOPPED)
1656 * (beto@aixwiz.austin.ibm.com - aug/03/91)
1657 * 7. I removed the line completely and added extra checks for
1658 * pstart, so that if a job gets attached to and dies inside
1659 * a debugger it does not confuse the shell. [christos]
1660 * 8. on the nec sx-4 there seems to be a problem, which requires
1661 * a syscall(151, getpid(), getpid()) in osinit. Don't ask me
1662 * what this is doing. [schott@rzg.mpg.de]
1663 */
1664
1665 if (rv != -1)
1666 rv = killpg(pp->p_jobid, SIGCONT);
1667 #endif /* BSDJOBS */
1668 cleanup_until(&pchild_disabled);
1669 return rv != -1;
1670 }
1671
1672 void
panystop(int neednl)1673 panystop(int neednl)
1674 {
1675 struct process *pp;
1676
1677 chkstop = 2;
1678 for (pp = proclist.p_next; pp; pp = pp->p_next)
1679 if (pp->p_flags & PSTOPPED)
1680 stderror(ERR_STOPPED, neednl ? "\n" : "");
1681 }
1682
1683 struct process *
pfind(Char * cp)1684 pfind(Char *cp)
1685 {
1686 struct process *pp, *np;
1687
1688 if (cp == 0 || cp[1] == 0 || eq(cp, STRcent2) || eq(cp, STRcentplus)) {
1689 if (pcurrent == NULL)
1690 stderror(ERR_NAME | ERR_JOBCUR);
1691 return (pcurrent);
1692 }
1693 if (eq(cp, STRcentminus) || eq(cp, STRcenthash)) {
1694 if (pprevious == NULL)
1695 stderror(ERR_NAME | ERR_JOBPREV);
1696 return (pprevious);
1697 }
1698 if (Isdigit(cp[1])) {
1699 int idx = atoi(short2str(cp + 1));
1700
1701 for (pp = proclist.p_next; pp; pp = pp->p_next)
1702 if (pp->p_index == idx && pp->p_procid == pp->p_jobid)
1703 return (pp);
1704 stderror(ERR_NAME | ERR_NOSUCHJOB);
1705 }
1706 np = NULL;
1707 for (pp = proclist.p_next; pp; pp = pp->p_next)
1708 if (pp->p_procid == pp->p_jobid) {
1709 if (cp[1] == '?') {
1710 Char *dp;
1711
1712 for (dp = pp->p_command; *dp; dp++) {
1713 if (*dp != cp[2])
1714 continue;
1715 if (prefix(cp + 2, dp))
1716 goto match;
1717 }
1718 }
1719 else if (prefix(cp + 1, pp->p_command)) {
1720 match:
1721 if (np)
1722 stderror(ERR_NAME | ERR_AMBIG);
1723 np = pp;
1724 }
1725 }
1726 if (np)
1727 return (np);
1728 stderror(ERR_NAME | (cp[1] == '?' ? ERR_JOBPAT : ERR_NOSUCHJOB));
1729 /* NOTREACHED */
1730 return (0);
1731 }
1732
1733
1734 /*
1735 * pgetcurr - find most recent job that is not pp, preferably stopped
1736 */
1737 static struct process *
pgetcurr(struct process * pp)1738 pgetcurr(struct process *pp)
1739 {
1740 struct process *np;
1741 struct process *xp = NULL;
1742
1743 for (np = proclist.p_next; np; np = np->p_next)
1744 if (np != pcurrent && np != pp && np->p_procid &&
1745 np->p_procid == np->p_jobid) {
1746 if (np->p_flags & PSTOPPED)
1747 return (np);
1748 if (xp == NULL)
1749 xp = np;
1750 }
1751 return (xp);
1752 }
1753
1754 /*
1755 * donotify - flag the job so as to report termination asynchronously
1756 */
1757 /*ARGSUSED*/
1758 void
donotify(Char ** v,struct command * c)1759 donotify(Char **v, struct command *c)
1760 {
1761 struct process *pp;
1762
1763 USE(c);
1764 pp = pfind(*++v);
1765 pp->p_flags |= PNOTIFY;
1766 }
1767
1768 #ifdef SIGSYNCH
1769 static void
synch_handler(int sno)1770 synch_handler(int sno)
1771 {
1772 USE(sno);
1773 }
1774 #endif /* SIGSYNCH */
1775
1776 /*
1777 * Do the fork and whatever should be done in the child side that
1778 * should not be done if we are not forking at all (like for simple builtin's)
1779 * Also do everything that needs any signals fiddled with in the parent side
1780 *
1781 * Wanttty tells whether process and/or tty pgrps are to be manipulated:
1782 * -1: leave tty alone; inherit pgrp from parent
1783 * 0: already have tty; manipulate process pgrps only
1784 * 1: want to claim tty; manipulate process and tty pgrps
1785 * It is usually just the value of tpgrp.
1786 */
1787
1788 pid_t
pfork(struct command * t,int wanttty)1789 pfork(struct command *t, int wanttty)
1790 {
1791 pid_t pid;
1792 int ignint = 0;
1793 pid_t pgrp;
1794 #ifdef SIGSYNCH
1795 struct sigaction osa, nsa;
1796 #endif /* SIGSYNCH */
1797
1798 /*
1799 * A child will be uninterruptible only under very special conditions.
1800 * Remember that the semantics of '&' is implemented by disconnecting the
1801 * process from the tty so signals do not need to ignored just for '&'.
1802 * Thus signals are set to default action for children unless: we have had
1803 * an "onintr -" (then specifically ignored) we are not playing with
1804 * signals (inherit action)
1805 */
1806 if (setintr)
1807 ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
1808 || (gointr && eq(gointr, STRminus));
1809
1810 /*
1811 * Check for maximum nesting of 16 processes to avoid Forking loops
1812 */
1813 if (child == 16)
1814 stderror(ERR_NESTING, 16);
1815 #ifdef SIGSYNCH
1816 nsa.sa_handler = synch_handler;
1817 sigfillset(&nsa.sa_mask);
1818 nsa.sa_flags = SA_RESTART;
1819 if (sigaction(SIGSYNCH, &nsa, &osa))
1820 stderror(ERR_SYSTEM, "pfork: sigaction set", strerror(errno));
1821 #endif /* SIGSYNCH */
1822 /*
1823 * Hold pchild() until we have the process installed in our table.
1824 */
1825 if (wanttty < 0) {
1826 pchild_disabled++;
1827 cleanup_push(&pchild_disabled, disabled_cleanup);
1828 }
1829 while ((pid = fork()) == -1)
1830 if (setintr == 0)
1831 (void) sleep(FORKSLEEP);
1832 else
1833 stderror(ERR_NOPROC);
1834 if (pid == 0) {
1835 (void)cleanup_push_mark(); /* Never to be popped */
1836 pchild_disabled = 0;
1837 settimes();
1838 pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
1839 pflushall();
1840 pcurrjob = NULL;
1841 #if !defined(BSDTIMES) && !defined(_SEQUENT_)
1842 timesdone = 0;
1843 #endif /* !defined(BSDTIMES) && !defined(_SEQUENT_) */
1844 child++;
1845 if (setintr) {
1846 setintr = 0; /* until I think otherwise */
1847 /*
1848 * Children just get blown away on SIGINT, SIGQUIT unless "onintr
1849 * -" seen.
1850 */
1851 (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
1852 (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
1853 #ifdef BSDJOBS
1854 if (wanttty >= 0) {
1855 /* make stoppable */
1856 (void) signal(SIGTSTP, SIG_DFL);
1857 (void) signal(SIGTTIN, SIG_DFL);
1858 (void) signal(SIGTTOU, SIG_DFL);
1859 }
1860 #endif /* BSDJOBS */
1861 sigaction(SIGTERM, &parterm, NULL);
1862 }
1863 else if (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) {
1864 (void) signal(SIGINT, SIG_IGN);
1865 (void) signal(SIGQUIT, SIG_IGN);
1866 }
1867 #ifdef OREO
1868 signal(SIGIO, SIG_IGN); /* ignore SIGIO in child too */
1869 #endif /* OREO */
1870
1871 pgetty(wanttty, pgrp);
1872 /*
1873 * Nohup and nice apply only to NODE_COMMAND's but it would be nice
1874 * (?!?) if you could say "nohup (foo;bar)" Then the parser would have
1875 * to know about nice/nohup/time
1876 */
1877 if (t->t_dflg & F_NOHUP)
1878 (void) signal(SIGHUP, SIG_IGN);
1879 if (t->t_dflg & F_NICE) {
1880 int nval = SIGN_EXTEND_CHAR(t->t_nice);
1881 #if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
1882 if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
1883 stderror(ERR_SYSTEM, "setpriority", strerror(errno));
1884 #else /* !HAVE_SETPRIORITY || !PRIO_PROCESS */
1885 (void) nice(nval);
1886 #endif /* HAVE_SETPRIORITY && PRIO_PROCESS */
1887 }
1888 #ifdef F_VER
1889 if (t->t_dflg & F_VER) {
1890 tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
1891 dohash(NULL, NULL);
1892 }
1893 #endif /* F_VER */
1894 #ifdef SIGSYNCH
1895 /* rfw 8/89 now parent can continue */
1896 if (kill(getppid(), SIGSYNCH))
1897 stderror(ERR_SYSTEM, "pfork child: kill", strerror(errno));
1898 #endif /* SIGSYNCH */
1899
1900 }
1901 else {
1902 #ifdef POSIXJOBS
1903 if (wanttty >= 0) {
1904 /*
1905 * `Walking' process group fix from Beto Appleton.
1906 * (beto@aixwiz.austin.ibm.com)
1907 * If setpgid fails at this point that means that
1908 * our process leader has died. We flush the current
1909 * job and become the process leader ourselves.
1910 * The parent will figure that out later.
1911 */
1912 pgrp = pcurrjob ? pcurrjob->p_jobid : pid;
1913 if (setpgid(pid, pgrp) == -1 && errno == EPERM) {
1914 pcurrjob = NULL;
1915 /*
1916 * We don't care if this causes an error here;
1917 * then we are already in the right process group
1918 */
1919 (void) setpgid(pid, pgrp = pid);
1920 }
1921 }
1922 #endif /* POSIXJOBS */
1923 palloc(pid, t);
1924 #ifdef SIGSYNCH
1925 {
1926 sigset_t pause_mask;
1927
1928 /*
1929 * rfw 8/89 Wait for child to own terminal. Solves half of ugly
1930 * synchronization problem. With this change, we know that the only
1931 * reason setpgrp to a previous process in a pipeline can fail is that
1932 * the previous process has already exited. Without this hack, he may
1933 * either have exited or not yet started to run. Two uglies become
1934 * one.
1935 */
1936 sigprocmask(SIG_BLOCK, NULL, &pause);
1937 sigdelset(&pause_mask, SIGCHLD);
1938 sigdelset(&pause_mask, SIGSYNCH);
1939 sigsuspend(&pause_mask);
1940 (void)handle_pending_signals();
1941 if (sigaction(SIGSYNCH, &osa, NULL))
1942 stderror(ERR_SYSTEM, "pfork parent: sigaction restore",
1943 strerror(errno));
1944 }
1945 #endif /* SIGSYNCH */
1946
1947 if (wanttty < 0)
1948 cleanup_until(&pchild_disabled);
1949 }
1950 return (pid);
1951 }
1952
1953 static void
okpcntl(void)1954 okpcntl(void)
1955 {
1956 if (tpgrp == -1)
1957 stderror(ERR_JOBCONTROL);
1958 if (tpgrp == 0)
1959 stderror(ERR_JOBCTRLSUB);
1960 }
1961
1962
1963 static void
setttypgrp(int pgrp)1964 setttypgrp(int pgrp)
1965 {
1966 /*
1967 * If we are piping out a builtin, eg. 'echo | more' things can go
1968 * out of sequence, i.e. the more can run before the echo. This
1969 * can happen even if we have vfork, since the echo will be forked
1970 * with the regular fork. In this case, we need to set the tty
1971 * pgrp ourselves. If that happens, then the process will be still
1972 * alive. And the tty process group will already be set.
1973 * This should fix the famous sequent problem as a side effect:
1974 * The controlling terminal is lost if all processes in the
1975 * terminal process group are zombies. In this case tcgetpgrp()
1976 * returns 0. If this happens we must set the terminal process
1977 * group again.
1978 */
1979 if (tcgetpgrp(FSHTTY) != pgrp) {
1980 #ifdef POSIXJOBS
1981 struct sigaction old;
1982
1983 /*
1984 * tcsetpgrp will set SIGTTOU to all the the processes in
1985 * the background according to POSIX... We ignore this here.
1986 */
1987 sigaction(SIGTTOU, NULL, &old);
1988 signal(SIGTTOU, SIG_IGN);
1989 #endif
1990 (void) tcsetpgrp(FSHTTY, pgrp);
1991 # ifdef POSIXJOBS
1992 sigaction(SIGTTOU, &old, NULL);
1993 # endif
1994
1995 }
1996 }
1997
1998
1999 /*
2000 * if we don't have vfork(), things can still go in the wrong order
2001 * resulting in the famous 'Stopped (tty output)'. But some systems
2002 * don't permit the setpgid() call, (these are more recent secure
2003 * systems such as ibm's aix), when they do. Then we'd rather print
2004 * an error message than hang the shell!
2005 * I am open to suggestions how to fix that.
2006 */
2007 void
pgetty(int wanttty,pid_t pgrp)2008 pgetty(int wanttty, pid_t pgrp)
2009 {
2010 #ifdef BSDJOBS
2011 # ifdef POSIXJOBS
2012 sigset_t oset, set;
2013 # endif /* POSIXJOBS */
2014
2015 jobdebug_xprintf(("wanttty %d pid %d opgrp%d pgrp %d tpgrp %d\n",
2016 wanttty, (int)getpid(), (int)pgrp, (int)mygetpgrp(),
2017 (int)tcgetpgrp(FSHTTY)));
2018 # ifdef POSIXJOBS
2019 /*
2020 * christos: I am blocking the tty signals till I've set things
2021 * correctly....
2022 */
2023 if (wanttty > 0) {
2024 sigemptyset(&set);
2025 sigaddset(&set, SIGTSTP);
2026 sigaddset(&set, SIGTTIN);
2027 (void)sigprocmask(SIG_BLOCK, &set, &oset);
2028 cleanup_push(&oset, sigprocmask_cleanup);
2029 }
2030 # endif /* POSIXJOBS */
2031
2032 # ifndef POSIXJOBS
2033 if (wanttty > 0)
2034 setttypgrp(pgrp);
2035 # endif /* !POSIXJOBS */
2036
2037 /*
2038 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
2039 * Don't check for tpgrp >= 0 so even non-interactive shells give
2040 * background jobs process groups Same for the comparison in the other part
2041 * of the #ifdef
2042 */
2043 if (wanttty >= 0) {
2044 if (setpgid(0, pgrp) == -1) {
2045 # ifdef POSIXJOBS
2046 /* Walking process group fix; see above */
2047 if (setpgid(0, pgrp = getpid()) == -1) {
2048 # endif /* POSIXJOBS */
2049 stderror(ERR_SYSTEM, "setpgid child:\n", strerror(errno));
2050 xexit(0);
2051 # ifdef POSIXJOBS
2052 }
2053 wanttty = pgrp; /* Now we really want the tty, since we became the
2054 * the process group leader
2055 */
2056 # endif /* POSIXJOBS */
2057 }
2058 }
2059
2060 # ifdef POSIXJOBS
2061 if (wanttty > 0) {
2062 setttypgrp(pgrp);
2063 cleanup_until(&oset);
2064 }
2065 # endif /* POSIXJOBS */
2066
2067 jobdebug_xprintf(("wanttty %d pid %d pgrp %d tpgrp %d\n",
2068 wanttty, getpid(), mygetpgrp(), tcgetpgrp(FSHTTY)));
2069
2070 if (tpgrp > 0)
2071 tpgrp = 0; /* gave tty away */
2072 #endif /* BSDJOBS */
2073 }
2074