/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *      cscope - interactive C symbol cross-reference
 *
 *      process execution functions
 */

#include "global.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <stdarg.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <libgen.h>

#define getdtablesize() _NFILE

#define MAXARGS 100     /* maximum number of arguments to executed command */

pid_t   childpid;       /* child's process ID */

static  SIGTYPE (*oldsigquit)();        /* old value of quit signal */
static  SIGTYPE (*oldsigtstp)();        /* old value of terminal stop signal */

static pid_t myfork(void);
static int join(pid_t p);

/*
 * execute forks and executes a program or shell script, waits for it to
 * finish, and returns its exit code.
 */

/*VARARGS0*/
int
execute(char *path, ...)
{
        va_list ap;
        char    *args[MAXARGS + 1];
        int     exitcode;
        int     i;
        char    msg[MSGLEN + 1];
        pid_t   p;

        /* fork and exec the program or shell script */
        exitcurses();
        if ((p = myfork()) == 0) {

                /* close all files except stdin, stdout, and stderr */
                for (i = 3; i < getdtablesize() && close(i) == 0; ++i) {
                        ;
                }
                /* execute the program or shell script */
                va_start(ap, path);
                for (i = 0; i < MAXARGS &&
                    (args[i] = va_arg(ap, char *)) != NULL; ++i) {
                }
                va_end(ap);
                args[i] = NULL;                 /* in case MAXARGS reached */
                args[0] = basename(args[0]);
                (void) execvp(path, args);      /* returns only on failure */
                (void) sprintf(msg, "\ncscope: cannot execute %s", path);
                (void) perror(msg);     /* display the reason */
                askforreturn();  /* wait until the user sees the message */
                exit(1);                /* exit the child */
        } else {
                exitcode = join(p);     /* parent */
        }
        if (noacttimeout) {
                (void) fprintf(stderr,
                    "cscope: no activity time out--exiting\n");
                myexit(SIGALRM);
        }
        entercurses();
        return (exitcode);
}

/* myfork acts like fork but also handles signals */

static pid_t
myfork(void)
{
        pid_t   p;              /* process number */

        oldsigtstp = signal(SIGTSTP, SIG_DFL);
        /* the parent ignores the interrupt and quit signals */
        if ((p = fork()) > 0) {
                childpid = p;
                oldsigquit = signal(SIGQUIT, SIG_IGN);
        }
        /* so they can be used to stop the child */
        else if (p == 0) {
                (void) signal(SIGINT, SIG_DFL);
                (void) signal(SIGQUIT, SIG_DFL);
                (void) signal(SIGHUP, SIG_DFL); /* restore hangup default */
        }
        /* check for fork failure */
        if (p == -1) {
                myperror("Cannot fork");
        }
        return (p);
}

/* join is the compliment of fork */

static int
join(pid_t p)
{
        int     status;
        pid_t   w;

        /* wait for the correct child to exit */
        do {
                w = wait(&status);
        } while (p != -1 && w != p);
        childpid = 0;

        /* restore signal handling */
        (void) signal(SIGQUIT, oldsigquit);
        (void) signal(SIGTSTP, oldsigtstp);
        /* return the child's exit code */
        return (status >> 8);
}