Move signal handler setup code into its own function, and share
[dragonfly.git] / usr.bin / make / job.c
1 /*-
2  * Copyright (c) 1988, 1989, 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1988, 1989 by Adam de Boor
5  * Copyright (c) 1989 by Berkeley Softworks
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Adam de Boor.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  * @(#)job.c    8.2 (Berkeley) 3/19/94
40  * $FreeBSD: src/usr.bin/make/job.c,v 1.75 2005/02/10 14:32:14 harti Exp $
41  * $DragonFly: src/usr.bin/make/job.c,v 1.109 2005/05/23 18:25:34 okumoto Exp $
42  */
43
44 #ifndef OLD_JOKE
45 #define OLD_JOKE 0
46 #endif /* OLD_JOKE */
47
48 /**
49  * job.c
50  *      handle the creation etc. of our child processes.
51  *
52  * Interface:
53  *      Job_Make        Start the creation of the given target.
54  *
55  *      Job_CatchChildren
56  *                      Check for and handle the termination of any children.
57  *                      This must be called reasonably frequently to keep the
58  *                      whole make going at a decent clip, since job table
59  *                      entries aren't removed until their process is caught
60  *                      this way. Its single argument is TRUE if the function
61  *                      should block waiting for a child to terminate.
62  *
63  *      Job_CatchOutput Print any output our children have produced. Should
64  *                      also be called fairly frequently to keep the user
65  *                      informed of what's going on. If no output is waiting,
66  *                      it will block for a time given by the SEL_* constants,
67  *                      below, or until output is ready.
68  *
69  *      Job_Init        Called to intialize this module. in addition, any
70  *                      commands attached to the .BEGIN target are executed
71  *                      before this function returns. Hence, the makefile must
72  *                      have been parsed before this function is called.
73  *
74  *      Job_Full        Return TRUE if the job table is filled.
75  *
76  *      Job_Empty       Return TRUE if the job table is completely empty.
77  *
78  *      Job_Finish      Perform any final processing which needs doing. This
79  *                      includes the execution of any commands which have
80  *                      been/were attached to the .END target. It should only
81  *                      be called when the job table is empty.
82  *
83  *      Job_AbortAll    Abort all currently running jobs. It doesn't handle
84  *                      output or do anything for the jobs, just kills them.
85  *                      It should only be called in an emergency, as it were.
86  *
87  *      Job_CheckCommands
88  *                      Verify that the commands for a target are ok. Provide
89  *                      them if necessary and possible.
90  *
91  *      Job_Touch       Update a target without really updating it.
92  *
93  *      Job_Wait        Wait for all currently-running jobs to finish.
94  *
95  * compat.c
96  *      The routines in this file implement the full-compatibility
97  *      mode of PMake. Most of the special functionality of PMake
98  *      is available in this mode. Things not supported:
99  *          - different shells.
100  *          - friendly variable substitution.
101  *
102  * Interface:
103  *      Compat_Run          Initialize things for this module and recreate
104  *                          thems as need creatin'
105  */
106
107 #include <sys/queue.h>
108 #include <sys/types.h>
109 #include <sys/select.h>
110 #include <sys/stat.h>
111 #ifdef USE_KQUEUE
112 #include <sys/event.h>
113 #endif
114 #include <sys/wait.h>
115 #include <ctype.h>
116 #include <err.h>
117 #include <errno.h>
118 #include <fcntl.h>
119 #include <inttypes.h>
120 #include <string.h>
121 #include <signal.h>
122 #include <stdlib.h>
123 #include <unistd.h>
124 #include <utime.h>
125
126 #include "arch.h"
127 #include "buf.h"
128 #include "config.h"
129 #include "dir.h"
130 #include "globals.h"
131 #include "GNode.h"
132 #include "job.h"
133 #include "make.h"
134 #include "parse.h"
135 #include "pathnames.h"
136 #include "proc.h"
137 #include "shell.h"
138 #include "str.h"
139 #include "suff.h"
140 #include "targ.h"
141 #include "util.h"
142 #include "var.h"
143
144 #define TMPPAT  "/tmp/makeXXXXXXXXXX"
145 #define MKLVL_MAXVAL    500
146 #define MKLVL_ENVVAR    "__MKLVL__"
147
148 #ifndef USE_KQUEUE
149 /*
150  * The SEL_ constants determine the maximum amount of time spent in select
151  * before coming out to see if a child has finished. SEL_SEC is the number of
152  * seconds and SEL_USEC is the number of micro-seconds
153  */
154 #define SEL_SEC         2
155 #define SEL_USEC        0
156 #endif /* !USE_KQUEUE */
157
158 /*
159  * Job Table definitions.
160  *
161  * The job "table" is kept as a linked Lst in 'jobs', with the number of
162  * active jobs maintained in the 'nJobs' variable. At no time will this
163  * exceed the value of 'maxJobs', initialized by the Job_Init function.
164  *
165  * When a job is finished, the Make_Update function is called on each of the
166  * parents of the node which was just remade. This takes care of the upward
167  * traversal of the dependency graph.
168  */
169 #define JOB_BUFSIZE     1024
170 typedef struct Job {
171         pid_t           pid;    /* The child's process ID */
172
173         struct GNode    *node;  /* The target the child is making */
174
175         /*
176          * A LstNode for the first command to be saved after the job completes.
177          * This is NULL if there was no "..." in the job's commands.
178          */
179         LstNode         *tailCmds;
180
181         /*
182          * An FILE* for writing out the commands. This is only
183          * used before the job is actually started.
184          */
185         FILE            *cmdFILE;
186
187         /*
188          * A word of flags which determine how the module handles errors,
189          * echoing, etc. for the job
190          */
191         short           flags;  /* Flags to control treatment of job */
192 #define JOB_IGNERR      0x001   /* Ignore non-zero exits */
193 #define JOB_SILENT      0x002   /* no output */
194 #define JOB_SPECIAL     0x004   /* Target is a special one. i.e. run it locally
195                                  * if we can't export it and maxLocal is 0 */
196 #define JOB_IGNDOTS     0x008   /* Ignore "..." lines when processing
197                                  * commands */
198 #define JOB_FIRST       0x020   /* Job is first job for the node */
199 #define JOB_RESTART     0x080   /* Job needs to be completely restarted */
200 #define JOB_RESUME      0x100   /* Job needs to be resumed b/c it stopped,
201                                  * for some reason */
202 #define JOB_CONTINUING  0x200   /* We are in the process of resuming this job.
203                                  * Used to avoid infinite recursion between
204                                  * JobFinish and JobRestart */
205
206         /* union for handling shell's output */
207         union {
208                 /*
209                  * This part is used when usePipes is true.
210                  * The output is being caught via a pipe and the descriptors
211                  * of our pipe, an array in which output is line buffered and
212                  * the current position in that buffer are all maintained for
213                  * each job.
214                  */
215                 struct {
216                         /*
217                          * Input side of pipe associated with
218                          * job's output channel
219                          */
220                         int     op_inPipe;
221
222                         /*
223                          * Output side of pipe associated with job's
224                          * output channel
225                          */
226                         int     op_outPipe;
227
228                         /*
229                          * Buffer for storing the output of the
230                          * job, line by line
231                          */
232                         char    op_outBuf[JOB_BUFSIZE + 1];
233
234                         /* Current position in op_outBuf */
235                         int     op_curPos;
236                 }       o_pipe;
237
238                 /*
239                  * If usePipes is false the output is routed to a temporary
240                  * file and all that is kept is the name of the file and the
241                  * descriptor open to the file.
242                  */
243                 struct {
244                         /* Name of file to which shell output was rerouted */
245                         char    of_outFile[sizeof(TMPPAT)];
246
247                         /*
248                          * Stream open to the output file. Used to funnel all
249                          * from a single job to one file while still allowing
250                          * multiple shell invocations
251                          */
252                         int     of_outFd;
253                 }       o_file;
254
255         } output;       /* Data for tracking a shell's output */
256
257         TAILQ_ENTRY(Job) link;  /* list link */
258 } Job;
259
260 #define outPipe         output.o_pipe.op_outPipe
261 #define inPipe          output.o_pipe.op_inPipe
262 #define outBuf          output.o_pipe.op_outBuf
263 #define curPos          output.o_pipe.op_curPos
264 #define outFile         output.o_file.of_outFile
265 #define outFd           output.o_file.of_outFd
266
267 TAILQ_HEAD(JobList, Job);
268
269 /*
270  * error handling variables
271  */
272 static int      errors = 0;     /* number of errors reported */
273 static int      aborting = 0;   /* why is the make aborting? */
274 #define ABORT_ERROR     1       /* Because of an error */
275 #define ABORT_INTERRUPT 2       /* Because it was interrupted */
276 #define ABORT_WAIT      3       /* Waiting for jobs to finish */
277
278 /*
279  * XXX: Avoid SunOS bug... FILENO() is fp->_file, and file
280  * is a char! So when we go above 127 we turn negative!
281  */
282 #define FILENO(a) ((unsigned)fileno(a))
283
284 /*
285  * post-make command processing. The node postCommands is really just the
286  * .END target but we keep it around to avoid having to search for it
287  * all the time.
288  */
289 static GNode    *postCommands;
290
291 /*
292  * The number of commands actually printed for a target. Should this
293  * number be 0, no shell will be executed.
294  */
295 static int      numCommands;
296
297 /*
298  * Return values from JobStart.
299  */
300 #define JOB_RUNNING     0       /* Job is running */
301 #define JOB_ERROR       1       /* Error in starting the job */
302 #define JOB_FINISHED    2       /* The job is already finished */
303 #define JOB_STOPPED     3       /* The job is stopped */
304
305 /*
306  * The maximum number of jobs that may run. This is initialize from the
307  * -j argument for the leading make and from the FIFO for sub-makes.
308  */
309 static int      maxJobs;
310 static int      nJobs;          /* The number of children currently running */
311
312 /* The structures that describe them */
313 static struct JobList jobs = TAILQ_HEAD_INITIALIZER(jobs);
314
315 static Boolean  jobFull;        /* Flag to tell when the job table is full. It
316                                  * is set TRUE when (1) the total number of
317                                  * running jobs equals the maximum allowed */
318 #ifdef USE_KQUEUE
319 static int      kqfd;           /* File descriptor obtained by kqueue() */
320 #else
321 static fd_set   outputs;        /* Set of descriptors of pipes connected to
322                                  * the output channels of children */
323 #endif
324
325 static GNode    *lastNode;      /* The node for which output was most recently
326                                  * produced. */
327 static const char *targFmt;     /* Format string to use to head output from a
328                                  * job when it's not the most-recent job heard
329                                  * from */
330
331 #define TARG_FMT  "--- %s ---\n" /* Default format */
332 #define MESSAGE(fp, gn) \
333          fprintf(fp, targFmt, gn->name);
334
335 /*
336  * When JobStart attempts to run a job but isn't allowed to
337  * or when Job_CatchChildren detects a job that has
338  * been stopped somehow, the job is placed on the stoppedJobs queue to be run
339  * when the next job finishes.
340  *
341  * Lst of Job structures describing jobs that were stopped due to
342  * concurrency limits or externally
343  */
344 static struct JobList stoppedJobs = TAILQ_HEAD_INITIALIZER(stoppedJobs);
345
346 static int      fifoFd;         /* Fd of our job fifo */
347 static char     fifoName[] = "/tmp/make_fifo_XXXXXXXXX";
348 static int      fifoMaster;
349
350 static sig_atomic_t interrupted;
351
352
353 #if defined(USE_PGRP) && defined(SYSV)
354 # define KILL(pid, sig)         killpg(-(pid), (sig))
355 #else
356 # if defined(USE_PGRP)
357 #  define KILL(pid, sig)        killpg((pid), (sig))
358 # else
359 #  define KILL(pid, sig)        kill((pid), (sig))
360 # endif
361 #endif
362
363 /*
364  * Grmpf... There is no way to set bits of the wait structure
365  * anymore with the stupid W*() macros. I liked the union wait
366  * stuff much more. So, we devise our own macros... This is
367  * really ugly, use dramamine sparingly. You have been warned.
368  */
369 #define W_SETMASKED(st, val, fun)                               \
370         {                                                       \
371                 int sh = (int)~0;                               \
372                 int mask = fun(sh);                             \
373                                                                 \
374                 for (sh = 0; ((mask >> sh) & 1) == 0; sh++)     \
375                         continue;                               \
376                 *(st) = (*(st) & ~mask) | ((val) << sh);        \
377         }
378
379 #define W_SETTERMSIG(st, val) W_SETMASKED(st, val, WTERMSIG)
380 #define W_SETEXITSTATUS(st, val) W_SETMASKED(st, val, WEXITSTATUS)
381
382 static void JobRestart(Job *);
383 static int JobStart(GNode *, int, Job *);
384 static void JobDoOutput(Job *, Boolean);
385 static void JobInterrupt(int, int);
386 static void JobRestartJobs(void);
387 static int Compat_RunCommand(char *, struct GNode *);
388
389 static GNode        *curTarg = NULL;
390 static GNode        *ENDNode;
391
392 /**
393  * Create a fifo file with a uniq filename, and returns a file
394  * descriptor to that fifo.
395  */
396 static int
397 mkfifotemp(char *template)
398 {
399         char *start;
400         char *pathend;
401         char *ptr;
402         const char padchar[] =
403             "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
404
405         if (template[0] == '\0') {
406                 errno = EINVAL; /* bad input string */
407                 return (-1);
408         }
409
410         /* Find end of template string. */
411         pathend = strchr(template, '\0');
412         ptr = pathend - 1;
413
414         /*
415          * Starting from the end of the template replace spaces with 'X' in
416          * them with random characters until there are no more 'X'.
417          */
418         while (ptr >= template && *ptr == 'X') {
419                 uint32_t rand_num = arc4random() % (sizeof(padchar) - 1);
420                 *ptr-- = padchar[rand_num];
421         }
422         start = ptr + 1;
423
424         /* Check the target directory. */
425         for (; ptr > template; --ptr) {
426                 if (*ptr == '/') {
427                         struct stat sbuf;
428
429                         *ptr = '\0';
430                         if (stat(template, &sbuf) != 0)
431                                 return (-1);
432
433                         if (!S_ISDIR(sbuf.st_mode)) {
434                                 errno = ENOTDIR;
435                                 return (-1);
436                         }
437                         *ptr = '/';
438                         break;
439                 }
440         }
441
442         for (;;) {
443                 if (mkfifo(template, 0600) == 0) {
444                         int fd;
445
446                         if ((fd = open(template, O_RDWR, 0600)) < 0) {
447                                 unlink(template);
448                                 return (-1);
449                         } else {
450                                 return (fd);
451                         }
452                 } else {
453                         if (errno != EEXIST) {
454                                 return (-1);
455                         }
456                 }
457
458                 /*
459                  * If we have a collision, cycle through the space of
460                  * filenames.
461                  */
462                 for (ptr = start;;) {
463                         char *pad;
464
465                         if (*ptr == '\0' || ptr == pathend)
466                                 return (-1);
467
468                         pad = strchr(padchar, *ptr);
469                         if (pad == NULL || *++pad == '\0') {
470                                 *ptr++ = padchar[0];
471                         } else {
472                                 *ptr++ = *pad;
473                                 break;
474                         }
475                 }
476         }
477         /*NOTREACHED*/
478 }
479
480 static void
481 catch_child(int sig __unused)
482 {
483 }
484
485 /**
486  * In lieu of a good way to prevent every possible looping in make(1), stop
487  * there from being more than MKLVL_MAXVAL processes forked by make(1), to
488  * prevent a forkbomb from happening, in a dumb and mechanical way.
489  *
490  * Side Effects:
491  *      Creates or modifies enviornment variable MKLVL_ENVVAR via setenv().
492  */
493 static void
494 check_make_level(void)
495 {
496         char    *value = getenv(MKLVL_ENVVAR);
497         int     level = (value == NULL) ? 0 : atoi(value);
498
499         if (level < 0) {
500                 errc(2, EAGAIN, "Invalid value for recursion level (%d).",
501                     level);
502         } else if (level > MKLVL_MAXVAL) {
503                 errc(2, EAGAIN, "Max recursion level (%d) exceeded.",
504                     MKLVL_MAXVAL);
505         } else {
506                 char new_value[32];
507                 sprintf(new_value, "%d", level + 1);
508                 setenv(MKLVL_ENVVAR, new_value, 1);
509         }
510 }
511
512 /**
513  */
514 void
515 Proc_Init()
516 {
517         /*
518          * Catch SIGCHLD so that we get kicked out of select() when we
519          * need to look at a child.  This is only known to matter for the
520          * -j case (perhaps without -P).
521          *
522          * XXX this is intentionally misplaced.
523          */
524         struct sigaction sa;
525
526         sigemptyset(&sa.sa_mask);
527         sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
528         sa.sa_handler = catch_child;
529         sigaction(SIGCHLD, &sa, NULL);
530
531         check_make_level();
532
533 #ifdef RLIMIT_NOFILE
534         /*
535          * get rid of resource limit on file descriptors
536          */
537         {
538                 struct rlimit rl;
539                 if (getrlimit(RLIMIT_NOFILE, &rl) == -1) {
540                         err(2, "getrlimit");
541                 }
542                 rl.rlim_cur = rl.rlim_max;
543                 if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
544                         err(2, "setrlimit");
545                 }
546         }
547 #endif
548
549 #if DEFSHELL == 2
550         /*
551          * Turn off ENV to make ksh happier.
552          */
553         unsetenv("ENV");
554 #endif
555 }
556
557 /**
558  * Signal handler - set a variable and defer handling to the main code.
559  */
560 static void
561 catchsignal(int signo)
562 {
563         interrupted = signo;
564 }
565
566 /**
567  * Catch the four signals that POSIX specifies if they aren't ignored.
568  */
569 static void
570 Proc_Setupsignals(Boolean compat)
571 {
572         struct sigaction sa;
573
574         sigemptyset(&sa.sa_mask);
575         sa.sa_flags = 0;
576         sa.sa_handler = catchsignal;
577
578         if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
579                 sigaction(SIGHUP, &sa, NULL);
580         }
581         if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
582                 sigaction(SIGINT, &sa, NULL);
583         }
584         if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
585                 sigaction(SIGQUIT, &sa, NULL);
586         }
587         if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
588                 sigaction(SIGTERM, &sa, NULL);
589         }
590
591         if (compat) {
592                 return;
593         }
594
595         /*
596          * There are additional signals that need to be caught and
597          * passed if either the export system wants to be told
598          * directly of signals or if we're giving each job its own
599          * process group (since then it won't get signals from the
600          * terminal driver as we own the terminal)
601          */
602 #ifdef USE_PGRP
603         if (signal(SIGTSTP, SIG_IGN) != SIG_IGN) {
604                 sigaction(SIGTSTP, &sa, NULL);
605         }
606         if (signal(SIGTTOU, SIG_IGN) != SIG_IGN) {
607                 sigaction(SIGTTOU, &sa, NULL);
608         }
609         if (signal(SIGTTIN, SIG_IGN) != SIG_IGN) {
610                 sigaction(SIGTTIN, &sa, NULL);
611         }
612         if (signal(SIGWINCH, SIG_IGN) != SIG_IGN) {
613                 sigaction(SIGWINCH, &sa, NULL);
614         }
615 #endif
616 }
617
618 /**
619  * Wait for child process to terminate.
620  */
621 static int
622 ProcWait(ProcStuff *ps)
623 {
624         pid_t   pid;
625         int     status;
626
627         /*
628          * Wait for the process to exit.
629          */
630         for (;;) {
631                 pid = waitpid(ps->child_pid, &status, 0);
632                 if (pid == -1 && errno != EINTR) {
633                         Fatal("error in wait: %d", pid);
634                         /* NOTREACHED */
635                 }
636                 if (pid == ps->child_pid) {
637                         break;
638                 }
639                 if (interrupted) {
640                         break;
641                 }
642         }
643
644         return (status);
645 }
646
647 /**
648  * JobPassSig
649  *      Pass a signal on to all local jobs if
650  *      USE_PGRP is defined, then die ourselves.
651  *
652  * Side Effects:
653  *      We die by the same signal.
654  */
655 static void
656 JobPassSig(int signo)
657 {
658         Job     *job;
659         sigset_t nmask, omask;
660         struct sigaction act;
661
662         sigemptyset(&nmask);
663         sigaddset(&nmask, signo);
664         sigprocmask(SIG_SETMASK, &nmask, &omask);
665
666         DEBUGF(JOB, ("JobPassSig(%d) called.\n", signo));
667         TAILQ_FOREACH(job, &jobs, link) {
668                 DEBUGF(JOB, ("JobPassSig passing signal %d to child %jd.\n",
669                     signo, (intmax_t)job->pid));
670                 KILL(job->pid, signo);
671         }
672
673         /*
674          * Deal with proper cleanup based on the signal received. We only run
675          * the .INTERRUPT target if the signal was in fact an interrupt.
676          * The other three termination signals are more of a "get out *now*"
677          * command.
678          */
679         if (signo == SIGINT) {
680                 JobInterrupt(TRUE, signo);
681         } else if (signo == SIGHUP || signo == SIGTERM || signo == SIGQUIT) {
682                 JobInterrupt(FALSE, signo);
683         }
684
685         /*
686          * Leave gracefully if SIGQUIT, rather than core dumping.
687          */
688         if (signo == SIGQUIT) {
689                 signo = SIGINT;
690         }
691
692         /*
693          * Send ourselves the signal now we've given the message to everyone
694          * else. Note we block everything else possible while we're getting
695          * the signal. This ensures that all our jobs get continued when we
696          * wake up before we take any other signal.
697          * XXX this comment seems wrong.
698          */
699         act.sa_handler = SIG_DFL;
700         sigemptyset(&act.sa_mask);
701         act.sa_flags = 0;
702         sigaction(signo, &act, NULL);
703
704         DEBUGF(JOB, ("JobPassSig passing signal to self, mask = %x.\n",
705             ~0 & ~(1 << (signo - 1))));
706
707         signal(signo, SIG_DFL);
708         KILL(getpid(), signo);
709
710         signo = SIGCONT;
711         TAILQ_FOREACH(job, &jobs, link) {
712                 DEBUGF(JOB, ("JobPassSig passing signal %d to child %jd.\n",
713                     signo, (intmax_t)job->pid));
714                 KILL(job->pid, signo);
715         }
716
717         sigprocmask(SIG_SETMASK, &omask, NULL);
718         sigprocmask(SIG_SETMASK, &omask, NULL);
719         act.sa_handler = JobPassSig;
720         sigaction(signo, &act, NULL);
721 }
722
723 /**
724  * JobPrintCommand
725  *      Put out another command for the given job. If the command starts
726  *      with an @ or a - we process it specially. In the former case,
727  *      so long as the -s and -n flags weren't given to make, we stick
728  *      a shell-specific echoOff command in the script. In the latter,
729  *      we ignore errors for the entire job, unless the shell has error
730  *      control.
731  *      If the command is just "..." we take all future commands for this
732  *      job to be commands to be executed once the entire graph has been
733  *      made and return non-zero to signal that the end of the commands
734  *      was reached. These commands are later attached to the postCommands
735  *      node and executed by Job_Finish when all things are done.
736  *      This function is called from JobStart via LST_FOREACH.
737  *
738  * Results:
739  *      Always 0, unless the command was "..."
740  *
741  * Side Effects:
742  *      If the command begins with a '-' and the shell has no error control,
743  *      the JOB_IGNERR flag is set in the job descriptor.
744  *      If the command is "..." and we're not ignoring such things,
745  *      tailCmds is set to the successor node of the cmd.
746  *      numCommands is incremented if the command is actually printed.
747  */
748 static int
749 JobPrintCommand(char *cmd, Job *job)
750 {
751         Boolean noSpecials;     /* true if we shouldn't worry about
752                                  * inserting special commands into
753                                  * the input stream. */
754         Boolean shutUp = FALSE; /* true if we put a no echo command
755                                  * into the command file */
756         Boolean errOff = FALSE; /* true if we turned error checking
757                                  * off before printing the command
758                                  * and need to turn it back on */
759         const char *cmdTemplate;/* Template to use when printing the command */
760         char    *cmdStart;      /* Start of expanded command */
761         LstNode *cmdNode;       /* Node for replacing the command */
762
763         noSpecials = (noExecute && !(job->node->type & OP_MAKE));
764
765         if (strcmp(cmd, "...") == 0) {
766                 job->node->type |= OP_SAVE_CMDS;
767                 if ((job->flags & JOB_IGNDOTS) == 0) {
768                         job->tailCmds =
769                             Lst_Succ(Lst_Member(&job->node->commands, cmd));
770                         return (1);
771                 }
772                 return (0);
773         }
774
775 #define DBPRINTF(fmt, arg)                      \
776         DEBUGF(JOB, (fmt, arg));                \
777         fprintf(job->cmdFILE, fmt, arg);        \
778         fflush(job->cmdFILE);
779
780         numCommands += 1;
781
782         /*
783          * For debugging, we replace each command with the result of expanding
784          * the variables in the command.
785          */
786         cmdNode = Lst_Member(&job->node->commands, cmd);
787
788         cmd = Buf_Peel(Var_Subst(cmd, job->node, FALSE));
789         cmdStart = cmd;
790
791         Lst_Replace(cmdNode, cmdStart);
792
793         cmdTemplate = "%s\n";
794
795         /*
796          * Check for leading @', -' or +'s to control echoing, error checking,
797          * and execution on -n.
798          */
799         while (*cmd == '@' || *cmd == '-' || *cmd == '+') {
800                 switch (*cmd) {
801
802                   case '@':
803                         shutUp = DEBUG(LOUD) ? FALSE : TRUE;
804                         break;
805
806                   case '-':
807                         errOff = TRUE;
808                         break;
809
810                   case '+':
811                         if (noSpecials) {
812                                 /*
813                                  * We're not actually exececuting anything...
814                                  * but this one needs to be - use compat mode
815                                  * just for it.
816                                  */
817                                 Compat_RunCommand(cmd, job->node);
818                                 return (0);
819                         }
820                         break;
821                 }
822                 cmd++;
823         }
824
825         while (isspace((unsigned char)*cmd))
826                 cmd++;
827
828         if (shutUp) {
829                 if (!(job->flags & JOB_SILENT) && !noSpecials &&
830                     commandShell->hasEchoCtl) {
831                         DBPRINTF("%s\n", commandShell->echoOff);
832                 } else {
833                         shutUp = FALSE;
834                 }
835         }
836
837         if (errOff) {
838                 if (!(job->flags & JOB_IGNERR) && !noSpecials) {
839                         if (commandShell->hasErrCtl) {
840                                 /*
841                                  * We don't want the error-control commands
842                                  * showing up either, so we turn off echoing
843                                  * while executing them. We could put another
844                                  * field in the shell structure to tell
845                                  * JobDoOutput to look for this string too,
846                                  * but why make it any more complex than
847                                  * it already is?
848                                  */
849                                 if (!(job->flags & JOB_SILENT) && !shutUp &&
850                                     commandShell->hasEchoCtl) {
851                                         DBPRINTF("%s\n", commandShell->echoOff);
852                                         DBPRINTF("%s\n", commandShell->ignErr);
853                                         DBPRINTF("%s\n", commandShell->echoOn);
854                                 } else {
855                                         DBPRINTF("%s\n", commandShell->ignErr);
856                                 }
857                         } else if (commandShell->ignErr &&
858                             *commandShell->ignErr != '\0') {
859                                 /*
860                                  * The shell has no error control, so we need to
861                                  * be weird to get it to ignore any errors from
862                                  * the command. If echoing is turned on, we turn
863                                  * it off and use the errCheck template to echo
864                                  * the command. Leave echoing off so the user
865                                  * doesn't see the weirdness we go through to
866                                  * ignore errors. Set cmdTemplate to use the
867                                  * weirdness instead of the simple "%s\n"
868                                  * template.
869                                  */
870                                 if (!(job->flags & JOB_SILENT) && !shutUp &&
871                                     commandShell->hasEchoCtl) {
872                                         DBPRINTF("%s\n", commandShell->echoOff);
873                                         DBPRINTF(commandShell->errCheck, cmd);
874                                         shutUp = TRUE;
875                                 }
876                                 cmdTemplate = commandShell->ignErr;
877                                 /*
878                                  * The error ignoration (hee hee) is already
879                                  * taken care of by the ignErr template, so
880                                  * pretend error checking is still on.
881                                 */
882                                 errOff = FALSE;
883                         } else {
884                                 errOff = FALSE;
885                         }
886                 } else {
887                         errOff = FALSE;
888                 }
889         }
890
891         DBPRINTF(cmdTemplate, cmd);
892
893         if (errOff) {
894                 /*
895                  * If echoing is already off, there's no point in issuing the
896                  * echoOff command. Otherwise we issue it and pretend it was on
897                  * for the whole command...
898                  */
899                 if (!shutUp && !(job->flags & JOB_SILENT) &&
900                     commandShell->hasEchoCtl) {
901                         DBPRINTF("%s\n", commandShell->echoOff);
902                         shutUp = TRUE;
903                 }
904                 DBPRINTF("%s\n", commandShell->errCheck);
905         }
906         if (shutUp) {
907                 DBPRINTF("%s\n", commandShell->echoOn);
908         }
909         return (0);
910 }
911
912 /**
913  * JobClose
914  *      Called to close both input and output pipes when a job is finished.
915  *
916  * Side Effects:
917  *      The file descriptors associated with the job are closed.
918  */
919 static void
920 JobClose(Job *job)
921 {
922
923         if (usePipes) {
924 #if !defined(USE_KQUEUE)
925                 FD_CLR(job->inPipe, &outputs);
926 #endif
927                 if (job->outPipe != job->inPipe) {
928                         close(job->outPipe);
929                 }
930                 JobDoOutput(job, TRUE);
931                 close(job->inPipe);
932         } else {
933                 close(job->outFd);
934                 JobDoOutput(job, TRUE);
935         }
936 }
937
938 /**
939  * JobFinish
940  *      Do final processing for the given job including updating
941  *      parents and starting new jobs as available/necessary. Note
942  *      that we pay no attention to the JOB_IGNERR flag here.
943  *      This is because when we're called because of a noexecute flag
944  *      or something, jstat.w_status is 0 and when called from
945  *      Job_CatchChildren, the status is zeroed if it s/b ignored.
946  *
947  * Side Effects:
948  *      Some nodes may be put on the toBeMade queue.
949  *      Final commands for the job are placed on postCommands.
950  *
951  *      If we got an error and are aborting (aborting == ABORT_ERROR) and
952  *      the job list is now empty, we are done for the day.
953  *      If we recognized an error (errors !=0), we set the aborting flag
954  *      to ABORT_ERROR so no more jobs will be started.
955  */
956 static void
957 JobFinish(Job *job, int *status)
958 {
959         Boolean done;
960         LstNode *ln;
961
962         if (WIFEXITED(*status)) {
963                 int     job_status = WEXITSTATUS(*status);
964
965                 JobClose(job);
966                 /*
967                  * Deal with ignored errors in -B mode. We need to
968                  * print a message telling of the ignored error as
969                  * well as setting status.w_status to 0 so the next
970                  * command gets run. To do this, we set done to be
971                  * TRUE if in -B mode and the job exited non-zero.
972                  */
973                 if (job_status == 0) {
974                         done = FALSE;
975                 } else {
976                         if (job->flags & JOB_IGNERR) {
977                                 done = TRUE;
978                         } else {
979                                 /*
980                                  * If it exited non-zero and either we're
981                                  * doing things our way or we're not ignoring
982                                  * errors, the job is finished. Similarly, if
983                                  * the shell died because of a signal the job
984                                  * is also finished. In these cases, finish
985                                  * out the job's output before printing the
986                                  * exit status...
987                                  */
988                                 done = TRUE;
989                                 if (job->cmdFILE != NULL &&
990                                     job->cmdFILE != stdout) {
991                                         fclose(job->cmdFILE);
992                                 }
993
994                         }
995                 }
996         } else if (WIFSIGNALED(*status)) {
997                 if (WTERMSIG(*status) == SIGCONT) {
998                         /*
999                          * No need to close things down or anything.
1000                          */
1001                         done = FALSE;
1002                 } else {
1003                         /*
1004                          * If it exited non-zero and either we're
1005                          * doing things our way or we're not ignoring
1006                          * errors, the job is finished. Similarly, if
1007                          * the shell died because of a signal the job
1008                          * is also finished. In these cases, finish
1009                          * out the job's output before printing the
1010                          * exit status...
1011                          */
1012                         JobClose(job);
1013                         if (job->cmdFILE != NULL &&
1014                             job->cmdFILE != stdout) {
1015                                 fclose(job->cmdFILE);
1016                         }
1017                         done = TRUE;
1018                 }
1019         } else {
1020                 /*
1021                  * No need to close things down or anything.
1022                  */
1023                 done = FALSE;
1024         }
1025
1026         if (WIFEXITED(*status)) {
1027                 if (done || DEBUG(JOB)) {
1028                         FILE   *out;
1029
1030                         if (compatMake &&
1031                             !usePipes &&
1032                             (job->flags & JOB_IGNERR)) {
1033                                 /*
1034                                  * If output is going to a file and this job
1035                                  * is ignoring errors, arrange to have the
1036                                  * exit status sent to the output file as
1037                                  * well.
1038                                  */
1039                                 out = fdopen(job->outFd, "w");
1040                                 if (out == NULL)
1041                                         Punt("Cannot fdopen");
1042                         } else {
1043                                 out = stdout;
1044                         }
1045
1046                         DEBUGF(JOB, ("Process %jd exited.\n",
1047                             (intmax_t)job->pid));
1048
1049                         if (WEXITSTATUS(*status) == 0) {
1050                                 if (DEBUG(JOB)) {
1051                                         if (usePipes && job->node != lastNode) {
1052                                                 MESSAGE(out, job->node);
1053                                                 lastNode = job->node;
1054                                         }
1055                                         fprintf(out,
1056                                             "*** Completed successfully\n");
1057                                 }
1058                         } else {
1059                                 if (usePipes && job->node != lastNode) {
1060                                         MESSAGE(out, job->node);
1061                                         lastNode = job->node;
1062                                 }
1063                                 fprintf(out, "*** Error code %d%s\n",
1064                                         WEXITSTATUS(*status),
1065                                         (job->flags & JOB_IGNERR) ?
1066                                         "(ignored)" : "");
1067
1068                                 if (job->flags & JOB_IGNERR) {
1069                                         *status = 0;
1070                                 }
1071                         }
1072
1073                         fflush(out);
1074                 }
1075         } else if (WIFSIGNALED(*status)) {
1076                 if (done || DEBUG(JOB) || (WTERMSIG(*status) == SIGCONT)) {
1077                         FILE   *out;
1078
1079                         if (compatMake &&
1080                             !usePipes &&
1081                             (job->flags & JOB_IGNERR)) {
1082                                 /*
1083                                  * If output is going to a file and this job
1084                                  * is ignoring errors, arrange to have the
1085                                  * exit status sent to the output file as
1086                                  * well.
1087                                  */
1088                                 out = fdopen(job->outFd, "w");
1089                                 if (out == NULL)
1090                                         Punt("Cannot fdopen");
1091                         } else {
1092                                 out = stdout;
1093                         }
1094
1095                         if (WTERMSIG(*status) == SIGCONT) {
1096                                 /*
1097                                  * If the beastie has continued, shift the
1098                                  * Job from the stopped list to the running
1099                                  * one (or re-stop it if concurrency is
1100                                  * exceeded) and go and get another child.
1101                                  */
1102                                 if (job->flags & (JOB_RESUME | JOB_RESTART)) {
1103                                         if (usePipes && job->node != lastNode) {
1104                                                 MESSAGE(out, job->node);
1105                                                 lastNode = job->node;
1106                                         }
1107                                         fprintf(out, "*** Continued\n");
1108                                 }
1109                                 if (!(job->flags & JOB_CONTINUING)) {
1110                                         DEBUGF(JOB, ("Warning: process %jd was not "
1111                                                      "continuing.\n", (intmax_t) job->pid));
1112 #ifdef notdef
1113                                         /*
1114                                          * We don't really want to restart a
1115                                          * job from scratch just because it
1116                                          * continued, especially not without
1117                                          * killing the continuing process!
1118                                          * That's why this is ifdef'ed out.
1119                                          * FD - 9/17/90
1120                                          */
1121                                         JobRestart(job);
1122 #endif
1123                                 }
1124                                 job->flags &= ~JOB_CONTINUING;
1125                                 TAILQ_INSERT_TAIL(&jobs, job, link);
1126                                 nJobs += 1;
1127                                 DEBUGF(JOB, ("Process %jd is continuing locally.\n",
1128                                              (intmax_t) job->pid));
1129                                 if (nJobs == maxJobs) {
1130                                         jobFull = TRUE;
1131                                         DEBUGF(JOB, ("Job queue is full.\n"));
1132                                 }
1133                                 fflush(out);
1134                                 return;
1135
1136                         } else {
1137                                 if (usePipes && job->node != lastNode) {
1138                                         MESSAGE(out, job->node);
1139                                         lastNode = job->node;
1140                                 }
1141                                 fprintf(out,
1142                                     "*** Signal %d\n", WTERMSIG(*status));
1143                                 fflush(out);
1144                         }
1145                 }
1146         } else {
1147                 /* STOPPED */
1148                 FILE   *out;
1149
1150                 if (compatMake && !usePipes && (job->flags & JOB_IGNERR)) {
1151                         /*
1152                          * If output is going to a file and this job
1153                          * is ignoring errors, arrange to have the
1154                          * exit status sent to the output file as
1155                          * well.
1156                          */
1157                         out = fdopen(job->outFd, "w");
1158                         if (out == NULL)
1159                                 Punt("Cannot fdopen");
1160                 } else {
1161                         out = stdout;
1162                 }
1163
1164                 DEBUGF(JOB, ("Process %jd stopped.\n", (intmax_t) job->pid));
1165                 if (usePipes && job->node != lastNode) {
1166                         MESSAGE(out, job->node);
1167                         lastNode = job->node;
1168                 }
1169                 fprintf(out, "*** Stopped -- signal %d\n", WSTOPSIG(*status));
1170                 job->flags |= JOB_RESUME;
1171                 TAILQ_INSERT_TAIL(&stoppedJobs, job, link);
1172                 fflush(out);
1173                 return;
1174         }
1175
1176         /*
1177          * Now handle the -B-mode stuff. If the beast still isn't finished,
1178          * try and restart the job on the next command. If JobStart says it's
1179          * ok, it's ok. If there's an error, this puppy is done.
1180          */
1181         if (compatMake && WIFEXITED(*status) &&
1182             Lst_Succ(job->node->compat_command) != NULL) {
1183                 switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job)) {
1184                   case JOB_RUNNING:
1185                         done = FALSE;
1186                         break;
1187                   case JOB_ERROR:
1188                         done = TRUE;
1189                         W_SETEXITSTATUS(status, 1);
1190                         break;
1191                   case JOB_FINISHED:
1192                         /*
1193                          * If we got back a JOB_FINISHED code, JobStart has
1194                          * already called Make_Update and freed the job
1195                          * descriptor. We set done to false here to avoid fake
1196                          * cycles and double frees. JobStart needs to do the
1197                          * update so we can proceed up the graph when given
1198                          * the -n flag..
1199                          */
1200                         done = FALSE;
1201                         break;
1202                   default:
1203                         break;
1204                 }
1205         } else {
1206                 done = TRUE;
1207         }
1208
1209         if (done && aborting != ABORT_ERROR &&
1210             aborting != ABORT_INTERRUPT && *status == 0) {
1211                 /*
1212                  * As long as we aren't aborting and the job didn't return a
1213                  * non-zero status that we shouldn't ignore, we call
1214                  * Make_Update to update the parents. In addition, any saved
1215                  * commands for the node are placed on the .END target.
1216                  */
1217                 for (ln = job->tailCmds; ln != NULL; ln = LST_NEXT(ln)) {
1218                         Lst_AtEnd(&postCommands->commands,
1219                             Buf_Peel(
1220                                 Var_Subst(Lst_Datum(ln), job->node, FALSE)));
1221                 }
1222
1223                 job->node->made = MADE;
1224                 Make_Update(job->node);
1225                 free(job);
1226
1227         } else if (*status != 0) {
1228                 errors += 1;
1229                 free(job);
1230         }
1231
1232         JobRestartJobs();
1233
1234         /*
1235          * Set aborting if any error.
1236          */
1237         if (errors && !keepgoing && aborting != ABORT_INTERRUPT) {
1238                 /*
1239                  * If we found any errors in this batch of children and the -k
1240                  * flag wasn't given, we set the aborting flag so no more jobs
1241                  * get started.
1242                  */
1243                 aborting = ABORT_ERROR;
1244         }
1245
1246         if (aborting == ABORT_ERROR && Job_Empty()) {
1247                 /*
1248                  * If we are aborting and the job table is now empty, we finish.
1249                  */
1250                 Finish(errors);
1251         }
1252 }
1253
1254 /**
1255  * Job_Touch
1256  *      Touch the given target. Called by JobStart when the -t flag was
1257  *      given.  Prints messages unless told to be silent.
1258  *
1259  * Side Effects:
1260  *      The data modification of the file is changed. In addition, if the
1261  *      file did not exist, it is created.
1262  */
1263 void
1264 Job_Touch(GNode *gn, Boolean silent)
1265 {
1266         int     streamID;       /* ID of stream opened to do the touch */
1267         struct utimbuf times;   /* Times for utime() call */
1268
1269         if (gn->type & (OP_JOIN | OP_USE | OP_EXEC | OP_OPTIONAL)) {
1270                 /*
1271                  * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual"
1272                  * targets and, as such, shouldn't really be created.
1273                  */
1274                 return;
1275         }
1276
1277         if (!silent) {
1278                 fprintf(stdout, "touch %s\n", gn->name);
1279                 fflush(stdout);
1280         }
1281
1282         if (noExecute) {
1283                 return;
1284         }
1285
1286         if (gn->type & OP_ARCHV) {
1287                 Arch_Touch(gn);
1288         } else if (gn->type & OP_LIB) {
1289                 Arch_TouchLib(gn);
1290         } else {
1291                 char    *file = gn->path ? gn->path : gn->name;
1292
1293                 times.actime = times.modtime = now;
1294                 if (utime(file, &times) < 0) {
1295                         streamID = open(file, O_RDWR | O_CREAT, 0666);
1296
1297                         if (streamID >= 0) {
1298                                 char    c;
1299
1300                                 /*
1301                                  * Read and write a byte to the file to change
1302                                  * the modification time, then close the file.
1303                                  */
1304                                 if (read(streamID, &c, 1) == 1) {
1305                                         lseek(streamID, (off_t)0, SEEK_SET);
1306                                         write(streamID, &c, 1);
1307                                 }
1308
1309                                 close(streamID);
1310                         } else {
1311                                 fprintf(stdout, "*** couldn't touch %s: %s",
1312                                     file, strerror(errno));
1313                                 fflush(stdout);
1314                         }
1315                 }
1316         }
1317 }
1318
1319 /**
1320  * Job_CheckCommands
1321  *      Make sure the given node has all the commands it needs.
1322  *
1323  * Results:
1324  *      TRUE if the commands list is/was ok.
1325  *
1326  * Side Effects:
1327  *      The node will have commands from the .DEFAULT rule added to it
1328  *      if it needs them.
1329  */
1330 Boolean
1331 Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
1332 {
1333
1334         if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands) &&
1335             (gn->type & OP_LIB) == 0) {
1336                 /*
1337                  * No commands. Look for .DEFAULT rule from which we might infer
1338                  * commands.
1339                  */
1340                 if (DEFAULT != NULL && !Lst_IsEmpty(&DEFAULT->commands)) {
1341                         /*
1342                          * Make only looks for a .DEFAULT if the node was
1343                          * never the target of an operator, so that's what we
1344                          * do too. If a .DEFAULT was given, we substitute its
1345                          * commands for gn's commands and set the IMPSRC
1346                          * variable to be the target's name The DEFAULT node
1347                          * acts like a transformation rule, in that gn also
1348                          * inherits any attributes or sources attached to
1349                          * .DEFAULT itself.
1350                          */
1351                         Make_HandleUse(DEFAULT, gn);
1352                         Var_Set(IMPSRC, Var_Value(TARGET, gn), gn);
1353
1354                 } else if (Dir_MTime(gn) == 0) {
1355                         /*
1356                          * The node wasn't the target of an operator we have
1357                          * no .DEFAULT rule to go on and the target doesn't
1358                          * already exist. There's nothing more we can do for
1359                          * this branch. If the -k flag wasn't given, we stop
1360                          * in our tracks, otherwise we just don't update
1361                          * this node's parents so they never get examined.
1362                          */
1363                         static const char msg[] =
1364                             "make: don't know how to make";
1365
1366                         if (gn->type & OP_OPTIONAL) {
1367                                 fprintf(stdout, "%s %s(ignored)\n",
1368                                     msg, gn->name);
1369                                 fflush(stdout);
1370                         } else if (keepgoing) {
1371                                 fprintf(stdout, "%s %s(continuing)\n",
1372                                     msg, gn->name);
1373                                 fflush(stdout);
1374                                 return (FALSE);
1375                         } else {
1376 #if OLD_JOKE
1377                                 if (strcmp(gn->name,"love") == 0)
1378                                         (*abortProc)("Not war.");
1379                                 else
1380 #endif
1381                                         (*abortProc)("%s %s. Stop",
1382                                             msg, gn->name);
1383                                 return (FALSE);
1384                         }
1385                 }
1386         }
1387         return (TRUE);
1388 }
1389
1390 /**
1391  * JobExec
1392  *      Execute the shell for the given job. Called from JobStart and
1393  *      JobRestart.
1394  *
1395  * Side Effects:
1396  *      A shell is executed, outputs is altered and the Job structure added
1397  *      to the job table.
1398  */
1399 static void
1400 JobExec(Job *job, char **argv)
1401 {
1402         ProcStuff       ps;
1403
1404         if (DEBUG(JOB)) {
1405                 int       i;
1406
1407                 DEBUGF(JOB, ("Running %s\n", job->node->name));
1408                 DEBUGF(JOB, ("\tCommand: "));
1409                 for (i = 0; argv[i] != NULL; i++) {
1410                         DEBUGF(JOB, ("%s ", argv[i]));
1411                 }
1412                 DEBUGF(JOB, ("\n"));
1413         }
1414
1415         /*
1416          * Some jobs produce no output and it's disconcerting to have
1417          * no feedback of their running (since they produce no output, the
1418          * banner with their name in it never appears). This is an attempt to
1419          * provide that feedback, even if nothing follows it.
1420          */
1421         if (lastNode != job->node && (job->flags & JOB_FIRST) &&
1422             !(job->flags & JOB_SILENT)) {
1423                 MESSAGE(stdout, job->node);
1424                 lastNode = job->node;
1425         }
1426
1427         ps.in = FILENO(job->cmdFILE);
1428         if (usePipes) {
1429                 /*
1430                  * Set up the child's output to be routed through the
1431                  * pipe we've created for it.
1432                  */
1433                 ps.out = job->outPipe;
1434         } else {
1435                 /*
1436                  * We're capturing output in a file, so we duplicate
1437                  * the descriptor to the temporary file into the
1438                  * standard output.
1439                  */
1440                 ps.out = job->outFd;
1441         }
1442         ps.err = STDERR_FILENO;
1443
1444         ps.merge_errors = 1;
1445         ps.pgroup = 1;
1446         ps.searchpath = 0;
1447
1448         ps.argv = argv;
1449         ps.argv_free = 0;
1450
1451         /*
1452          * Fork.  Warning since we are doing vfork() instead of fork(),
1453          * do not allocate memory in the child process!
1454          */
1455         if ((ps.child_pid = vfork()) == -1) {
1456                 Punt("Cannot fork");
1457
1458         } else if (ps.child_pid == 0) {
1459                 /*
1460                  * Child
1461                  */
1462                 if (fifoFd >= 0)
1463                         close(fifoFd);
1464
1465                 ProcExec(&ps);
1466                 /* NOTREACHED */
1467
1468         } else {
1469                 /*
1470                  * Parent
1471                  */
1472                 job->pid = ps.child_pid;
1473
1474                 if (usePipes && (job->flags & JOB_FIRST)) {
1475                         /*
1476                          * The first time a job is run for a node, we set the
1477                          * current position in the buffer to the beginning and
1478                          * mark another stream to watch in the outputs mask.
1479                          */
1480 #ifdef USE_KQUEUE
1481                         struct kevent   kev[2];
1482 #endif
1483                         job->curPos = 0;
1484
1485 #if defined(USE_KQUEUE)
1486                         EV_SET(&kev[0], job->inPipe, EVFILT_READ, EV_ADD, 0, 0, job);
1487                         EV_SET(&kev[1], job->pid, EVFILT_PROC,
1488                             EV_ADD | EV_ONESHOT, NOTE_EXIT, 0, NULL);
1489                         if (kevent(kqfd, kev, 2, NULL, 0, NULL) != 0) {
1490                                 /*
1491                                  * kevent() will fail if the job is already
1492                                  * finished
1493                                  */
1494                                 if (errno != EINTR && errno != EBADF && errno != ESRCH)
1495                                         Punt("kevent: %s", strerror(errno));
1496                         }
1497 #else
1498                         FD_SET(job->inPipe, &outputs);
1499 #endif /* USE_KQUEUE */
1500                 }
1501
1502                 if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1503                         fclose(job->cmdFILE);
1504                         job->cmdFILE = NULL;
1505                 }
1506
1507                 /*
1508                  * Now the job is actually running, add it to the table.
1509                  */
1510                 nJobs += 1;
1511                 TAILQ_INSERT_TAIL(&jobs, job, link);
1512                 if (nJobs == maxJobs) {
1513                         jobFull = TRUE;
1514                 }
1515         }
1516 }
1517
1518 /**
1519  * JobMakeArgv
1520  *      Create the argv needed to execute the shell for a given job.
1521  */
1522 static void
1523 JobMakeArgv(Job *job, char **argv)
1524 {
1525         int             argc;
1526         static char     args[10];       /* For merged arguments */
1527
1528         argv[0] = commandShell->name;
1529         argc = 1;
1530
1531         if ((commandShell->exit && *commandShell->exit != '-') ||
1532             (commandShell->echo && *commandShell->echo != '-')) {
1533                 /*
1534                  * At least one of the flags doesn't have a minus before it, so
1535                  * merge them together. Have to do this because the *(&(@*#*&#$#
1536                  * Bourne shell thinks its second argument is a file to source.
1537                  * Grrrr. Note the ten-character limitation on the combined
1538                  * arguments.
1539                  */
1540                 sprintf(args, "-%s%s", (job->flags & JOB_IGNERR) ? "" :
1541                     commandShell->exit ? commandShell->exit : "",
1542                     (job->flags & JOB_SILENT) ? "" :
1543                     commandShell->echo ? commandShell->echo : "");
1544
1545                 if (args[1]) {
1546                         argv[argc] = args;
1547                         argc++;
1548                 }
1549         } else {
1550                 if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
1551                         argv[argc] = commandShell->exit;
1552                         argc++;
1553                 }
1554                 if (!(job->flags & JOB_SILENT) && commandShell->echo) {
1555                         argv[argc] = commandShell->echo;
1556                         argc++;
1557                 }
1558         }
1559         argv[argc] = NULL;
1560 }
1561
1562 /**
1563  * JobRestart
1564  *      Restart a job that stopped for some reason. The job must be neither
1565  *      on the jobs nor on the stoppedJobs list.
1566  *
1567  * Side Effects:
1568  *      jobFull will be set if the job couldn't be run.
1569  */
1570 static void
1571 JobRestart(Job *job)
1572 {
1573
1574         if (job->flags & JOB_RESTART) {
1575                 /*
1576                  * Set up the control arguments to the shell. This is based on
1577                  * the flags set earlier for this job. If the JOB_IGNERR flag
1578                  * is clear, the 'exit' flag of the commandShell is used to
1579                  * cause it to exit upon receiving an error. If the JOB_SILENT
1580                  * flag is clear, the 'echo' flag of the commandShell is used
1581                  * to get it to start echoing as soon as it starts
1582                  * processing commands.
1583                  */
1584                 char    *argv[4];
1585
1586                 JobMakeArgv(job, argv);
1587
1588                 DEBUGF(JOB, ("Restarting %s...", job->node->name));
1589                 if (nJobs >= maxJobs && !(job->flags & JOB_SPECIAL)) {
1590                         /*
1591                          * Not allowed to run -- put it back on the hold
1592                          * queue and mark the table full
1593                          */
1594                         DEBUGF(JOB, ("holding\n"));
1595                         TAILQ_INSERT_HEAD(&stoppedJobs, job, link);
1596                         jobFull = TRUE;
1597                         DEBUGF(JOB, ("Job queue is full.\n"));
1598                         return;
1599                 } else {
1600                         /*
1601                          * Job may be run locally.
1602                          */
1603                         DEBUGF(JOB, ("running locally\n"));
1604                 }
1605                 JobExec(job, argv);
1606
1607         } else {
1608                 /*
1609                  * The job has stopped and needs to be restarted.
1610                  * Why it stopped, we don't know...
1611                  */
1612                 DEBUGF(JOB, ("Resuming %s...", job->node->name));
1613                 if ((nJobs < maxJobs || ((job->flags & JOB_SPECIAL) &&
1614                     maxJobs == 0)) && nJobs != maxJobs) {
1615                         /*
1616                          * If we haven't reached the concurrency limit already
1617                          * (or the job must be run and maxJobs is 0), it's ok
1618                          * to resume it.
1619                          */
1620                         Boolean error;
1621                         int status;
1622
1623                         error = (KILL(job->pid, SIGCONT) != 0);
1624
1625                         if (!error) {
1626                                 /*
1627                                  * Make sure the user knows we've continued
1628                                  * the beast and actually put the thing in the
1629                                  * job table.
1630                                  */
1631                                 job->flags |= JOB_CONTINUING;
1632                                 status = 0;
1633                                 W_SETTERMSIG(&status, SIGCONT);
1634                                 JobFinish(job, &status);
1635
1636                                 job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
1637                                 DEBUGF(JOB, ("done\n"));
1638                         } else {
1639                                 Error("couldn't resume %s: %s",
1640                                 job->node->name, strerror(errno));
1641                                 status = 0;
1642                                 W_SETEXITSTATUS(&status, 1);
1643                                 JobFinish(job, &status);
1644                         }
1645                 } else {
1646                         /*
1647                         * Job cannot be restarted. Mark the table as full and
1648                         * place the job back on the list of stopped jobs.
1649                         */
1650                         DEBUGF(JOB, ("table full\n"));
1651                         TAILQ_INSERT_HEAD(&stoppedJobs, job, link);
1652                         jobFull = TRUE;
1653                         DEBUGF(JOB, ("Job queue is full.\n"));
1654                 }
1655         }
1656 }
1657
1658 /**
1659  * JobStart
1660  *      Start a target-creation process going for the target described
1661  *      by the graph node gn.
1662  *
1663  * Results:
1664  *      JOB_ERROR if there was an error in the commands, JOB_FINISHED
1665  *      if there isn't actually anything left to do for the job and
1666  *      JOB_RUNNING if the job has been started.
1667  *
1668  * Side Effects:
1669  *      A new Job node is created and added to the list of running
1670  *      jobs. PMake is forked and a child shell created.
1671  */
1672 static int
1673 JobStart(GNode *gn, int flags, Job *previous)
1674 {
1675         Job     *job;           /* new job descriptor */
1676         char    *argv[4];       /* Argument vector to shell */
1677         Boolean cmdsOK;         /* true if the nodes commands were all right */
1678         Boolean noExec;         /* Set true if we decide not to run the job */
1679         int     tfd;            /* File descriptor for temp file */
1680         LstNode *ln;
1681         char    tfile[sizeof(TMPPAT)];
1682
1683         if (interrupted) {
1684                 JobPassSig(interrupted);
1685                 return (JOB_ERROR);
1686         }
1687         if (previous != NULL) {
1688                 previous->flags &= ~(JOB_FIRST | JOB_IGNERR | JOB_SILENT);
1689                 job = previous;
1690         } else {
1691                 job = emalloc(sizeof(Job));
1692                 flags |= JOB_FIRST;
1693         }
1694
1695         job->node = gn;
1696         job->tailCmds = NULL;
1697
1698         /*
1699          * Set the initial value of the flags for this job based on the global
1700          * ones and the node's attributes... Any flags supplied by the caller
1701          * are also added to the field.
1702          */
1703         job->flags = 0;
1704         if (Targ_Ignore(gn)) {
1705                 job->flags |= JOB_IGNERR;
1706         }
1707         if (Targ_Silent(gn)) {
1708                 job->flags |= JOB_SILENT;
1709         }
1710         job->flags |= flags;
1711
1712         /*
1713          * Check the commands now so any attributes from .DEFAULT have a chance
1714          * to migrate to the node.
1715          */
1716         if (!compatMake && (job->flags & JOB_FIRST)) {
1717                 cmdsOK = Job_CheckCommands(gn, Error);
1718         } else {
1719                 cmdsOK = TRUE;
1720         }
1721
1722         /*
1723          * If the -n flag wasn't given, we open up OUR (not the child's)
1724          * temporary file to stuff commands in it. The thing is rd/wr so we
1725          * don't need to reopen it to feed it to the shell. If the -n flag
1726          * *was* given, we just set the file to be stdout. Cute, huh?
1727          */
1728         if ((gn->type & OP_MAKE) || (!noExecute && !touchFlag)) {
1729                 /*
1730                  * We're serious here, but if the commands were bogus, we're
1731                  * also dead...
1732                  */
1733                 if (!cmdsOK) {
1734                         DieHorribly();
1735                 }
1736
1737                 strcpy(tfile, TMPPAT);
1738                 if ((tfd = mkstemp(tfile)) == -1)
1739                         Punt("Cannot create temp file: %s", strerror(errno));
1740                 job->cmdFILE = fdopen(tfd, "w+");
1741                 eunlink(tfile);
1742                 if (job->cmdFILE == NULL) {
1743                         close(tfd);
1744                         Punt("Could not open %s", tfile);
1745                 }
1746                 fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
1747                 /*
1748                  * Send the commands to the command file, flush all its
1749                  * buffers then rewind and remove the thing.
1750                  */
1751                 noExec = FALSE;
1752
1753                 /*
1754                  * Used to be backwards; replace when start doing multiple
1755                  * commands per shell.
1756                  */
1757                 if (compatMake) {
1758                         /*
1759                          * Be compatible: If this is the first time for this
1760                          * node, verify its commands are ok and open the
1761                          * commands list for sequential access by later
1762                          * invocations of JobStart. Once that is done, we take
1763                          * the next command off the list and print it to the
1764                          * command file. If the command was an ellipsis, note
1765                          * that there's nothing more to execute.
1766                          */
1767                         if (job->flags & JOB_FIRST)
1768                                 gn->compat_command = Lst_First(&gn->commands);
1769                         else
1770                                 gn->compat_command =
1771                                     Lst_Succ(gn->compat_command);
1772
1773                         if (gn->compat_command == NULL ||
1774                             JobPrintCommand(Lst_Datum(gn->compat_command), job))
1775                                 noExec = TRUE;
1776
1777                         if (noExec && !(job->flags & JOB_FIRST)) {
1778                                 /*
1779                                  * If we're not going to execute anything, the
1780                                  * job is done and we need to close down the
1781                                  * various file descriptors we've opened for
1782                                  * output, then call JobDoOutput to catch the
1783                                  * final characters or send the file to the
1784                                  * screen... Note that the i/o streams are only
1785                                  * open if this isn't the first job. Note also
1786                                  * that this could not be done in
1787                                  * Job_CatchChildren b/c it wasn't clear if
1788                                  * there were more commands to execute or not...
1789                                  */
1790                                 JobClose(job);
1791                         }
1792                 } else {
1793                         /*
1794                          * We can do all the commands at once. hooray for sanity
1795                          */
1796                         numCommands = 0;
1797                         LST_FOREACH(ln, &gn->commands) {
1798                                 if (JobPrintCommand(Lst_Datum(ln), job))
1799                                         break;
1800                         }
1801
1802                         /*
1803                          * If we didn't print out any commands to the shell
1804                          * script, there's not much point in executing the
1805                          * shell, is there?
1806                          */
1807                         if (numCommands == 0) {
1808                                 noExec = TRUE;
1809                         }
1810                 }
1811
1812         } else if (noExecute) {
1813                 /*
1814                  * Not executing anything -- just print all the commands to
1815                  * stdout in one fell swoop. This will still set up
1816                  * job->tailCmds correctly.
1817                  */
1818                 if (lastNode != gn) {
1819                         MESSAGE(stdout, gn);
1820                         lastNode = gn;
1821                 }
1822                 job->cmdFILE = stdout;
1823
1824                 /*
1825                  * Only print the commands if they're ok, but don't die if
1826                  * they're not -- just let the user know they're bad and keep
1827                  * going. It doesn't do any harm in this case and may do
1828                  * some good.
1829                  */
1830                 if (cmdsOK) {
1831                         LST_FOREACH(ln, &gn->commands) {
1832                                 if (JobPrintCommand(Lst_Datum(ln), job))
1833                                         break;
1834                         }
1835                 }
1836                 /*
1837                 * Don't execute the shell, thank you.
1838                 */
1839                 noExec = TRUE;
1840
1841         } else {
1842                 /*
1843                  * Just touch the target and note that no shell should be
1844                  * executed. Set cmdFILE to stdout to make life easier. Check
1845                  * the commands, too, but don't die if they're no good -- it
1846                  * does no harm to keep working up the graph.
1847                  */
1848                 job->cmdFILE = stdout;
1849                 Job_Touch(gn, job->flags & JOB_SILENT);
1850                 noExec = TRUE;
1851         }
1852
1853         /*
1854          * If we're not supposed to execute a shell, don't.
1855          */
1856         if (noExec) {
1857                 /*
1858                  * Unlink and close the command file if we opened one
1859                  */
1860                 if (job->cmdFILE != stdout) {
1861                         if (job->cmdFILE != NULL)
1862                                 fclose(job->cmdFILE);
1863                 } else {
1864                         fflush(stdout);
1865                 }
1866
1867                 /*
1868                  * We only want to work our way up the graph if we aren't here
1869                  * because the commands for the job were no good.
1870                 */
1871                 if (cmdsOK) {
1872                         if (aborting == 0) {
1873                                 for (ln = job->tailCmds; ln != NULL;
1874                                     ln = LST_NEXT(ln)) {
1875                                         Lst_AtEnd(&postCommands->commands,
1876                                             Buf_Peel(Var_Subst(Lst_Datum(ln),
1877                                             job->node, FALSE)));
1878                                 }
1879                                 job->node->made = MADE;
1880                                 Make_Update(job->node);
1881                         }
1882                         free(job);
1883                         return(JOB_FINISHED);
1884                 } else {
1885                         free(job);
1886                         return(JOB_ERROR);
1887                 }
1888         } else {
1889                 fflush(job->cmdFILE);
1890         }
1891
1892         /*
1893          * Set up the control arguments to the shell. This is based on the flags
1894          * set earlier for this job.
1895          */
1896         JobMakeArgv(job, argv);
1897
1898         /*
1899          * If we're using pipes to catch output, create the pipe by which we'll
1900          * get the shell's output. If we're using files, print out that we're
1901          * starting a job and then set up its temporary-file name.
1902          */
1903         if (!compatMake || (job->flags & JOB_FIRST)) {
1904                 if (usePipes) {
1905                         int fd[2];
1906
1907                         if (pipe(fd) == -1)
1908                                 Punt("Cannot create pipe: %s", strerror(errno));
1909                         job->inPipe = fd[0];
1910                         job->outPipe = fd[1];
1911                         fcntl(job->inPipe, F_SETFD, 1);
1912                         fcntl(job->outPipe, F_SETFD, 1);
1913                 } else {
1914                         fprintf(stdout, "Remaking `%s'\n", gn->name);
1915                         fflush(stdout);
1916                         strcpy(job->outFile, TMPPAT);
1917                         if ((job->outFd = mkstemp(job->outFile)) == -1)
1918                                 Punt("cannot create temp file: %s",
1919                                     strerror(errno));
1920                         fcntl(job->outFd, F_SETFD, 1);
1921                 }
1922         }
1923
1924         if (nJobs >= maxJobs && !(job->flags & JOB_SPECIAL) && maxJobs != 0) {
1925                 /*
1926                  * We've hit the limit of concurrency, so put the job on hold
1927                  * until some other job finishes. Note that the special jobs
1928                  * (.BEGIN, .INTERRUPT and .END) may be run even when the
1929                  * limit has been reached (e.g. when maxJobs == 0).
1930                  */
1931                 jobFull = TRUE;
1932
1933                 DEBUGF(JOB, ("Can only run job locally.\n"));
1934                 job->flags |= JOB_RESTART;
1935                 TAILQ_INSERT_TAIL(&stoppedJobs, job, link);
1936         } else {
1937                 if (nJobs >= maxJobs) {
1938                         /*
1939                          * If we're running this job as a special case
1940                          * (see above), at least say the table is full.
1941                          */
1942                         jobFull = TRUE;
1943                         DEBUGF(JOB, ("Local job queue is full.\n"));
1944                 }
1945                 JobExec(job, argv);
1946         }
1947         return (JOB_RUNNING);
1948 }
1949
1950 static char *
1951 JobOutput(Job *job, char *cp, char *endp, int msg)
1952 {
1953         char *ecp;
1954
1955         if (commandShell->noPrint) {
1956                 ecp = strstr(cp, commandShell->noPrint);
1957                 while (ecp != NULL) {
1958                         if (cp != ecp) {
1959                                 *ecp = '\0';
1960                                 if (msg && job->node != lastNode) {
1961                                         MESSAGE(stdout, job->node);
1962                                         lastNode = job->node;
1963                                 }
1964                                 /*
1965                                  * The only way there wouldn't be a newline
1966                                  * after this line is if it were the last in
1967                                  * the buffer. However, since the non-printable
1968                                  * comes after it, there must be a newline, so
1969                                  * we don't print one.
1970                                  */
1971                                 fprintf(stdout, "%s", cp);
1972                                 fflush(stdout);
1973                         }
1974                         cp = ecp + strlen(commandShell->noPrint);
1975                         if (cp != endp) {
1976                                 /*
1977                                  * Still more to print, look again after
1978                                  * skipping the whitespace following the
1979                                  * non-printable command....
1980                                  */
1981                                 cp++;
1982                                 while (*cp == ' ' || *cp == '\t' ||
1983                                     *cp == '\n') {
1984                                         cp++;
1985                                 }
1986                                 ecp = strstr(cp, commandShell->noPrint);
1987                         } else {
1988                                 return (cp);
1989                         }
1990                 }
1991         }
1992         return (cp);
1993 }
1994
1995 /**
1996  * JobDoOutput
1997  *      This function is called at different times depending on
1998  *      whether the user has specified that output is to be collected
1999  *      via pipes or temporary files. In the former case, we are called
2000  *      whenever there is something to read on the pipe. We collect more
2001  *      output from the given job and store it in the job's outBuf. If
2002  *      this makes up a line, we print it tagged by the job's identifier,
2003  *      as necessary.
2004  *      If output has been collected in a temporary file, we open the
2005  *      file and read it line by line, transfering it to our own
2006  *      output channel until the file is empty. At which point we
2007  *      remove the temporary file.
2008  *      In both cases, however, we keep our figurative eye out for the
2009  *      'noPrint' line for the shell from which the output came. If
2010  *      we recognize a line, we don't print it. If the command is not
2011  *      alone on the line (the character after it is not \0 or \n), we
2012  *      do print whatever follows it.
2013  *
2014  * Side Effects:
2015  *      curPos may be shifted as may the contents of outBuf.
2016  */
2017 static void
2018 JobDoOutput(Job *job, Boolean finish)
2019 {
2020         Boolean gotNL = FALSE;  /* true if got a newline */
2021         Boolean fbuf;           /* true if our buffer filled up */
2022         int     nr;             /* number of bytes read */
2023         int     i;              /* auxiliary index into outBuf */
2024         int     max;            /* limit for i (end of current data) */
2025         int     nRead;          /* (Temporary) number of bytes read */
2026         FILE    *oFILE;         /* Stream pointer to shell's output file */
2027         char    inLine[132];
2028
2029         if (usePipes) {
2030                 /*
2031                  * Read as many bytes as will fit in the buffer.
2032                  */
2033   end_loop:
2034                 gotNL = FALSE;
2035                 fbuf = FALSE;
2036
2037                 nRead = read(job->inPipe, &job->outBuf[job->curPos],
2038                     JOB_BUFSIZE - job->curPos);
2039                 /*
2040                  * Check for interrupt here too, because the above read may
2041                  * block when the child process is stopped. In this case the
2042                  * interrupt will unblock it (we don't use SA_RESTART).
2043                  */
2044                 if (interrupted)
2045                         JobPassSig(interrupted);
2046
2047                 if (nRead < 0) {
2048                         DEBUGF(JOB, ("JobDoOutput(piperead)"));
2049                         nr = 0;
2050                 } else {
2051                         nr = nRead;
2052                 }
2053
2054                 /*
2055                  * If we hit the end-of-file (the job is dead), we must flush
2056                  * its remaining output, so pretend we read a newline if
2057                  * there's any output remaining in the buffer.
2058                  * Also clear the 'finish' flag so we stop looping.
2059                  */
2060                 if (nr == 0 && job->curPos != 0) {
2061                         job->outBuf[job->curPos] = '\n';
2062                         nr = 1;
2063                         finish = FALSE;
2064                 } else if (nr == 0) {
2065                         finish = FALSE;
2066                 }
2067
2068                 /*
2069                  * Look for the last newline in the bytes we just got. If there
2070                  * is one, break out of the loop with 'i' as its index and
2071                  * gotNL set TRUE.
2072                 */
2073                 max = job->curPos + nr;
2074                 for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
2075                         if (job->outBuf[i] == '\n') {
2076                                 gotNL = TRUE;
2077                                 break;
2078                         } else if (job->outBuf[i] == '\0') {
2079                                 /*
2080                                  * Why?
2081                                  */
2082                                 job->outBuf[i] = ' ';
2083                         }
2084                 }
2085
2086                 if (!gotNL) {
2087                         job->curPos += nr;
2088                         if (job->curPos == JOB_BUFSIZE) {
2089                                 /*
2090                                  * If we've run out of buffer space, we have
2091                                  * no choice but to print the stuff. sigh.
2092                                  */
2093                                 fbuf = TRUE;
2094                                 i = job->curPos;
2095                         }
2096                 }
2097                 if (gotNL || fbuf) {
2098                         /*
2099                          * Need to send the output to the screen. Null terminate
2100                          * it first, overwriting the newline character if there
2101                          * was one. So long as the line isn't one we should
2102                          * filter (according to the shell description), we print
2103                          * the line, preceded by a target banner if this target
2104                          * isn't the same as the one for which we last printed
2105                          * something. The rest of the data in the buffer are
2106                          * then shifted down to the start of the buffer and
2107                          * curPos is set accordingly.
2108                          */
2109                         job->outBuf[i] = '\0';
2110                         if (i >= job->curPos) {
2111                                 char *cp;
2112
2113                                 cp = JobOutput(job, job->outBuf,
2114                                     &job->outBuf[i], FALSE);
2115
2116                                 /*
2117                                  * There's still more in that buffer. This time,
2118                                  * though, we know there's no newline at the
2119                                  * end, so we add one of our own free will.
2120                                  */
2121                                 if (*cp != '\0') {
2122                                         if (job->node != lastNode) {
2123                                                 MESSAGE(stdout, job->node);
2124                                                 lastNode = job->node;
2125                                         }
2126                                         fprintf(stdout, "%s%s", cp,
2127                                             gotNL ? "\n" : "");
2128                                         fflush(stdout);
2129                                 }
2130                         }
2131                         if (i < max - 1) {
2132                                 /* shift the remaining characters down */
2133                                 memcpy(job->outBuf, &job->outBuf[i + 1],
2134                                     max - (i + 1));
2135                                 job->curPos = max - (i + 1);
2136
2137                         } else {
2138                                 /*
2139                                  * We have written everything out, so we just
2140                                  * start over from the start of the buffer.
2141                                  * No copying. No nothing.
2142                                  */
2143                                 job->curPos = 0;
2144                         }
2145                 }
2146                 if (finish) {
2147                         /*
2148                          * If the finish flag is true, we must loop until we hit
2149                          * end-of-file on the pipe. This is guaranteed to happen
2150                          * eventually since the other end of the pipe is now
2151                          * closed (we closed it explicitly and the child has
2152                          * exited). When we do get an EOF, finish will be set
2153                          * FALSE and we'll fall through and out.
2154                          */
2155                         goto end_loop;
2156                 }
2157
2158         } else {
2159                 /*
2160                  * We've been called to retrieve the output of the job from the
2161                  * temporary file where it's been squirreled away. This consists
2162                  * of opening the file, reading the output line by line, being
2163                  * sure not to print the noPrint line for the shell we used,
2164                  * then close and remove the temporary file. Very simple.
2165                  *
2166                  * Change to read in blocks and do FindSubString type things
2167                  * as for pipes? That would allow for "@echo -n..."
2168                  */
2169                 oFILE = fopen(job->outFile, "r");
2170                 if (oFILE != NULL) {
2171                         fprintf(stdout, "Results of making %s:\n",
2172                             job->node->name);
2173                         fflush(stdout);
2174
2175                         while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
2176                                 char    *cp, *endp, *oendp;
2177
2178                                 cp = inLine;
2179                                 oendp = endp = inLine + strlen(inLine);
2180                                 if (endp[-1] == '\n') {
2181                                         *--endp = '\0';
2182                                 }
2183                                 cp = JobOutput(job, inLine, endp, FALSE);
2184
2185                                 /*
2186                                  * There's still more in that buffer. This time,
2187                                  * though, we know there's no newline at the
2188                                  * end, so we add one of our own free will.
2189                                  */
2190                                 fprintf(stdout, "%s", cp);
2191                                 fflush(stdout);
2192                                 if (endp != oendp) {
2193                                         fprintf(stdout, "\n");
2194                                         fflush(stdout);
2195                                 }
2196                         }
2197                         fclose(oFILE);
2198                         eunlink(job->outFile);
2199                 }
2200         }
2201 }
2202
2203 /**
2204  * Job_CatchChildren
2205  *      Handle the exit of a child. Called from Make_Make.
2206  *
2207  * Side Effects:
2208  *      The job descriptor is removed from the list of children.
2209  *
2210  * Notes:
2211  *      We do waits, blocking or not, according to the wisdom of our
2212  *      caller, until there are no more children to report. For each
2213  *      job, call JobFinish to finish things off. This will take care of
2214  *      putting jobs on the stoppedJobs queue.
2215  */
2216 void
2217 Job_CatchChildren(Boolean block)
2218 {
2219         pid_t   pid;    /* pid of dead child */
2220         Job     *job;   /* job descriptor for dead child */
2221         int     status; /* Exit/termination status */
2222
2223         /*
2224          * Don't even bother if we know there's no one around.
2225          */
2226         if (nJobs == 0) {
2227                 return;
2228         }
2229
2230         for (;;) {
2231                 pid = waitpid((pid_t)-1, &status,
2232                     (block ? 0 : WNOHANG) | WUNTRACED);
2233                 if (pid <= 0)
2234                         break;
2235
2236                 DEBUGF(JOB, ("Process %jd exited or stopped.\n",
2237                     (intmax_t)pid));
2238
2239                 TAILQ_FOREACH(job, &jobs, link) {
2240                         if (job->pid == pid)
2241                                 break;
2242                 }
2243
2244                 if (job == NULL) {
2245                         if (WIFSIGNALED(status) &&
2246                             (WTERMSIG(status) == SIGCONT)) {
2247                                 TAILQ_FOREACH(job, &jobs, link) {
2248                                         if (job->pid == pid)
2249                                                 break;
2250                                 }
2251                                 if (job == NULL) {
2252                                         Error("Resumed child (%jd) "
2253                                             "not in table", (intmax_t)pid);
2254                                         continue;
2255                                 }
2256                                 TAILQ_REMOVE(&stoppedJobs, job, link);
2257                         } else {
2258                                 Error("Child (%jd) not in table?",
2259                                     (intmax_t)pid);
2260                                 continue;
2261                         }
2262                 } else {
2263                         TAILQ_REMOVE(&jobs, job, link);
2264                         nJobs -= 1;
2265                         if (fifoFd >= 0 && maxJobs > 1) {
2266                                 write(fifoFd, "+", 1);
2267                                 maxJobs--;
2268                                 if (nJobs >= maxJobs)
2269                                         jobFull = TRUE;
2270                                 else
2271                                         jobFull = FALSE;
2272                         } else {
2273                                 DEBUGF(JOB, ("Job queue is no longer full.\n"));
2274                                 jobFull = FALSE;
2275                         }
2276                 }
2277
2278                 JobFinish(job, &status);
2279         }
2280         if (interrupted)
2281                 JobPassSig(interrupted);
2282 }
2283
2284 /**
2285  * Job_CatchOutput
2286  *      Catch the output from our children, if we're using
2287  *      pipes do so. Otherwise just block time until we get a
2288  *      signal(most likely a SIGCHLD) since there's no point in
2289  *      just spinning when there's nothing to do and the reaping
2290  *      of a child can wait for a while.
2291  *
2292  * Side Effects:
2293  *      Output is read from pipes if we're piping.
2294  */
2295 void
2296 #ifdef USE_KQUEUE
2297 Job_CatchOutput(int flag __unused)
2298 #else
2299 Job_CatchOutput(int flag)
2300 #endif
2301 {
2302         int             nfds;
2303 #ifdef USE_KQUEUE
2304 #define KEV_SIZE        4
2305         struct kevent   kev[KEV_SIZE];
2306         int             i;
2307 #else
2308         struct timeval  timeout;
2309         fd_set          readfds;
2310         Job             *job;
2311 #endif
2312
2313         fflush(stdout);
2314
2315         if (usePipes) {
2316 #ifdef USE_KQUEUE
2317                 if ((nfds = kevent(kqfd, NULL, 0, kev, KEV_SIZE, NULL)) == -1) {
2318                         if (errno != EINTR)
2319                                 Punt("kevent: %s", strerror(errno));
2320                         if (interrupted)
2321                                 JobPassSig(interrupted);
2322                 } else {
2323                         for (i = 0; i < nfds; i++) {
2324                                 if (kev[i].flags & EV_ERROR) {
2325                                         warnc(kev[i].data, "kevent");
2326                                         continue;
2327                                 }
2328                                 switch (kev[i].filter) {
2329                                   case EVFILT_READ:
2330                                         JobDoOutput(kev[i].udata, FALSE);
2331                                         break;
2332                                   case EVFILT_PROC:
2333                                         /*
2334                                          * Just wake up and let
2335                                          * Job_CatchChildren() collect the
2336                                          * terminated job.
2337                                          */
2338                                         break;
2339                                 }
2340                         }
2341                 }
2342 #else
2343                 readfds = outputs;
2344                 timeout.tv_sec = SEL_SEC;
2345                 timeout.tv_usec = SEL_USEC;
2346                 if (flag && jobFull && fifoFd >= 0)
2347                         FD_SET(fifoFd, &readfds);
2348
2349                 nfds = select(FD_SETSIZE, &readfds, (fd_set *)NULL,
2350                     (fd_set *)NULL, &timeout);
2351                 if (nfds <= 0) {
2352                         if (interrupted)
2353                                 JobPassSig(interrupted);
2354                         return;
2355                 }
2356                 if (fifoFd >= 0 && FD_ISSET(fifoFd, &readfds)) {
2357                         if (--nfds <= 0)
2358                                 return;
2359                 }
2360                 job = TAILQ_FIRST(&jobs);
2361                 while (nfds != 0 && job != NULL) {
2362                         if (FD_ISSET(job->inPipe, &readfds)) {
2363                                 JobDoOutput(job, FALSE);
2364                                 nfds--;
2365                         }
2366                         job = TAILQ_NEXT(job, link);
2367                 }
2368 #endif /* !USE_KQUEUE */
2369         }
2370 }
2371
2372 /**
2373  * Job_Make
2374  *      Start the creation of a target. Basically a front-end for
2375  *      JobStart used by the Make module.
2376  *
2377  * Side Effects:
2378  *      Another job is started.
2379  */
2380 void
2381 Job_Make(GNode *gn)
2382 {
2383
2384         JobStart(gn, 0, NULL);
2385 }
2386
2387 /**
2388  * Job_Init
2389  *      Initialize the process module, given a maximum number of jobs.
2390  *
2391  * Side Effects:
2392  *      lists and counters are initialized
2393  */
2394 void
2395 Job_Init(int maxproc)
2396 {
2397         GNode           *begin; /* node for commands to do at the very start */
2398         const char      *env;
2399
2400         fifoFd = -1;
2401         env = getenv("MAKE_JOBS_FIFO");
2402
2403         if (env == NULL && maxproc > 1) {
2404                 /*
2405                  * We did not find the environment variable so we are the
2406                  * leader. Create the fifo, open it, write one char per
2407                  * allowed job into the pipe.
2408                  */
2409                 fifoFd = mkfifotemp(fifoName);
2410                 if (fifoFd < 0) {
2411                         env = NULL;
2412                 } else {
2413                         fifoMaster = 1;
2414                         fcntl(fifoFd, F_SETFL, O_NONBLOCK);
2415                         env = fifoName;
2416                         setenv("MAKE_JOBS_FIFO", env, 1);
2417                         while (maxproc-- > 0) {
2418                                 write(fifoFd, "+", 1);
2419                         }
2420                         /* The master make does not get a magic token */
2421                         jobFull = TRUE;
2422                         maxJobs = 0;
2423                 }
2424
2425         } else if (env != NULL) {
2426                 /*
2427                  * We had the environment variable so we are a slave.
2428                  * Open fifo and give ourselves a magic token which represents
2429                  * the token our parent make has grabbed to start his make
2430                  * process. Otherwise the sub-makes would gobble up tokens and
2431                  * the proper number of tokens to specify to -j would depend
2432                  * on the depth of the tree and the order of execution.
2433                  */
2434                 fifoFd = open(env, O_RDWR, 0);
2435                 if (fifoFd >= 0) {
2436                         fcntl(fifoFd, F_SETFL, O_NONBLOCK);
2437                         maxJobs = 1;
2438                         jobFull = FALSE;
2439                 }
2440         }
2441         if (fifoFd <= 0) {
2442                 maxJobs = maxproc;
2443                 jobFull = FALSE;
2444         } else {
2445         }
2446         nJobs = 0;
2447
2448         aborting = 0;
2449         errors = 0;
2450
2451         lastNode = NULL;
2452
2453         if ((maxJobs == 1 && fifoFd < 0) || beVerbose == 0) {
2454                 /*
2455                  * If only one job can run at a time, there's no need for a
2456                  * banner, no is there?
2457                  */
2458                 targFmt = "";
2459         } else {
2460                 targFmt = TARG_FMT;
2461         }
2462
2463         Proc_Setupsignals(FALSE);
2464
2465 #ifdef USE_KQUEUE
2466         if ((kqfd = kqueue()) == -1) {
2467                 Punt("kqueue: %s", strerror(errno));
2468         }
2469 #endif
2470
2471         begin = Targ_FindNode(".BEGIN", TARG_NOCREATE);
2472
2473         if (begin != NULL) {
2474                 JobStart(begin, JOB_SPECIAL, (Job *)NULL);
2475                 while (nJobs) {
2476                         Job_CatchOutput(0);
2477                         Job_CatchChildren(!usePipes);
2478                 }
2479         }
2480         postCommands = Targ_FindNode(".END", TARG_CREATE);
2481 }
2482
2483 /**
2484  * Job_Full
2485  *      See if the job table is full. It is considered full if it is OR
2486  *      if we are in the process of aborting OR if we have
2487  *      reached/exceeded our local quota. This prevents any more jobs
2488  *      from starting up.
2489  *
2490  * Results:
2491  *      TRUE if the job table is full, FALSE otherwise
2492  */
2493 Boolean
2494 Job_Full(void)
2495 {
2496         char c;
2497         int i;
2498
2499         if (aborting)
2500                 return (aborting);
2501         if (fifoFd >= 0 && jobFull) {
2502                 i = read(fifoFd, &c, 1);
2503                 if (i > 0) {
2504                         maxJobs++;
2505                         jobFull = FALSE;
2506                 }
2507         }
2508         return (jobFull);
2509 }
2510
2511 /**
2512  * Job_Empty
2513  *      See if the job table is empty.  Because the local concurrency may
2514  *      be set to 0, it is possible for the job table to become empty,
2515  *      while the list of stoppedJobs remains non-empty. In such a case,
2516  *      we want to restart as many jobs as we can.
2517  *
2518  * Results:
2519  *      TRUE if it is. FALSE if it ain't.
2520  */
2521 Boolean
2522 Job_Empty(void)
2523 {
2524         if (nJobs == 0) {
2525                 if (!TAILQ_EMPTY(&stoppedJobs) && !aborting) {
2526                         /*
2527                          * The job table is obviously not full if it has no
2528                          * jobs in it...Try and restart the stopped jobs.
2529                          */
2530                         jobFull = FALSE;
2531                         JobRestartJobs();
2532                         return (FALSE);
2533                 } else {
2534                         return (TRUE);
2535                 }
2536         } else {
2537                 return (FALSE);
2538         }
2539 }
2540
2541 /**
2542  * JobInterrupt
2543  *      Handle the receipt of an interrupt.
2544  *
2545  * Side Effects:
2546  *      All children are killed. Another job will be started if the
2547  *      .INTERRUPT target was given.
2548  */
2549 static void
2550 JobInterrupt(int runINTERRUPT, int signo)
2551 {
2552         Job     *job;           /* job descriptor in that element */
2553         GNode   *interrupt;     /* the node describing the .INTERRUPT target */
2554
2555         aborting = ABORT_INTERRUPT;
2556
2557         TAILQ_FOREACH(job, &jobs, link) {
2558                 if (!Targ_Precious(job->node)) {
2559                         char *file = (job->node->path == NULL ?
2560                             job->node->name : job->node->path);
2561
2562                         if (!noExecute && eunlink(file) != -1) {
2563                                 Error("*** %s removed", file);
2564                         }
2565                 }
2566                 if (job->pid) {
2567                         DEBUGF(JOB, ("JobInterrupt passing signal to child "
2568                             "%jd.\n", (intmax_t)job->pid));
2569                         KILL(job->pid, signo);
2570                 }
2571         }
2572
2573         if (runINTERRUPT && !touchFlag) {
2574                 /*
2575                  * clear the interrupted flag because we would get an
2576                  * infinite loop otherwise.
2577                  */
2578                 interrupted = 0;
2579
2580                 interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
2581                 if (interrupt != NULL) {
2582                         ignoreErrors = FALSE;
2583
2584                         JobStart(interrupt, JOB_IGNDOTS, (Job *)NULL);
2585                         while (nJobs) {
2586                                 Job_CatchOutput(0);
2587                                 Job_CatchChildren(!usePipes);
2588                         }
2589                 }
2590         }
2591 }
2592
2593 /**
2594  * Job_Finish
2595  *      Do final processing such as the running of the commands
2596  *      attached to the .END target.
2597  *
2598  * Results:
2599  *      Number of errors reported.
2600  */
2601 int
2602 Job_Finish(void)
2603 {
2604
2605         if (postCommands != NULL && !Lst_IsEmpty(&postCommands->commands)) {
2606                 if (errors) {
2607                         Error("Errors reported so .END ignored");
2608                 } else {
2609                         JobStart(postCommands, JOB_SPECIAL | JOB_IGNDOTS, NULL);
2610
2611                         while (nJobs) {
2612                                 Job_CatchOutput(0);
2613                                 Job_CatchChildren(!usePipes);
2614                         }
2615                 }
2616         }
2617         if (fifoFd >= 0) {
2618                 close(fifoFd);
2619                 fifoFd = -1;
2620                 if (fifoMaster)
2621                         unlink(fifoName);
2622         }
2623         return (errors);
2624 }
2625
2626 /**
2627  * Job_Wait
2628  *      Waits for all running jobs to finish and returns. Sets 'aborting'
2629  *      to ABORT_WAIT to prevent other jobs from starting.
2630  *
2631  * Side Effects:
2632  *      Currently running jobs finish.
2633  */
2634 void
2635 Job_Wait(void)
2636 {
2637
2638         aborting = ABORT_WAIT;
2639         while (nJobs != 0) {
2640                 Job_CatchOutput(0);
2641                 Job_CatchChildren(!usePipes);
2642         }
2643         aborting = 0;
2644 }
2645
2646 /**
2647  * Job_AbortAll
2648  *      Abort all currently running jobs without handling output or anything.
2649  *      This function is to be called only in the event of a major
2650  *      error. Most definitely NOT to be called from JobInterrupt.
2651  *
2652  * Side Effects:
2653  *      All children are killed, not just the firstborn
2654  */
2655 void
2656 Job_AbortAll(void)
2657 {
2658         Job     *job;   /* the job descriptor in that element */
2659         int     status;
2660
2661         aborting = ABORT_ERROR;
2662
2663         if (nJobs) {
2664                 TAILQ_FOREACH(job, &jobs, link) {
2665                         /*
2666                          * kill the child process with increasingly drastic
2667                          * signals to make darn sure it's dead.
2668                          */
2669                         KILL(job->pid, SIGINT);
2670                         KILL(job->pid, SIGKILL);
2671                 }
2672         }
2673
2674         /*
2675          * Catch as many children as want to report in at first, then give up
2676          */
2677         while (waitpid((pid_t)-1, &status, WNOHANG) > 0)
2678                 ;
2679 }
2680
2681 /**
2682  * JobRestartJobs
2683  *      Tries to restart stopped jobs if there are slots available.
2684  *      Note that this tries to restart them regardless of pending errors.
2685  *      It's not good to leave stopped jobs lying around!
2686  *
2687  * Side Effects:
2688  *      Resumes(and possibly migrates) jobs.
2689  */
2690 static void
2691 JobRestartJobs(void)
2692 {
2693         Job *job;
2694
2695         while (!jobFull && (job = TAILQ_FIRST(&stoppedJobs)) != NULL) {
2696                 DEBUGF(JOB, ("Job queue is not full. "
2697                     "Restarting a stopped job.\n"));
2698                 TAILQ_REMOVE(&stoppedJobs, job, link);
2699                 JobRestart(job);
2700         }
2701 }
2702
2703 /**
2704  * Cmd_Exec
2705  *      Execute the command in cmd, and return the output of that command
2706  *      in a string.
2707  *
2708  * Results:
2709  *      A string containing the output of the command, or the empty string
2710  *      If error is not NULL, it contains the reason for the command failure
2711  *      Any output sent to stderr in the child process is passed to stderr,
2712  *      and not captured in the string.
2713  *
2714  * Side Effects:
2715  *      The string must be freed by the caller.
2716  */
2717 Buffer *
2718 Cmd_Exec(const char *cmd, const char **error)
2719 {
2720         int     fds[2]; /* Pipe streams */
2721         int     status; /* command exit status */
2722         Buffer  *buf;   /* buffer to store the result */
2723         ssize_t rcnt;
2724         ProcStuff       ps;
2725
2726         *error = NULL;
2727         buf = Buf_Init(0);
2728
2729         /*
2730          * Open a pipe for fetching its output
2731          */
2732         if (pipe(fds) == -1) {
2733                 *error = "Couldn't create pipe for \"%s\"";
2734                 return (buf);
2735         }
2736
2737         /* Set close-on-exec on read side of pipe. */
2738         fcntl(fds[0], F_SETFD, fcntl(fds[0], F_GETFD) | FD_CLOEXEC);
2739
2740         ps.in = STDIN_FILENO;
2741         ps.out = fds[1];
2742         ps.err = STDERR_FILENO;
2743
2744         ps.merge_errors = 0;
2745         ps.pgroup = 0;
2746         ps.searchpath = 0;
2747
2748         /* Set up arguments for shell */
2749         ps.argv = emalloc(4 * sizeof(char *));
2750         ps.argv[0] = strdup(commandShell->name);
2751         ps.argv[1] = strdup("-c");
2752         ps.argv[2] = strdup(cmd);
2753         ps.argv[3] = NULL;
2754         ps.argv_free = 1;
2755
2756         /*
2757          * Fork.  Warning since we are doing vfork() instead of fork(),
2758          * do not allocate memory in the child process!
2759          */
2760         if ((ps.child_pid = vfork()) == -1) {
2761                 *error = "Couldn't exec \"%s\"";
2762
2763         } else if (ps.child_pid == 0) {
2764                 /*
2765                  * Child
2766                  */
2767                 ProcExec(&ps);
2768                 /* NOTREACHED */
2769
2770         } else {
2771                 free(ps.argv[2]);
2772                 free(ps.argv[1]);
2773                 free(ps.argv[0]);
2774                 free(ps.argv);
2775
2776                 close(fds[1]); /* No need for the writing half of the pipe. */
2777
2778                 do {
2779                         char    result[BUFSIZ];
2780
2781                         rcnt = read(fds[0], result, sizeof(result));
2782                         if (rcnt != -1)
2783                                 Buf_AddBytes(buf, (size_t)rcnt, (Byte *)result);
2784                 } while (rcnt > 0 || (rcnt == -1 && errno == EINTR));
2785
2786                 if (rcnt == -1)
2787                         *error = "Error reading shell's output for \"%s\"";
2788
2789                 /*
2790                  * Close the input side of the pipe.
2791                  */
2792                 close(fds[0]);
2793
2794                 status = ProcWait(&ps);
2795                 if (status)
2796                         *error = "\"%s\" returned non-zero status";
2797
2798                 Buf_StripNewlines(buf);
2799
2800         }
2801         return (buf);
2802 }
2803
2804 /**
2805  * CompatInterrupt
2806  *      Interrupt the creation of the current target and remove it if
2807  *      it ain't precious.
2808  *
2809  * Results:
2810  *      None.
2811  *
2812  * Side Effects:
2813  *      The target is removed and the process exits. If .INTERRUPT exists,
2814  *      its commands are run first WITH INTERRUPTS IGNORED..
2815  */
2816 static void
2817 CompatInterrupt(int signo)
2818 {
2819         GNode           *gn;
2820         sigset_t        nmask, omask;
2821         LstNode         *ln;
2822
2823         sigemptyset(&nmask);
2824         sigaddset(&nmask, SIGINT);
2825         sigaddset(&nmask, SIGTERM);
2826         sigaddset(&nmask, SIGHUP);
2827         sigaddset(&nmask, SIGQUIT);
2828         sigprocmask(SIG_SETMASK, &nmask, &omask);
2829
2830         /* prevent recursion in evaluation of .INTERRUPT */
2831         interrupted = 0;
2832
2833         if (curTarg != NULL && !Targ_Precious(curTarg)) {
2834                 const char *file = Var_Value(TARGET, curTarg);
2835
2836                 if (!noExecute && eunlink(file) != -1) {
2837                         printf("*** %s removed\n", file);
2838                 }
2839         }
2840
2841         /*
2842          * Run .INTERRUPT only if hit with interrupt signal
2843          */
2844         if (signo == SIGINT) {
2845                 gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
2846                 if (gn != NULL) {
2847                         LST_FOREACH(ln, &gn->commands) {
2848                                 if (Compat_RunCommand(Lst_Datum(ln), gn))
2849                                         break;
2850                         }
2851                 }
2852         }
2853
2854         sigprocmask(SIG_SETMASK, &omask, NULL);
2855
2856         if (signo == SIGQUIT)
2857                 exit(signo);
2858         signal(signo, SIG_DFL);
2859         kill(getpid(), signo);
2860 }
2861
2862 /**
2863  * Compat_RunCommand
2864  *      Execute the next command for a target. If the command returns an
2865  *      error, the node's made field is set to ERROR and creation stops.
2866  *      The node from which the command came is also given.
2867  *
2868  * Results:
2869  *      0 if the command succeeded, 1 if an error occurred.
2870  *
2871  * Side Effects:
2872  *      The node's 'made' field may be set to ERROR.
2873  */
2874 static int
2875 Compat_RunCommand(char *cmd, GNode *gn)
2876 {
2877         ArgArray        aa;
2878         char            *cmdStart;      /* Start of expanded command */
2879         Boolean         silent;         /* Don't print command */
2880         Boolean         doit;           /* Execute even in -n */
2881         Boolean         errCheck;       /* Check errors */
2882         int             reason;         /* Reason for child's death */
2883         int             status;         /* Description of child's death */
2884         LstNode         *cmdNode;       /* Node where current cmd is located */
2885         char            **av;           /* Argument vector for thing to exec */
2886         ProcStuff       ps;
2887
2888         silent = gn->type & OP_SILENT;
2889         errCheck = !(gn->type & OP_IGNORE);
2890         doit = FALSE;
2891
2892         cmdNode = Lst_Member(&gn->commands, cmd);
2893         cmdStart = Buf_Peel(Var_Subst(cmd, gn, FALSE));
2894
2895         if (*cmdStart == '\0') {
2896                 free(cmdStart);
2897                 Error("%s expands to empty string", cmd);
2898                 return (0);
2899         } else {
2900                 cmd = cmdStart;
2901         }
2902         Lst_Replace(cmdNode, cmdStart);
2903
2904         if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
2905                 Lst_AtEnd(&ENDNode->commands, cmdStart);
2906                 return (0);
2907         } else if (strcmp(cmdStart, "...") == 0) {
2908                 gn->type |= OP_SAVE_CMDS;
2909                 return (0);
2910         }
2911
2912         while (*cmd == '@' || *cmd == '-' || *cmd == '+') {
2913                 switch (*cmd) {
2914
2915                   case '@':
2916                         silent = DEBUG(LOUD) ? FALSE : TRUE;
2917                         break;
2918
2919                   case '-':
2920                         errCheck = FALSE;
2921                         break;
2922
2923                 case '+':
2924                         doit = TRUE;
2925                         break;
2926                 }
2927                 cmd++;
2928         }
2929
2930         while (isspace((unsigned char)*cmd))
2931                 cmd++;
2932
2933         /*
2934          * Print the command before echoing if we're not supposed to be quiet
2935          * for this one. We also print the command if -n given, but not if '+'.
2936          */
2937         if (!silent || (noExecute && !doit)) {
2938                 printf("%s\n", cmd);
2939                 fflush(stdout);
2940         }
2941
2942         /*
2943          * If we're not supposed to execute any commands, this is as far as
2944          * we go...
2945          */
2946         if (!doit && noExecute) {
2947                 return (0);
2948         }
2949
2950         if (strpbrk(cmd, "#=|^(){};&<>*?[]:$`\\\n")) {
2951                 /*
2952                  * We found a "meta" character and need to pass the command
2953                  * off to the shell.
2954                  */
2955                 av = NULL;
2956
2957         } else {
2958                 const char **p;
2959                 const char *sh_builtin[] = {
2960                         "alias", "cd", "eval", "exec",
2961                         "exit", "read", "set", "ulimit",
2962                         "unalias", "umask", "unset", "wait",
2963                         ":", NULL
2964                 };
2965
2966                 /*
2967                  * Break the command into words to form an argument
2968                  * vector we can execute.
2969                  */
2970                 brk_string(&aa, cmd, TRUE);
2971                 av = aa.argv + 1;
2972
2973                 for (p = sh_builtin; *p != 0; p++) {
2974                         if (strcmp(av[0], *p) == 0) {
2975                                 /*
2976                                  * This command must be passed by the shell
2977                                  * for other reasons.. or.. possibly not at
2978                                  * all.
2979                                  */
2980                                 av = NULL;
2981                                 break;
2982                         }
2983                 }
2984         }
2985
2986         ps.in = STDIN_FILENO;
2987         ps.out = STDOUT_FILENO;
2988         ps.err = STDERR_FILENO;
2989
2990         ps.merge_errors = 0;
2991         ps.pgroup = 0;
2992         ps.searchpath = 1;
2993
2994         if (av == NULL) {
2995                 /*
2996                  * We give the shell the -e flag as well as -c if it's
2997                  * supposed to exit when it hits an error.
2998                  */
2999                 ps.argv = emalloc(4 * sizeof(char *));
3000                 ps.argv[0] = strdup(commandShell->path);
3001                 ps.argv[1] = strdup(errCheck ? "-ec" : "-c");
3002                 ps.argv[2] = strdup(cmd);
3003                 ps.argv[3] = NULL;
3004                 ps.argv_free = 1;
3005         } else {
3006                 ps.argv = av;
3007                 ps.argv_free = 0;
3008         }
3009         ps.errCheck = errCheck;
3010
3011         /*
3012          * Fork and execute the single command. If the fork fails, we abort.
3013          * Warning since we are doing vfork() instead of fork(),
3014          * do not allocate memory in the child process!
3015          */
3016         if ((ps.child_pid = vfork()) == -1) {
3017                 Fatal("Could not fork");
3018
3019         } else if (ps.child_pid == 0) {
3020                 /*
3021                  * Child
3022                  */
3023                 ProcExec(&ps);
3024                 /* NOTREACHED */
3025
3026         } else {
3027                 if (ps.argv_free) {
3028                         free(ps.argv[2]);
3029                         free(ps.argv[1]);
3030                         free(ps.argv[0]);
3031                         free(ps.argv);
3032                 } else {
3033                         ArgArray_Done(&aa);
3034                 }
3035
3036                 /*
3037                  * we need to print out the command associated with this
3038                  * Gnode in Targ_PrintCmd from Targ_PrintGraph when debugging
3039                  * at level g2, in main(), Fatal() and DieHorribly(),
3040                  * therefore do not free it when debugging.
3041                  */
3042                 if (!DEBUG(GRAPH2)) {
3043                         free(cmdStart);
3044                 }
3045
3046                 /*
3047                  * The child is off and running. Now all we can do is wait...
3048                  */
3049                 reason = ProcWait(&ps);
3050
3051                 if (interrupted)
3052                         CompatInterrupt(interrupted);
3053
3054                 /*
3055                  * Decode and report the reason child exited, then
3056                  * indicate how we handled it.
3057                  */
3058                 if (WIFEXITED(reason)) {
3059                         status = WEXITSTATUS(reason);
3060                         if (status == 0) {
3061                                 return (0);
3062                         } else {
3063                                 printf("*** Error code %d", status);
3064                         }
3065                 } else if (WIFSTOPPED(reason)) {
3066                         status = WSTOPSIG(reason);
3067                 } else {
3068                         status = WTERMSIG(reason);
3069                         printf("*** Signal %d", status);
3070                 }
3071
3072                 if (ps.errCheck) {
3073                         gn->made = ERROR;
3074                         if (keepgoing) {
3075                                 /*
3076                                  * Abort the current
3077                                  * target, but let
3078                                  * others continue.
3079                                  */
3080                                 printf(" (continuing)\n");
3081                         }
3082                         return (status);
3083                 } else {
3084                         /*
3085                          * Continue executing
3086                          * commands for this target.
3087                          * If we return 0, this will
3088                          * happen...
3089                          */
3090                         printf(" (ignored)\n");
3091                         return (0);
3092                 }
3093         }
3094 }
3095
3096 /**
3097  * CompatMake
3098  *      Make a target, given the parent, to abort if necessary.
3099  *
3100  * Side Effects:
3101  *      If an error is detected and not being ignored, the process exits.
3102  */
3103 static int
3104 CompatMake(GNode *gn, GNode *pgn)
3105 {
3106         LstNode *ln;
3107
3108         if (gn->type & OP_USE) {
3109                 Make_HandleUse(gn, pgn);
3110
3111         } else if (gn->made == UNMADE) {
3112                 /*
3113                  * First mark ourselves to be made, then apply whatever
3114                  * transformations the suffix module thinks are necessary.
3115                  * Once that's done, we can descend and make all our children.
3116                  * If any of them has an error but the -k flag was given, our
3117                  * 'make' field will be set FALSE again. This is our signal to
3118                  * not attempt to do anything but abort our parent as well.
3119                  */
3120                 gn->make = TRUE;
3121                 gn->made = BEINGMADE;
3122                 Suff_FindDeps(gn);
3123                 LST_FOREACH(ln, &gn->children)
3124                         CompatMake(Lst_Datum(ln), gn);
3125                 if (!gn->make) {
3126                         gn->made = ABORTED;
3127                         pgn->make = FALSE;
3128                         return (0);
3129                 }
3130
3131                 if (Lst_Member(&gn->iParents, pgn) != NULL) {
3132                         Var_Set(IMPSRC, Var_Value(TARGET, gn), pgn);
3133                 }
3134
3135                 /*
3136                  * All the children were made ok. Now cmtime contains the
3137                  * modification time of the newest child, we need to find out
3138                  * if we exist and when we were modified last. The criteria for
3139                  * datedness are defined by the Make_OODate function.
3140                  */
3141                 DEBUGF(MAKE, ("Examining %s...", gn->name));
3142                 if (!Make_OODate(gn)) {
3143                         gn->made = UPTODATE;
3144                         DEBUGF(MAKE, ("up-to-date.\n"));
3145                         return (0);
3146                 } else {
3147                         DEBUGF(MAKE, ("out-of-date.\n"));
3148                 }
3149
3150                 /*
3151                  * If the user is just seeing if something is out-of-date,
3152                  * exit now to tell him/her "yes".
3153                  */
3154                 if (queryFlag) {
3155                         exit(1);
3156                 }
3157
3158                 /*
3159                  * We need to be re-made. We also have to make sure we've got
3160                  * a $? variable. To be nice, we also define the $> variable
3161                  * using Make_DoAllVar().
3162                  */
3163                 Make_DoAllVar(gn);
3164
3165                 /*
3166                  * Alter our type to tell if errors should be ignored or things
3167                  * should not be printed so Compat_RunCommand knows what to do.
3168                  */
3169                 if (Targ_Ignore(gn)) {
3170                         gn->type |= OP_IGNORE;
3171                 }
3172                 if (Targ_Silent(gn)) {
3173                         gn->type |= OP_SILENT;
3174                 }
3175
3176                 if (Job_CheckCommands(gn, Fatal)) {
3177                         /*
3178                          * Our commands are ok, but we still have to worry
3179                          * about the -t flag...
3180                          */
3181                         if (!touchFlag) {
3182                                 curTarg = gn;
3183                                 LST_FOREACH(ln, &gn->commands) {
3184                                         if (Compat_RunCommand(Lst_Datum(ln),
3185                                             gn))
3186                                                 break;
3187                                 }
3188                                 curTarg = NULL;
3189                         } else {
3190                                 Job_Touch(gn, gn->type & OP_SILENT);
3191                         }
3192                 } else {
3193                         gn->made = ERROR;
3194                 }
3195
3196                 if (gn->made != ERROR) {
3197                         /*
3198                          * If the node was made successfully, mark it so, update
3199                          * its modification time and timestamp all its parents.
3200                          * Note that for .ZEROTIME targets, the timestamping
3201                          * isn't done. This is to keep its state from affecting
3202                          * that of its parent.
3203                          */
3204                         gn->made = MADE;
3205 #ifndef RECHECK
3206                         /*
3207                          * We can't re-stat the thing, but we can at least take
3208                          * care of rules where a target depends on a source that
3209                          * actually creates the target, but only if it has
3210                          * changed, e.g.
3211                          *
3212                          * parse.h : parse.o
3213                          *
3214                          * parse.o : parse.y
3215                          *      yacc -d parse.y
3216                          *      cc -c y.tab.c
3217                          *      mv y.tab.o parse.o
3218                          *      cmp -s y.tab.h parse.h || mv y.tab.h parse.h
3219                          *
3220                          * In this case, if the definitions produced by yacc
3221                          * haven't changed from before, parse.h won't have been
3222                          * updated and gn->mtime will reflect the current
3223                          * modification time for parse.h. This is something of a
3224                          * kludge, I admit, but it's a useful one..
3225                          *
3226                          * XXX: People like to use a rule like
3227                          *
3228                          * FRC:
3229                          *
3230                          * To force things that depend on FRC to be made, so we
3231                          * have to check for gn->children being empty as well...
3232                          */
3233                         if (!Lst_IsEmpty(&gn->commands) ||
3234                             Lst_IsEmpty(&gn->children)) {
3235                                 gn->mtime = now;
3236                         }
3237 #else
3238                         /*
3239                          * This is what Make does and it's actually a good
3240                          * thing, as it allows rules like
3241                          *
3242                          *      cmp -s y.tab.h parse.h || cp y.tab.h parse.h
3243                          *
3244                          * to function as intended. Unfortunately, thanks to
3245                          * the stateless nature of NFS (and the speed of this
3246                          * program), there are times when the modification time
3247                          * of a file created on a remote machine will not be
3248                          * modified before the stat() implied by the Dir_MTime
3249                          * occurs, thus leading us to believe that the file
3250                          * is unchanged, wreaking havoc with files that depend
3251                          * on this one.
3252                          *
3253                          * I have decided it is better to make too much than to
3254                          * make too little, so this stuff is commented out
3255                          * unless you're sure it's ok.
3256                          * -- ardeb 1/12/88
3257                          */
3258                         if (noExecute || Dir_MTime(gn) == 0) {
3259                                 gn->mtime = now;
3260                         }
3261                         if (gn->cmtime > gn->mtime)
3262                                 gn->mtime = gn->cmtime;
3263                         DEBUGF(MAKE, ("update time: %s\n",
3264                             Targ_FmtTime(gn->mtime)));
3265 #endif
3266                         if (!(gn->type & OP_EXEC)) {
3267                                 pgn->childMade = TRUE;
3268                                 Make_TimeStamp(pgn, gn);
3269                         }
3270
3271                 } else if (keepgoing) {
3272                         pgn->make = FALSE;
3273
3274                 } else {
3275                         printf("\n\nStop in %s.\n", Var_Value(".CURDIR", gn));
3276                         exit(1);
3277                 }
3278         } else if (gn->made == ERROR) {
3279                 /*
3280                  * Already had an error when making this beastie. Tell the
3281                  * parent to abort.
3282                  */
3283                 pgn->make = FALSE;
3284         } else {
3285                 if (Lst_Member(&gn->iParents, pgn) != NULL) {
3286                         Var_Set(IMPSRC, Var_Value(TARGET, gn), pgn);
3287                 }
3288                 switch(gn->made) {
3289                   case BEINGMADE:
3290                         Error("Graph cycles through %s\n", gn->name);
3291                         gn->made = ERROR;
3292                         pgn->make = FALSE;
3293                         break;
3294                   case MADE:
3295                         if ((gn->type & OP_EXEC) == 0) {
3296                             pgn->childMade = TRUE;
3297                             Make_TimeStamp(pgn, gn);
3298                         }
3299                         break;
3300                   case UPTODATE:
3301                         if ((gn->type & OP_EXEC) == 0) {
3302                             Make_TimeStamp(pgn, gn);
3303                         }
3304                         break;
3305                   default:
3306                         break;
3307                 }
3308         }
3309
3310         return (0);
3311 }
3312
3313 /**
3314  * Compat_Run
3315  *      Start making again, given a list of target nodes.
3316  *
3317  * Results:
3318  *      None.
3319  *
3320  * Side Effects:
3321  *      Guess what?
3322  */
3323 void
3324 Compat_Run(Lst *targs)
3325 {
3326         GNode   *gn = NULL;     /* Current root target */
3327         int     error_cnt;      /* Number of targets not remade due to errors */
3328         LstNode *ln;
3329
3330         Proc_Setupsignals(TRUE);
3331
3332         ENDNode = Targ_FindNode(".END", TARG_CREATE);
3333         /*
3334          * If the user has defined a .BEGIN target, execute the commands
3335          * attached to it.
3336         */
3337         if (!queryFlag) {
3338                 gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
3339                 if (gn != NULL) {
3340                         LST_FOREACH(ln, &gn->commands) {
3341                                 if (Compat_RunCommand(Lst_Datum(ln), gn))
3342                                         break;
3343                         }
3344                         if (gn->made == ERROR) {
3345                                 printf("\n\nStop.\n");
3346                                 exit(1);
3347                         }
3348                 }
3349         }
3350
3351         /*
3352          * For each entry in the list of targets to create, call CompatMake on
3353          * it to create the thing. CompatMake will leave the 'made' field of gn
3354          * in one of several states:
3355          *      UPTODATE  gn was already up-to-date
3356          *      MADE      gn was recreated successfully
3357          *      ERROR     An error occurred while gn was being created
3358          *      ABORTED   gn was not remade because one of its inferiors
3359          *                could not be made due to errors.
3360          */
3361         error_cnt = 0;
3362         while (!Lst_IsEmpty(targs)) {
3363                 gn = Lst_DeQueue(targs);
3364                 CompatMake(gn, gn);
3365
3366                 if (gn->made == UPTODATE) {
3367                         printf("`%s' is up to date.\n", gn->name);
3368                 } else if (gn->made == ABORTED) {
3369                         printf("`%s' not remade because of errors.\n",
3370                             gn->name);
3371                         error_cnt += 1;
3372                 }
3373         }
3374
3375         /*
3376          * If the user has defined a .END target, run its commands.
3377          */
3378         if (error_cnt == 0) {
3379                 LST_FOREACH(ln, &ENDNode->commands) {
3380                         if (Compat_RunCommand(Lst_Datum(ln), gn))
3381                                 break;
3382                 }
3383         }
3384 }
3385