/* * get next entry in a directory. */ struct dirent * _readdir_unlocked(DIR *dirp, int skipdeleted) { struct dirent *dp; for (;;) { if (dirp->dd_loc >= dirp->dd_size) { if (dirp->dd_flags & __DTF_READALL) return (NULL); dirp->dd_loc = 0; } if (dirp->dd_loc == 0 && !(dirp->dd_flags & __DTF_READALL)) { dirp->dd_seek = lseek(dirp->dd_fd, (off_t)0, SEEK_CUR); dirp->dd_size = getdents(dirp->dd_fd, dirp->dd_buf, (size_t)dirp->dd_len); if (dirp->dd_size <= 0) return (NULL); } dp = (struct dirent *) (void *)(dirp->dd_buf + (size_t)dirp->dd_loc); if ((intptr_t)dp & _DIRENT_ALIGN(dp))/* bogus pointer check */ return (NULL); /* d_reclen is unsigned; no need to compare it <= 0 */ if (dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return (NULL); dirp->dd_loc += dp->d_reclen; if (dp->d_ino == 0 && skipdeleted) continue; #ifndef __minix if (dp->d_type == DT_WHT && (dirp->dd_flags & DTF_HIDEW)) continue; #endif return (dp); } }
/* * get next entry in a directory. */ struct dirent * _readdir_unlocked(DIR *dirp, int skipdeleted) { struct dirent *dp; for (;;) { if (dirp->dd_loc >= dirp->dd_size) { if (dirp->dd_flags & __DTF_READALL) return (NULL); dirp->dd_loc = 0; } if (dirp->dd_loc == 0 && !(dirp->dd_flags & __DTF_READALL)) { dirp->dd_size = (long)read(dirp->dd_fd, dirp->dd_buf, (size_t)dirp->dd_len); if (dirp->dd_size <= 0) return (NULL); } dp = (struct dirent *) (void *)(dirp->dd_buf + (size_t)dirp->dd_loc); if ((intptr_t)dp & _DIRENT_ALIGN(dp))/* bogus pointer check */ return (NULL); dirp->dd_loc += (long)dp->Size; if ((dp->Attribute & DT_HIDDEN) && (dirp->dd_flags & DTF_HIDEW)) continue; return (dp); } }
int _initdir(DIR *dirp, int fd, const char *name) { int flags = dirp->dd_flags; int pagesz; int incr; /* * If the machine's page size is an exact multiple of DIRBLKSIZ, * use a buffer that is cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdents() */ if (((pagesz = getpagesize()) % DIRBLKSIZ) == 0) incr = pagesz; else incr = DIRBLKSIZ; if ((flags & DTF_REWIND) && name == NULL) { return EINVAL; } if ((flags & __DTF_READALL) != 0) { size_t len; size_t space; char *buf, *nbuf; char *ddptr; char *ddeptr; int n; struct dirent **dpv; int i; /* * The strategy here for directories on top of a union stack * is to read all the directory entries into a buffer, sort * the buffer, and remove duplicate entries by setting the * inode number to zero. * * For directories on an NFS mounted filesystem, we try * to get a consistent snapshot by trying until we have * successfully read all of the directory without errors * (i.e. 'bad cookie' errors from the server because * the directory was modified). These errors should not * happen often, but need to be dealt with. */ i = 0; retry: len = 0; space = 0; buf = 0; ddptr = 0; do { /* * Always make at least DIRBLKSIZ bytes * available to getdents */ if (space < DIRBLKSIZ) { space += incr; len += incr; nbuf = realloc(buf, len); if (nbuf == NULL) { dirp->dd_buf = buf; return errno; } buf = nbuf; ddptr = buf + (len - space); } dirp->dd_seek = lseek(fd, (off_t)0, SEEK_CUR); n = getdents(fd, ddptr, space); /* * For NFS: EINVAL means a bad cookie error * from the server. Keep trying to get a * consistent view, in this case this means * starting all over again. */ if (n == -1 && errno == EINVAL && (flags & __DTF_RETRY_ON_BADCOOKIE) != 0) { free(buf); lseek(fd, (off_t)0, SEEK_SET); if (++i > MAXITERATIONS) return EINVAL; goto retry; } if (n > 0) { ddptr += n; space -= n; } } while (n > 0); ddeptr = ddptr; /* * Re-open the directory. * This has the effect of rewinding back to the * top of the union stack and is needed by * programs which plan to fchdir to a descriptor * which has also been read -- see fts.c. */ if (flags & DTF_REWIND) { (void) close(fd); if ((fd = open(name, O_RDONLY | O_CLOEXEC)) == -1) { dirp->dd_buf = buf; return errno; } } /* * There is now a buffer full of (possibly) duplicate * names. */ dirp->dd_buf = buf; /* * Go round this loop twice... * * Scan through the buffer, counting entries. * On the second pass, save pointers to each one. * Then sort the pointers and remove duplicate names. */ if ((flags & DTF_NODUP) != 0) { for (dpv = 0;;) { for (n = 0, ddptr = buf; ddptr < ddeptr;) { struct dirent *dp; dp = (struct dirent *)(void *)ddptr; if ((long)dp & _DIRENT_ALIGN(dp)) break; /* * d_reclen is unsigned, * so no need to compare <= 0 */ if (dp->d_reclen > (ddeptr + 1 - ddptr)) break; ddptr += dp->d_reclen; if (dp->d_fileno) { if (dpv) dpv[n] = dp; n++; } } if (dpv) { struct dirent *xp; /* * This sort must be stable. */ mergesort(dpv, (size_t)n, sizeof(*dpv), alphasort); dpv[n] = NULL; xp = NULL; /* * Scan through the buffer in sort * order, zapping the inode number * of any duplicate names. */ for (n = 0; dpv[n]; n++) { struct dirent *dp = dpv[n]; if ((xp == NULL) || strcmp(dp->d_name, xp->d_name)) xp = dp; else dp->d_fileno = 0; #ifndef __minix if (dp->d_type == DT_WHT && (flags & DTF_HIDEW)) dp->d_fileno = 0; #endif } free(dpv); break; } else { dpv = malloc((n + 1) * sizeof(struct dirent *)); if (dpv == NULL) break; } } } _DIAGASSERT(__type_fit(int, len)); dirp->dd_len = (int)len; dirp->dd_size = ddptr - dirp->dd_buf; } else { dirp->dd_len = incr; dirp->dd_buf = malloc((size_t)dirp->dd_len); if (dirp->dd_buf == NULL) return errno; dirp->dd_seek = 0; flags &= ~DTF_REWIND; } dirp->dd_loc = 0; dirp->dd_fd = fd; dirp->dd_flags = flags; /* * Set up seek point for rewinddir. */ (void)_telldir_unlocked(dirp); return 0; }
static DIR * __opendir_common(int fd, const char *name, int flags) { DIR *dirp = NULL; int serrno; struct stat sb; int pagesz; int incr; int unionstack, nfsdir; struct statvfs sfb; _DIAGASSERT(name != NULL); if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) goto error; if (fstat(fd, &sb) || !S_ISDIR(sb.st_mode)) { errno = ENOTDIR; goto error; } if ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL) goto error; dirp->dd_buf = NULL; /* * If the machine's page size is an exact multiple of DIRBLKSIZ, * use a buffer that is cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdirentries() */ if (((pagesz = getpagesize()) % DIRBLKSIZ) == 0) incr = pagesz; else incr = DIRBLKSIZ; /* * Determine whether this directory is the top of a union stack. */ if (fstatvfs1(fd, &sfb, ST_NOWAIT) < 0) goto error; if (flags & DTF_NODUP) unionstack = !(strncmp(sfb.f_fstypename, MOUNT_UNION, sizeof(sfb.f_fstypename))) || (sfb.f_flag & MNT_UNION); else unionstack = 0; nfsdir = !(strncmp(sfb.f_fstypename, MOUNT_NFS, sizeof(sfb.f_fstypename))); if (unionstack || nfsdir) { size_t len; size_t space; char *buf, *nbuf; char *ddptr; char *ddeptr; int n; struct dirent **dpv; int i; /* * The strategy here for directories on top of a union stack * is to read all the directory entries into a buffer, sort * the buffer, and remove duplicate entries by setting the * inode number to zero. * * For directories on an NFS mounted filesystem, we try * to get a consistent snapshot by trying until we have * successfully read all of the directory without errors * (i.e. 'bad cookie' errors from the server because * the directory was modified). These errors should not * happen often, but need to be dealt with. */ i = 0; retry: len = 0; space = 0; buf = 0; ddptr = 0; do { /* * Always make at least DIRBLKSIZ bytes * available to getdirentries */ if (space < DIRBLKSIZ) { space += incr; len += incr; nbuf = realloc(buf, len); if (nbuf == NULL) { dirp->dd_buf = buf; goto error; } buf = nbuf; ddptr = buf + (len - space); } dirp->dd_seek = lseek(fd, (off_t)0, SEEK_CUR); n = getdents(fd, ddptr, space); /* * For NFS: EINVAL means a bad cookie error * from the server. Keep trying to get a * consistent view, in this case this means * starting all over again. */ if (n == -1 && errno == EINVAL && nfsdir) { free(buf); lseek(fd, (off_t)0, SEEK_SET); if (++i > MAXITERATIONS) goto error; goto retry; } if (n > 0) { ddptr += n; space -= n; } } while (n > 0); ddeptr = ddptr; flags |= __DTF_READALL; /* * Re-open the directory. * This has the effect of rewinding back to the * top of the union stack and is needed by * programs which plan to fchdir to a descriptor * which has also been read -- see fts.c. */ if (flags & DTF_REWIND) { (void) close(fd); if ((fd = open(name, O_RDONLY)) == -1 || fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) { dirp->dd_buf = buf; goto error; } } /* * There is now a buffer full of (possibly) duplicate * names. */ dirp->dd_buf = buf; /* * Go round this loop twice... * * Scan through the buffer, counting entries. * On the second pass, save pointers to each one. * Then sort the pointers and remove duplicate names. */ if (!nfsdir) { for (dpv = 0;;) { for (n = 0, ddptr = buf; ddptr < ddeptr;) { struct dirent *dp; dp = (struct dirent *)(void *)ddptr; if ((long)dp & _DIRENT_ALIGN(dp)) break; /* * d_reclen is unsigned, * so no need to compare <= 0 */ if (dp->d_reclen > (ddeptr + 1 - ddptr)) break; ddptr += dp->d_reclen; if (dp->d_fileno) { if (dpv) dpv[n] = dp; n++; } } if (dpv) { struct dirent *xp; /* * This sort must be stable. */ mergesort(dpv, (size_t)n, sizeof(*dpv), alphasort); dpv[n] = NULL; xp = NULL; /* * Scan through the buffer in sort * order, zapping the inode number * of any duplicate names. */ for (n = 0; dpv[n]; n++) { struct dirent *dp = dpv[n]; if ((xp == NULL) || strcmp(dp->d_name, xp->d_name)) xp = dp; else dp->d_fileno = 0; if (dp->d_type == DT_WHT && (flags & DTF_HIDEW)) dp->d_fileno = 0; } free(dpv); break; } else { dpv = malloc((n + 1) * sizeof(struct dirent *)); if (dpv == NULL) break; } } } dirp->dd_len = len; dirp->dd_size = ddptr - dirp->dd_buf; } else { dirp->dd_len = incr; dirp->dd_buf = malloc((size_t)dirp->dd_len); if (dirp->dd_buf == NULL) goto error; dirp->dd_seek = 0; flags &= ~DTF_REWIND; } dirp->dd_loc = 0; dirp->dd_fd = fd; dirp->dd_flags = flags; /* * Set up seek point for rewinddir. */ #ifdef _REENTRANT if (__isthreaded) { if ((dirp->dd_lock = malloc(sizeof(mutex_t))) == NULL) goto error; mutex_init((mutex_t *)dirp->dd_lock, NULL); } #endif dirp->dd_internal = NULL; (void)_telldir_unlocked(dirp); return (dirp); error: serrno = errno; if (dirp && dirp->dd_buf) free(dirp->dd_buf); if (dirp) free(dirp); if (fd != -1) (void)close(fd); errno = serrno; return NULL; }