Return to readdir.c CVS log

Up to [Research Unix] / researchv10no / libc / gen

Annotation of researchv10no/libc/gen/readdir.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1982 Regents of the University of California */
        !             2: /* and modified by pjw in 1986 and 1987, dmg in 1989 */
        !             3: 
        !             4: #include <sys/types.h> /* only for ino_t */
        !             5: #include "ndir.h"
        !             6: #include <ctype.h>
        !             7: 
        !             8: /*
        !             9:  * get next entry in a directory.
        !            10:  *
        !            11:  * subtlety:
        !            12:  * ino_t is still a 16-bit type,
        !            13:  * but i-numbers returned by dirread or pdirread may be larger.
        !            14:  * stat returns an ino_t in st_ino.
        !            15:  * d_ino is a long.
        !            16:  * if d_ino has 32 significant bits, programs like pwd may fail.
        !            17:  * if it is truncated to 16, information is lost.
        !            18:  * it would be helpful to fix stat, but it wouldn't be a magic cure;
        !            19:  * the i-number from dirread may have more than 32 bits!
        !            20:  * truncate for now, via dir.d_ino = (ino_t) ...
        !            21:  *
        !            22:  * most of the tedious code below is error checking
        !            23:  */
        !            24: struct direct *
        !            25: readdir(dirp)
        !            26: register DIR *dirp;
        !            27: {
        !            28:        static struct direct dir;
        !            29:        register char *p;
        !            30:        register int i;
        !            31: 
        !            32: loop:
        !            33:        if (dirp->dd_size <= 0 || dirp->dd_loc >= dirp->dd_size) {
        !            34:                dirp->dd_offset++;      /* see seekdir.c */
        !            35:                dirp->dd_size = dirread(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ-1);
        !            36:                if(dirp->dd_size < 0)
        !            37:                        dirp->dd_size = pdirread(dirp->dd_fd, dirp->dd_buf,
        !            38:                                DIRBLKSIZ-1);
        !            39:                if(dirp->dd_size <= 0)
        !            40:                        return(0);
        !            41:                dirp->dd_loc = 0;
        !            42:                dirp->dd_buf[dirp->dd_size] = 0;        /* sentinel */
        !            43:        }
        !            44:        p = dirp->dd_buf + dirp->dd_loc;
        !            45:        dir.d_ino = 0;
        !            46:        while (isdigit(*p))
        !            47:                dir.d_ino = dir.d_ino*10 + *p++ - '0';
        !            48:        dir.d_ino = (ino_t)dir.d_ino;
        !            49:        while (*p != '\t')      /* in case we add fields someday */
        !            50:                if (*p++ == 0) {        /* badly formed */
        !            51:                        dirp->dd_loc = p - dirp->dd_buf;
        !            52:                        goto loop;
        !            53:                }
        !            54:        p++;
        !            55:        for (i = 0; i < MAXNAMLEN; i++)
        !            56:                if ((dir.d_name[i] = *p++) == 0)
        !            57:                        break;
        !            58:        if (i >= MAXNAMLEN && *p++ != 0) {      /* name too long */
        !            59:                while (*p++)
        !            60:                        ;
        !            61:                dirp->dd_loc = p - dirp->dd_buf;
        !            62:                goto loop;
        !            63:        }
        !            64:        dir.d_name[i] = 0;
        !            65:        dir.d_namlen = i;
        !            66:        dir.d_reclen = sizeof(dir);     /* bogus, but who cares? */
        !            67:        dirp->dd_loc = p - dirp->dd_buf;
        !            68:        if (dirp->dd_loc > dirp->dd_size)       /* hit the sentinel */
        !            69:                goto loop;
        !            70:        return (&dir);
        !            71: }

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