Commit | Line | Data |
---|---|---|
15637ed4 RG |
1 | /* |
2 | * Copyright (c) 1983 Regents of the University of California. | |
3 | * All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions | |
7 | * are met: | |
8 | * 1. Redistributions of source code must retain the above copyright | |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * 2. Redistributions in binary form must reproduce the above copyright | |
11 | * notice, this list of conditions and the following disclaimer in the | |
12 | * documentation and/or other materials provided with the distribution. | |
13 | * 3. All advertising materials mentioning features or use of this software | |
14 | * must display the following acknowledgement: | |
15 | * This product includes software developed by the University of | |
16 | * California, Berkeley and its contributors. | |
17 | * 4. Neither the name of the University nor the names of its contributors | |
18 | * may be used to endorse or promote products derived from this software | |
19 | * without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
31 | * SUCH DAMAGE. | |
32 | */ | |
33 | ||
34 | #if defined(LIBC_SCCS) && !defined(lint) | |
35 | static char sccsid[] = "@(#)scandir.c 5.10 (Berkeley) 2/23/91"; | |
36 | #endif /* LIBC_SCCS and not lint */ | |
37 | ||
38 | /* | |
39 | * Scan the directory dirname calling select to make a list of selected | |
40 | * directory entries then sort using qsort and compare routine dcomp. | |
41 | * Returns the number of entries and a pointer to a list of pointers to | |
42 | * struct dirent (through namelist). Returns -1 if there were any errors. | |
43 | */ | |
44 | ||
45 | #include <sys/types.h> | |
46 | #include <sys/stat.h> | |
47 | #include <dirent.h> | |
48 | #include <stdlib.h> | |
49 | #include <string.h> | |
50 | ||
51 | /* | |
52 | * The DIRSIZ macro gives the minimum record length which will hold | |
53 | * the directory entry. This requires the amount of space in struct dirent | |
54 | * without the d_name field, plus enough space for the name with a terminating | |
55 | * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary. | |
56 | */ | |
57 | #undef DIRSIZ | |
58 | #define DIRSIZ(dp) \ | |
59 | ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3)) | |
60 | ||
61 | int | |
62 | scandir(dirname, namelist, select, dcomp) | |
63 | const char *dirname; | |
64 | struct dirent ***namelist; | |
65 | int (*select) __P((struct dirent *)); | |
66 | int (*dcomp) __P((const void *, const void *)); | |
67 | { | |
68 | register struct dirent *d, *p, **names; | |
69 | register size_t nitems; | |
70 | struct stat stb; | |
71 | long arraysz; | |
72 | DIR *dirp; | |
73 | ||
74 | if ((dirp = opendir(dirname)) == NULL) | |
75 | return(-1); | |
76 | if (fstat(dirp->dd_fd, &stb) < 0) | |
77 | return(-1); | |
78 | ||
79 | /* | |
80 | * estimate the array size by taking the size of the directory file | |
81 | * and dividing it by a multiple of the minimum size entry. | |
82 | */ | |
83 | arraysz = (stb.st_size / 24); | |
84 | names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); | |
85 | if (names == NULL) | |
86 | return(-1); | |
87 | ||
88 | nitems = 0; | |
89 | while ((d = readdir(dirp)) != NULL) { | |
90 | if (select != NULL && !(*select)(d)) | |
91 | continue; /* just selected names */ | |
92 | /* | |
93 | * Make a minimum size copy of the data | |
94 | */ | |
95 | p = (struct dirent *)malloc(DIRSIZ(d)); | |
96 | if (p == NULL) | |
97 | return(-1); | |
98 | p->d_ino = d->d_ino; | |
99 | p->d_reclen = d->d_reclen; | |
100 | p->d_namlen = d->d_namlen; | |
101 | bcopy(d->d_name, p->d_name, p->d_namlen + 1); | |
102 | /* | |
103 | * Check to make sure the array has space left and | |
104 | * realloc the maximum size. | |
105 | */ | |
106 | if (++nitems >= arraysz) { | |
107 | if (fstat(dirp->dd_fd, &stb) < 0) | |
108 | return(-1); /* just might have grown */ | |
109 | arraysz = stb.st_size / 12; | |
110 | names = (struct dirent **)realloc((char *)names, | |
111 | arraysz * sizeof(struct dirent *)); | |
112 | if (names == NULL) | |
113 | return(-1); | |
114 | } | |
115 | names[nitems-1] = p; | |
116 | } | |
117 | closedir(dirp); | |
118 | if (nitems && dcomp != NULL) | |
119 | qsort(names, nitems, sizeof(struct dirent *), dcomp); | |
120 | *namelist = names; | |
121 | return(nitems); | |
122 | } | |
123 | ||
124 | /* | |
125 | * Alphabetic order comparison routine for those who want it. | |
126 | */ | |
127 | int | |
128 | alphasort(d1, d2) | |
129 | const void *d1; | |
130 | const void *d2; | |
131 | { | |
132 | return(strcmp((*(struct dirent **)d1)->d_name, | |
133 | (*(struct dirent **)d2)->d_name)); | |
134 | } |