Return to mkdir.c CVS log

Up to [Research Unix] / researchv10no / cmd / odist / opkg

Annotation of researchv10no/cmd/odist/opkg/mkdir.c, revision 1.1

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

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