buf = nbuf;
__opendir2(name, flags)	const char *name;	int flags;{	DIR *dirp;	int fd;	struct stat sb;	int pagesz;	int incr;	int unionstack;	if ((fd = open(name, O_RDONLY | O_NONBLOCK)) == -1)		return (NULL);	if (fstat(fd, &sb) || !S_ISDIR(sb.st_mode)) {		errno = ENOTDIR;		close(fd);		return (NULL);	}	if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1 ||	    (dirp = (DIR *)malloc(sizeof(DIR))) == NULL) {		close(fd);		return (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 (flags & DTF_NODUP) {		struct statfs sfb;		if (fstatfs(fd, &sfb) < 0) {			free(dirp);			close(fd);			return (NULL);		}		unionstack = strncmp(sfb.f_fstypename, MOUNT_UNION, MFSNAMELEN) == 0 ||			     (sfb.f_flags & MNT_UNION);	} else {		unionstack = 0;	}	if (unionstack) {		int len = 0;		int space = 0;		char *buf = 0;		char *ddptr = 0;		char *ddeptr;		int n;		struct dirent **dpv;		/*		 * The strategy here is to read all the directory		 * entries into a buffer, sort the buffer, and		 * remove duplicate entries by setting the inode		 * number to zero.		 */		do {			/*			 * Always make at least DIRBLKSIZ bytes			 * available to getdirentries			 */			if (space < DIRBLKSIZ) {				char *nbuf;				space += incr;				len += incr;				nbuf = realloc(buf, len);				if (nbuf == NULL) {					if (buf)						free(buf);					free(dirp);					close(fd);					return (NULL);				}				ddptr = buf + (len - space);			}			n = getdirentries(fd, ddptr, space, &dirp->dd_seek);			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) {				free(buf);				free(dirp);				return (NULL);			}		}		/*		 * 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.		 */		for (dpv = 0;;) {			for (n = 0, ddptr = buf; ddptr < ddeptr;) {				struct dirent *dp;				dp = (struct dirent *) ddptr;				if ((long)dp & 03)					break;				if ((dp->d_reclen <= 0) ||				    (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, 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(dirp->dd_len);		if (dirp->dd_buf == NULL) {			free(dirp);			close (fd);			return (NULL);		}		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.	 */	dirp->dd_rewind = telldir(dirp);	return (dirp);}