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

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.