gen/scandir.c

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