usr.bin/make/job.c

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