Return to mkdir.c CVS log

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

Annotation of researchv10no/cmd/asd/mkdir.c, revision 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:        case FTW_SL:
        !            98:                r = unlink (name);
        !            99:                if (r < 0) {
        !           100:                        perror (name);
        !           101:                        return r;
        !           102:                }
        !           103:                break;
        !           104:        
        !           105:        case FTW_D:
        !           106:                break;
        !           107:        
        !           108:        case FTW_DNR:
        !           109:                fprintf (stderr, "cannot read directory %s\n", name);
        !           110:                exit (1);
        !           111:        
        !           112:        case FTW_NS:
        !           113:                fprintf (stderr, "cannot stat %s\n", name);
        !           114:                exit (1);
        !           115:        
        !           116:        case FTW_DP:
        !           117:                r = rmdir (name);
        !           118:                if (r != 0) {
        !           119:                        fprintf (stderr,
        !           120:                            "trouble removing directory %s\n", name);
        !           121:                        return r;
        !           122:                }
        !           123:        }
        !           124: 
        !           125:        return 0;
        !           126: }

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