git
/
dir-iterator.c
307 строк · 7.2 Кб
1#include "git-compat-util.h"2#include "dir.h"3#include "iterator.h"4#include "dir-iterator.h"5#include "string-list.h"6
7struct dir_iterator_level {8DIR *dir;9
10/*11* The directory entries of the current level. This list will only be
12* populated when the iterator is ordered. In that case, `dir` will be
13* set to `NULL`.
14*/
15struct string_list entries;16size_t entries_idx;17
18/*19* The length of the directory part of path at this level
20* (including a trailing '/'):
21*/
22size_t prefix_len;23};24
25/*
26* The full data structure used to manage the internal directory
27* iteration state. It includes members that are not part of the
28* public interface.
29*/
30struct dir_iterator_int {31struct dir_iterator base;32
33/*34* The number of levels currently on the stack. After the first
35* call to dir_iterator_begin(), if it succeeds to open the
36* first level's dir, this will always be at least 1. Then,
37* when it comes to zero the iteration is ended and this
38* struct is freed.
39*/
40size_t levels_nr;41
42/* The number of levels that have been allocated on the stack */43size_t levels_alloc;44
45/*46* A stack of levels. levels[0] is the uppermost directory
47* that will be included in this iteration.
48*/
49struct dir_iterator_level *levels;50
51/* Combination of flags for this dir-iterator */52unsigned int flags;53};54
55static int next_directory_entry(DIR *dir, const char *path,56struct dirent **out)57{
58struct dirent *de;59
60repeat:61errno = 0;62de = readdir(dir);63if (!de) {64if (errno) {65warning_errno("error reading directory '%s'",66path);67return -1;68}69
70return 1;71}72
73if (is_dot_or_dotdot(de->d_name))74goto repeat;75
76*out = de;77return 0;78}
79
80/*
81* Push a level in the iter stack and initialize it with information from
82* the directory pointed by iter->base->path. It is assumed that this
83* strbuf points to a valid directory path. Return 0 on success and -1
84* otherwise, setting errno accordingly and leaving the stack unchanged.
85*/
86static int push_level(struct dir_iterator_int *iter)87{
88struct dir_iterator_level *level;89
90ALLOC_GROW(iter->levels, iter->levels_nr + 1, iter->levels_alloc);91level = &iter->levels[iter->levels_nr++];92
93if (!is_dir_sep(iter->base.path.buf[iter->base.path.len - 1]))94strbuf_addch(&iter->base.path, '/');95level->prefix_len = iter->base.path.len;96
97level->dir = opendir(iter->base.path.buf);98if (!level->dir) {99int saved_errno = errno;100if (errno != ENOENT) {101warning_errno("error opening directory '%s'",102iter->base.path.buf);103}104iter->levels_nr--;105errno = saved_errno;106return -1;107}108
109string_list_init_dup(&level->entries);110level->entries_idx = 0;111
112/*113* When the iterator is sorted we read and sort all directory entries
114* directly.
115*/
116if (iter->flags & DIR_ITERATOR_SORTED) {117struct dirent *de;118
119while (1) {120int ret = next_directory_entry(level->dir, iter->base.path.buf, &de);121if (ret < 0) {122if (errno != ENOENT &&123iter->flags & DIR_ITERATOR_PEDANTIC)124return -1;125continue;126} else if (ret > 0) {127break;128}129
130string_list_append(&level->entries, de->d_name);131}132string_list_sort(&level->entries);133
134closedir(level->dir);135level->dir = NULL;136}137
138return 0;139}
140
141/*
142* Pop the top level on the iter stack, releasing any resources associated
143* with it. Return the new value of iter->levels_nr.
144*/
145static int pop_level(struct dir_iterator_int *iter)146{
147struct dir_iterator_level *level =148&iter->levels[iter->levels_nr - 1];149
150if (level->dir && closedir(level->dir))151warning_errno("error closing directory '%s'",152iter->base.path.buf);153level->dir = NULL;154string_list_clear(&level->entries, 0);155
156return --iter->levels_nr;157}
158
159/*
160* Populate iter->base with the necessary information on the next iteration
161* entry, represented by the given name. Return 0 on success and -1
162* otherwise, setting errno accordingly.
163*/
164static int prepare_next_entry_data(struct dir_iterator_int *iter,165const char *name)166{
167int err, saved_errno;168
169strbuf_addstr(&iter->base.path, name);170/*171* We have to reset these because the path strbuf might have
172* been realloc()ed at the previous strbuf_addstr().
173*/
174iter->base.relative_path = iter->base.path.buf +175iter->levels[0].prefix_len;176iter->base.basename = iter->base.path.buf +177iter->levels[iter->levels_nr - 1].prefix_len;178
179err = lstat(iter->base.path.buf, &iter->base.st);180
181saved_errno = errno;182if (err && errno != ENOENT)183warning_errno("failed to stat '%s'", iter->base.path.buf);184
185errno = saved_errno;186return err;187}
188
189int dir_iterator_advance(struct dir_iterator *dir_iterator)190{
191struct dir_iterator_int *iter =192(struct dir_iterator_int *)dir_iterator;193
194if (S_ISDIR(iter->base.st.st_mode) && push_level(iter)) {195if (errno != ENOENT && iter->flags & DIR_ITERATOR_PEDANTIC)196goto error_out;197if (iter->levels_nr == 0)198goto error_out;199}200
201/* Loop until we find an entry that we can give back to the caller. */202while (1) {203struct dirent *de;204struct dir_iterator_level *level =205&iter->levels[iter->levels_nr - 1];206const char *name;207
208strbuf_setlen(&iter->base.path, level->prefix_len);209
210if (level->dir) {211int ret = next_directory_entry(level->dir, iter->base.path.buf, &de);212if (ret < 0) {213if (iter->flags & DIR_ITERATOR_PEDANTIC)214goto error_out;215continue;216} else if (ret > 0) {217if (pop_level(iter) == 0)218return dir_iterator_abort(dir_iterator);219continue;220}221
222name = de->d_name;223} else {224if (level->entries_idx >= level->entries.nr) {225if (pop_level(iter) == 0)226return dir_iterator_abort(dir_iterator);227continue;228}229
230name = level->entries.items[level->entries_idx++].string;231}232
233if (prepare_next_entry_data(iter, name)) {234if (errno != ENOENT && iter->flags & DIR_ITERATOR_PEDANTIC)235goto error_out;236continue;237}238
239return ITER_OK;240}241
242error_out:243dir_iterator_abort(dir_iterator);244return ITER_ERROR;245}
246
247int dir_iterator_abort(struct dir_iterator *dir_iterator)248{
249struct dir_iterator_int *iter = (struct dir_iterator_int *)dir_iterator;250
251for (; iter->levels_nr; iter->levels_nr--) {252struct dir_iterator_level *level =253&iter->levels[iter->levels_nr - 1];254
255if (level->dir && closedir(level->dir)) {256int saved_errno = errno;257strbuf_setlen(&iter->base.path, level->prefix_len);258errno = saved_errno;259warning_errno("error closing directory '%s'",260iter->base.path.buf);261}262
263string_list_clear(&level->entries, 0);264}265
266free(iter->levels);267strbuf_release(&iter->base.path);268free(iter);269return ITER_DONE;270}
271
272struct dir_iterator *dir_iterator_begin(const char *path, unsigned int flags)273{
274struct dir_iterator_int *iter = xcalloc(1, sizeof(*iter));275struct dir_iterator *dir_iterator = &iter->base;276int saved_errno, err;277
278strbuf_init(&iter->base.path, PATH_MAX);279strbuf_addstr(&iter->base.path, path);280
281ALLOC_GROW(iter->levels, 10, iter->levels_alloc);282iter->levels_nr = 0;283iter->flags = flags;284
285/*286* Note: lstat already checks for NULL or empty strings and
287* nonexistent paths.
288*/
289err = lstat(iter->base.path.buf, &iter->base.st);290
291if (err < 0) {292saved_errno = errno;293goto error_out;294}295
296if (!S_ISDIR(iter->base.st.st_mode)) {297saved_errno = ENOTDIR;298goto error_out;299}300
301return dir_iterator;302
303error_out:304dir_iterator_abort(dir_iterator);305errno = saved_errno;306return NULL;307}
308