summaryrefslogtreecommitdiffstats
path: root/lib/recursive_action.c
blob: 9505c86284d15bb7c27e125bcb83e67b16f3c90d (plain)
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
/* vi: set sw=8 ts=8: */
/*
 * Utility routines.
 *
 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */
#ifdef __BAREBOX__

#include <common.h>
#include <fs.h>
#include <linux/stat.h>
#include <malloc.h>
#include <libbb.h>
#include <xfuncs.h>

/*
 * Sorting not required for barebox itself currently, support for it is only added
 * for generating reproducible envfs images on the build host.
 */
#define DO_SORT(flags)	0

#else

#define DO_SORT(flags)	((flags) & ACTION_SORT)

#endif

#include <linux/list.h>
#include <linux/list_sort.h>

struct dirlist {
	char *dirname;
	struct list_head list;
};

/*
 * Walk down all the directories under the specified
 * location, and do something (something specified
 * by the fileAction and dirAction function pointers).
 *
 * Unfortunately, while nftw(3) could replace this and reduce
 * code size a bit, nftw() wasn't supported before GNU libc 2.1,
 * and so isn't sufficiently portable to take over since glibc2.1
 * is so stinking huge.
 */

static int true_action(const char *fileName, struct stat *statbuf,
						void* userData, int depth)
{
	return 1;
}

static int cmp_dirlist(void *priv, struct list_head *a, struct list_head *b)
{
	struct dirlist *ra, *rb;

	if (a == b)
		return 0;

	ra = list_entry(a, struct dirlist, list);
	rb = list_entry(b, struct dirlist, list);

	return strcmp(ra->dirname, rb->dirname);
}

/* fileAction return value of 0 on any file in directory will make
 * recursive_action() return 0, but it doesn't stop directory traversal
 * (fileAction/dirAction will be called on each file).
 *
 * if !depthFirst, dirAction return value of 0 (FALSE) or 2 (SKIP)
 * prevents recursion into that directory, instead
 * recursive_action() returns 0 (if FALSE) or 1 (if SKIP).
 *
 * followLinks=0/1 differs mainly in handling of links to dirs.
 * 0: lstat(statbuf). Calls fileAction on link name even if points to dir.
 * 1: stat(statbuf). Calls dirAction and optionally recurse on link to dir.
 */

int recursive_action(const char *fileName,
		unsigned flags,
		int (*fileAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
		int (*dirAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
		void* userData,
		const unsigned depth)
{
	struct stat statbuf;
	unsigned follow;
	int status;
	DIR *dir;
	struct dirent *next;
	struct dirlist *entry, *entry_tmp;
	LIST_HEAD(dirs);

	if (!fileAction) fileAction = true_action;
	if (!dirAction) dirAction = true_action;

	follow = ACTION_FOLLOWLINKS;
	if (depth == 0)
		follow = ACTION_FOLLOWLINKS;
	follow &= flags;
	status = (follow ? stat : lstat)(fileName, &statbuf);
	if (status < 0) {
#ifdef DEBUG_RECURS_ACTION
		bb_error_msg("status=%d followLinks=%d TRUE=%d",
				status, flags & ACTION_FOLLOWLINKS, TRUE);
#endif
		goto done_nak_warn;
	}

	/* If S_ISLNK(m), then we know that !S_ISDIR(m).
	 * Then we can skip checking first part: if it is true, then
	 * (!dir) is also true! */
	if ( /* (!(flags & ACTION_FOLLOWLINKS) && S_ISLNK(statbuf.st_mode)) || */
	 !S_ISDIR(statbuf.st_mode)
	) {
		return fileAction(fileName, &statbuf, userData, depth);
	}

	/* It's a directory (or a link to one, and followLinks is set) */

	if (!(flags & ACTION_RECURSE)) {
		return dirAction(fileName, &statbuf, userData, depth);
	}

	if (!(flags & ACTION_DEPTHFIRST)) {
		status = dirAction(fileName, &statbuf, userData, depth);
		if (!status) {
			goto done_nak_warn;
		}
		if (status == 2)
			return 1;
	}

	dir = opendir(fileName);
	if (!dir) {
		/* findutils-4.1.20 reports this */
		/* (i.e. it doesn't silently return with exit code 1) */
		/* To trigger: "find -exec rm -rf {} \;" */
		goto done_nak_warn;
	}

	status = 1;
	while ((next = readdir(dir)) != NULL) {
		char *nextFile = concat_subpath_file(fileName, next->d_name);
		if (nextFile == NULL)
			continue;

		if (DO_SORT(flags)) {
			struct dirlist *e = xmalloc(sizeof(*e));
			e->dirname = nextFile;
			list_add(&e->list, &dirs);
		} else {
			/* descend into it, forcing recursion. */
			if (!recursive_action(nextFile, flags | ACTION_RECURSE,
						fileAction, dirAction, userData, depth+1)) {
				status = 0;
			}
			free(nextFile);
		}
	}

	if (DO_SORT(flags)) {
		list_sort(NULL, &dirs, &cmp_dirlist);

		list_for_each_entry_safe(entry, entry_tmp, &dirs, list){
			/* descend into it, forcing recursion. */
			if (!recursive_action(entry->dirname, flags | ACTION_RECURSE,
						fileAction, dirAction, userData, depth+1)) {
				status = 0;
			}

			list_del(&entry->list);
			free(entry->dirname);
		}
	}
	closedir(dir);
	if ((flags & ACTION_DEPTHFIRST) &&
		!dirAction(fileName, &statbuf, userData, depth)) {
			goto done_nak_warn;
	}

	if (!status)
		return 0;
	return 1;
done_nak_warn:
	return 0;
}

#ifdef __BAREBOX__
EXPORT_SYMBOL(recursive_action);
#endif