CI: add libgcrypt to sanitizer run
[tinc] / src / dirent.h
1 /*
2  * Dirent interface for Microsoft Visual Studio
3  *
4  * Copyright (C) 1998-2019 Toni Ronkko
5  * This file is part of dirent.  Dirent may be freely distributed
6  * under the MIT license.  For all details and documentation, see
7  * https://github.com/tronkko/dirent
8  */
9 #ifndef DIRENT_H
10 #define DIRENT_H
11
12 /* Hide warnings about unreferenced local functions */
13 #if defined(__clang__)
14 #       pragma clang diagnostic ignored "-Wunused-function"
15 #elif defined(_MSC_VER)
16 #       pragma warning(disable:4505)
17 #elif defined(__GNUC__)
18 #       pragma GCC diagnostic ignored "-Wunused-function"
19 #endif
20
21 /*
22  * Include windows.h without Windows Sockets 1.1 to prevent conflicts with
23  * Windows Sockets 2.0.
24  */
25 #ifndef WIN32_LEAN_AND_MEAN
26 #       define WIN32_LEAN_AND_MEAN
27 #endif
28 #include <windows.h>
29
30 #include <stdio.h>
31 #include <stdarg.h>
32 #include <wchar.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <malloc.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <errno.h>
39 #include <ctype.h>
40
41 /* Indicates that d_type field is available in dirent structure */
42 #define _DIRENT_HAVE_D_TYPE
43
44 /* Indicates that d_namlen field is available in dirent structure */
45 #define _DIRENT_HAVE_D_NAMLEN
46
47 /* Entries missing from MSVC 6.0 */
48 #if !defined(FILE_ATTRIBUTE_DEVICE)
49 #       define FILE_ATTRIBUTE_DEVICE 0x40
50 #endif
51
52 /* File type and permission flags for stat(), general mask */
53 #if !defined(S_IFMT)
54 #       define S_IFMT _S_IFMT
55 #endif
56
57 /* Directory bit */
58 #if !defined(S_IFDIR)
59 #       define S_IFDIR _S_IFDIR
60 #endif
61
62 /* Character device bit */
63 #if !defined(S_IFCHR)
64 #       define S_IFCHR _S_IFCHR
65 #endif
66
67 /* Pipe bit */
68 #if !defined(S_IFFIFO)
69 #       define S_IFFIFO _S_IFFIFO
70 #endif
71
72 /* Regular file bit */
73 #if !defined(S_IFREG)
74 #       define S_IFREG _S_IFREG
75 #endif
76
77 /* Read permission */
78 #if !defined(S_IREAD)
79 #       define S_IREAD _S_IREAD
80 #endif
81
82 /* Write permission */
83 #if !defined(S_IWRITE)
84 #       define S_IWRITE _S_IWRITE
85 #endif
86
87 /* Execute permission */
88 #if !defined(S_IEXEC)
89 #       define S_IEXEC _S_IEXEC
90 #endif
91
92 /* Pipe */
93 #if !defined(S_IFIFO)
94 #       define S_IFIFO _S_IFIFO
95 #endif
96
97 /* Block device */
98 #if !defined(S_IFBLK)
99 #       define S_IFBLK 0
100 #endif
101
102 /* Link */
103 #if !defined(S_IFLNK)
104 #       define S_IFLNK 0
105 #endif
106
107 /* Socket */
108 #if !defined(S_IFSOCK)
109 #       define S_IFSOCK 0
110 #endif
111
112 /* Read user permission */
113 #if !defined(S_IRUSR)
114 #       define S_IRUSR S_IREAD
115 #endif
116
117 /* Write user permission */
118 #if !defined(S_IWUSR)
119 #       define S_IWUSR S_IWRITE
120 #endif
121
122 /* Execute user permission */
123 #if !defined(S_IXUSR)
124 #       define S_IXUSR 0
125 #endif
126
127 /* Read group permission */
128 #if !defined(S_IRGRP)
129 #       define S_IRGRP 0
130 #endif
131
132 /* Write group permission */
133 #if !defined(S_IWGRP)
134 #       define S_IWGRP 0
135 #endif
136
137 /* Execute group permission */
138 #if !defined(S_IXGRP)
139 #       define S_IXGRP 0
140 #endif
141
142 /* Read others permission */
143 #if !defined(S_IROTH)
144 #       define S_IROTH 0
145 #endif
146
147 /* Write others permission */
148 #if !defined(S_IWOTH)
149 #       define S_IWOTH 0
150 #endif
151
152 /* Execute others permission */
153 #if !defined(S_IXOTH)
154 #       define S_IXOTH 0
155 #endif
156
157 /* Maximum length of file name */
158 #if !defined(PATH_MAX)
159 #       define PATH_MAX MAX_PATH
160 #endif
161 #if !defined(FILENAME_MAX)
162 #       define FILENAME_MAX MAX_PATH
163 #endif
164 #if !defined(NAME_MAX)
165 #       define NAME_MAX FILENAME_MAX
166 #endif
167
168 /* File type flags for d_type */
169 #define DT_UNKNOWN 0
170 #define DT_REG S_IFREG
171 #define DT_DIR S_IFDIR
172 #define DT_FIFO S_IFIFO
173 #define DT_SOCK S_IFSOCK
174 #define DT_CHR S_IFCHR
175 #define DT_BLK S_IFBLK
176 #define DT_LNK S_IFLNK
177
178 /* Macros for converting between st_mode and d_type */
179 #define IFTODT(mode) ((mode) & S_IFMT)
180 #define DTTOIF(type) (type)
181
182 /*
183  * File type macros.  Note that block devices, sockets and links cannot be
184  * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
185  * only defined for compatibility.  These macros should always return false
186  * on Windows.
187  */
188 #if !defined(S_ISFIFO)
189 #       define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
190 #endif
191 #if !defined(S_ISDIR)
192 #       define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
193 #endif
194 #if !defined(S_ISREG)
195 #       define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
196 #endif
197 #if !defined(S_ISLNK)
198 #       define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
199 #endif
200 #if !defined(S_ISSOCK)
201 #       define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
202 #endif
203 #if !defined(S_ISCHR)
204 #       define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
205 #endif
206 #if !defined(S_ISBLK)
207 #       define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
208 #endif
209
210 /* Return the exact length of the file name without zero terminator */
211 #define _D_EXACT_NAMLEN(p) ((p)->d_namlen)
212
213 /* Return the maximum size of a file name */
214 #define _D_ALLOC_NAMLEN(p) ((PATH_MAX)+1)
215
216
217 #ifdef __cplusplus
218 extern "C" {
219 #endif
220
221
222 /* Wide-character version */
223 struct _wdirent {
224         /* Always zero */
225         long d_ino;
226
227         /* File position within stream */
228         long d_off;
229
230         /* Structure size */
231         unsigned short d_reclen;
232
233         /* Length of name without \0 */
234         size_t d_namlen;
235
236         /* File type */
237         int d_type;
238
239         /* File name */
240         wchar_t d_name[PATH_MAX + 1];
241 };
242 typedef struct _wdirent _wdirent;
243
244 struct _WDIR {
245         /* Current directory entry */
246         struct _wdirent ent;
247
248         /* Private file data */
249         WIN32_FIND_DATAW data;
250
251         /* True if data is valid */
252         int cached;
253
254         /* Win32 search handle */
255         HANDLE handle;
256
257         /* Initial directory name */
258         wchar_t *patt;
259 };
260 typedef struct _WDIR _WDIR;
261
262 /* Multi-byte character version */
263 struct dirent {
264         /* Always zero */
265         long d_ino;
266
267         /* File position within stream */
268         long d_off;
269
270         /* Structure size */
271         unsigned short d_reclen;
272
273         /* Length of name without \0 */
274         size_t d_namlen;
275
276         /* File type */
277         int d_type;
278
279         /* File name */
280         char d_name[PATH_MAX + 1];
281 };
282 typedef struct dirent dirent;
283
284 struct DIR {
285         struct dirent ent;
286         struct _WDIR *wdirp;
287 };
288 typedef struct DIR DIR;
289
290
291 /* Dirent functions */
292 static DIR *opendir(const char *dirname);
293 static _WDIR *_wopendir(const wchar_t *dirname);
294
295 static struct dirent *readdir(DIR *dirp);
296 static struct _wdirent *_wreaddir(_WDIR *dirp);
297
298 static int readdir_r(
299         DIR *dirp, struct dirent *entry, struct dirent **result);
300 static int _wreaddir_r(
301         _WDIR *dirp, struct _wdirent *entry, struct _wdirent **result);
302
303 static int closedir(DIR *dirp);
304 static int _wclosedir(_WDIR *dirp);
305
306 static void rewinddir(DIR *dirp);
307 static void _wrewinddir(_WDIR *dirp);
308
309 static int scandir(const char *dirname, struct dirent ***namelist,
310                    int (*filter)(const struct dirent *),
311                    int (*compare)(const struct dirent **, const struct dirent **));
312
313 static int alphasort(const struct dirent **a, const struct dirent **b);
314
315 static int versionsort(const struct dirent **a, const struct dirent **b);
316
317 static int strverscmp(const char *a, const char *b);
318
319 /* For compatibility with Symbian */
320 #define wdirent _wdirent
321 #define WDIR _WDIR
322 #define wopendir _wopendir
323 #define wreaddir _wreaddir
324 #define wclosedir _wclosedir
325 #define wrewinddir _wrewinddir
326
327 /* Compatibility with older Microsoft compilers and non-Microsoft compilers */
328 #if !defined(_MSC_VER) || _MSC_VER < 1400
329 #       define wcstombs_s dirent_wcstombs_s
330 #       define mbstowcs_s dirent_mbstowcs_s
331 #endif
332
333 /* Optimize dirent_set_errno() away on modern Microsoft compilers */
334 #if defined(_MSC_VER) && _MSC_VER >= 1400
335 #       define dirent_set_errno _set_errno
336 #endif
337
338
339 /* Internal utility functions */
340 static WIN32_FIND_DATAW *dirent_first(_WDIR *dirp);
341 static WIN32_FIND_DATAW *dirent_next(_WDIR *dirp);
342
343 #if !defined(_MSC_VER) || _MSC_VER < 1400
344 static int dirent_mbstowcs_s(
345         size_t *pReturnValue, wchar_t *wcstr, size_t sizeInWords,
346         const char *mbstr, size_t count);
347 #endif
348
349 #if !defined(_MSC_VER) || _MSC_VER < 1400
350 static int dirent_wcstombs_s(
351         size_t *pReturnValue, char *mbstr, size_t sizeInBytes,
352         const wchar_t *wcstr, size_t count);
353 #endif
354
355 #if !defined(_MSC_VER) || _MSC_VER < 1400
356 static void dirent_set_errno(int error);
357 #endif
358
359
360 /*
361  * Open directory stream DIRNAME for read and return a pointer to the
362  * internal working area that is used to retrieve individual directory
363  * entries.
364  */
365 static _WDIR *_wopendir(const wchar_t *dirname) {
366         wchar_t *p;
367
368         /* Must have directory name */
369         if(dirname == NULL || dirname[0] == '\0') {
370                 dirent_set_errno(ENOENT);
371                 return NULL;
372         }
373
374         /* Allocate new _WDIR structure */
375         _WDIR *dirp = (_WDIR *) malloc(sizeof(struct _WDIR));
376
377         if(!dirp) {
378                 return NULL;
379         }
380
381         /* Reset _WDIR structure */
382         dirp->handle = INVALID_HANDLE_VALUE;
383         dirp->patt = NULL;
384         dirp->cached = 0;
385
386         /*
387          * Compute the length of full path plus zero terminator
388          *
389          * Note that on WinRT there's no way to convert relative paths
390          * into absolute paths, so just assume it is an absolute path.
391          */
392 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
393         /* Desktop */
394         DWORD n = GetFullPathNameW(dirname, 0, NULL, NULL);
395 #else
396         /* WinRT */
397         size_t n = wcslen(dirname);
398 #endif
399
400         /* Allocate room for absolute directory name and search pattern */
401         dirp->patt = (wchar_t *) malloc(sizeof(wchar_t) * n + 16);
402
403         if(dirp->patt == NULL) {
404                 goto exit_closedir;
405         }
406
407         /*
408          * Convert relative directory name to an absolute one.  This
409          * allows rewinddir() to function correctly even when current
410          * working directory is changed between opendir() and rewinddir().
411          *
412          * Note that on WinRT there's no way to convert relative paths
413          * into absolute paths, so just assume it is an absolute path.
414          */
415 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
416         /* Desktop */
417         n = GetFullPathNameW(dirname, n, dirp->patt, NULL);
418
419         if(n <= 0) {
420                 goto exit_closedir;
421         }
422
423 #else
424         /* WinRT */
425         wcsncpy_s(dirp->patt, n + 1, dirname, n);
426 #endif
427
428         /* Append search pattern \* to the directory name */
429         p = dirp->patt + n;
430
431         switch(p[-1]) {
432         case '\\':
433         case '/':
434         case ':':
435                 /* Directory ends in path separator, e.g. c:\temp\ */
436                 /*NOP*/
437                 ;
438                 break;
439
440         default:
441                 /* Directory name doesn't end in path separator */
442                 *p++ = '\\';
443         }
444
445         *p++ = '*';
446         *p = '\0';
447
448         /* Open directory stream and retrieve the first entry */
449         if(!dirent_first(dirp)) {
450                 goto exit_closedir;
451         }
452
453         /* Success */
454         return dirp;
455
456         /* Failure */
457 exit_closedir:
458         _wclosedir(dirp);
459         return NULL;
460 }
461
462 /*
463  * Read next directory entry.
464  *
465  * Returns pointer to static directory entry which may be overwritten by
466  * subsequent calls to _wreaddir().
467  */
468 static struct _wdirent *_wreaddir(_WDIR *dirp) {
469         /*
470          * Read directory entry to buffer.  We can safely ignore the return
471          * value as entry will be set to NULL in case of error.
472          */
473         struct _wdirent *entry;
474         (void) _wreaddir_r(dirp, &dirp->ent, &entry);
475
476         /* Return pointer to statically allocated directory entry */
477         return entry;
478 }
479
480 /*
481  * Read next directory entry.
482  *
483  * Returns zero on success.  If end of directory stream is reached, then sets
484  * result to NULL and returns zero.
485  */
486 static int _wreaddir_r(
487         _WDIR *dirp, struct _wdirent *entry, struct _wdirent **result) {
488         /* Read next directory entry */
489         WIN32_FIND_DATAW *datap = dirent_next(dirp);
490
491         if(!datap) {
492                 /* Return NULL to indicate end of directory */
493                 *result = NULL;
494                 return /*OK*/0;
495         }
496
497         /*
498          * Copy file name as wide-character string.  If the file name is too
499          * long to fit in to the destination buffer, then truncate file name
500          * to PATH_MAX characters and zero-terminate the buffer.
501          */
502         size_t n = 0;
503
504         while(n < PATH_MAX && datap->cFileName[n] != 0) {
505                 entry->d_name[n] = datap->cFileName[n];
506                 n++;
507         }
508
509         entry->d_name[n] = 0;
510
511         /* Length of file name excluding zero terminator */
512         entry->d_namlen = n;
513
514         /* File type */
515         DWORD attr = datap->dwFileAttributes;
516
517         if((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
518                 entry->d_type = DT_CHR;
519         } else if((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
520                 entry->d_type = DT_DIR;
521         } else {
522                 entry->d_type = DT_REG;
523         }
524
525         /* Reset dummy fields */
526         entry->d_ino = 0;
527         entry->d_off = 0;
528         entry->d_reclen = sizeof(struct _wdirent);
529
530         /* Set result address */
531         *result = entry;
532         return /*OK*/0;
533 }
534
535 /*
536  * Close directory stream opened by opendir() function.  This invalidates the
537  * DIR structure as well as any directory entry read previously by
538  * _wreaddir().
539  */
540 static int _wclosedir(_WDIR *dirp) {
541         if(!dirp) {
542                 dirent_set_errno(EBADF);
543                 return /*failure*/ -1;
544         }
545
546         /* Release search handle */
547         if(dirp->handle != INVALID_HANDLE_VALUE) {
548                 FindClose(dirp->handle);
549         }
550
551         /* Release search pattern */
552         free(dirp->patt);
553
554         /* Release directory structure */
555         free(dirp);
556         return /*success*/0;
557 }
558
559 /*
560  * Rewind directory stream such that _wreaddir() returns the very first
561  * file name again.
562  */
563 static void _wrewinddir(_WDIR *dirp) {
564         if(!dirp) {
565                 return;
566         }
567
568         /* Release existing search handle */
569         if(dirp->handle != INVALID_HANDLE_VALUE) {
570                 FindClose(dirp->handle);
571         }
572
573         /* Open new search handle */
574         dirent_first(dirp);
575 }
576
577 /* Get first directory entry */
578 static WIN32_FIND_DATAW *dirent_first(_WDIR *dirp) {
579         if(!dirp) {
580                 return NULL;
581         }
582
583         /* Open directory and retrieve the first entry */
584         dirp->handle = FindFirstFileExW(
585                                dirp->patt, FindExInfoStandard, &dirp->data,
586                                FindExSearchNameMatch, NULL, 0);
587
588         if(dirp->handle == INVALID_HANDLE_VALUE) {
589                 goto error;
590         }
591
592         /* A directory entry is now waiting in memory */
593         dirp->cached = 1;
594         return &dirp->data;
595
596 error:
597         /* Failed to open directory: no directory entry in memory */
598         dirp->cached = 0;
599
600         /* Set error code */
601         DWORD errorcode = GetLastError();
602
603         switch(errorcode) {
604         case ERROR_ACCESS_DENIED:
605                 /* No read access to directory */
606                 dirent_set_errno(EACCES);
607                 break;
608
609         case ERROR_DIRECTORY:
610                 /* Directory name is invalid */
611                 dirent_set_errno(ENOTDIR);
612                 break;
613
614         case ERROR_PATH_NOT_FOUND:
615         default:
616                 /* Cannot find the file */
617                 dirent_set_errno(ENOENT);
618         }
619
620         return NULL;
621 }
622
623 /* Get next directory entry */
624 static WIN32_FIND_DATAW *dirent_next(_WDIR *dirp) {
625         /* Is the next directory entry already in cache? */
626         if(dirp->cached) {
627                 /* Yes, a valid directory entry found in memory */
628                 dirp->cached = 0;
629                 return &dirp->data;
630         }
631
632         /* No directory entry in cache */
633         if(dirp->handle == INVALID_HANDLE_VALUE) {
634                 return NULL;
635         }
636
637         /* Read the next directory entry from stream */
638         if(FindNextFileW(dirp->handle, &dirp->data) == FALSE) {
639                 goto exit_close;
640         }
641
642         /* Success */
643         return &dirp->data;
644
645         /* Failure */
646 exit_close:
647         FindClose(dirp->handle);
648         dirp->handle = INVALID_HANDLE_VALUE;
649         return NULL;
650 }
651
652 /* Open directory stream using plain old C-string */
653 static DIR *opendir(const char *dirname) {
654         /* Must have directory name */
655         if(dirname == NULL || dirname[0] == '\0') {
656                 dirent_set_errno(ENOENT);
657                 return NULL;
658         }
659
660         /* Allocate memory for DIR structure */
661         struct DIR *dirp = (DIR *) malloc(sizeof(struct DIR));
662
663         if(!dirp) {
664                 return NULL;
665         }
666
667         /* Convert directory name to wide-character string */
668         wchar_t wname[PATH_MAX + 1];
669         size_t n;
670         int error = mbstowcs_s(&n, wname, PATH_MAX + 1, dirname, PATH_MAX + 1);
671
672         if(error) {
673                 goto exit_failure;
674         }
675
676         /* Open directory stream using wide-character name */
677         dirp->wdirp = _wopendir(wname);
678
679         if(!dirp->wdirp) {
680                 goto exit_failure;
681         }
682
683         /* Success */
684         return dirp;
685
686         /* Failure */
687 exit_failure:
688         free(dirp);
689         return NULL;
690 }
691
692 /* Read next directory entry */
693 static struct dirent *readdir(DIR *dirp) {
694         /*
695          * Read directory entry to buffer.  We can safely ignore the return
696          * value as entry will be set to NULL in case of error.
697          */
698         struct dirent *entry;
699         (void) readdir_r(dirp, &dirp->ent, &entry);
700
701         /* Return pointer to statically allocated directory entry */
702         return entry;
703 }
704
705 /*
706  * Read next directory entry into called-allocated buffer.
707  *
708  * Returns zero on success.  If the end of directory stream is reached, then
709  * sets result to NULL and returns zero.
710  */
711 static int readdir_r(
712         DIR *dirp, struct dirent *entry, struct dirent **result) {
713         /* Read next directory entry */
714         WIN32_FIND_DATAW *datap = dirent_next(dirp->wdirp);
715
716         if(!datap) {
717                 /* No more directory entries */
718                 *result = NULL;
719                 return /*OK*/0;
720         }
721
722         /* Attempt to convert file name to multi-byte string */
723         size_t n;
724         int error = wcstombs_s(
725                             &n, entry->d_name, PATH_MAX + 1,
726                             datap->cFileName, PATH_MAX + 1);
727
728         /*
729          * If the file name cannot be represented by a multi-byte string, then
730          * attempt to use old 8+3 file name.  This allows the program to
731          * access files although file names may seem unfamiliar to the user.
732          *
733          * Be ware that the code below cannot come up with a short file name
734          * unless the file system provides one.  At least VirtualBox shared
735          * folders fail to do this.
736          */
737         if(error && datap->cAlternateFileName[0] != '\0') {
738                 error = wcstombs_s(
739                                 &n, entry->d_name, PATH_MAX + 1,
740                                 datap->cAlternateFileName, PATH_MAX + 1);
741         }
742
743         if(!error) {
744                 /* Length of file name excluding zero terminator */
745                 entry->d_namlen = n - 1;
746
747                 /* File attributes */
748                 DWORD attr = datap->dwFileAttributes;
749
750                 if((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
751                         entry->d_type = DT_CHR;
752                 } else if((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
753                         entry->d_type = DT_DIR;
754                 } else {
755                         entry->d_type = DT_REG;
756                 }
757
758                 /* Reset dummy fields */
759                 entry->d_ino = 0;
760                 entry->d_off = 0;
761                 entry->d_reclen = sizeof(struct dirent);
762         } else {
763                 /*
764                  * Cannot convert file name to multi-byte string so construct
765                  * an erroneous directory entry and return that.  Note that
766                  * we cannot return NULL as that would stop the processing
767                  * of directory entries completely.
768                  */
769                 entry->d_name[0] = '?';
770                 entry->d_name[1] = '\0';
771                 entry->d_namlen = 1;
772                 entry->d_type = DT_UNKNOWN;
773                 entry->d_ino = 0;
774                 entry->d_off = -1;
775                 entry->d_reclen = 0;
776         }
777
778         /* Return pointer to directory entry */
779         *result = entry;
780         return /*OK*/0;
781 }
782
783 /* Close directory stream */
784 static int closedir(DIR *dirp) {
785         int ok;
786
787         if(!dirp) {
788                 goto exit_failure;
789         }
790
791         /* Close wide-character directory stream */
792         ok = _wclosedir(dirp->wdirp);
793         dirp->wdirp = NULL;
794
795         /* Release multi-byte character version */
796         free(dirp);
797         return ok;
798
799 exit_failure:
800         /* Invalid directory stream */
801         dirent_set_errno(EBADF);
802         return /*failure*/ -1;
803 }
804
805 /* Rewind directory stream to beginning */
806 static void rewinddir(DIR *dirp) {
807         if(!dirp) {
808                 return;
809         }
810
811         /* Rewind wide-character string directory stream */
812         _wrewinddir(dirp->wdirp);
813 }
814
815 /* Scan directory for entries */
816 static int scandir(
817         const char *dirname, struct dirent ***namelist,
818         int (*filter)(const struct dirent *),
819         int (*compare)(const struct dirent **, const struct dirent **)) {
820         int result;
821
822         /* Open directory stream */
823         DIR *dir = opendir(dirname);
824
825         if(!dir) {
826                 /* Cannot open directory */
827                 return /*Error*/ -1;
828         }
829
830         /* Read directory entries to memory */
831         struct dirent *tmp = NULL;
832         struct dirent **files = NULL;
833         size_t size = 0;
834         size_t allocated = 0;
835
836         while(1) {
837                 /* Allocate room for a temporary directory entry */
838                 if(!tmp) {
839                         tmp = (struct dirent *) malloc(sizeof(struct dirent));
840
841                         if(!tmp) {
842                                 goto exit_failure;
843                         }
844                 }
845
846                 /* Read directory entry to temporary area */
847                 struct dirent *entry;
848
849                 if(readdir_r(dir, tmp, &entry) != /*OK*/0) {
850                         goto exit_failure;
851                 }
852
853                 /* Stop if we already read the last directory entry */
854                 if(entry == NULL) {
855                         goto exit_success;
856                 }
857
858                 /* Determine whether to include the entry in results */
859                 if(filter && !filter(tmp)) {
860                         continue;
861                 }
862
863                 /* Enlarge pointer table to make room for another pointer */
864                 if(size >= allocated) {
865                         /* Compute number of entries in the new table */
866                         size_t num_entries = size * 2 + 16;
867
868                         /* Allocate new pointer table or enlarge existing */
869                         void *p = realloc(files, sizeof(void *) * num_entries);
870
871                         if(!p) {
872                                 goto exit_failure;
873                         }
874
875                         /* Got the memory */
876                         files = (dirent **) p;
877                         allocated = num_entries;
878                 }
879
880                 /* Store the temporary entry to ptr table */
881                 files[size++] = tmp;
882                 tmp = NULL;
883         }
884
885 exit_failure:
886
887         /* Release allocated file entries */
888         for(size_t i = 0; i < size; i++) {
889                 free(files[i]);
890         }
891
892         /* Release the pointer table */
893         free(files);
894         files = NULL;
895
896         /* Exit with error code */
897         result = /*error*/ -1;
898         goto exit_status;
899
900 exit_success:
901         /* Sort directory entries */
902         qsort(files, size, sizeof(void *),
903               (int (*)(const void *, const void *)) compare);
904
905         /* Pass pointer table to caller */
906         if(namelist) {
907                 *namelist = files;
908         }
909
910         /* Return the number of directory entries read */
911         result = (int) size;
912
913 exit_status:
914         /* Release temporary directory entry, if we had one */
915         free(tmp);
916
917         /* Close directory stream */
918         closedir(dir);
919         return result;
920 }
921
922 /* Alphabetical sorting */
923 static int alphasort(const struct dirent **a, const struct dirent **b) {
924         return strcoll((*a)->d_name, (*b)->d_name);
925 }
926
927 /* Sort versions */
928 static int versionsort(const struct dirent **a, const struct dirent **b) {
929         return strverscmp((*a)->d_name, (*b)->d_name);
930 }
931
932 /* Compare strings */
933 static int strverscmp(const char *a, const char *b) {
934         size_t i = 0;
935         size_t j;
936
937         /* Find first difference */
938         while(a[i] == b[i]) {
939                 if(a[i] == '\0') {
940                         /* No difference */
941                         return 0;
942                 }
943
944                 ++i;
945         }
946
947         /* Count backwards and find the leftmost digit */
948         j = i;
949
950         while(j > 0 && isdigit(a[j - 1])) {
951                 --j;
952         }
953
954         /* Determine mode of comparison */
955         if(a[j] == '0' || b[j] == '0') {
956                 /* Find the next non-zero digit */
957                 while(a[j] == '0' && a[j] == b[j]) {
958                         j++;
959                 }
960
961                 /* String with more digits is smaller, e.g 002 < 01 */
962                 if(isdigit(a[j])) {
963                         if(!isdigit(b[j])) {
964                                 return -1;
965                         }
966                 } else if(isdigit(b[j])) {
967                         return 1;
968                 }
969         } else if(isdigit(a[j]) && isdigit(b[j])) {
970                 /* Numeric comparison */
971                 size_t k1 = j;
972                 size_t k2 = j;
973
974                 /* Compute number of digits in each string */
975                 while(isdigit(a[k1])) {
976                         k1++;
977                 }
978
979                 while(isdigit(b[k2])) {
980                         k2++;
981                 }
982
983                 /* Number with more digits is bigger, e.g 999 < 1000 */
984                 if(k1 < k2) {
985                         return -1;
986                 } else if(k1 > k2) {
987                         return 1;
988                 }
989         }
990
991         /* Alphabetical comparison */
992         return (int)((unsigned char) a[i]) - ((unsigned char) b[i]);
993 }
994
995 /* Convert multi-byte string to wide character string */
996 #if !defined(_MSC_VER) || _MSC_VER < 1400
997 static int dirent_mbstowcs_s(
998         size_t *pReturnValue, wchar_t *wcstr,
999         size_t sizeInWords, const char *mbstr, size_t count) {
1000         /* Older Visual Studio or non-Microsoft compiler */
1001         size_t n = mbstowcs(wcstr, mbstr, sizeInWords);
1002
1003         if(wcstr && n >= count) {
1004                 return /*error*/ 1;
1005         }
1006
1007         /* Zero-terminate output buffer */
1008         if(wcstr && sizeInWords) {
1009                 if(n >= sizeInWords) {
1010                         n = sizeInWords - 1;
1011                 }
1012
1013                 wcstr[n] = 0;
1014         }
1015
1016         /* Length of multi-byte string with zero terminator */
1017         if(pReturnValue) {
1018                 *pReturnValue = n + 1;
1019         }
1020
1021         /* Success */
1022         return 0;
1023 }
1024 #endif
1025
1026 /* Convert wide-character string to multi-byte string */
1027 #if !defined(_MSC_VER) || _MSC_VER < 1400
1028 static int dirent_wcstombs_s(
1029         size_t *pReturnValue, char *mbstr,
1030         size_t sizeInBytes, const wchar_t *wcstr, size_t count) {
1031         /* Older Visual Studio or non-Microsoft compiler */
1032         size_t n = wcstombs(mbstr, wcstr, sizeInBytes);
1033
1034         if(mbstr && n >= count) {
1035                 return /*error*/1;
1036         }
1037
1038         /* Zero-terminate output buffer */
1039         if(mbstr && sizeInBytes) {
1040                 if(n >= sizeInBytes) {
1041                         n = sizeInBytes - 1;
1042                 }
1043
1044                 mbstr[n] = '\0';
1045         }
1046
1047         /* Length of resulting multi-bytes string WITH zero-terminator */
1048         if(pReturnValue) {
1049                 *pReturnValue = n + 1;
1050         }
1051
1052         /* Success */
1053         return 0;
1054 }
1055 #endif
1056
1057 /* Set errno variable */
1058 #if !defined(_MSC_VER) || _MSC_VER < 1400
1059 static void dirent_set_errno(int error) {
1060         /* Non-Microsoft compiler or older Microsoft compiler */
1061         errno = error;
1062 }
1063 #endif
1064
1065 #ifdef __cplusplus
1066 }
1067 #endif
1068 #endif /*DIRENT_H*/