ref: 75e062c7753c7dd4229f00932ffa34f87fd7fead
dir: /DoConfig/fltk/src/scandir_posix.c/
/* * "$Id$" * * This implementation of 'scandir()' is intended to be POSIX.1-2008 compliant. * A POSIX.1-1990 compliant system is required as minimum base. * Note: * The 'const' declarations were removed to match FLTK 1.3 wrapper (STR #2931) * * Copyright (c) 2013 by Michael Baeuerle * * This library is free software. Distribution and use rights are outlined in * the file "COPYING" which should have been included with this file. If this * file is missing or damaged, see the license at: * * http://www.fltk.org/COPYING.php * * Please report all bugs and problems on the following page: * * http://www.fltk.org/str.php * * It is required that 'SIZE_MAX' is at least 'INT_MAX'. * Don't use a C++ compiler to build this module. * * The build system must define 'HAVE_PTHREAD' and link against a potentially * required library to switch this implementation into thread-safe mode. * The POSIX.1c-1995 extension is required if 'HAVE_PTHREAD' is defined. * * Note: * In theory, a system that provide threads should also provide 'readdir_r()', * a thread-safe version of 'readdir()'. In reality this is not always the case. * In addition there may be a race condition that can lead to a buffer overflow: * http://womble.decadent.org.uk/readdir_r-advisory.html */ #ifndef HAVE_PTHREAD /* Switch system headers into POSIX.1-1990 mode */ # define _POSIX_SOURCE #else /* HAVE_PTHREAD */ /* Switch system headers into POSIX.1c-1995 mode */ # define _POSIX_C_SOURCE 199506L #endif /* HAVE_PTHREAD */ #include <sys/types.h> /* XPG2 require this for '*dir()' functions */ #include <dirent.h> #include <errno.h> #include <stdlib.h> /* For 'malloc()', 'realloc()' and 'qsort()' */ #include <stddef.h> /* For 'offsetof()', 'NULL' and 'size_t' */ #include <limits.h> /* For 'INT_MAX' */ #include <string.h> /* For 'memcpy()' */ #if defined(HAVE_PTHREAD) && defined(HAVE_PTHREAD_H) # include <pthread.h> #endif /* HAVE_PTHREAD */ /* ========================================================================== */ /* At startup allocate memory for this number of result array elements */ #define ENTRIES_MIN (size_t) 32 /* ========================================================================== */ #ifdef HAVE_PTHREAD static pthread_mutex_t scandir_mutex = PTHREAD_MUTEX_INITIALIZER; #endif /* HAVE_PTHREAD */ /* ========================================================================== */ /* * This function reads the next entry from the directory referenced by 'dirp', * allocate a buffer for the entry and copy it into this buffer. * A pointer to this buffer is written to 'entryp' and the size of the buffer is * written to 'len'. * Success and a NULL pointer is returned for 'entryp' if there are no more * entries in the directory. * On sucess zero is returned and the caller is responsible for 'free()'ing the * buffer after use. * On error the return value is nonzero, 'entryp' and 'len' are invalid. * * Should be declared as 'static inline' if the compiler support that. */ static int readentry(DIR *dirp, struct dirent **entryp, size_t *len) { int result = -1; struct dirent *e; #ifdef HAVE_PTHREAD if (!pthread_mutex_lock(&scandir_mutex)) { /* Ensure that there is no code path that bypass the '_unlock()' call! */ #endif /* HAVE_PTHREAD */ errno = 0; e = readdir(dirp); if (NULL == e) { if (!errno) { /* No more entries in directory */ *entryp = NULL; *len = 0; result = 0; } } else { /* Entry found, allocate local buffer */ *len = offsetof(struct dirent, d_name) + strlen(e->d_name) + (size_t) 1; *entryp = (struct dirent *) malloc(*len); if (NULL != *entryp) { memcpy((void *) *entryp, (void *) e, *len); /* Force NUL termination at end of buffer */ ((char *) *entryp)[*len - (size_t) 1] = 0; result = 0; } } #ifdef HAVE_PTHREAD /* * In a multithreading environment the systems dirent buffer may be shared * between all threads. Therefore the mutex must stay locked until we have * copied the data to our thread local buffer. */ pthread_mutex_unlock(&scandir_mutex); } #endif /* HAVE_PTHREAD */ return result; } /* ========================================================================== */ int fl_scandir(const char *dir, struct dirent ***namelist, int (*sel)(struct dirent *), int (*compar)(struct dirent **, struct dirent **)) { int result = -1; DIR *dirp; size_t len, num = 0, max = ENTRIES_MIN; struct dirent *entryp, **entries, **p; entries = (struct dirent **) malloc(sizeof(*entries) * max); if (NULL != entries) { /* Open directory 'dir' (and verify that it really is a directory) */ dirp = opendir(dir); if (NULL != dirp) { /* Read next directory entry */ while (!readentry(dirp, &entryp, &len)) { if (NULL == entryp) { /* EOD => Return number of directory entries */ result = (int) num; break; } /* Apply select function if there is one provided */ if (NULL != sel) { if (!sel(entryp)) continue; } entries[num++] = entryp; if (num >= max) { /* Allocate exponentially increasing sized memory chunks */ if (INT_MAX / 2 >= (int) max) { max *= (size_t) 2; } else { errno = ENOMEM; break; } p = (struct dirent **) realloc((void *) entries, sizeof(*entries) * max); if (NULL != p) { entries = p; } else break; } } closedir(dirp); /* * A standard compliant 'closedir()' is allowed to fail with 'EINTR', but * the state of the directory structure is undefined in this case. * Therefore we ignore the return value because we can't call 'closedir()' * again and must hope that the system has released all ressources. */ } /* Sort entries in array if there is a compare function provided */ if (NULL != compar) { qsort((void *) entries, num, sizeof(*entries), (int (*)(const void *, const void *)) compar); } *namelist = entries; } /* Check for error */ if (-1 == result) { /* Free all memory we have allocated */ while (num--) { free(entries[num]); } free(entries); } return result; } /* * End of "$Id$". */