1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
| | #include <dirent.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <stddef.h>
struct cleanup_params {
DIR *d;
struct dirent **names;
size_t cnt;
};
static void cleanup(void *p)
{
struct cleanup_params *c = p;
/* Cancellation is disabled if c->d is not NULL, so closedir()
* won't act upon a cancellation request here. */
if (c->d) closedir(c->d);
if (c->names) {
size_t cnt = c->cnt;
while (cnt-->0) free(c->names[cnt]);
free(c->names);
}
}
int scandir(const char *path, struct dirent ***res,
int (*sel)(const struct dirent *),
int (*cmp)(const struct dirent **, const struct dirent **))
{
/* opendir() might act upon a cancellation request. */
struct cleanup_params c = {.d = opendir(path)};
struct dirent *de, **tmp;
size_t len=0;
int old_errno = errno, err;
if (!c.d) return -1;
/* sel(), closedir(), or cmp() might act upon a cancellation request. */
pthread_cleanup_push(cleanup, &c);
while ((errno=0), (de = readdir(c.d))) {
if (sel) {
/* sel() must not observe that errno was set to 0. */
errno = old_errno;
if (!sel(de)) continue;
}
if (c.cnt >= len) {
len = 2*len+1;
if (len > SIZE_MAX/sizeof *c.names) break;
tmp = realloc(c.names, len * sizeof *c.names);
if (!tmp) break;
c.names = tmp;
}
c.names[c.cnt] = malloc(de->d_reclen);
if (!c.names[c.cnt]) break;
memcpy(c.names[c.cnt++], de, de->d_reclen);
}
/* closedir() might set errno via __aio_close(). It might also "fail"
* (return -1 and set errno). But even then, the file descriptor is
* closed and memory is freed, so there is no reason to report the
* "failure" of closedir() as a failure of scandir(). */
err = errno;
/* If closedir() acts upon a cancellation request, it is retried by
* cleanup() with cancellation disabled. closedir() won't act upon a
* cancellation request in masked cancellation mode, meaning errno does
* not need to be inspected for ECANCELED. */
closedir(c.d);
/* cleanup() shouldn't call closedir() from here on, because the
* directory stream is already closed. */
c.d = 0;
if (!err) {
/* cmp() and caller must not observe that errno was set to 0. */
errno = old_errno;
if (cmp) qsort(c.names, c.cnt, sizeof *c.names, (int (*)(const void *, const void *))cmp);
*res = c.names;
}
pthread_cleanup_pop(err);
return err ? (errno = err), -1 : c.cnt;
}
|