1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 1997 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 /*
31  * University Copyright- Copyright (c) 1982, 1986, 1988
32  * The Regents of the University of California
33  * All Rights Reserved
34  *
35  * University Acknowledgment- Portions of this document are derived from
36  * software developed by the University of California, Berkeley, and its
37  * contributors.
38  */
39 
40 #pragma ident	"%Z%%M%	%I%	%E% SMI"
41 
42 /*LINTLIBRARY*/
43 
44 /*
45  * Scan the directory dirname calling select to make a list of selected
46  * directory entries then sort using qsort and compare routine dcomp.
47  * Returns the number of entries and a pointer to a list of pointers to
48  * struct direct (through namelist). Returns -1 if there were any errors.
49  */
50 
51 #include <sys/types.h>
52 #include <sys/stat.h>
53 #include <sys/dir.h>
54 #include <errno.h>
55 #include <limits.h>
56 #include <stdlib.h>
57 #include <string.h>
58 
59 /*
60  * The macro DIRSIZ(dp) gives an amount of space required to represent
61  * a directory entry.  For any directory entry dp->d_reclen >= DIRSIZ(dp).
62  * Specific filesystem types may use this use this macro to construct the value
63  * for d_reclen.
64  */
65 #undef DIRSIZ
66 #define	DIRSIZ(dp)  \
67 	((sizeof (struct direct) - sizeof ((dp)->d_name) + \
68 	(strlen((dp)->d_name)+1) + 3) & ~3)
69 
70 #if !defined(_LP64)
71 int
scandir64(char * dirname,struct direct64 * (* namelist[]),int (* select)(struct direct64 *),int (* dcomp)(struct direct64 **,struct direct64 **))72 scandir64(char *dirname, struct direct64 *(*namelist[]),
73     int (*select)(struct direct64 *),
74     int (*dcomp)(struct direct64 **, struct direct64 **))
75 {
76 	struct direct64 *d, *p, **names;
77 	int nitems;
78 	char *cp1, *cp2;
79 	struct stat64 stb;
80 	long arraysz;
81 	DIR *dirp;
82 
83 	if ((dirp = opendir(dirname)) == NULL)
84 		return (-1);
85 	if (fstat64(dirp->dd_fd, &stb) < 0)
86 		return (-1);
87 
88 	/*
89 	 * estimate the array size by taking the size of the directory file
90 	 * and dividing it by a multiple of the minimum size entry.
91 	 */
92 	arraysz = (stb.st_size / 24);
93 	names = (struct direct64 **)malloc(arraysz *
94 		sizeof (struct direct64 *));
95 	if (names == NULL)
96 		return (-1);
97 
98 	nitems = 0;
99 	while ((d = readdir64(dirp)) != NULL) {
100 		if (select != NULL && !(*select)(d))
101 			continue;	/* just selected names */
102 		/*
103 		 * Make a minimum size copy of the data
104 		 */
105 		p = (struct direct64 *)malloc(DIRSIZ64(d));
106 		if (p == NULL)
107 			return (-1);
108 		p->d_ino = d->d_ino;
109 		p->d_reclen = d->d_reclen;
110 		p->d_namlen = d->d_namlen;
111 		for (cp1 = p->d_name, cp2 = d->d_name; *cp1++ = *cp2++; )
112 			;
113 		/*
114 		 * Check to make sure the array has space left and
115 		 * realloc the maximum size.
116 		 */
117 		if (++nitems >= arraysz) {
118 			if (fstat64(dirp->dd_fd, &stb) < 0)
119 				return (-1);	/* just might have grown */
120 			arraysz = stb.st_size / 12;
121 			names = (struct direct64 **)realloc((char *)names,
122 				arraysz * sizeof (struct direct64 *));
123 			if (names == NULL)
124 				return (-1);
125 		}
126 		names[nitems-1] = p;
127 	}
128 	(void) closedir(dirp);
129 	if (nitems && dcomp != NULL)
130 		qsort(names, nitems, sizeof (struct direct64 *),
131 			(int(*)(const void *, const void *)) dcomp);
132 	*namelist = names;
133 	return (nitems);
134 }
135 #endif
136 
137 
138 int
scandir(char * dirname,struct direct * (* namelist[]),int (* select)(struct direct *),int (* dcomp)(struct direct **,struct direct **))139 scandir(char *dirname, struct direct *(*namelist[]),
140     int (*select)(struct direct *),
141     int (*dcomp)(struct direct **, struct direct **))
142 {
143 	struct direct *d, *p, **names;
144 	int nitems;
145 	char *cp1, *cp2;
146 	struct stat64 stb;
147 	long arraysz;
148 	DIR *dirp;
149 
150 	if ((dirp = opendir(dirname)) == NULL)
151 		return (-1);
152 	if (fstat64(dirp->dd_fd, &stb) < 0)
153 		return (-1);
154 	/*
155 	 * estimate the array size by taking the size of the directory file
156 	 * and dividing it by a multiple of the minimum size entry.
157 	 */
158 	if (stb.st_size > SSIZE_MAX) {
159 		errno = EOVERFLOW;
160 		return (-1);
161 	}
162 	arraysz = (stb.st_size / 24);
163 
164 	names = (struct direct **)malloc(arraysz * sizeof (struct direct *));
165 	if (names == NULL)
166 		return (-1);
167 
168 	nitems = 0;
169 	while ((d = readdir(dirp)) != NULL) {
170 		if (select != NULL && !(*select)(d))
171 			continue;	/* just selected names */
172 		/*
173 		 * Make a minimum size copy of the data
174 		 */
175 		p = (struct direct *)malloc(DIRSIZ(d));
176 		if (p == NULL)
177 			return (-1);
178 		p->d_ino = d->d_ino;
179 		p->d_reclen = d->d_reclen;
180 		p->d_namlen = d->d_namlen;
181 		for (cp1 = p->d_name, cp2 = d->d_name; *cp1++ = *cp2++; )
182 			;
183 		/*
184 		 * Check to make sure the array has space left and
185 		 * realloc the maximum size.
186 		 */
187 		if (++nitems >= arraysz) {
188 			if (fstat64(dirp->dd_fd, &stb) < 0)
189 				return (-1);	/* just might have grown */
190 			arraysz = stb.st_size / 12;
191 			names = (struct direct **)realloc((char *)names,
192 				arraysz * sizeof (struct direct *));
193 			if (names == NULL)
194 				return (-1);
195 		}
196 		names[nitems-1] = p;
197 	}
198 	(void) closedir(dirp);
199 	if (nitems && dcomp != NULL)
200 		qsort(names, nitems, sizeof (struct direct *),
201 			(int(*)(const void *, const void *)) dcomp);
202 	*namelist = names;
203 	return (nitems);
204 }
205 
206 /*
207  * Alphabetic order comparison routine for those who want it.
208  */
209 int
alphasort(struct direct ** d1,struct direct ** d2)210 alphasort(struct direct **d1, struct direct **d2)
211 {
212 	return (strcmp((*d1)->d_name, (*d2)->d_name));
213 }
214 
215 #if !defined(_LP64)
216 int
alphasort64(struct direct64 ** d1,struct direct64 ** d2)217 alphasort64(struct direct64 **d1, struct direct64 **d2)
218 {
219 	return (strcmp((*d1)->d_name, (*d2)->d_name));
220 }
221 #endif
222