Return to execute.c CVS log

Up to [Apple XNU] / GNUtools / cctools / libstuff

Annotation of GNUtools/cctools/libstuff/execute.c, revision 1.1.1.1

1.1       root        1: #include <bsd/libc.h> /* first to get rid of pre-comp warning */
                      2: #include <mach/mach.h> /* first to get rid of pre-comp warning */
                      3: #include "stdio.h"
                      4: #include <signal.h>
                      5: #include <sys/wait.h>
                      6: #include "stuff/errors.h"
                      7: #include "stuff/allocate.h"
                      8: #include "stuff/execute.h"
                      9: 
                     10: /*
                     11:  * execute() does an execvp using the argv passed to it.  If the parameter
                     12:  * verbose is non-zero the command is printed to stderr.  A non-zero return
                     13:  * value indicates success zero indicates failure.
                     14:  */
                     15: int
                     16: execute(
                     17: char **argv,
                     18: long verbose)
                     19: {
                     20:     char *name, **p;
                     21:     int forkpid, waitpid, termsig;
                     22:     union wait waitstatus;
                     23: 
                     24:        name = argv[0];
                     25: 
                     26:        if(verbose){
                     27:            fprintf(stderr, "+ %s ", name);
                     28:            p = &(argv[1]);
                     29:            while(*p != (char *)0)
                     30:                    fprintf(stderr, "%s ", *p++);
                     31:            fprintf(stderr, "\n");
                     32:        }
                     33: 
                     34:        forkpid = fork();
                     35:        if(forkpid == -1)
                     36:            system_fatal("can't fork a new process to execute: %s", name);
                     37: 
                     38:        if(forkpid == 0){
                     39:            if(execvp(name, argv) == -1)
                     40:                system_fatal("can't find or exec: %s", name);
                     41:            return(1); /* can't get here, removes a warning from the compiler */
                     42:        }
                     43:        else{
                     44:            waitpid = wait(&waitstatus);
                     45:            if(waitpid == -1)
                     46:                system_fatal("wait on forked process %d failed", forkpid);
                     47:            termsig = waitstatus.w_termsig;
                     48:            if(termsig != 0 && termsig != SIGINT)
                     49:                fatal("fatal error in %s", name);
                     50:            return(waitstatus.w_retcode == 0 && termsig == 0);
                     51:        }
                     52: }
                     53: 
                     54: /*
                     55:  * runlist is used by the routine execute_list() to execute a program and it 
                     56:  * contains the command line arguments.  Strings are added to it by
                     57:  * add_execute_list().  The routine reset_execute_list() resets it for new use.
                     58:  */
                     59: static struct {
                     60:     int size;
                     61:     int next;
                     62:     char **strings;
                     63: } runlist;
                     64: 
                     65: /*
                     66:  * This routine is passed a string to be added to the list of strings for 
                     67:  * command line arguments.
                     68:  */
                     69: void
                     70: add_execute_list(
                     71: char *str)
                     72: {
                     73:        if(runlist.strings == (char **)0){
                     74:            runlist.next = 0;
                     75:            runlist.size = 128;
                     76:            runlist.strings = allocate(runlist.size * sizeof(char **));
                     77:        }
                     78:        if(runlist.next + 1 >= runlist.size){
                     79:            runlist.strings = reallocate(runlist.strings,
                     80:                                (runlist.size * 2) * sizeof(char **));
                     81:            runlist.size *= 2;
                     82:        }
                     83:        runlist.strings[runlist.next++] = str;
                     84:        runlist.strings[runlist.next] = (char *)0;
                     85: }
                     86: 
                     87: /*
                     88:  * This routine reset the list of strings of command line arguments so that
                     89:  * an new command line argument list can be built.
                     90:  */
                     91: void
                     92: reset_execute_list(void)
                     93: {
                     94:        runlist.next = 0;
                     95: }
                     96: 
                     97: /*
                     98:  * This routine calls execute() to run the command built up in the runlist
                     99:  * strings.
                    100:  */
                    101: int
                    102: execute_list(
                    103: long verbose)
                    104: {
                    105:        return(execute(runlist.strings, verbose));
                    106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.