Return to opendir.c CVS log

Up to [Micropolis - Activity] / micropolis / src / tcl / compat

Annotation of micropolis/src/tcl/compat/opendir.c, revision 1.1

1.1     ! root        1: /* 
        !             2:  * opendir.c --
        !             3:  *
        !             4:  *     This file provides dirent-style directory-reading procedures
        !             5:  *     for V7 Unix systems that don't have such procedures.  The
        !             6:  *     origin of this code is unclear, but it seems to have come
        !             7:  *     originally from Larry Wall.
        !             8:  *
        !             9:  */
        !            10: 
        !            11: #include <tclint.h>
        !            12: #include <tclunix.h>
        !            13: 
        !            14: #undef DIRSIZ
        !            15: #define DIRSIZ(dp) \
        !            16:     ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))
        !            17: 
        !            18: /*
        !            19:  * open a directory.
        !            20:  */
        !            21: DIR *
        !            22: opendir(name)
        !            23: char *name;
        !            24: {
        !            25:        register DIR *dirp;
        !            26:        register int fd;
        !            27:        char *myname;
        !            28: 
        !            29:        myname = ((*name == '\0') ? "." : name);
        !            30:        if ((fd = open(myname, 0, 0)) == -1)
        !            31:                return NULL;
        !            32:        if ((dirp = (DIR *)ckalloc(sizeof(DIR))) == NULL) {
        !            33:                close (fd);
        !            34:                return NULL;
        !            35:        }
        !            36:        dirp->dd_fd = fd;
        !            37:        dirp->dd_loc = 0;
        !            38:        return dirp;
        !            39: }
        !            40: 
        !            41: /*
        !            42:  * read an old style directory entry and present it as a new one
        !            43:  */
        !            44: #ifndef pyr
        !            45: #define        ODIRSIZ 14
        !            46: 
        !            47: struct olddirect {
        !            48:        ino_t   od_ino;
        !            49:        char    od_name[ODIRSIZ];
        !            50: };
        !            51: #else  /* a Pyramid in the ATT universe */
        !            52: #define        ODIRSIZ 248
        !            53: 
        !            54: struct olddirect {
        !            55:        long    od_ino;
        !            56:        short   od_fill1, od_fill2;
        !            57:        char    od_name[ODIRSIZ];
        !            58: };
        !            59: #endif
        !            60: 
        !            61: /*
        !            62:  * get next entry in a directory.
        !            63:  */
        !            64: struct dirent *
        !            65: readdir(dirp)
        !            66: register DIR *dirp;
        !            67: {
        !            68:        register struct olddirect *dp;
        !            69:        static struct dirent dir;
        !            70: 
        !            71:        for (;;) {
        !            72:                if (dirp->dd_loc == 0) {
        !            73:                        dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
        !            74:                            DIRBLKSIZ);
        !            75:                        if (dirp->dd_size <= 0)
        !            76:                                return NULL;
        !            77:                }
        !            78:                if (dirp->dd_loc >= dirp->dd_size) {
        !            79:                        dirp->dd_loc = 0;
        !            80:                        continue;
        !            81:                }
        !            82:                dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
        !            83:                dirp->dd_loc += sizeof(struct olddirect);
        !            84:                if (dp->od_ino == 0)
        !            85:                        continue;
        !            86:                dir.d_ino = dp->od_ino;
        !            87:                strncpy(dir.d_name, dp->od_name, ODIRSIZ);
        !            88:                dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
        !            89:                dir.d_namlen = strlen(dir.d_name);
        !            90:                dir.d_reclen = DIRSIZ(&dir);
        !            91:                return (&dir);
        !            92:        }
        !            93: }
        !            94: 
        !            95: /*
        !            96:  * close a directory.
        !            97:  */
        !            98: void
        !            99: closedir(dirp)
        !           100: register DIR *dirp;
        !           101: {
        !           102:        close(dirp->dd_fd);
        !           103:        dirp->dd_fd = -1;
        !           104:        dirp->dd_loc = 0;
        !           105:        ckfree((char *) dirp);
        !           106: }

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