Subversion Repositories planix.SVN

#include "defs.h"
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

static int      metas(char *);
static int      waitproc(int *);
static int      doshell(char *, int);
static int      doexec(char *);

int
dosys(char *comstring, int nohalt, int nowait, char *prefix)
{
int status;
struct process *procp;

/* make sure there is room in the process stack */
if(nproc >= MAXPROC)
        waitstack(MAXPROC-1);

/* make sure fewer than proclimit processes are running */
while(proclive >= proclimit)
        {
        enbint(SIG_IGN);
        waitproc(&status);
        enbint(intrupt);
        }

if(prefix)
        {
        fputs(prefix, stdout);
        fputs(comstring, stdout);
        }

procp = procstack + nproc;
procp->pid = (forceshell || metas(comstring) ) ?
        doshell(comstring,nohalt) : doexec(comstring);
if(procp->pid == -1)
        fatal("fork failed");
procstack[nproc].nohalt = nohalt;
procstack[nproc].nowait = nowait;
procstack[nproc].done = NO;
++proclive;
++nproc;

if(nowait)
        {
        printf(" &%d\n", procp->pid);
        fflush(stdout);
        return 0;
        }
if(prefix)
        {
        putchar('\n');
        fflush(stdout);
        }
return waitstack(nproc-1);
}

static int
metas(char *s)   /* Are there are any  Shell meta-characters? */
{
char c;

while( (funny[c = *s++] & META) == 0 )
        ;
return( c );
}

static void
doclose(void)   /* Close open directory files before exec'ing */
{
struct dirhd *od;

for (od = firstod; od; od = od->nxtdirhd)
        if(od->dirfc)
                closedir(od->dirfc);
}

/*  wait till none of the processes in the stack starting at k is live */
int
waitstack(int k)
{
int npending, status, totstatus;
int i;

totstatus = 0;
npending = 0;
for(i=k ; i<nproc; ++i)
        if(! procstack[i].done)
                ++npending;
enbint(SIG_IGN);
if(dbgflag > 1)
        printf("waitstack(%d)\n", k);

while(npending>0 && proclive>0)
        {
        if(waitproc(&status) >= k)
                --npending;
        totstatus |= status;
        }

if(nproc > k)
        nproc = k;
enbint(intrupt);
return totstatus;
}

static int
waitproc(int *statp)
{
pid_t pid;
int status;
int i;
struct process *procp;
char junk[50];
static int inwait = NO;

if(inwait)      /* avoid infinite recursions on errors */
        return MAXPROC;
inwait = YES;

pid = wait(&status);
if(dbgflag > 1)
        fprintf(stderr, "process %d done, status = %d\n", pid, status);
if(pid == -1)
        {
        if(errno == ECHILD)     /* multiple deaths, no problem */
                {
                if(proclive)
                        {
                        for(i=0, procp=procstack; i<nproc; ++i, ++procp)
                                procp->done = YES;
                        proclive = nproc = 0;
                        }
                return MAXPROC;
                }
        fatal("bad wait code");
        }
for(i=0, procp=procstack; i<nproc; ++i, ++procp)
        if(procp->pid == pid)
                {
                --proclive;
                procp->done = YES;

                if(status)
                        {
                        if(procp->nowait)
                                printf("%d: ", pid);
                        if( WEXITSTATUS(status) )
                                printf("*** Error code %d", WEXITSTATUS(status) );
                        else    printf("*** Termination code %d", WTERMSIG(status));
                
                        printf(procp->nohalt ? "(ignored)\n" : "\n");
                        fflush(stdout);
                        if(!keepgoing && !procp->nohalt)
                                fatal(CHNULL);
                        }
                *statp = status;
                inwait = NO;
                return i;
                }

sprintf(junk, "spurious return from process %d", pid);
fatal(junk);
/*NOTREACHED*/
return -1;
}

static int
doshell(char *comstring, int nohalt)
{
pid_t pid;

if((pid = fork()) == 0)
        {
        enbint(SIG_DFL);
        doclose();

        execl(SHELLCOM, "sh", (nohalt ? "-c" : "-ce"), comstring, NULL);
        fatal("Couldn't load Shell");
        }

return pid;
}

static int
doexec(char *str)
{
char *t, *tend;
char **argv;
char **p;
int nargs;
pid_t pid;

while( *str==' ' || *str=='\t' )
        ++str;
if( *str == '\0' )
        return(-1);     /* no command */

nargs = 1;
for(t = str ; *t ; )
        {
        ++nargs;
        while(*t!=' ' && *t!='\t' && *t!='\0')
                ++t;
        if(*t)  /* replace first white space with \0, skip rest */
                for( *t++ = '\0' ; *t==' ' || *t=='\t'  ; ++t)
                        ;
        }

/* now allocate args array, copy pointer to start of each string,
   then terminate array with a null
*/
p = argv = (char **) ckalloc(nargs*sizeof(char *));
tend = t;
for(t = str ; t<tend ; )
        {
        *p++ = t;
        while( *t )
                ++t;
        do      {
                ++t;
                } while(t<tend && (*t==' ' || *t=='\t') );
        }
*p = NULL;
/*TEMP  for(p=argv; *p; ++p)printf("arg=%s\n", *p);*/

if((pid = fork()) == 0)
        {
        enbint(SIG_DFL);
        doclose();
        enbint(intrupt);
        execvp(str, argv);
        printf("\n");
        fatal1("Cannot load %s",str);
        }

free( (char *) argv);
return pid;
}

void
touch(int force, char *name)
{
struct stat stbuff;
char junk[1];
int fd;

if( stat(name,&stbuff) < 0)
        if(force)
                goto create;
        else
                {
                fprintf(stderr, "touch: file %s does not exist.\n", name);
                return;
                }

if(stbuff.st_size == 0)
        goto create;

if( (fd = open(name, O_RDWR)) < 0)
        goto bad;

if( read(fd, junk, 1) < 1)
        {
        close(fd);
        goto bad;
        }
lseek(fd, 0L, SEEK_SET);
if( write(fd, junk, 1) < 1 )
        {
        close(fd);
        goto bad;
        }
close(fd);
return;

bad:
        fprintf(stderr, "Cannot touch %s\n", name);
        return;

create:
        if( (fd = creat(name, 0666)) < 0)
                goto bad;
        close(fd);
}