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