Return to seekdir.c CVS log

Up to [MW Coherent from dump] / coherent / d / usr / lib / ndir / libndir

Annotation of coherent/d/usr/lib/ndir/libndir/seekdir.c, revision 1.1.1.1

1.1       root        1: /*
                      2:        seekdir -- reposition a directory stream
                      3: 
                      4:        last edit:      25-Apr-1987     D A Gwyn
                      5: 
                      6:        An unsuccessful seekdir() will in general alter the current
                      7:        directory position; beware.
                      8: 
                      9:        NOTE:   4.nBSD directory compaction makes seekdir() & telldir()
                     10:                practically impossible to do right.  Avoid using them!
                     11: */
                     12: #ifdef COHERENT
                     13: #include       <errno.h>
                     14: #else
                     15: #include       <sys/errno.h>
                     16: #endif
                     17: 
                     18: #include       <sys/types.h>
                     19: #include       "dirent.h"
                     20: 
                     21: typedef daddr_t off_t; 
                     22: extern off_t   lseek();
                     23: 
                     24: extern int     errno;
                     25: 
                     26: #ifndef NULL
                     27: #define        NULL    0
                     28: #endif
                     29: 
                     30: #ifndef SEEK_SET
                     31: #define        SEEK_SET        0
                     32: #endif
                     33: 
                     34: typedef int    bool;                   /* Boolean data type */
                     35: #define        false   0
                     36: #define        true    1
                     37: 
                     38: void
                     39: seekdir( dirp, loc )
                     40:        register DIR            *dirp;  /* stream from opendir() */
                     41:        register off_t          loc;    /* position from telldir() */
                     42:        {
                     43:        register bool           rewind; /* "start over when stymied" flag */
                     44: 
                     45:        if ( dirp == NULL || dirp->dd_buf == NULL )
                     46:                {
                     47:                errno = EFAULT;
                     48:                return;                 /* invalid pointer */
                     49:                }
                     50: 
                     51:        /* A (struct dirent)'s d_off is an invented quantity on 4.nBSD
                     52:           NFS-supporting systems, so it is not safe to lseek() to it. */
                     53: 
                     54:        /* Monotonicity of d_off is heavily exploited in the following. */
                     55: 
                     56:        /* This algorithm is tuned for modest directory sizes.  For
                     57:           huge directories, it might be more efficient to read blocks
                     58:           until the first d_off is too large, then back up one block,
                     59:           or even to use binary search on the directory blocks.  I
                     60:           doubt that the extra code for that would be worthwhile. */
                     61: 
                     62:        if ( dirp->dd_loc >= dirp->dd_size      /* invalid index */
                     63:          || ((struct dirent *)&dirp->dd_buf[dirp->dd_loc])->d_off > loc
                     64:                                        /* too far along in buffer */
                     65:           )
                     66:                dirp->dd_loc = 0;       /* reset to beginning of buffer */
                     67:        /* else save time by starting at current dirp->dd_loc */
                     68: 
                     69:        for ( rewind = true; ; )
                     70:                {
                     71:                register struct dirent  *dp;
                     72: 
                     73:                /* See whether the matching entry is in the current buffer. */
                     74: 
                     75:                if ( (dirp->dd_loc < dirp->dd_size      /* valid index */
                     76:                   || readdir( dirp ) != NULL   /* next buffer read */
                     77:                   && (dirp->dd_loc = 0, true)  /* beginning of buffer set */
                     78:                     )
                     79:                  && (dp = (struct dirent *)&dirp->dd_buf[dirp->dd_loc])->d_off
                     80:                        <= loc          /* match possible in this buffer */
                     81:                   )    {
                     82:                        for ( /* dp initialized above */ ;
                     83:                              (char *)dp < &dirp->dd_buf[dirp->dd_size];
                     84:                              dp = (struct dirent *)((char *)dp + dp->d_reclen)
                     85:                            )
                     86:                                if ( dp->d_off == loc )
                     87:                                        {       /* found it! */
                     88:                                        dirp->dd_loc =
                     89:                                                (char *)dp - dirp->dd_buf;
                     90:                                        return;
                     91:                                        }
                     92: 
                     93:                        rewind = false; /* no point in backing up later */
                     94:                        dirp->dd_loc = dirp->dd_size;   /* set end of buffer */
                     95:                        }
                     96:                else                    /* whole buffer past matching entry */
                     97:                        if ( !rewind )
                     98:                                {       /* no point in searching further */
                     99:                                errno = EINVAL;
                    100:                                return; /* no entry at specified loc */
                    101:                                }
                    102:                        else    {       /* rewind directory and start over */
                    103:                                rewind = false; /* but only once! */
                    104: 
                    105:                                dirp->dd_loc = dirp->dd_size = 0;
                    106: 
                    107:                                if ( lseek( dirp->dd_fd, (off_t)0, SEEK_SET )
                    108:                                        != 0
                    109:                                   )
                    110:                                        return; /* errno already set (EBADF) */
                    111: 
                    112:                                if ( loc == 0 )
                    113:                                        return; /* save time for rewinddir() */
                    114:                                }
                    115:                }
                    116:        }

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