/*      $OpenBSD: engine.c,v 1.74 2024/04/09 15:08:21 cheloha Exp $ */
/*
 * Copyright (c) 2012 Marc Espie.
 *
 * Extensive code modifications for the OpenBSD project.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE OPENBSD PROJECT AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OPENBSD
 * PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
 * Copyright (c) 1988, 1989 by Adam de Boor
 * Copyright (c) 1989 by Berkeley Softworks
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Adam de Boor.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "defines.h"
#include "cmd_exec.h"
#include "dir.h"
#include "engine.h"
#include "arch.h"
#include "gnode.h"
#include "targ.h"
#include "var.h"
#include "extern.h"
#include "lst.h"
#include "timestamp.h"
#include "main.h"
#include "make.h"
#include "pathnames.h"
#include "error.h"
#include "memory.h"
#include "buf.h"
#include "job.h"
#include "lowparse.h"

static void MakeTimeStamp(void *, void *);
static int rewrite_time(const char *);
static void list_parents(GNode *, FILE *);

/* XXX due to a bug in make's logic, targets looking like *.a or -l*
 * have been silently dropped when make couldn't figure them out.
 * Now, we warn about them until all Makefile bugs have been fixed.
 */
static bool
drop_silently(const char *s)
{
        size_t len;

        if (s[0] == '-' && s[1] == 'l')
                return true;

        len = strlen(s);
        if (len >=2 && s[len-2] == '.' && s[len-1] == 'a')
                return true;
        return false;
}

bool
node_find_valid_commands(GNode *gn)
{
        if (DEBUG(DOUBLE) && (gn->type & OP_DOUBLE))
                fprintf(stderr, "Warning: target %s had >1 lists of "
                    "shell commands (ignoring later ones)\n", gn->name);
        if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands)) {
                if (drop_silently(gn->name)) {
                        printf("Warning: target %s", gn->name);
                        list_parents(gn, stdout);
                        printf(" does not have any command (BUG)\n");
                        return true;
                }
                /*
                 * No commands. Look for .DEFAULT rule from which we might infer
                 * commands
                 */
                if ((gn->type & OP_NODEFAULT) == 0 &&
                    (DEFAULT->type & OP_DUMMY) == 0 &&
                    !Lst_IsEmpty(&DEFAULT->commands)) {
                        /*
                         * Make only looks for a .DEFAULT if the node was never
                         * the target of an operator, so that's what we do too.
                         * If a .DEFAULT was given, we substitute its commands
                         * for gn's commands and set the IMPSRC variable to be
                         * the target's name The DEFAULT node acts like a
                         * transformation rule, in that gn also inherits any
                         * attributes or sources attached to .DEFAULT itself.
                         */
                        Make_HandleUse(DEFAULT, gn);
                        Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn);
                } else if (is_out_of_date(Dir_MTime(gn))) {
                        /*
                         * The node wasn't the target of an operator we have no
                         * .DEFAULT rule to go on and the target doesn't
                         * already exist. There's nothing more we can do for
                         * this branch.
                         */
                         return false;
                }
        }
        return true;
}

static void
list_parents(GNode *gn, FILE *out)
{
        LstNode ln;
        bool first = true;

        for (ln = Lst_First(&gn->parents); ln != NULL; ln = Lst_Adv(ln)) {
                GNode *p = Lst_Datum(ln);
                if (!p->must_make)
                        continue;
                if (first) {
                        fprintf(out, " (prerequisite of:");
                        first = false;
                }
                fprintf(out, " %s", p->name);
        }
        if (!first)
                fprintf(out, ")");
}

void
node_failure(GNode *gn)
{
        /*
         If the -k flag wasn't given, we stop in
         * our tracks, otherwise we just don't update this
         * node's parents so they never get examined.
         */
        const char *diag;
        FILE *out;

        if (gn->type & OP_OPTIONAL) {
                out = stdout;
                diag = "(ignored)";
        } else if (keepgoing) {
                out = stdout;
                diag = "(continuing)";
        } else {
                out = stderr;
                diag = "";
        }
        fprintf(out, "make: don't know how to make %s", gn->name);
        list_parents(gn, out);
        fprintf(out, "%s\n", diag);
        if (out == stdout)
                fflush(stdout);
        else {
                print_errors();
                dump_unreadable();
                Punt(NULL);
        }
}

/* touch files the hard way, by writing stuff to them */
static int
rewrite_time(const char *name)
{
        int fd;
        char c;

        fd = open(name, O_RDWR | O_CREAT, 0666);
        if (fd < 0)
                return -1;
        /*
         * Read and write a byte to the file to change
         * the modification time.
         */
        if (read(fd, &c, 1) == 1) {
                (void)lseek(fd, 0, SEEK_SET);
                (void)write(fd, &c, 1);
        }

        (void)close(fd);
        return 0;
}

void
Job_Touch(GNode *gn)
{
        handle_all_signals();
        if (gn->type & (OP_USE|OP_OPTIONAL|OP_PHONY)) {
                /*
                 * .JOIN, .USE, and .OPTIONAL targets are "virtual" targets
                 * and, as such, shouldn't really be created.
                 * Likewise, .PHONY targets are not really files
                 */
                return;
        }

        if (!Targ_Silent(gn)) {
                (void)fprintf(stdout, "touch %s\n", gn->name);
                (void)fflush(stdout);
        }

        if (noExecute) {
                return;
        }

        if (gn->type & OP_ARCHV) {
                Arch_Touch(gn);
        } else {
                const char *file = gn->path != NULL ? gn->path : gn->name;

                if (utimes(file, NULL) == -1){
                        if (rewrite_time(file) == -1) {
                                (void)fprintf(stderr,
                                    "*** couldn't touch %s: %s", file,
                                    strerror(errno));
                        }
                }
        }
}

void
Make_TimeStamp(GNode *parent, GNode *child)
{
        if (is_strictly_before(parent->youngest->mtime, child->mtime)) {
                parent->youngest = child;
        }
}

void
Make_HandleUse(GNode    *cgn,   /* The .USE node */
    GNode       *pgn)   /* The target of the .USE node */
{
        GNode   *gn;    /* A child of the .USE node */
        LstNode ln;     /* An element in the children list */

        assert(cgn->type & (OP_USE|OP_TRANSFORM));

        if (pgn == NULL)
                Fatal("Trying to apply .USE to '%s' without a parent",
                    cgn->name);

        if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) {
                /* .USE or transformation and target has no commands
                 * -- append the child's commands to the parent.  */
                Lst_Concat(&pgn->commands, &cgn->commands);
        }

        for (ln = Lst_First(&cgn->children); ln != NULL;
            ln = Lst_Adv(ln)) {
                gn = Lst_Datum(ln);

                if (Lst_AddNew(&pgn->children, gn)) {
                        Lst_AtEnd(&gn->parents, pgn);
                        pgn->children_left++;
                }
        }

        if (DEBUG(DOUBLE) && (cgn->type & OP_DOUBLE))
                fprintf(stderr, 
                    "Warning: .USE %s expanded in %s had >1 lists of "
                    "shell commands (ignoring later ones)\n", 
                    cgn->name, pgn->name);
        pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM|OP_DOUBLE);

        /*
         * This child node is now built, so we decrement the count of
         * not yet built children in the parent... We also remove the child
         * from the parent's list to accurately reflect the number of
         * remaining children the parent has. This is used by Make_Run to
         * decide whether to queue the parent or examine its children...
         */
        if (cgn->type & OP_USE)
                pgn->children_left--;
}

void
Make_DoAllVar(GNode *gn)
{
        GNode *child;
        LstNode ln;
        BUFFER allsrc, oodate;
        char *target;
        bool do_oodate;
        int oodate_count, allsrc_count = 0;

        oodate_count = 0;
        allsrc_count = 0;

        Var(OODATE_INDEX, gn) = "";
        Var(ALLSRC_INDEX, gn) = "";

        for (ln = Lst_First(&gn->children); ln != NULL; ln = Lst_Adv(ln)) {
                child = Lst_Datum(ln);
                if ((child->type & (OP_USE|OP_INVISIBLE)) != 0)
                        continue;
                if (OP_NOP(child->type) ||
                    (target = Var(TARGET_INDEX, child)) == NULL) {
                        /*
                         * this node is only source; use the specific pathname
                         * for it
                         */
                        target = child->path != NULL ? child->path :
                            child->name;
                }

                /*
                 * It goes in the OODATE variable if the parent is younger than
                 * the child or if the child has been modified more recently
                 * than the start of the make.  This is to keep make from
                 * getting confused if something else updates the parent after
                 * the make starts (shouldn't happen, I know, but sometimes it
                 * does). In such a case, if we've updated the kid, the parent
                 * is likely to have a modification time later than that of the
                 * kid and anything that relies on the OODATE variable will be
                 * hosed.
                 */
                do_oodate = false;
                if (is_strictly_before(gn->mtime, child->mtime) ||
                   (!is_strictly_before(child->mtime, starttime) &&
                   child->built_status == REBUILT))
                        do_oodate = true;
                if (do_oodate) {
                        oodate_count++;
                        if (oodate_count == 1)
                                Var(OODATE_INDEX, gn) = target;
                        else {
                                if (oodate_count == 2) {
                                        Buf_Init(&oodate, 0);
                                        Buf_AddString(&oodate,
                                            Var(OODATE_INDEX, gn));
                                }
                                Buf_AddSpace(&oodate);
                                Buf_AddString(&oodate, target);
                        }
                }
                allsrc_count++;
                if (allsrc_count == 1)
                        Var(ALLSRC_INDEX, gn) = target;
                else {
                        if (allsrc_count == 2) {
                                Buf_Init(&allsrc, 0);
                                Buf_AddString(&allsrc,
                                    Var(ALLSRC_INDEX, gn));
                        }
                        Buf_AddSpace(&allsrc);
                        Buf_AddString(&allsrc, target);
                }
        }

        if (allsrc_count > 1)
                Var(ALLSRC_INDEX, gn) = Buf_Retrieve(&allsrc);
        if (oodate_count > 1)
                Var(OODATE_INDEX, gn) = Buf_Retrieve(&oodate);

        if (gn->impliedsrc)
                Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn->impliedsrc);
}

/* Wrapper to call Make_TimeStamp from a forEach loop.  */
static void
MakeTimeStamp(void *parent, void *child)
{
    Make_TimeStamp(parent, child);
}

bool
Make_OODate(GNode *gn)
{
        bool        oodate;

        /*
         * Certain types of targets needn't even be sought as their datedness
         * doesn't depend on their modification time...
         */
        if ((gn->type & (OP_USE|OP_PHONY)) == 0) {
                (void)Dir_MTime(gn);
                if (DEBUG(MAKE)) {
                        if (!is_out_of_date(gn->mtime))
                                printf("modified %s...",
                                    time_to_string(&gn->mtime));
                        else
                                printf("non-existent...");
                }
        }

        /*
         * A target is rebuilt in one of the following circumstances:
         * - its modification time is smaller than that of its youngest child
         *   and it would actually be run (has commands or type OP_NOP)
         * - it's the object of a force operator
         * - it has no children, was on the lhs of an operator and doesn't
         *   exist already.
         *
         */
        if (gn->type & OP_USE) {
                /*
                 * If the node is a USE node it is *never* out of date
                 * no matter *what*.
                 */
                if (DEBUG(MAKE))
                        printf(".USE node...");
                oodate = false;
        } else if (gn->type & (OP_FORCE|OP_PHONY)) {
                /*
                 * A node which is the object of the force (!) operator or which
                 * has the .EXEC attribute is always considered out-of-date.
                 */
                if (DEBUG(MAKE)) {
                        if (gn->type & OP_FORCE)
                                printf("! operator...");
                        else if (gn->type & OP_PHONY)
                                printf(".PHONY node...");
                        else
                                printf(".EXEC node...");
                }
                oodate = true;
        } else if (is_strictly_before(gn->mtime, gn->youngest->mtime) ||
           (gn == gn->youngest &&
            (is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP)))) {
                /*
                 * A node whose modification time is less than that of its
                 * youngest child or that has no children (gn->youngest == gn)
                 * and either doesn't exist (mtime == OUT_OF_DATE)
                 * or was the object of a :: operator is out-of-date.
                 */
                if (DEBUG(MAKE)) {
                        if (is_strictly_before(gn->mtime, gn->youngest->mtime))
                                printf("modified before source(%s)...",
                                    gn->youngest->name);
                        else if (is_out_of_date(gn->mtime))
                                printf("non-existent and no sources...");
                        else
                                printf(":: operator and no sources...");
                }
                oodate = true;
        } else {
                oodate = false;
        }

        /*
         * If the target isn't out-of-date, the parents need to know its
         * modification time. Note that targets that appear to be out-of-date
         * but aren't, because they have no commands and aren't of type OP_NOP,
         * have their mtime stay below their children's mtime to keep parents
         * from thinking they're out-of-date.
         */
        if (!oodate)
                Lst_ForEach(&gn->parents, MakeTimeStamp, gn);

        return oodate;
}


void
job_attach_node(Job *job, GNode *node)
{
        job->node = node;
        job->node->built_status = BUILDING;
        job->next_cmd = Lst_First(&node->commands);
        job->exit_type = JOB_EXIT_OKAY;
        job->location = NULL;
        job->flags = 0;
}

void
handle_job_status(Job *job, int status)
{
        bool silent;
        int dying;

        /* if there's one job running and we don't keep going, no need 
         * to report right now.
         */
        if ((job->flags & JOB_ERRCHECK) && !keepgoing && runningJobs == NULL) 
                silent = !DEBUG(JOB);
        else
                silent = false;

        debug_job_printf("Process %ld (%s) exited with status %d.\n",
            (long)job->pid, job->node->name, status);

        /* classify status */
        if (WIFEXITED(status)) {
                job->code = WEXITSTATUS(status);/* exited */
                if (job->code != 0) {
                        /* if we're already dying from that signal, be silent */
                        if (!silent && job->code > 128 
                            && job->code <= 128 + _NSIG) {
                                dying = check_dying_signal();
                                silent = dying && job->code == dying + 128;
                        }
                        if (!silent)
                                printf("*** Error %d", job->code);
                        job->exit_type = JOB_EXIT_BAD;
                } else 
                        job->exit_type = JOB_EXIT_OKAY;
        } else {
                job->exit_type = JOB_SIGNALED;
                job->code = WTERMSIG(status);   /* signaled */
                /* if we're already dying from that signal, be silent */
                if (!silent) {
                        dying = check_dying_signal();
                        silent = dying && job->code == dying;
                }
                if (!silent)
                        printf("*** Signal %d", job->code);
        }

        /* if there is a problem, what's going on ? */
        if (job->exit_type != JOB_EXIT_OKAY) {
                if (!silent)
                        printf(" in target '%s'", job->node->name);
                if (job->flags & JOB_ERRCHECK) {
                        job->node->built_status = ERROR;
                        if (!keepgoing) {
                                if (!silent)
                                        printf("\n");
                                job->flags |= JOB_KEEPERROR;
                                /* XXX don't free the command */
                                return;
                        }
                        printf(", line %lu of %s", job->location->lineno, 
                            job->location->fname);
                        /* Parallel make already determined whether
                         * JOB_IS_EXPENSIVE, perform the computation for
                         * sequential make to figure out whether to display the
                         * command or not.  */
                        if ((job->flags & JOB_SILENT) && sequential)
                                determine_expensive_job(job);
                        if ((job->flags & (JOB_SILENT | JOB_IS_EXPENSIVE)) 
                            == JOB_SILENT)
                                printf(": %s", job->cmd);
                        /* Abort the current target,
                         * but let others continue.  */
                        printf(" (continuing)\n");
                } else {
                        /* Continue executing commands for
                         * this target.  If we return 0,
                         * this will happen...  */
                        printf(" (ignored)\n");
                        job->exit_type = JOB_EXIT_OKAY;
                }
        }
        free(job->cmd);
}

int
run_gnode(GNode *gn)
{
        if (!gn || (gn->type & OP_DUMMY))
                return NOSUCHNODE;

        Job_Make(gn);
        loop_handle_running_jobs();
        return gn->built_status;
}


static bool
do_run_command(Job *job, const char *pre)
{
        bool silent;    /* Don't print command */
        bool doExecute; /* Execute the command */
        bool errCheck;  /* Check errors */
        pid_t cpid;     /* Child pid */

        const char *cmd = job->cmd;
        silent = Targ_Silent(job->node);
        errCheck = !Targ_Ignore(job->node);
        if (job->node->type & OP_MAKE)
                doExecute = true;
        else
                doExecute = !noExecute;

        /* How can we execute a null command ? we warn the user that the
         * command expanded to nothing (is this the right thing to do?).  */
        if (*cmd == '\0') {
                Parse_Error(PARSE_WARNING, 
                    "'%s' expands to '' while building %s", 
                    pre, job->node->name);
                return false;
        }

        for (;; cmd++) {
                if (*cmd == '@')
                        silent = DEBUG(LOUD) ? false : true;
                else if (*cmd == '-')
                        errCheck = false;
                else if (*cmd == '+')
                        doExecute = true;
                else
                        break;
        }
        while (ISSPACE(*cmd))
                cmd++;
        /* Print the command before fork if make -n or !silent*/
        if ( noExecute || !silent)
                printf("%s\n", cmd);
        
        if (silent)
                job->flags |= JOB_SILENT;
        else
                job->flags &= ~JOB_SILENT;

        /* If we're not supposed to execute any commands, this is as far as
         * we go...  */
        if (!doExecute)
                return false;
        /* always flush for other stuff */
        fflush(stdout);

        /* Optimization: bypass comments entirely */
        if (*cmd == '#')
                return false;

        /* Fork and execute the single command. If the fork fails, we abort.  */
        switch (cpid = fork()) {
        case -1:
                Punt("Could not fork");
                /*NOTREACHED*/
        case 0:
                reset_signal_mask();
                /* put a random delay unless we're the only job running
                 * and there's nothing left to do.
                 */
                if (random_delay)
                        if (!(runningJobs == NULL && nothing_left_to_build()))
                                usleep(arc4random_uniform(random_delay));
                run_command(cmd, errCheck);
                /*NOTREACHED*/
        default:
                job->pid = cpid;
                job->next = runningJobs;
                runningJobs = job;
                if (errCheck)
                        job->flags |= JOB_ERRCHECK;
                else
                        job->flags &= ~JOB_ERRCHECK;
                debug_job_printf("Running %ld (%s) %s\n", (long)job->pid, 
                    job->node->name, (noExecute || !silent) ? "" : cmd);
                return true;
        }
}

bool
job_run_next(Job *job)
{
        bool started;
        GNode *gn = job->node;

        while (job->next_cmd != NULL) {
                struct command *command = Lst_Datum(job->next_cmd);

                handle_all_signals();
                job->location = &command->location;
                Parse_SetLocation(job->location);
                job->cmd = Var_Subst(command->string, &gn->localvars, false);
                job->next_cmd = Lst_Adv(job->next_cmd);
                if (fatal_errors)
                        Punt(NULL);
                started = do_run_command(job, command->string);
                if (started)
                        return false;
                else
                        free(job->cmd);
        }
        job->exit_type = JOB_EXIT_OKAY;
        return true;
}