Return to ndir.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / news / src

Annotation of 43BSDTahoe/new/news/src/ndir.c, revision 1.1.1.1

1.1       root        1: #include "defs.h"
                      2: #if !defined(BSD4_2) && !defined(BSD4_1C) && !defined(HP9K5)
                      3: #ifdef M_XENIX
                      4: #include <sys/types.h>
                      5: #endif /* M_XENIX */
                      6: #include <sys/param.h>
                      7: #include "ndir.h"
                      8: 
                      9: #ifdef SCCSID
                     10: static char    *SccsId = "@(#)ndir.c   1.12    10/15/87";
                     11: #endif /* SCCSID */
                     12: 
                     13: /*
                     14:  * support for Berkeley directory reading routine on a V7 file system
                     15:  */
                     16: 
                     17: extern char *malloc();
                     18: 
                     19: /*
                     20:  * open a directory.
                     21:  */
                     22: DIR *
                     23: opendir(name)
                     24: char *name;
                     25: {
                     26:        register DIR *dirp;
                     27:        register int fd;
                     28: 
                     29:        if ((fd = open(name, 0)) == -1)
                     30:                return NULL;
                     31:        if ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL) {
                     32:                close (fd);
                     33:                return NULL;
                     34:        }
                     35:        dirp->dd_fd = fd;
                     36:        dirp->dd_loc = 0;
                     37:        return dirp;
                     38: }
                     39: 
                     40: /*
                     41:  * read an old style directory entry and present it as a new one
                     42:  */
                     43: #ifdef pyr
                     44: /* Pyramid in the AT&T universe */
                     45: #define ODIRSIZ 248
                     46: struct olddirect {
                     47:        long    od_ino;
                     48:        short   od_fill1, od_fill2;
                     49:        char od_name[ODIRSIZ];
                     50: };
                     51: #else /* V7 file system */
                     52: #define        ODIRSIZ 14
                     53: 
                     54: struct olddirect {
                     55:        short   od_ino;
                     56:        char    od_name[ODIRSIZ];
                     57: };
                     58: #endif /* !pyr */
                     59: 
                     60: /*
                     61:  * get next entry in a directory.
                     62:  */
                     63: struct direct *
                     64: readdir(dirp)
                     65: register DIR *dirp;
                     66: {
                     67:        register struct olddirect *dp;
                     68:        static struct direct dir;
                     69: 
                     70:        for (;;) {
                     71:                if (dirp->dd_loc == 0) {
                     72:                        dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, 
                     73:                            DIRBLKSIZ);
                     74:                        if (dirp->dd_size <= 0)
                     75:                                return NULL;
                     76:                }
                     77:                if (dirp->dd_loc >= dirp->dd_size) {
                     78:                        dirp->dd_loc = 0;
                     79:                        continue;
                     80:                }
                     81:                dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
                     82:                dirp->dd_loc += sizeof(struct olddirect);
                     83:                if (dp->od_ino == 0)
                     84:                        continue;
                     85:                dir.d_ino = dp->od_ino;
                     86:                strncpy(dir.d_name, dp->od_name, ODIRSIZ);
                     87:                dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
                     88:                dir.d_namlen = strlen(dir.d_name);
                     89:                dir.d_reclen = DIRSIZ(&dir);
                     90:                return (&dir);
                     91:        }
                     92: }
                     93: 
                     94: /*
                     95:  * close a directory.
                     96:  */
                     97: void
                     98: closedir(dirp)
                     99: register DIR *dirp;
                    100: {
                    101:        close(dirp->dd_fd);
                    102:        dirp->dd_fd = -1;
                    103:        dirp->dd_loc = 0;
                    104:        free((char *)dirp);
                    105: }
                    106: 
                    107: /*
                    108:  * seek to an entry in a directory.
                    109:  * Only values returned by "telldir" should be passed to seekdir.
                    110:  */
                    111: void
                    112: seekdir(dirp, loc)
                    113: register DIR *dirp;
                    114: long loc;
                    115: {
                    116:        long curloc, base, offset;
                    117:        struct direct *dp;
                    118:        long lseek(), telldir();
                    119: 
                    120:        curloc = telldir(dirp);
                    121:        if (loc == curloc)
                    122:                return;
                    123:        base = loc & ~(DIRBLKSIZ - 1);
                    124:        offset = loc & (DIRBLKSIZ - 1);
                    125:        (void) lseek(dirp->dd_fd, base, 0);
                    126:        dirp->dd_loc = 0;
                    127:        while (dirp->dd_loc < offset) {
                    128:                dp = readdir(dirp);
                    129:                if (dp == NULL)
                    130:                        return;
                    131:        }
                    132: }
                    133: 
                    134: /*
                    135:  * return a pointer into a directory
                    136:  */
                    137: long
                    138: telldir(dirp)
                    139: DIR *dirp;
                    140: {
                    141:        return lseek(dirp->dd_fd, 0L, 1) - dirp->dd_size + dirp->dd_loc;
                    142: }
                    143: #endif /* !BSD4_2 && !BSD4_1C && !HP9K5 */

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