Return to dirdmp.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs / TEST / unix-tests / tools

Annotation of 43BSDReno/sys/nfs/TEST/unix-tests/tools/dirdmp.c, revision 1.1

1.1     ! root        1: /*     @(#)dirdmp.c    1.2 90/01/03 NFS Rev 2 Testsuite
        !             2:  *     1.2 Lachman ONC Test Suite source
        !             3:  */
        !             4: 
        !             5: #include <sys/param.h>
        !             6: #ifndef major
        !             7: #include <sys/types.h>
        !             8: #endif
        !             9: #ifdef SVR3
        !            10: #include <dirent.h>
        !            11: #else
        !            12: #include <sys/dir.h>
        !            13: #endif
        !            14: #include <stdio.h>
        !            15: #include <ctype.h>
        !            16: 
        !            17: main(argc, argv)
        !            18:        int argc;
        !            19:        char *argv[];
        !            20: {
        !            21:        argv++;
        !            22:        argc--;
        !            23:        while (argc--) {
        !            24:                print(*argv++);
        !            25:        }
        !            26: }
        !            27: 
        !            28: print(dir)
        !            29:        char *dir;
        !            30: {
        !            31:        DIR *dirp;
        !            32: #ifdef SVR3
        !            33:        struct dirent *dp;
        !            34: #else
        !            35:        struct direct *dp;
        !            36: #endif
        !            37:        int rec = 0;
        !            38: 
        !            39:        dirp = opendir(dir);
        !            40:        if (dirp == NULL) {
        !            41:                perror(dir);
        !            42:                return;
        !            43:        }
        !            44:        while ((dp = readdir(dirp)) != NULL) ;
        !            45:        closedir(dirp);
        !            46: }
        !            47: 
        !            48: #include <sys/stat.h>
        !            49: 
        !            50: /*
        !            51:  * open a directory.
        !            52:  */
        !            53: DIR *
        !            54: opendir(name)
        !            55:        char *name;
        !            56: {
        !            57:        register DIR *dirp;
        !            58:        register int fd;
        !            59:        struct stat sb;
        !            60:        extern char *malloc();
        !            61: 
        !            62:        if ((fd = open(name, 0)) == -1) {
        !            63:                printf("open failed\n");
        !            64:                return (NULL);
        !            65:        }
        !            66:        if (fstat(fd, &sb) == -1) {
        !            67:                printf("stat failed\n");
        !            68:                return (NULL);
        !            69:        }
        !            70:        /*
        !            71:        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
        !            72:                printf("not a directory\n");
        !            73:                return (NULL);
        !            74:        }
        !            75:        */
        !            76:        printf("%s mode %o dir %o\n", name, sb.st_mode, S_IFDIR);
        !            77:        if (((dirp = (DIR *)malloc(sizeof(DIR))) == NULL) ||
        !            78: #ifdef SVR3
        !            79:            ((dirp->dd_buf = malloc(DIRBUF)) == NULL)) {
        !            80: #else
        !            81:            ((dirp->dd_buf = malloc((int)sb.st_blksize)) == NULL)) {
        !            82: #endif
        !            83:                if (dirp) {
        !            84:                        if (dirp->dd_buf) {
        !            85:                                free(dirp->dd_buf);
        !            86:                        }
        !            87:                        free(dirp);
        !            88:                }
        !            89:                close(fd);
        !            90:                return (NULL);
        !            91:        }
        !            92: #ifndef SVR3
        !            93:        dirp->dd_bsize = sb.st_blksize;
        !            94:        dirp->dd_bbase = 0;
        !            95:        dirp->dd_entno = 0;
        !            96: #endif
        !            97:        dirp->dd_fd = fd;
        !            98:        dirp->dd_loc = 0;
        !            99:        return (dirp);
        !           100: }
        !           101: 
        !           102: /*
        !           103:  * get next entry in a directory.
        !           104:  */
        !           105: #ifdef SVR3
        !           106: struct dirent *
        !           107: #else
        !           108: struct direct *
        !           109: #endif
        !           110: readdir(dirp)
        !           111:        register DIR *dirp;
        !           112: {
        !           113: #ifdef SVR3
        !           114:        register struct dirent *dp;
        !           115: #else
        !           116:        register struct direct *dp;
        !           117: #endif
        !           118: 
        !           119:        for (;;) {
        !           120:                if (dirp->dd_loc == 0) {
        !           121: #ifdef SVR3
        !           122:                        dirp->dd_size = getdents(dirp->dd_fd,
        !           123:                            dirp->dd_buf, DIRBUF);
        !           124: #else
        !           125:                        dirp->dd_size = getdirentries(dirp->dd_fd,
        !           126:                            dirp->dd_buf, dirp->dd_bsize, &dirp->dd_bbase);
        !           127: #endif
        !           128:                        if (dirp->dd_size <= 0) {
        !           129:                                printf("EOF\n");
        !           130:                                return (NULL);
        !           131:                        }
        !           132: #ifndef SVR3
        !           133:                        dirp->dd_entno = 0;
        !           134: #endif
        !           135:                }
        !           136:                if (dirp->dd_loc >= dirp->dd_size) {
        !           137:                        printf("EOB offset %d\n", tell(dirp->dd_fd));
        !           138:                        dirp->dd_loc = 0;
        !           139:                        continue;
        !           140:                }
        !           141: #ifdef SVR3
        !           142:                dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc);
        !           143: #else
        !           144:                dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc);
        !           145: #endif
        !           146:                if (dp->d_reclen <= 0) {
        !           147:                        printf("0 reclen\n");
        !           148:                        return (NULL);
        !           149:                }
        !           150:                dirp->dd_loc += dp->d_reclen;
        !           151: #ifndef SVR3
        !           152:                dirp->dd_entno++;
        !           153: #endif
        !           154: #ifdef SVR3
        !           155:                printf("%5d %5ld %5d %s\n",
        !           156:                    dirp->dd_loc, dp->d_ino, dp->d_reclen,
        !           157:                    dp->d_name);
        !           158: #else
        !           159:                printf("%5d %5d %5d %5d %s\n",
        !           160:                    dirp->dd_loc, dp->d_fileno, dp->d_reclen,
        !           161:                    dp->d_namlen, dp->d_name);
        !           162: #endif
        !           163: #ifdef SVR3
        !           164:                if (dp->d_ino == 0) {
        !           165: #else
        !           166:                if (dp->d_fileno == 0) {
        !           167: #endif
        !           168:                        continue;
        !           169:                }
        !           170:                return (dp);
        !           171:        }
        !           172: }

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