Return to pdirread.c CVS log

Up to [Research Unix] / researchv10dc / libc / gen / tmp

Annotation of researchv10dc/libc/gen/tmp/pdirread.c, revision 1.1

1.1     ! root        1: /* simulate new system call */
        !             2: /* output is up to cnt bytes (up to some max)
        !             3:  * each directory entry gets a string which is
        !             4:  * the ascii representation of the inode number, a tab, and the
        !             5:  * zero-terminated file name.  these zero-terminated strings are packed together
        !             6:  * This implementation freely returns short reads.  End of directory
        !             7:  * is a 0 length read, -1 and ENOSPC indicate that cnt couldn't hold
        !             8:  * even the next entry
        !             9:  */
        !            10: #include "sys/types.h"
        !            11: #include "sys/dir.h"
        !            12: #include "errno.h"
        !            13: 
        !            14: char mb[4096], ncnv[23];
        !            15: pdirread(fd, buf, cnt)
        !            16: char *buf;
        !            17: {      int n, m, j, loc;
        !            18:        char *p, *lp;
        !            19:        struct direct *d;
        !            20: 
        !            21:        loc = lseek(fd, 0, 1);
        !            22:        n = read(fd, mb, sizeof(mb));
        !            23:        if(n <= 0)
        !            24:                return(n);
        !            25:        lp = p = buf;
        !            26:        d = (struct direct *) mb;
        !            27: loop:
        !            28:        if(d->d_ino == 0)
        !            29:                goto incr;
        !            30:        for(m = d->d_ino, j = 22; m; j--) {
        !            31:                ncnv[j] = m % 10 + '0';
        !            32:                m /= 10;
        !            33:        }
        !            34:        for(++j; j < 23 && p < buf + cnt; )
        !            35:                *p++ = ncnv[j++];
        !            36:        if(j != 23 || p >= buf + cnt)
        !            37:                goto early;
        !            38:        *p++ = '\t';
        !            39:        for(j = 0; d->d_name[j] && j < DIRSIZ && p < buf + cnt; j++)
        !            40:                *p++ = d->d_name[j];
        !            41:        if(p >= buf + cnt)
        !            42:                goto early;
        !            43:        *p++ = 0;
        !            44: incr:
        !            45:        lp = p;
        !            46:        n -= sizeof(*d);
        !            47:        d++;
        !            48:        if(lp < buf + cnt && n > 0)
        !            49:                goto loop;
        !            50: done:
        !            51:        lseek(fd, loc + (char *)d - mb, 0);
        !            52:        return(lp - buf);
        !            53: early:
        !            54:        *lp = 0;
        !            55:        if((char *)d != mb)
        !            56:                goto done;
        !            57:        errno = ENOSPC;
        !            58:        return(-1);
        !            59: }

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