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