]>
Commit | Line | Data |
---|---|---|
36bf1958 | 1 | #include "git-compat-util.h" |
0fe5043d MH |
2 | #include "dir.h" |
3 | #include "iterator.h" | |
4 | #include "dir-iterator.h" | |
5 | ||
6 | struct dir_iterator_level { | |
0fe5043d MH |
7 | DIR *dir; |
8 | ||
9 | /* | |
10 | * The length of the directory part of path at this level | |
11 | * (including a trailing '/'): | |
12 | */ | |
13 | size_t prefix_len; | |
0fe5043d MH |
14 | }; |
15 | ||
16 | /* | |
17 | * The full data structure used to manage the internal directory | |
18 | * iteration state. It includes members that are not part of the | |
19 | * public interface. | |
20 | */ | |
21 | struct dir_iterator_int { | |
22 | struct dir_iterator base; | |
23 | ||
24 | /* | |
3012397e MT |
25 | * The number of levels currently on the stack. After the first |
26 | * call to dir_iterator_begin(), if it succeeds to open the | |
27 | * first level's dir, this will always be at least 1. Then, | |
28 | * when it comes to zero the iteration is ended and this | |
29 | * struct is freed. | |
0fe5043d MH |
30 | */ |
31 | size_t levels_nr; | |
32 | ||
33 | /* The number of levels that have been allocated on the stack */ | |
34 | size_t levels_alloc; | |
35 | ||
36 | /* | |
37 | * A stack of levels. levels[0] is the uppermost directory | |
38 | * that will be included in this iteration. | |
39 | */ | |
40 | struct dir_iterator_level *levels; | |
fa1da7d2 MT |
41 | |
42 | /* Combination of flags for this dir-iterator */ | |
43 | unsigned int flags; | |
0fe5043d MH |
44 | }; |
45 | ||
3012397e MT |
46 | /* |
47 | * Push a level in the iter stack and initialize it with information from | |
48 | * the directory pointed by iter->base->path. It is assumed that this | |
49 | * strbuf points to a valid directory path. Return 0 on success and -1 | |
fa1da7d2 | 50 | * otherwise, setting errno accordingly and leaving the stack unchanged. |
3012397e MT |
51 | */ |
52 | static int push_level(struct dir_iterator_int *iter) | |
53 | { | |
54 | struct dir_iterator_level *level; | |
55 | ||
56 | ALLOC_GROW(iter->levels, iter->levels_nr + 1, iter->levels_alloc); | |
57 | level = &iter->levels[iter->levels_nr++]; | |
58 | ||
59 | if (!is_dir_sep(iter->base.path.buf[iter->base.path.len - 1])) | |
60 | strbuf_addch(&iter->base.path, '/'); | |
61 | level->prefix_len = iter->base.path.len; | |
62 | ||
63 | level->dir = opendir(iter->base.path.buf); | |
64 | if (!level->dir) { | |
fa1da7d2 | 65 | int saved_errno = errno; |
3012397e MT |
66 | if (errno != ENOENT) { |
67 | warning_errno("error opening directory '%s'", | |
68 | iter->base.path.buf); | |
69 | } | |
70 | iter->levels_nr--; | |
fa1da7d2 | 71 | errno = saved_errno; |
3012397e MT |
72 | return -1; |
73 | } | |
74 | ||
75 | return 0; | |
76 | } | |
77 | ||
78 | /* | |
79 | * Pop the top level on the iter stack, releasing any resources associated | |
80 | * with it. Return the new value of iter->levels_nr. | |
81 | */ | |
82 | static int pop_level(struct dir_iterator_int *iter) | |
83 | { | |
84 | struct dir_iterator_level *level = | |
85 | &iter->levels[iter->levels_nr - 1]; | |
86 | ||
87 | if (level->dir && closedir(level->dir)) | |
88 | warning_errno("error closing directory '%s'", | |
89 | iter->base.path.buf); | |
90 | level->dir = NULL; | |
91 | ||
92 | return --iter->levels_nr; | |
93 | } | |
94 | ||
95 | /* | |
96 | * Populate iter->base with the necessary information on the next iteration | |
97 | * entry, represented by the given dirent de. Return 0 on success and -1 | |
fa1da7d2 | 98 | * otherwise, setting errno accordingly. |
3012397e MT |
99 | */ |
100 | static int prepare_next_entry_data(struct dir_iterator_int *iter, | |
101 | struct dirent *de) | |
102 | { | |
fa1da7d2 MT |
103 | int err, saved_errno; |
104 | ||
3012397e MT |
105 | strbuf_addstr(&iter->base.path, de->d_name); |
106 | /* | |
107 | * We have to reset these because the path strbuf might have | |
108 | * been realloc()ed at the previous strbuf_addstr(). | |
109 | */ | |
110 | iter->base.relative_path = iter->base.path.buf + | |
111 | iter->levels[0].prefix_len; | |
112 | iter->base.basename = iter->base.path.buf + | |
113 | iter->levels[iter->levels_nr - 1].prefix_len; | |
114 | ||
e00e56a7 | 115 | err = lstat(iter->base.path.buf, &iter->base.st); |
3012397e | 116 | |
fa1da7d2 MT |
117 | saved_errno = errno; |
118 | if (err && errno != ENOENT) | |
119 | warning_errno("failed to stat '%s'", iter->base.path.buf); | |
120 | ||
121 | errno = saved_errno; | |
122 | return err; | |
3012397e MT |
123 | } |
124 | ||
0fe5043d MH |
125 | int dir_iterator_advance(struct dir_iterator *dir_iterator) |
126 | { | |
127 | struct dir_iterator_int *iter = | |
128 | (struct dir_iterator_int *)dir_iterator; | |
129 | ||
fa1da7d2 MT |
130 | if (S_ISDIR(iter->base.st.st_mode) && push_level(iter)) { |
131 | if (errno != ENOENT && iter->flags & DIR_ITERATOR_PEDANTIC) | |
132 | goto error_out; | |
133 | if (iter->levels_nr == 0) | |
134 | goto error_out; | |
3012397e MT |
135 | } |
136 | ||
137 | /* Loop until we find an entry that we can give back to the caller. */ | |
0fe5043d | 138 | while (1) { |
3012397e | 139 | struct dirent *de; |
0fe5043d MH |
140 | struct dir_iterator_level *level = |
141 | &iter->levels[iter->levels_nr - 1]; | |
0fe5043d | 142 | |
3012397e MT |
143 | strbuf_setlen(&iter->base.path, level->prefix_len); |
144 | errno = 0; | |
145 | de = readdir(level->dir); | |
146 | ||
147 | if (!de) { | |
fa1da7d2 | 148 | if (errno) { |
3012397e | 149 | warning_errno("error reading directory '%s'", |
c9bba372 | 150 | iter->base.path.buf); |
fa1da7d2 MT |
151 | if (iter->flags & DIR_ITERATOR_PEDANTIC) |
152 | goto error_out; | |
153 | } else if (pop_level(iter) == 0) { | |
3012397e | 154 | return dir_iterator_abort(dir_iterator); |
fa1da7d2 | 155 | } |
3012397e | 156 | continue; |
0fe5043d MH |
157 | } |
158 | ||
3012397e MT |
159 | if (is_dot_or_dotdot(de->d_name)) |
160 | continue; | |
0fe5043d | 161 | |
fa1da7d2 MT |
162 | if (prepare_next_entry_data(iter, de)) { |
163 | if (errno != ENOENT && iter->flags & DIR_ITERATOR_PEDANTIC) | |
164 | goto error_out; | |
0fe5043d | 165 | continue; |
fa1da7d2 | 166 | } |
0fe5043d | 167 | |
3012397e | 168 | return ITER_OK; |
0fe5043d | 169 | } |
fa1da7d2 MT |
170 | |
171 | error_out: | |
172 | dir_iterator_abort(dir_iterator); | |
173 | return ITER_ERROR; | |
0fe5043d MH |
174 | } |
175 | ||
176 | int dir_iterator_abort(struct dir_iterator *dir_iterator) | |
177 | { | |
178 | struct dir_iterator_int *iter = (struct dir_iterator_int *)dir_iterator; | |
179 | ||
180 | for (; iter->levels_nr; iter->levels_nr--) { | |
181 | struct dir_iterator_level *level = | |
182 | &iter->levels[iter->levels_nr - 1]; | |
183 | ||
184 | if (level->dir && closedir(level->dir)) { | |
c9bba372 | 185 | int saved_errno = errno; |
0fe5043d | 186 | strbuf_setlen(&iter->base.path, level->prefix_len); |
c9bba372 MT |
187 | errno = saved_errno; |
188 | warning_errno("error closing directory '%s'", | |
189 | iter->base.path.buf); | |
0fe5043d MH |
190 | } |
191 | } | |
192 | ||
193 | free(iter->levels); | |
194 | strbuf_release(&iter->base.path); | |
195 | free(iter); | |
196 | return ITER_DONE; | |
197 | } | |
198 | ||
fa1da7d2 | 199 | struct dir_iterator *dir_iterator_begin(const char *path, unsigned int flags) |
0fe5043d MH |
200 | { |
201 | struct dir_iterator_int *iter = xcalloc(1, sizeof(*iter)); | |
202 | struct dir_iterator *dir_iterator = &iter->base; | |
bffc762f | 203 | int saved_errno, err; |
0fe5043d MH |
204 | |
205 | strbuf_init(&iter->base.path, PATH_MAX); | |
206 | strbuf_addstr(&iter->base.path, path); | |
207 | ||
208 | ALLOC_GROW(iter->levels, 10, iter->levels_alloc); | |
3012397e | 209 | iter->levels_nr = 0; |
fa1da7d2 | 210 | iter->flags = flags; |
0fe5043d | 211 | |
3012397e | 212 | /* |
e00e56a7 | 213 | * Note: lstat already checks for NULL or empty strings and |
bffc762f | 214 | * nonexistent paths. |
3012397e | 215 | */ |
e00e56a7 | 216 | err = lstat(iter->base.path.buf, &iter->base.st); |
bffc762f TB |
217 | |
218 | if (err < 0) { | |
3012397e MT |
219 | saved_errno = errno; |
220 | goto error_out; | |
221 | } | |
222 | ||
223 | if (!S_ISDIR(iter->base.st.st_mode)) { | |
224 | saved_errno = ENOTDIR; | |
225 | goto error_out; | |
226 | } | |
0fe5043d MH |
227 | |
228 | return dir_iterator; | |
3012397e MT |
229 | |
230 | error_out: | |
231 | dir_iterator_abort(dir_iterator); | |
232 | errno = saved_errno; | |
233 | return NULL; | |
0fe5043d | 234 | } |