1/*      $NetBSD: meta.c,v 1.68 2017/07/09 04:54:00 sjg Exp $ */
2
3/*
4 * Implement 'meta' mode.
5 * Adapted from John Birrell's patches to FreeBSD make.
6 * --sjg
7 */
8/*
9 * Copyright (c) 2009-2016, Juniper Networks, Inc.
10 * Portions Copyright (c) 2009, John Birrell.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33#if defined(USE_META)
34
35#ifdef HAVE_CONFIG_H
36# include "config.h"
37#endif
38#include <sys/stat.h>
39#include <sys/ioctl.h>
40#ifdef HAVE_LIBGEN_H
41#include <libgen.h>
42#elif !defined(HAVE_DIRNAME)
43char * dirname(char *);
44#endif
45#include <errno.h>
46#if !defined(HAVE_CONFIG_H) || defined(HAVE_ERR_H)
47#include <err.h>
48#endif
49
50#include "make.h"
51#include "job.h"
52
53#ifdef HAVE_FILEMON_H
54# include <filemon.h>
55#endif
56#if !defined(USE_FILEMON) && defined(FILEMON_SET_FD)
57# define USE_FILEMON
58#endif
59
60static BuildMon Mybm;			/* for compat */
61static Lst metaBailiwick;		/* our scope of control */
62static char *metaBailiwickStr;		/* string storage for the list */
63static Lst metaIgnorePaths;		/* paths we deliberately ignore */
64static char *metaIgnorePathsStr;	/* string storage for the list */
65
66#ifndef MAKE_META_IGNORE_PATHS
67#define MAKE_META_IGNORE_PATHS ".MAKE.META.IGNORE_PATHS"
68#endif
69#ifndef MAKE_META_IGNORE_PATTERNS
70#define MAKE_META_IGNORE_PATTERNS ".MAKE.META.IGNORE_PATTERNS"
71#endif
72#ifndef MAKE_META_IGNORE_FILTER
73#define MAKE_META_IGNORE_FILTER ".MAKE.META.IGNORE_FILTER"
74#endif
75
76Boolean useMeta = FALSE;
77static Boolean useFilemon = FALSE;
78static Boolean writeMeta = FALSE;
79static Boolean metaMissing = FALSE;	/* oodate if missing */
80static Boolean filemonMissing = FALSE;	/* oodate if missing */
81static Boolean metaEnv = FALSE;		/* don't save env unless asked */
82static Boolean metaVerbose = FALSE;
83static Boolean metaIgnoreCMDs = FALSE;	/* ignore CMDs in .meta files */
84static Boolean metaIgnorePatterns = FALSE; /* do we need to do pattern matches */
85static Boolean metaIgnoreFilter = FALSE;   /* do we have more complex filtering? */
86static Boolean metaCurdirOk = FALSE;	/* write .meta in .CURDIR Ok? */
87static Boolean metaSilent = FALSE;	/* if we have a .meta be SILENT */
88
89extern Boolean forceJobs;
90extern Boolean comatMake;
91extern char    **environ;
92
93#define	MAKE_META_PREFIX	".MAKE.META.PREFIX"
94
95#ifndef N2U
96# define N2U(n, u)   (((n) + ((u) - 1)) / (u))
97#endif
98#ifndef ROUNDUP
99# define ROUNDUP(n, u)   (N2U((n), (u)) * (u))
100#endif
101
102#if !defined(HAVE_STRSEP)
103# define strsep(s, d) stresep((s), (d), 0)
104#endif
105
106/*
107 * Filemon is a kernel module which snoops certain syscalls.
108 *
109 * C chdir
110 * E exec
111 * F [v]fork
112 * L [sym]link
113 * M rename
114 * R read
115 * W write
116 * S stat
117 *
118 * See meta_oodate below - we mainly care about 'E' and 'R'.
119 *
120 * We can still use meta mode without filemon, but
121 * the benefits are more limited.
122 */
123#ifdef USE_FILEMON
124# ifndef _PATH_FILEMON
125#   define _PATH_FILEMON "/dev/filemon"
126# endif
127
128/*
129 * Open the filemon device.
130 */
131static void
132filemon_open(BuildMon *pbm)
133{
134    int retry;
135
136    pbm->mon_fd = pbm->filemon_fd = -1;
137    if (!useFilemon)
138	return;
139
140    for (retry = 5; retry >= 0; retry--) {
141	if ((pbm->filemon_fd = open(_PATH_FILEMON, O_RDWR)) >= 0)
142	    break;
143    }
144
145    if (pbm->filemon_fd < 0) {
146	useFilemon = FALSE;
147	warn("Could not open %s", _PATH_FILEMON);
148	return;
149    }
150
151    /*
152     * We use a file outside of '.'
153     * to avoid a FreeBSD kernel bug where unlink invalidates
154     * cwd causing getcwd to do a lot more work.
155     * We only care about the descriptor.
156     */
157    pbm->mon_fd = mkTempFile("filemon.XXXXXX", NULL);
158    if (ioctl(pbm->filemon_fd, FILEMON_SET_FD, &pbm->mon_fd) < 0) {
159	err(1, "Could not set filemon file descriptor!");
160    }
161    /* we don't need these once we exec */
162    (void)fcntl(pbm->mon_fd, F_SETFD, FD_CLOEXEC);
163    (void)fcntl(pbm->filemon_fd, F_SETFD, FD_CLOEXEC);
164}
165
166/*
167 * Read the build monitor output file and write records to the target's
168 * metadata file.
169 */
170static int
171filemon_read(FILE *mfp, int fd)
172{
173    char buf[BUFSIZ];
174    int n;
175    int error;
176
177    /* Check if we're not writing to a meta data file.*/
178    if (mfp == NULL) {
179	if (fd >= 0)
180	    close(fd);			/* not interested */
181	return 0;
182    }
183    /* rewind */
184    (void)lseek(fd, (off_t)0, SEEK_SET);
185
186    error = 0;
187    fprintf(mfp, "\n-- filemon acquired metadata --\n");
188
189    while ((n = read(fd, buf, sizeof(buf))) > 0) {
190	if ((int)fwrite(buf, 1, n, mfp) < n)
191	    error = EIO;
192    }
193    fflush(mfp);
194    if (close(fd) < 0)
195	error = errno;
196    return error;
197}
198#endif
199
200/*
201 * when realpath() fails,
202 * we use this, to clean up ./ and ../
203 */
204static void
205eat_dots(char *buf, size_t bufsz, int dots)
206{
207    char *cp;
208    char *cp2;
209    const char *eat;
210    size_t eatlen;
211
212    switch (dots) {
213    case 1:
214	eat = "/./";
215	eatlen = 2;
216	break;
217    case 2:
218	eat = "/../";
219	eatlen = 3;
220	break;
221    default:
222	return;
223    }
224
225    do {
226	cp = strstr(buf, eat);
227	if (cp) {
228	    cp2 = cp + eatlen;
229	    if (dots == 2 && cp > buf) {
230		do {
231		    cp--;
232		} while (cp > buf && *cp != '/');
233	    }
234	    if (*cp == '/') {
235		strlcpy(cp, cp2, bufsz - (cp - buf));
236	    } else {
237		return;			/* can't happen? */
238	    }
239	}
240    } while (cp);
241}
242
243static char *
244meta_name(char *mname, size_t mnamelen,
245	  const char *dname,
246	  const char *tname,
247	  const char *cwd)
248{
249    char buf[MAXPATHLEN];
250    char *rp;
251    char *cp;
252    char *tp;
253
254    /*
255     * Weed out relative paths from the target file name.
256     * We have to be careful though since if target is a
257     * symlink, the result will be unstable.
258     * So we use realpath() just to get the dirname, and leave the
259     * basename as given to us.
260     */
261    if ((cp = strrchr(tname, '/'))) {
262	if (cached_realpath(tname, buf)) {
263	    if ((rp = strrchr(buf, '/'))) {
264		rp++;
265		cp++;
266		if (strcmp(cp, rp) != 0)
267		    strlcpy(rp, cp, sizeof(buf) - (rp - buf));
268	    }
269	    tname = buf;
270	} else {
271	    /*
272	     * We likely have a directory which is about to be made.
273	     * We pretend realpath() succeeded, to have a chance
274	     * of generating the same meta file name that we will
275	     * next time through.
276	     */
277	    if (tname[0] == '/') {
278		strlcpy(buf, tname, sizeof(buf));
279	    } else {
280		snprintf(buf, sizeof(buf), "%s/%s", cwd, tname);
281	    }
282	    eat_dots(buf, sizeof(buf), 1);	/* ./ */
283	    eat_dots(buf, sizeof(buf), 2);	/* ../ */
284	    tname = buf;
285	}
286    }
287    /* on some systems dirname may modify its arg */
288    tp = bmake_strdup(tname);
289    if (strcmp(dname, dirname(tp)) == 0)
290	snprintf(mname, mnamelen, "%s.meta", tname);
291    else {
292	snprintf(mname, mnamelen, "%s/%s.meta", dname, tname);
293
294	/*
295	 * Replace path separators in the file name after the
296	 * current object directory path.
297	 */
298	cp = mname + strlen(dname) + 1;
299
300	while (*cp != '\0') {
301	    if (*cp == '/')
302		*cp = '_';
303	    cp++;
304	}
305    }
306    free(tp);
307    return (mname);
308}
309
310/*
311 * Return true if running ${.MAKE}
312 * Bypassed if target is flagged .MAKE
313 */
314static int
315is_submake(void *cmdp, void *gnp)
316{
317    static char *p_make = NULL;
318    static int p_len;
319    char  *cmd = cmdp;
320    GNode *gn = gnp;
321    char *mp = NULL;
322    char *cp;
323    char *cp2;
324    int rc = 0;				/* keep looking */
325
326    if (!p_make) {
327	p_make = Var_Value(".MAKE", gn, &cp);
328	p_len = strlen(p_make);
329    }
330    cp = strchr(cmd, '$');
331    if ((cp)) {
332	mp = Var_Subst(NULL, cmd, gn, VARF_WANTRES);
333	cmd = mp;
334    }
335    cp2 = strstr(cmd, p_make);
336    if ((cp2)) {
337	switch (cp2[p_len]) {
338	case '\0':
339	case ' ':
340	case '\t':
341	case '\n':
342	    rc = 1;
343	    break;
344	}
345	if (cp2 > cmd && rc > 0) {
346	    switch (cp2[-1]) {
347	    case ' ':
348	    case '\t':
349	    case '\n':
350		break;
351	    default:
352		rc = 0;			/* no match */
353		break;
354	    }
355	}
356    }
357    free(mp);
358    return (rc);
359}
360
361typedef struct meta_file_s {
362    FILE *fp;
363    GNode *gn;
364} meta_file_t;
365
366static int
367printCMD(void *cmdp, void *mfpp)
368{
369    meta_file_t *mfp = mfpp;
370    char *cmd = cmdp;
371    char *cp = NULL;
372
373    if (strchr(cmd, '$')) {
374	cmd = cp = Var_Subst(NULL, cmd, mfp->gn, VARF_WANTRES);
375    }
376    fprintf(mfp->fp, "CMD %s\n", cmd);
377    free(cp);
378    return 0;
379}
380
381/*
382 * Certain node types never get a .meta file
383 */
384#define SKIP_META_TYPE(_type) do { \
385    if ((gn->type & __CONCAT(OP_, _type))) {	\
386	if (verbose) { \
387	    fprintf(debug_file, "Skipping meta for %s: .%s\n", \
388		    gn->name, __STRING(_type));		       \
389	} \
390	return FALSE; \
391    } \
392} while (0)
393
394
395/*
396 * Do we need/want a .meta file ?
397 */
398static Boolean
399meta_needed(GNode *gn, const char *dname,
400	     char *objdir, int verbose)
401{
402    struct stat fs;
403
404    if (verbose)
405	verbose = DEBUG(META);
406
407    /* This may be a phony node which we don't want meta data for... */
408    /* Skip .meta for .BEGIN, .END, .ERROR etc as well. */
409    /* Or it may be explicitly flagged as .NOMETA */
410    SKIP_META_TYPE(NOMETA);
411    /* Unless it is explicitly flagged as .META */
412    if (!(gn->type & OP_META)) {
413	SKIP_META_TYPE(PHONY);
414	SKIP_META_TYPE(SPECIAL);
415	SKIP_META_TYPE(MAKE);
416    }
417
418    /* Check if there are no commands to execute. */
419    if (Lst_IsEmpty(gn->commands)) {
420	if (verbose)
421	    fprintf(debug_file, "Skipping meta for %s: no commands\n",
422		    gn->name);
423	return FALSE;
424    }
425    if ((gn->type & (OP_META|OP_SUBMAKE)) == OP_SUBMAKE) {
426	/* OP_SUBMAKE is a bit too aggressive */
427	if (Lst_ForEach(gn->commands, is_submake, gn)) {
428	    if (DEBUG(META))
429		fprintf(debug_file, "Skipping meta for %s: .SUBMAKE\n",
430			gn->name);
431	    return FALSE;
432	}
433    }
434
435    /* The object directory may not exist. Check it.. */
436    if (cached_stat(dname, &fs) != 0) {
437	if (verbose)
438	    fprintf(debug_file, "Skipping meta for %s: no .OBJDIR\n",
439		    gn->name);
440	return FALSE;
441    }
442
443    /* make sure these are canonical */
444    if (cached_realpath(dname, objdir))
445	dname = objdir;
446
447    /* If we aren't in the object directory, don't create a meta file. */
448    if (!metaCurdirOk && strcmp(curdir, dname) == 0) {
449	if (verbose)
450	    fprintf(debug_file, "Skipping meta for %s: .OBJDIR == .CURDIR\n",
451		    gn->name);
452	return FALSE;
453    }
454    return TRUE;
455}
456
457
458static FILE *
459meta_create(BuildMon *pbm, GNode *gn)
460{
461    meta_file_t mf;
462    char buf[MAXPATHLEN];
463    char objdir[MAXPATHLEN];
464    char **ptr;
465    const char *dname;
466    const char *tname;
467    char *fname;
468    const char *cp;
469    char *p[4];				/* >= possible uses */
470    int i;
471
472    mf.fp = NULL;
473    i = 0;
474
475    dname = Var_Value(".OBJDIR", gn, &p[i++]);
476    tname = Var_Value(TARGET, gn, &p[i++]);
477
478    /* if this succeeds objdir is realpath of dname */
479    if (!meta_needed(gn, dname, objdir, TRUE))
480	goto out;
481    dname = objdir;
482
483    if (metaVerbose) {
484	char *mp;
485
486	/* Describe the target we are building */
487	mp = Var_Subst(NULL, "${" MAKE_META_PREFIX "}", gn, VARF_WANTRES);
488	if (*mp)
489	    fprintf(stdout, "%s\n", mp);
490	free(mp);
491    }
492    /* Get the basename of the target */
493    if ((cp = strrchr(tname, '/')) == NULL) {
494	cp = tname;
495    } else {
496	cp++;
497    }
498
499    fflush(stdout);
500
501    if (!writeMeta)
502	/* Don't create meta data. */
503	goto out;
504
505    fname = meta_name(pbm->meta_fname, sizeof(pbm->meta_fname),
506		      dname, tname, objdir);
507
508#ifdef DEBUG_META_MODE
509    if (DEBUG(META))
510	fprintf(debug_file, "meta_create: %s\n", fname);
511#endif
512
513    if ((mf.fp = fopen(fname, "w")) == NULL)
514	err(1, "Could not open meta file '%s'", fname);
515
516    fprintf(mf.fp, "# Meta data file %s\n", fname);
517
518    mf.gn = gn;
519
520    Lst_ForEach(gn->commands, printCMD, &mf);
521
522    fprintf(mf.fp, "CWD %s\n", getcwd(buf, sizeof(buf)));
523    fprintf(mf.fp, "TARGET %s\n", tname);
524
525    if (metaEnv) {
526	for (ptr = environ; *ptr != NULL; ptr++)
527	    fprintf(mf.fp, "ENV %s\n", *ptr);
528    }
529
530    fprintf(mf.fp, "-- command output --\n");
531    fflush(mf.fp);
532
533    Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
534    Var_Append(".MAKE.META.CREATED", fname, VAR_GLOBAL);
535
536    gn->type |= OP_META;		/* in case anyone wants to know */
537    if (metaSilent) {
538	    gn->type |= OP_SILENT;
539    }
540 out:
541    for (i--; i >= 0; i--) {
542	free(p[i]);
543    }
544
545    return (mf.fp);
546}
547
548static Boolean
549boolValue(char *s)
550{
551    switch(*s) {
552    case '0':
553    case 'N':
554    case 'n':
555    case 'F':
556    case 'f':
557	return FALSE;
558    }
559    return TRUE;
560}
561
562/*
563 * Initialization we need before reading makefiles.
564 */
565void
566meta_init(void)
567{
568#ifdef USE_FILEMON
569	/* this allows makefiles to test if we have filemon support */
570	Var_Set(".MAKE.PATH_FILEMON", _PATH_FILEMON, VAR_GLOBAL, 0);
571#endif
572}
573
574
575#define get_mode_bf(bf, token) \
576    if ((cp = strstr(make_mode, token))) \
577	bf = boolValue(&cp[sizeof(token) - 1])
578
579/*
580 * Initialization we need after reading makefiles.
581 */
582void
583meta_mode_init(const char *make_mode)
584{
585    static int once = 0;
586    char *cp;
587
588    useMeta = TRUE;
589    useFilemon = TRUE;
590    writeMeta = TRUE;
591
592    if (make_mode) {
593	if (strstr(make_mode, "env"))
594	    metaEnv = TRUE;
595	if (strstr(make_mode, "verb"))
596	    metaVerbose = TRUE;
597	if (strstr(make_mode, "read"))
598	    writeMeta = FALSE;
599	if (strstr(make_mode, "nofilemon"))
600	    useFilemon = FALSE;
601	if (strstr(make_mode, "ignore-cmd"))
602	    metaIgnoreCMDs = TRUE;
603	if (useFilemon)
604	    get_mode_bf(filemonMissing, "missing-filemon=");
605	get_mode_bf(metaCurdirOk, "curdirok=");
606	get_mode_bf(metaMissing, "missing-meta=");
607	get_mode_bf(metaSilent, "silent=");
608    }
609    if (metaVerbose && !Var_Exists(MAKE_META_PREFIX, VAR_GLOBAL)) {
610	/*
611	 * The default value for MAKE_META_PREFIX
612	 * prints the absolute path of the target.
613	 * This works be cause :H will generate '.' if there is no /
614	 * and :tA will resolve that to cwd.
615	 */
616	Var_Set(MAKE_META_PREFIX, "Building ${.TARGET:H:tA}/${.TARGET:T}", VAR_GLOBAL, 0);
617    }
618    if (once)
619	return;
620    once = 1;
621    memset(&Mybm, 0, sizeof(Mybm));
622    /*
623     * We consider ourselves master of all within ${.MAKE.META.BAILIWICK}
624     */
625    metaBailiwick = Lst_Init(FALSE);
626    metaBailiwickStr = Var_Subst(NULL, "${.MAKE.META.BAILIWICK:O:u:tA}",
627	VAR_GLOBAL, VARF_WANTRES);
628    if (metaBailiwickStr) {
629	str2Lst_Append(metaBailiwick, metaBailiwickStr, NULL);
630    }
631    /*
632     * We ignore any paths that start with ${.MAKE.META.IGNORE_PATHS}
633     */
634    metaIgnorePaths = Lst_Init(FALSE);
635    Var_Append(MAKE_META_IGNORE_PATHS,
636	       "/dev /etc /proc /tmp /var/run /var/tmp ${TMPDIR}", VAR_GLOBAL);
637    metaIgnorePathsStr = Var_Subst(NULL,
638		   "${" MAKE_META_IGNORE_PATHS ":O:u:tA}", VAR_GLOBAL,
639		   VARF_WANTRES);
640    if (metaIgnorePathsStr) {
641	str2Lst_Append(metaIgnorePaths, metaIgnorePathsStr, NULL);
642    }
643
644    /*
645     * We ignore any paths that match ${.MAKE.META.IGNORE_PATTERNS}
646     */
647    cp = NULL;
648    if (Var_Value(MAKE_META_IGNORE_PATTERNS, VAR_GLOBAL, &cp)) {
649	metaIgnorePatterns = TRUE;
650	free(cp);
651    }
652    cp = NULL;
653    if (Var_Value(MAKE_META_IGNORE_FILTER, VAR_GLOBAL, &cp)) {
654	metaIgnoreFilter = TRUE;
655	free(cp);
656    }
657}
658
659/*
660 * In each case below we allow for job==NULL
661 */
662void
663meta_job_start(Job *job, GNode *gn)
664{
665    BuildMon *pbm;
666
667    if (job != NULL) {
668	pbm = &job->bm;
669    } else {
670	pbm = &Mybm;
671    }
672    pbm->mfp = meta_create(pbm, gn);
673#ifdef USE_FILEMON_ONCE
674    /* compat mode we open the filemon dev once per command */
675    if (job == NULL)
676	return;
677#endif
678#ifdef USE_FILEMON
679    if (pbm->mfp != NULL && useFilemon) {
680	filemon_open(pbm);
681    } else {
682	pbm->mon_fd = pbm->filemon_fd = -1;
683    }
684#endif
685}
686
687/*
688 * The child calls this before doing anything.
689 * It does not disturb our state.
690 */
691void
692meta_job_child(Job *job)
693{
694#ifdef USE_FILEMON
695    BuildMon *pbm;
696
697    if (job != NULL) {
698	pbm = &job->bm;
699    } else {
700	pbm = &Mybm;
701    }
702    if (pbm->mfp != NULL) {
703	close(fileno(pbm->mfp));
704	if (useFilemon) {
705	    pid_t pid;
706
707	    pid = getpid();
708	    if (ioctl(pbm->filemon_fd, FILEMON_SET_PID, &pid) < 0) {
709		err(1, "Could not set filemon pid!");
710	    }
711	}
712    }
713#endif
714}
715
716void
717meta_job_error(Job *job, GNode *gn, int flags, int status)
718{
719    char cwd[MAXPATHLEN];
720    BuildMon *pbm;
721
722    if (job != NULL) {
723	pbm = &job->bm;
724	if (!gn)
725	    gn = job->node;
726    } else {
727	pbm = &Mybm;
728    }
729    if (pbm->mfp != NULL) {
730	fprintf(pbm->mfp, "\n*** Error code %d%s\n",
731		status,
732		(flags & JOB_IGNERR) ?
733		"(ignored)" : "");
734    }
735    if (gn) {
736	Var_Set(".ERROR_TARGET", gn->path ? gn->path : gn->name, VAR_GLOBAL, 0);
737    }
738    getcwd(cwd, sizeof(cwd));
739    Var_Set(".ERROR_CWD", cwd, VAR_GLOBAL, 0);
740    if (pbm->meta_fname[0]) {
741	Var_Set(".ERROR_META_FILE", pbm->meta_fname, VAR_GLOBAL, 0);
742    }
743    meta_job_finish(job);
744}
745
746void
747meta_job_output(Job *job, char *cp, const char *nl)
748{
749    BuildMon *pbm;
750
751    if (job != NULL) {
752	pbm = &job->bm;
753    } else {
754	pbm = &Mybm;
755    }
756    if (pbm->mfp != NULL) {
757	if (metaVerbose) {
758	    static char *meta_prefix = NULL;
759	    static int meta_prefix_len;
760
761	    if (!meta_prefix) {
762		char *cp2;
763
764		meta_prefix = Var_Subst(NULL, "${" MAKE_META_PREFIX "}",
765					VAR_GLOBAL, VARF_WANTRES);
766		if ((cp2 = strchr(meta_prefix, '$')))
767		    meta_prefix_len = cp2 - meta_prefix;
768		else
769		    meta_prefix_len = strlen(meta_prefix);
770	    }
771	    if (strncmp(cp, meta_prefix, meta_prefix_len) == 0) {
772		cp = strchr(cp+1, '\n');
773		if (!cp++)
774		    return;
775	    }
776	}
777	fprintf(pbm->mfp, "%s%s", cp, nl);
778    }
779}
780
781int
782meta_cmd_finish(void *pbmp)
783{
784    int error = 0;
785    BuildMon *pbm = pbmp;
786    int x;
787
788    if (!pbm)
789	pbm = &Mybm;
790
791#ifdef USE_FILEMON
792    if (pbm->filemon_fd >= 0) {
793	if (close(pbm->filemon_fd) < 0)
794	    error = errno;
795	x = filemon_read(pbm->mfp, pbm->mon_fd);
796	if (error == 0 && x != 0)
797	    error = x;
798	pbm->filemon_fd = pbm->mon_fd = -1;
799    } else
800#endif
801	fprintf(pbm->mfp, "\n");	/* ensure end with newline */
802    return error;
803}
804
805int
806meta_job_finish(Job *job)
807{
808    BuildMon *pbm;
809    int error = 0;
810    int x;
811
812    if (job != NULL) {
813	pbm = &job->bm;
814    } else {
815	pbm = &Mybm;
816    }
817    if (pbm->mfp != NULL) {
818	error = meta_cmd_finish(pbm);
819	x = fclose(pbm->mfp);
820	if (error == 0 && x != 0)
821	    error = errno;
822	pbm->mfp = NULL;
823	pbm->meta_fname[0] = '\0';
824    }
825    return error;
826}
827
828void
829meta_finish(void)
830{
831    Lst_Destroy(metaBailiwick, NULL);
832    free(metaBailiwickStr);
833    Lst_Destroy(metaIgnorePaths, NULL);
834    free(metaIgnorePathsStr);
835}
836
837/*
838 * Fetch a full line from fp - growing bufp if needed
839 * Return length in bufp.
840 */
841static int
842fgetLine(char **bufp, size_t *szp, int o, FILE *fp)
843{
844    char *buf = *bufp;
845    size_t bufsz = *szp;
846    struct stat fs;
847    int x;
848
849    if (fgets(&buf[o], bufsz - o, fp) != NULL) {
850    check_newline:
851	x = o + strlen(&buf[o]);
852	if (buf[x - 1] == '\n')
853	    return x;
854	/*
855	 * We need to grow the buffer.
856	 * The meta file can give us a clue.
857	 */
858	if (fstat(fileno(fp), &fs) == 0) {
859	    size_t newsz;
860	    char *p;
861
862	    newsz = ROUNDUP((fs.st_size / 2), BUFSIZ);
863	    if (newsz <= bufsz)
864		newsz = ROUNDUP(fs.st_size, BUFSIZ);
865	    if (newsz <= bufsz)
866		return x;		/* truncated */
867	    if (DEBUG(META))
868		fprintf(debug_file, "growing buffer %u -> %u\n",
869			(unsigned)bufsz, (unsigned)newsz);
870	    p = bmake_realloc(buf, newsz);
871	    if (p) {
872		*bufp = buf = p;
873		*szp = bufsz = newsz;
874		/* fetch the rest */
875		if (!fgets(&buf[x], bufsz - x, fp))
876		    return x;		/* truncated! */
877		goto check_newline;
878	    }
879	}
880    }
881    return 0;
882}
883
884/* Lst_ForEach wants 1 to stop search */
885static int
886prefix_match(void *p, void *q)
887{
888    const char *prefix = p;
889    const char *path = q;
890    size_t n = strlen(prefix);
891
892    return (0 == strncmp(path, prefix, n));
893}
894
895/*
896 * looking for exact or prefix/ match to
897 * Lst_Find wants 0 to stop search
898 */
899static int
900path_match(const void *p, const void *q)
901{
902    const char *prefix = q;
903    const char *path = p;
904    size_t n = strlen(prefix);
905    int rc;
906
907    if ((rc = strncmp(path, prefix, n)) == 0) {
908	switch (path[n]) {
909	case '\0':
910	case '/':
911	    break;
912	default:
913	    rc = 1;
914	    break;
915	}
916    }
917    return rc;
918}
919
920/* Lst_Find wants 0 to stop search */
921static int
922string_match(const void *p, const void *q)
923{
924    const char *p1 = p;
925    const char *p2 = q;
926
927    return strcmp(p1, p2);
928}
929
930
931static int
932meta_ignore(GNode *gn, const char *p)
933{
934    char fname[MAXPATHLEN];
935
936    if (p == NULL)
937	return TRUE;
938
939    if (*p == '/') {
940	cached_realpath(p, fname); /* clean it up */
941	if (Lst_ForEach(metaIgnorePaths, prefix_match, fname)) {
942#ifdef DEBUG_META_MODE
943	    if (DEBUG(META))
944		fprintf(debug_file, "meta_oodate: ignoring path: %s\n",
945			p);
946#endif
947	    return TRUE;
948	}
949    }
950
951    if (metaIgnorePatterns) {
952	char *pm;
953
954	Var_Set(".p.", p, gn, 0);
955	pm = Var_Subst(NULL,
956		       "${" MAKE_META_IGNORE_PATTERNS ":@m@${.p.:M$m}@}",
957		       gn, VARF_WANTRES);
958	if (*pm) {
959#ifdef DEBUG_META_MODE
960	    if (DEBUG(META))
961		fprintf(debug_file, "meta_oodate: ignoring pattern: %s\n",
962			p);
963#endif
964	    free(pm);
965	    return TRUE;
966	}
967	free(pm);
968    }
969
970    if (metaIgnoreFilter) {
971	char *fm;
972
973	/* skip if filter result is empty */
974	snprintf(fname, sizeof(fname),
975		 "${%s:L:${%s:ts:}}",
976		 p, MAKE_META_IGNORE_FILTER);
977	fm = Var_Subst(NULL, fname, gn, VARF_WANTRES);
978	if (*fm == '\0') {
979#ifdef DEBUG_META_MODE
980	    if (DEBUG(META))
981		fprintf(debug_file, "meta_oodate: ignoring filtered: %s\n",
982			p);
983#endif
984	    free(fm);
985	    return TRUE;
986	}
987	free(fm);
988    }
989    return FALSE;
990}
991
992/*
993 * When running with 'meta' functionality, a target can be out-of-date
994 * if any of the references in its meta data file is more recent.
995 * We have to track the latestdir on a per-process basis.
996 */
997#define LCWD_VNAME_FMT ".meta.%d.lcwd"
998#define LDIR_VNAME_FMT ".meta.%d.ldir"
999
1000/*
1001 * It is possible that a .meta file is corrupted,
1002 * if we detect this we want to reproduce it.
1003 * Setting oodate TRUE will have that effect.
1004 */
1005#define CHECK_VALID_META(p) if (!(p && *p)) { \
1006    warnx("%s: %d: malformed", fname, lineno); \
1007    oodate = TRUE; \
1008    continue; \
1009    }
1010
1011#define DEQUOTE(p) if (*p == '\'') {	\
1012    char *ep; \
1013    p++; \
1014    if ((ep = strchr(p, '\''))) \
1015	*ep = '\0'; \
1016    }
1017
1018Boolean
1019meta_oodate(GNode *gn, Boolean oodate)
1020{
1021    static char *tmpdir = NULL;
1022    static char cwd[MAXPATHLEN];
1023    char lcwd_vname[64];
1024    char ldir_vname[64];
1025    char lcwd[MAXPATHLEN];
1026    char latestdir[MAXPATHLEN];
1027    char fname[MAXPATHLEN];
1028    char fname1[MAXPATHLEN];
1029    char fname2[MAXPATHLEN];
1030    char fname3[MAXPATHLEN];
1031    const char *dname;
1032    const char *tname;
1033    char *p;
1034    char *cp;
1035    char *link_src;
1036    char *move_target;
1037    static size_t cwdlen = 0;
1038    static size_t tmplen = 0;
1039    FILE *fp;
1040    Boolean needOODATE = FALSE;
1041    Lst missingFiles;
1042    char *pa[4];			/* >= possible uses */
1043    int i;
1044    int have_filemon = FALSE;
1045
1046    if (oodate)
1047	return oodate;		/* we're done */
1048
1049    i = 0;
1050
1051    dname = Var_Value(".OBJDIR", gn, &pa[i++]);
1052    tname = Var_Value(TARGET, gn, &pa[i++]);
1053
1054    /* if this succeeds fname3 is realpath of dname */
1055    if (!meta_needed(gn, dname, fname3, FALSE))
1056	goto oodate_out;
1057    dname = fname3;
1058
1059    missingFiles = Lst_Init(FALSE);
1060
1061    /*
1062     * We need to check if the target is out-of-date. This includes
1063     * checking if the expanded command has changed. This in turn
1064     * requires that all variables are set in the same way that they
1065     * would be if the target needs to be re-built.
1066     */
1067    Make_DoAllVar(gn);
1068
1069    meta_name(fname, sizeof(fname), dname, tname, dname);
1070
1071#ifdef DEBUG_META_MODE
1072    if (DEBUG(META))
1073	fprintf(debug_file, "meta_oodate: %s\n", fname);
1074#endif
1075
1076    if ((fp = fopen(fname, "r")) != NULL) {
1077	static char *buf = NULL;
1078	static size_t bufsz;
1079	int lineno = 0;
1080	int lastpid = 0;
1081	int pid;
1082	int x;
1083	LstNode ln;
1084	struct stat fs;
1085
1086	if (!buf) {
1087	    bufsz = 8 * BUFSIZ;
1088	    buf = bmake_malloc(bufsz);
1089	}
1090
1091	if (!cwdlen) {
1092	    if (getcwd(cwd, sizeof(cwd)) == NULL)
1093		err(1, "Could not get current working directory");
1094	    cwdlen = strlen(cwd);
1095	}
1096	strlcpy(lcwd, cwd, sizeof(lcwd));
1097	strlcpy(latestdir, cwd, sizeof(latestdir));
1098
1099	if (!tmpdir) {
1100	    tmpdir = getTmpdir();
1101	    tmplen = strlen(tmpdir);
1102	}
1103
1104	/* we want to track all the .meta we read */
1105	Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
1106
1107	ln = Lst_First(gn->commands);
1108	while (!oodate && (x = fgetLine(&buf, &bufsz, 0, fp)) > 0) {
1109	    lineno++;
1110	    if (buf[x - 1] == '\n')
1111		buf[x - 1] = '\0';
1112	    else {
1113		warnx("%s: %d: line truncated at %u", fname, lineno, x);
1114		oodate = TRUE;
1115		break;
1116	    }
1117	    link_src = NULL;
1118	    move_target = NULL;
1119	    /* Find the start of the build monitor section. */
1120	    if (!have_filemon) {
1121		if (strncmp(buf, "-- filemon", 10) == 0) {
1122		    have_filemon = TRUE;
1123		    continue;
1124		}
1125		if (strncmp(buf, "# buildmon", 10) == 0) {
1126		    have_filemon = TRUE;
1127		    continue;
1128		}
1129	    }
1130
1131	    /* Delimit the record type. */
1132	    p = buf;
1133#ifdef DEBUG_META_MODE
1134	    if (DEBUG(META))
1135		fprintf(debug_file, "%s: %d: %s\n", fname, lineno, buf);
1136#endif
1137	    strsep(&p, " ");
1138	    if (have_filemon) {
1139		/*
1140		 * We are in the 'filemon' output section.
1141		 * Each record from filemon follows the general form:
1142		 *
1143		 * <key> <pid> <data>
1144		 *
1145		 * Where:
1146		 * <key> is a single letter, denoting the syscall.
1147		 * <pid> is the process that made the syscall.
1148		 * <data> is the arguments (of interest).
1149		 */
1150		switch(buf[0]) {
1151		case '#':		/* comment */
1152		case 'V':		/* version */
1153		    break;
1154		default:
1155		    /*
1156		     * We need to track pathnames per-process.
1157		     *
1158		     * Each process run by make, starts off in the 'CWD'
1159		     * recorded in the .meta file, if it chdirs ('C')
1160		     * elsewhere we need to track that - but only for
1161		     * that process.  If it forks ('F'), we initialize
1162		     * the child to have the same cwd as its parent.
1163		     *
1164		     * We also need to track the 'latestdir' of
1165		     * interest.  This is usually the same as cwd, but
1166		     * not if a process is reading directories.
1167		     *
1168		     * Each time we spot a different process ('pid')
1169		     * we save the current value of 'latestdir' in a
1170		     * variable qualified by 'lastpid', and
1171		     * re-initialize 'latestdir' to any pre-saved
1172		     * value for the current 'pid' and 'CWD' if none.
1173		     */
1174		    CHECK_VALID_META(p);
1175		    pid = atoi(p);
1176		    if (pid > 0 && pid != lastpid) {
1177			char *ldir;
1178			char *tp;
1179
1180			if (lastpid > 0) {
1181			    /* We need to remember these. */
1182			    Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0);
1183			    Var_Set(ldir_vname, latestdir, VAR_GLOBAL, 0);
1184			}
1185			snprintf(lcwd_vname, sizeof(lcwd_vname), LCWD_VNAME_FMT, pid);
1186			snprintf(ldir_vname, sizeof(ldir_vname), LDIR_VNAME_FMT, pid);
1187			lastpid = pid;
1188			ldir = Var_Value(ldir_vname, VAR_GLOBAL, &tp);
1189			if (ldir) {
1190			    strlcpy(latestdir, ldir, sizeof(latestdir));
1191			    free(tp);
1192			}
1193			ldir = Var_Value(lcwd_vname, VAR_GLOBAL, &tp);
1194			if (ldir) {
1195			    strlcpy(lcwd, ldir, sizeof(lcwd));
1196			    free(tp);
1197			}
1198		    }
1199		    /* Skip past the pid. */
1200		    if (strsep(&p, " ") == NULL)
1201			continue;
1202#ifdef DEBUG_META_MODE
1203		    if (DEBUG(META))
1204			    fprintf(debug_file, "%s: %d: %d: %c: cwd=%s lcwd=%s ldir=%s\n",
1205				    fname, lineno,
1206				    pid, buf[0], cwd, lcwd, latestdir);
1207#endif
1208		    break;
1209		}
1210
1211		CHECK_VALID_META(p);
1212
1213		/* Process according to record type. */
1214		switch (buf[0]) {
1215		case 'X':		/* eXit */
1216		    Var_Delete(lcwd_vname, VAR_GLOBAL);
1217		    Var_Delete(ldir_vname, VAR_GLOBAL);
1218		    lastpid = 0;	/* no need to save ldir_vname */
1219		    break;
1220
1221		case 'F':		/* [v]Fork */
1222		    {
1223			char cldir[64];
1224			int child;
1225
1226			child = atoi(p);
1227			if (child > 0) {
1228			    snprintf(cldir, sizeof(cldir), LCWD_VNAME_FMT, child);
1229			    Var_Set(cldir, lcwd, VAR_GLOBAL, 0);
1230			    snprintf(cldir, sizeof(cldir), LDIR_VNAME_FMT, child);
1231			    Var_Set(cldir, latestdir, VAR_GLOBAL, 0);
1232#ifdef DEBUG_META_MODE
1233			    if (DEBUG(META))
1234				    fprintf(debug_file, "%s: %d: %d: cwd=%s lcwd=%s ldir=%s\n",
1235					    fname, lineno,
1236					    child, cwd, lcwd, latestdir);
1237#endif
1238			}
1239		    }
1240		    break;
1241
1242		case 'C':		/* Chdir */
1243		    /* Update lcwd and latest directory. */
1244		    strlcpy(latestdir, p, sizeof(latestdir));
1245		    strlcpy(lcwd, p, sizeof(lcwd));
1246		    Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0);
1247		    Var_Set(ldir_vname, lcwd, VAR_GLOBAL, 0);
1248#ifdef DEBUG_META_MODE
1249		    if (DEBUG(META))
1250			fprintf(debug_file, "%s: %d: cwd=%s ldir=%s\n", fname, lineno, cwd, lcwd);
1251#endif
1252		    break;
1253
1254		case 'M':		/* renaMe */
1255		    /*
1256		     * For 'M'oves we want to check
1257		     * the src as for 'R'ead
1258		     * and the target as for 'W'rite.
1259		     */
1260		    cp = p;		/* save this for a second */
1261		    /* now get target */
1262		    if (strsep(&p, " ") == NULL)
1263			continue;
1264		    CHECK_VALID_META(p);
1265		    move_target = p;
1266		    p = cp;
1267		    /* 'L' and 'M' put single quotes around the args */
1268		    DEQUOTE(p);
1269		    DEQUOTE(move_target);
1270		    /* FALLTHROUGH */
1271		case 'D':		/* unlink */
1272		    if (*p == '/' && !Lst_IsEmpty(missingFiles)) {
1273			/* remove any missingFiles entries that match p */
1274			if ((ln = Lst_Find(missingFiles, p,
1275					   path_match)) != NULL) {
1276			    LstNode nln;
1277			    char *tp;
1278
1279			    do {
1280				nln = Lst_FindFrom(missingFiles, Lst_Succ(ln),
1281						   p, path_match);
1282				tp = Lst_Datum(ln);
1283				Lst_Remove(missingFiles, ln);
1284				free(tp);
1285			    } while ((ln = nln) != NULL);
1286			}
1287		    }
1288		    if (buf[0] == 'M') {
1289			/* the target of the mv is a file 'W'ritten */
1290#ifdef DEBUG_META_MODE
1291			if (DEBUG(META))
1292			    fprintf(debug_file, "meta_oodate: M %s -> %s\n",
1293				    p, move_target);
1294#endif
1295			p = move_target;
1296			goto check_write;
1297		    }
1298		    break;
1299		case 'L':		/* Link */
1300		    /*
1301		     * For 'L'inks check
1302		     * the src as for 'R'ead
1303		     * and the target as for 'W'rite.
1304		     */
1305		    link_src = p;
1306		    /* now get target */
1307		    if (strsep(&p, " ") == NULL)
1308			continue;
1309		    CHECK_VALID_META(p);
1310		    /* 'L' and 'M' put single quotes around the args */
1311		    DEQUOTE(p);
1312		    DEQUOTE(link_src);
1313#ifdef DEBUG_META_MODE
1314		    if (DEBUG(META))
1315			fprintf(debug_file, "meta_oodate: L %s -> %s\n",
1316				link_src, p);
1317#endif
1318		    /* FALLTHROUGH */
1319		case 'W':		/* Write */
1320		check_write:
1321		    /*
1322		     * If a file we generated within our bailiwick
1323		     * but outside of .OBJDIR is missing,
1324		     * we need to do it again.
1325		     */
1326		    /* ignore non-absolute paths */
1327		    if (*p != '/')
1328			break;
1329
1330		    if (Lst_IsEmpty(metaBailiwick))
1331			break;
1332
1333		    /* ignore cwd - normal dependencies handle those */
1334		    if (strncmp(p, cwd, cwdlen) == 0)
1335			break;
1336
1337		    if (!Lst_ForEach(metaBailiwick, prefix_match, p))
1338			break;
1339
1340		    /* tmpdir might be within */
1341		    if (tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0)
1342			break;
1343
1344		    /* ignore anything containing the string "tmp" */
1345		    if ((strstr("tmp", p)))
1346			break;
1347
1348		    if ((link_src != NULL && cached_lstat(p, &fs) < 0) ||
1349			(link_src == NULL && cached_stat(p, &fs) < 0)) {
1350			if (!meta_ignore(gn, p)) {
1351			    if (Lst_Find(missingFiles, p, string_match) == NULL)
1352				Lst_AtEnd(missingFiles, bmake_strdup(p));
1353			}
1354		    }
1355		    break;
1356		check_link_src:
1357		    p = link_src;
1358		    link_src = NULL;
1359#ifdef DEBUG_META_MODE
1360		    if (DEBUG(META))
1361			fprintf(debug_file, "meta_oodate: L src %s\n", p);
1362#endif
1363		    /* FALLTHROUGH */
1364		case 'R':		/* Read */
1365		case 'E':		/* Exec */
1366		    /*
1367		     * Check for runtime files that can't
1368		     * be part of the dependencies because
1369		     * they are _expected_ to change.
1370		     */
1371		    if (meta_ignore(gn, p))
1372			break;
1373
1374		    /*
1375		     * The rest of the record is the file name.
1376		     * Check if it's not an absolute path.
1377		     */
1378		    {
1379			char *sdirs[4];
1380			char **sdp;
1381			int sdx = 0;
1382			int found = 0;
1383
1384			if (*p == '/') {
1385			    sdirs[sdx++] = p; /* done */
1386			} else {
1387			    if (strcmp(".", p) == 0)
1388				continue;  /* no point */
1389
1390			    /* Check vs latestdir */
1391			    snprintf(fname1, sizeof(fname1), "%s/%s", latestdir, p);
1392			    sdirs[sdx++] = fname1;
1393
1394			    if (strcmp(latestdir, lcwd) != 0) {
1395				/* Check vs lcwd */
1396				snprintf(fname2, sizeof(fname2), "%s/%s", lcwd, p);
1397				sdirs[sdx++] = fname2;
1398			    }
1399			    if (strcmp(lcwd, cwd) != 0) {
1400				/* Check vs cwd */
1401				snprintf(fname3, sizeof(fname3), "%s/%s", cwd, p);
1402				sdirs[sdx++] = fname3;
1403			    }
1404			}
1405			sdirs[sdx++] = NULL;
1406
1407			for (sdp = sdirs; *sdp && !found; sdp++) {
1408#ifdef DEBUG_META_MODE
1409			    if (DEBUG(META))
1410				fprintf(debug_file, "%s: %d: looking for: %s\n", fname, lineno, *sdp);
1411#endif
1412			    if (cached_stat(*sdp, &fs) == 0) {
1413				found = 1;
1414				p = *sdp;
1415			    }
1416			}
1417			if (found) {
1418#ifdef DEBUG_META_MODE
1419			    if (DEBUG(META))
1420				fprintf(debug_file, "%s: %d: found: %s\n", fname, lineno, p);
1421#endif
1422			    if (!S_ISDIR(fs.st_mode) &&
1423				fs.st_mtime > gn->mtime) {
1424				if (DEBUG(META))
1425				    fprintf(debug_file, "%s: %d: file '%s' is newer than the target...\n", fname, lineno, p);
1426				oodate = TRUE;
1427			    } else if (S_ISDIR(fs.st_mode)) {
1428				/* Update the latest directory. */
1429				cached_realpath(p, latestdir);
1430			    }
1431			} else if (errno == ENOENT && *p == '/' &&
1432				   strncmp(p, cwd, cwdlen) != 0) {
1433			    /*
1434			     * A referenced file outside of CWD is missing.
1435			     * We cannot catch every eventuality here...
1436			     */
1437			    if (Lst_Find(missingFiles, p, string_match) == NULL)
1438				    Lst_AtEnd(missingFiles, bmake_strdup(p));
1439			}
1440		    }
1441		    if (buf[0] == 'E') {
1442			/* previous latestdir is no longer relevant */
1443			strlcpy(latestdir, lcwd, sizeof(latestdir));
1444		    }
1445		    break;
1446		default:
1447		    break;
1448		}
1449		if (!oodate && buf[0] == 'L' && link_src != NULL)
1450		    goto check_link_src;
1451	    } else if (strcmp(buf, "CMD") == 0) {
1452		/*
1453		 * Compare the current command with the one in the
1454		 * meta data file.
1455		 */
1456		if (ln == NULL) {
1457		    if (DEBUG(META))
1458			fprintf(debug_file, "%s: %d: there were more build commands in the meta data file than there are now...\n", fname, lineno);
1459		    oodate = TRUE;
1460		} else {
1461		    char *cmd = (char *)Lst_Datum(ln);
1462		    Boolean hasOODATE = FALSE;
1463
1464		    if (strstr(cmd, "$?"))
1465			hasOODATE = TRUE;
1466		    else if ((cp = strstr(cmd, ".OODATE"))) {
1467			/* check for $[{(].OODATE[:)}] */
1468			if (cp > cmd + 2 && cp[-2] == '$')
1469			    hasOODATE = TRUE;
1470		    }
1471		    if (hasOODATE) {
1472			needOODATE = TRUE;
1473			if (DEBUG(META))
1474			    fprintf(debug_file, "%s: %d: cannot compare command using .OODATE\n", fname, lineno);
1475		    }
1476		    cmd = Var_Subst(NULL, cmd, gn, VARF_WANTRES|VARF_UNDEFERR);
1477
1478		    if ((cp = strchr(cmd, '\n'))) {
1479			int n;
1480
1481			/*
1482			 * This command contains newlines, we need to
1483			 * fetch more from the .meta file before we
1484			 * attempt a comparison.
1485			 */
1486			/* first put the newline back at buf[x - 1] */
1487			buf[x - 1] = '\n';
1488			do {
1489			    /* now fetch the next line */
1490			    if ((n = fgetLine(&buf, &bufsz, x, fp)) <= 0)
1491				break;
1492			    x = n;
1493			    lineno++;
1494			    if (buf[x - 1] != '\n') {
1495				warnx("%s: %d: line truncated at %u", fname, lineno, x);
1496				break;
1497			    }
1498			    cp = strchr(++cp, '\n');
1499			} while (cp);
1500			if (buf[x - 1] == '\n')
1501			    buf[x - 1] = '\0';
1502		    }
1503		    if (!hasOODATE &&
1504			!(gn->type & OP_NOMETA_CMP) &&
1505			strcmp(p, cmd) != 0) {
1506			if (DEBUG(META))
1507			    fprintf(debug_file, "%s: %d: a build command has changed\n%s\nvs\n%s\n", fname, lineno, p, cmd);
1508			if (!metaIgnoreCMDs)
1509			    oodate = TRUE;
1510		    }
1511		    free(cmd);
1512		    ln = Lst_Succ(ln);
1513		}
1514	    } else if (strcmp(buf, "CWD") == 0) {
1515		/*
1516		 * Check if there are extra commands now
1517		 * that weren't in the meta data file.
1518		 */
1519		if (!oodate && ln != NULL) {
1520		    if (DEBUG(META))
1521			fprintf(debug_file, "%s: %d: there are extra build commands now that weren't in the meta data file\n", fname, lineno);
1522		    oodate = TRUE;
1523		}
1524		if (strcmp(p, cwd) != 0) {
1525		    if (DEBUG(META))
1526			fprintf(debug_file, "%s: %d: the current working directory has changed from '%s' to '%s'\n", fname, lineno, p, curdir);
1527		    oodate = TRUE;
1528		}
1529	    }
1530	}
1531
1532	fclose(fp);
1533	if (!Lst_IsEmpty(missingFiles)) {
1534	    if (DEBUG(META))
1535		fprintf(debug_file, "%s: missing files: %s...\n",
1536			fname, (char *)Lst_Datum(Lst_First(missingFiles)));
1537	    oodate = TRUE;
1538	}
1539	if (!oodate && !have_filemon && filemonMissing) {
1540	    if (DEBUG(META))
1541		fprintf(debug_file, "%s: missing filemon data\n", fname);
1542	    oodate = TRUE;
1543	}
1544    } else {
1545	if (writeMeta && metaMissing) {
1546	    cp = NULL;
1547
1548	    /* if target is in .CURDIR we do not need a meta file */
1549	    if (gn->path && (cp = strrchr(gn->path, '/')) && cp > gn->path) {
1550		if (strncmp(curdir, gn->path, (cp - gn->path)) != 0) {
1551		    cp = NULL;		/* not in .CURDIR */
1552		}
1553	    }
1554	    if (!cp) {
1555		if (DEBUG(META))
1556		    fprintf(debug_file, "%s: required but missing\n", fname);
1557		oodate = TRUE;
1558		needOODATE = TRUE;	/* assume the worst */
1559	    }
1560	}
1561    }
1562
1563    Lst_Destroy(missingFiles, (FreeProc *)free);
1564
1565    if (oodate && needOODATE) {
1566	/*
1567	 * Target uses .OODATE which is empty; or we wouldn't be here.
1568	 * We have decided it is oodate, so .OODATE needs to be set.
1569	 * All we can sanely do is set it to .ALLSRC.
1570	 */
1571	Var_Delete(OODATE, gn);
1572	Var_Set(OODATE, Var_Value(ALLSRC, gn, &cp), gn, 0);
1573	free(cp);
1574    }
1575
1576 oodate_out:
1577    for (i--; i >= 0; i--) {
1578	free(pa[i]);
1579    }
1580    return oodate;
1581}
1582
1583/* support for compat mode */
1584
1585static int childPipe[2];
1586
1587void
1588meta_compat_start(void)
1589{
1590#ifdef USE_FILEMON_ONCE
1591    /*
1592     * We need to re-open filemon for each cmd.
1593     */
1594    BuildMon *pbm = &Mybm;
1595
1596    if (pbm->mfp != NULL && useFilemon) {
1597	filemon_open(pbm);
1598    } else {
1599	pbm->mon_fd = pbm->filemon_fd = -1;
1600    }
1601#endif
1602    if (pipe(childPipe) < 0)
1603	Punt("Cannot create pipe: %s", strerror(errno));
1604    /* Set close-on-exec flag for both */
1605    (void)fcntl(childPipe[0], F_SETFD, FD_CLOEXEC);
1606    (void)fcntl(childPipe[1], F_SETFD, FD_CLOEXEC);
1607}
1608
1609void
1610meta_compat_child(void)
1611{
1612    meta_job_child(NULL);
1613    if (dup2(childPipe[1], 1) < 0 ||
1614	dup2(1, 2) < 0) {
1615	execError("dup2", "pipe");
1616	_exit(1);
1617    }
1618}
1619
1620void
1621meta_compat_parent(void)
1622{
1623    FILE *fp;
1624    char buf[BUFSIZ];
1625
1626    close(childPipe[1]);			/* child side */
1627    fp = fdopen(childPipe[0], "r");
1628    while (fgets(buf, sizeof(buf), fp)) {
1629	meta_job_output(NULL, buf, "");
1630	printf("%s", buf);
1631	fflush(stdout);
1632    }
1633    fclose(fp);
1634}
1635
1636#endif	/* USE_META */
1637