Return to execvp.c CVS log

Up to [Research Unix] / researchv9 / libc / gen

Annotation of researchv9/libc/gen/execvp.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     execlp(name, arg,...,0) (like execl, but does path search)
                      3:  *     execvp(name, argv)      (like execv, but does path search)
                      4:  */
                      5: #include <errno.h>
                      6: #define        NULL    0
                      7: 
                      8: static char shell[] =  "/bin/sh";
                      9: char   *execat(), *getenv(), *strchr();
                     10: extern errno;
                     11: 
                     12: execlp(name, argv)
                     13: char *name, *argv;
                     14: {
                     15:        return(execvp(name, &argv));
                     16: }
                     17: 
                     18: execvp(name, argv)
                     19: char *name, **argv;
                     20: {
                     21:        char *pathstr;
                     22:        register char *cp;
                     23:        char fname[128];
                     24:        char *newargs[256];
                     25:        int i;
                     26:        register unsigned etxtbsy = 1;
                     27:        register eacces = 0;
                     28: 
                     29:        if ((pathstr = getenv("PATH")) == NULL)
                     30:                pathstr = ":/bin:/usr/bin";
                     31:        cp = strchr(name, '/')? "": pathstr;
                     32: 
                     33:        do {
                     34:                cp = execat(cp, name, fname);
                     35:        retry:
                     36:                execv(fname, argv);
                     37:                switch(errno) {
                     38:                case ENOEXEC:
                     39:                        newargs[0] = "sh";
                     40:                        newargs[1] = fname;
                     41:                        for (i=1; newargs[i+1]=argv[i]; i++) {
                     42:                                if (i>=254) {
                     43:                                        errno = E2BIG;
                     44:                                        return(-1);
                     45:                                }
                     46:                        }
                     47:                        execv(shell, newargs);
                     48:                        return(-1);
                     49:                case ETXTBSY:
                     50:                        if (++etxtbsy > 5)
                     51:                                return(-1);
                     52:                        sleep(etxtbsy);
                     53:                        goto retry;
                     54:                case EACCES:
                     55:                        eacces++;
                     56:                        break;
                     57:                case ENOMEM:
                     58:                case E2BIG:
                     59:                        return(-1);
                     60:                }
                     61:        } while (cp);
                     62:        if (eacces)
                     63:                errno = EACCES;
                     64:        return(-1);
                     65: }
                     66: 
                     67: static char *
                     68: execat(s1, s2, si)
                     69: register char *s1, *s2;
                     70: char *si;
                     71: {
                     72:        register char *s;
                     73: 
                     74:        s = si;
                     75:        while (*s1 && *s1 != ':')
                     76:                *s++ = *s1++;
                     77:        if (si != s)
                     78:                *s++ = '/';
                     79:        while (*s2)
                     80:                *s++ = *s2++;
                     81:        *s = '\0';
                     82:        return(*s1? ++s1: 0);
                     83: }

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