Return to mkdir.c CVS log

Up to [Research Unix] / researchv8dc / cmd / asd

Annotation of researchv8dc/cmd/asd/mkdir.c, revision 1.1.1.1

1.1       root        1: #include "asd.h"
                      2: #include "ftw.h"
                      3: 
                      4: int rm();
                      5: 
                      6: /*
                      7:  *     mkdir function -- tries to make a directory whose name is "d".
                      8:  *     returns 0 if successful or if d already exists and is a
                      9:  *     directory.  On failure, returns mkdir's return code.
                     10:  */
                     11: 
                     12: int
                     13: mkdir (d)
                     14:        register char *d;
                     15: {
                     16:        register int pid, w;
                     17:        int status;
                     18:        struct stat sb;
                     19: 
                     20:        if (stat (d, &sb) >= 0)
                     21:                return (sb.st_mode & S_IFMT) != S_IFDIR;
                     22: 
                     23:        switch (pid = fork()) {
                     24:        case 0:
                     25:                /* we might be executed from a setuid program */
                     26:                setgid (getegid());
                     27:                setuid (geteuid());
                     28:                execl ("/bin/mkdir", "mkdir", d, 0);
                     29:                /* No break */
                     30:        case -1:
                     31:                return 1;
                     32: 
                     33:        default:
                     34:                do w = wait (&status);
                     35:                while (w != pid && w > 0);
                     36:                if (w == pid)
                     37:                        return status;
                     38:                return w;
                     39:        }
                     40: }
                     41: 
                     42: /*
                     43:  *     rmdir function -- tries to remove a directory whose name is "d".
                     44:  *     returns 0 if successful.  On failure, returns rmdir's return code.
                     45:  */
                     46: 
                     47: int
                     48: rmdir (d)
                     49:        register char *d;
                     50: {
                     51:        register int pid, w;
                     52:        int status;
                     53:        struct stat sb;
                     54: 
                     55:        if (stat (d, &sb) >= 0 && (sb.st_mode & S_IFMT) != S_IFDIR)
                     56:                return -1;
                     57: 
                     58:        switch (pid = fork()) {
                     59:        case 0:
                     60:                /* we might be executed from a setuid program */
                     61:                setgid (getegid());
                     62:                setuid (geteuid());
                     63:                execl ("/bin/rmdir", "rmdir", d, 0);
                     64:                /* No break */
                     65:        case -1:
                     66:                return 1;
                     67: 
                     68:        default:
                     69:                do w = wait (&status);
                     70:                while (w != pid && w > 0);
                     71:                if (w == pid)
                     72:                        return status;
                     73:                return w;
                     74:        }
                     75: }
                     76: 
                     77: /* rmall (s) recursively removes the object named s */
                     78: int
                     79: rmall (s)
                     80:        register char *s;
                     81: {
                     82:        return ftw (s, rm, 8);
                     83: }
                     84: 
                     85: /* ARGSUSED */
                     86: static int
                     87: rm (name, sb, type)
                     88:        register char *name;
                     89:        register struct stat *sb;
                     90:        register int type;
                     91: {
                     92:        register int r;
                     93: 
                     94:        switch (type) {
                     95: 
                     96:        case FTW_F:
                     97:                r = unlink (name);
                     98:                if (r < 0) {
                     99:                        perror (name);
                    100:                        return r;
                    101:                }
                    102:                break;
                    103:        
                    104:        case FTW_D:
                    105:                break;
                    106:        
                    107:        case FTW_DNR:
                    108:                fprintf (stderr, "cannot read directory %s\n", name);
                    109:                exit (1);
                    110:        
                    111:        case FTW_NS:
                    112:                fprintf (stderr, "cannot stat %s\n", name);
                    113:                exit (1);
                    114:        
                    115:        case FTW_DP:
                    116:                r = rmdir (name);
                    117:                if (r != 0) {
                    118:                        fprintf (stderr,
                    119:                            "trouble removing directory %s\n", name);
                    120:                        return r;
                    121:                }
                    122:        }
                    123: 
                    124:        return 0;
                    125: }

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