]>
Commit | Line | Data |
---|---|---|
1 | #include "cache.h" | |
2 | ||
3 | static int threaded_check_leading_path(struct cache_def *cache, const char *name, int len); | |
4 | static int threaded_has_dirs_only_path(struct cache_def *cache, const char *name, int len, int prefix_len); | |
5 | ||
6 | /* | |
7 | * Returns the length (on a path component basis) of the longest | |
8 | * common prefix match of 'name_a' and 'name_b'. | |
9 | */ | |
10 | static int longest_path_match(const char *name_a, int len_a, | |
11 | const char *name_b, int len_b, | |
12 | int *previous_slash) | |
13 | { | |
14 | int max_len, match_len = 0, match_len_prev = 0, i = 0; | |
15 | ||
16 | max_len = len_a < len_b ? len_a : len_b; | |
17 | while (i < max_len && name_a[i] == name_b[i]) { | |
18 | if (name_a[i] == '/') { | |
19 | match_len_prev = match_len; | |
20 | match_len = i; | |
21 | } | |
22 | i++; | |
23 | } | |
24 | /* | |
25 | * Is 'name_b' a substring of 'name_a', the other way around, | |
26 | * or is 'name_a' and 'name_b' the exact same string? | |
27 | */ | |
28 | if (i >= max_len && ((len_a > len_b && name_a[len_b] == '/') || | |
29 | (len_a < len_b && name_b[len_a] == '/') || | |
30 | (len_a == len_b))) { | |
31 | match_len_prev = match_len; | |
32 | match_len = i; | |
33 | } | |
34 | *previous_slash = match_len_prev; | |
35 | return match_len; | |
36 | } | |
37 | ||
38 | static struct cache_def default_cache = CACHE_DEF_INIT; | |
39 | ||
40 | static inline void reset_lstat_cache(struct cache_def *cache) | |
41 | { | |
42 | strbuf_reset(&cache->path); | |
43 | cache->flags = 0; | |
44 | /* | |
45 | * The track_flags and prefix_len_stat_func members is only | |
46 | * set by the safeguard rule inside lstat_cache() | |
47 | */ | |
48 | } | |
49 | ||
50 | #define FL_DIR (1 << 0) | |
51 | #define FL_NOENT (1 << 1) | |
52 | #define FL_SYMLINK (1 << 2) | |
53 | #define FL_LSTATERR (1 << 3) | |
54 | #define FL_ERR (1 << 4) | |
55 | #define FL_FULLPATH (1 << 5) | |
56 | ||
57 | /* | |
58 | * Check if name 'name' of length 'len' has a symlink leading | |
59 | * component, or if the directory exists and is real, or not. | |
60 | * | |
61 | * To speed up the check, some information is allowed to be cached. | |
62 | * This can be indicated by the 'track_flags' argument, which also can | |
63 | * be used to indicate that we should check the full path. | |
64 | * | |
65 | * The 'prefix_len_stat_func' parameter can be used to set the length | |
66 | * of the prefix, where the cache should use the stat() function | |
67 | * instead of the lstat() function to test each path component. | |
68 | */ | |
69 | static int lstat_cache_matchlen(struct cache_def *cache, | |
70 | const char *name, int len, | |
71 | int *ret_flags, int track_flags, | |
72 | int prefix_len_stat_func) | |
73 | { | |
74 | int match_len, last_slash, last_slash_dir, previous_slash; | |
75 | int save_flags, ret; | |
76 | struct stat st; | |
77 | ||
78 | if (cache->track_flags != track_flags || | |
79 | cache->prefix_len_stat_func != prefix_len_stat_func) { | |
80 | /* | |
81 | * As a safeguard rule we clear the cache if the | |
82 | * values of track_flags and/or prefix_len_stat_func | |
83 | * does not match with the last supplied values. | |
84 | */ | |
85 | reset_lstat_cache(cache); | |
86 | cache->track_flags = track_flags; | |
87 | cache->prefix_len_stat_func = prefix_len_stat_func; | |
88 | match_len = last_slash = 0; | |
89 | } else { | |
90 | /* | |
91 | * Check to see if we have a match from the cache for | |
92 | * the 2 "excluding" path types. | |
93 | */ | |
94 | match_len = last_slash = | |
95 | longest_path_match(name, len, cache->path.buf, | |
96 | cache->path.len, &previous_slash); | |
97 | *ret_flags = cache->flags & track_flags & (FL_NOENT|FL_SYMLINK); | |
98 | ||
99 | if (!(track_flags & FL_FULLPATH) && match_len == len) | |
100 | match_len = last_slash = previous_slash; | |
101 | ||
102 | if (*ret_flags && match_len == cache->path.len) | |
103 | return match_len; | |
104 | /* | |
105 | * If we now have match_len > 0, we would know that | |
106 | * the matched part will always be a directory. | |
107 | * | |
108 | * Also, if we are tracking directories and 'name' is | |
109 | * a substring of the cache on a path component basis, | |
110 | * we can return immediately. | |
111 | */ | |
112 | *ret_flags = track_flags & FL_DIR; | |
113 | if (*ret_flags && len == match_len) | |
114 | return match_len; | |
115 | } | |
116 | ||
117 | /* | |
118 | * Okay, no match from the cache so far, so now we have to | |
119 | * check the rest of the path components. | |
120 | */ | |
121 | *ret_flags = FL_DIR; | |
122 | last_slash_dir = last_slash; | |
123 | if (len > cache->path.len) | |
124 | strbuf_grow(&cache->path, len - cache->path.len); | |
125 | while (match_len < len) { | |
126 | do { | |
127 | cache->path.buf[match_len] = name[match_len]; | |
128 | match_len++; | |
129 | } while (match_len < len && name[match_len] != '/'); | |
130 | if (match_len >= len && !(track_flags & FL_FULLPATH)) | |
131 | break; | |
132 | last_slash = match_len; | |
133 | cache->path.buf[last_slash] = '\0'; | |
134 | ||
135 | if (last_slash <= prefix_len_stat_func) | |
136 | ret = stat(cache->path.buf, &st); | |
137 | else | |
138 | ret = lstat(cache->path.buf, &st); | |
139 | ||
140 | if (ret) { | |
141 | *ret_flags = FL_LSTATERR; | |
142 | if (errno == ENOENT) | |
143 | *ret_flags |= FL_NOENT; | |
144 | } else if (S_ISDIR(st.st_mode)) { | |
145 | last_slash_dir = last_slash; | |
146 | continue; | |
147 | } else if (S_ISLNK(st.st_mode)) { | |
148 | *ret_flags = FL_SYMLINK; | |
149 | } else { | |
150 | *ret_flags = FL_ERR; | |
151 | } | |
152 | break; | |
153 | } | |
154 | ||
155 | /* | |
156 | * At the end update the cache. Note that max 3 different | |
157 | * path types, FL_NOENT, FL_SYMLINK and FL_DIR, can be cached | |
158 | * for the moment! | |
159 | */ | |
160 | save_flags = *ret_flags & track_flags & (FL_NOENT|FL_SYMLINK); | |
161 | if (save_flags && last_slash > 0) { | |
162 | cache->path.buf[last_slash] = '\0'; | |
163 | cache->path.len = last_slash; | |
164 | cache->flags = save_flags; | |
165 | } else if ((track_flags & FL_DIR) && last_slash_dir > 0) { | |
166 | /* | |
167 | * We have a separate test for the directory case, | |
168 | * since it could be that we have found a symlink or a | |
169 | * non-existing directory and the track_flags says | |
170 | * that we cannot cache this fact, so the cache would | |
171 | * then have been left empty in this case. | |
172 | * | |
173 | * But if we are allowed to track real directories, we | |
174 | * can still cache the path components before the last | |
175 | * one (the found symlink or non-existing component). | |
176 | */ | |
177 | cache->path.buf[last_slash_dir] = '\0'; | |
178 | cache->path.len = last_slash_dir; | |
179 | cache->flags = FL_DIR; | |
180 | } else { | |
181 | reset_lstat_cache(cache); | |
182 | } | |
183 | return match_len; | |
184 | } | |
185 | ||
186 | static int lstat_cache(struct cache_def *cache, const char *name, int len, | |
187 | int track_flags, int prefix_len_stat_func) | |
188 | { | |
189 | int flags; | |
190 | (void)lstat_cache_matchlen(cache, name, len, &flags, track_flags, | |
191 | prefix_len_stat_func); | |
192 | return flags; | |
193 | } | |
194 | ||
195 | #define USE_ONLY_LSTAT 0 | |
196 | ||
197 | /* | |
198 | * Return non-zero if path 'name' has a leading symlink component | |
199 | */ | |
200 | int threaded_has_symlink_leading_path(struct cache_def *cache, const char *name, int len) | |
201 | { | |
202 | return lstat_cache(cache, name, len, FL_SYMLINK|FL_DIR, USE_ONLY_LSTAT) & FL_SYMLINK; | |
203 | } | |
204 | ||
205 | /* | |
206 | * Return non-zero if path 'name' has a leading symlink component | |
207 | */ | |
208 | int has_symlink_leading_path(const char *name, int len) | |
209 | { | |
210 | return threaded_has_symlink_leading_path(&default_cache, name, len); | |
211 | } | |
212 | ||
213 | /* | |
214 | * Return zero if path 'name' has a leading symlink component or | |
215 | * if some leading path component does not exists. | |
216 | * | |
217 | * Return -1 if leading path exists and is a directory. | |
218 | * | |
219 | * Return path length if leading path exists and is neither a | |
220 | * directory nor a symlink. | |
221 | */ | |
222 | int check_leading_path(const char *name, int len) | |
223 | { | |
224 | return threaded_check_leading_path(&default_cache, name, len); | |
225 | } | |
226 | ||
227 | /* | |
228 | * Return zero if path 'name' has a leading symlink component or | |
229 | * if some leading path component does not exists. | |
230 | * | |
231 | * Return -1 if leading path exists and is a directory. | |
232 | * | |
233 | * Return path length if leading path exists and is neither a | |
234 | * directory nor a symlink. | |
235 | */ | |
236 | static int threaded_check_leading_path(struct cache_def *cache, const char *name, int len) | |
237 | { | |
238 | int flags; | |
239 | int match_len = lstat_cache_matchlen(cache, name, len, &flags, | |
240 | FL_SYMLINK|FL_NOENT|FL_DIR, USE_ONLY_LSTAT); | |
241 | if (flags & FL_NOENT) | |
242 | return 0; | |
243 | else if (flags & FL_DIR) | |
244 | return -1; | |
245 | else | |
246 | return match_len; | |
247 | } | |
248 | ||
249 | /* | |
250 | * Return non-zero if all path components of 'name' exists as a | |
251 | * directory. If prefix_len > 0, we will test with the stat() | |
252 | * function instead of the lstat() function for a prefix length of | |
253 | * 'prefix_len', thus we then allow for symlinks in the prefix part as | |
254 | * long as those points to real existing directories. | |
255 | */ | |
256 | int has_dirs_only_path(const char *name, int len, int prefix_len) | |
257 | { | |
258 | return threaded_has_dirs_only_path(&default_cache, name, len, prefix_len); | |
259 | } | |
260 | ||
261 | /* | |
262 | * Return non-zero if all path components of 'name' exists as a | |
263 | * directory. If prefix_len > 0, we will test with the stat() | |
264 | * function instead of the lstat() function for a prefix length of | |
265 | * 'prefix_len', thus we then allow for symlinks in the prefix part as | |
266 | * long as those points to real existing directories. | |
267 | */ | |
268 | static int threaded_has_dirs_only_path(struct cache_def *cache, const char *name, int len, int prefix_len) | |
269 | { | |
270 | return lstat_cache(cache, name, len, | |
271 | FL_DIR|FL_FULLPATH, prefix_len) & | |
272 | FL_DIR; | |
273 | } | |
274 | ||
275 | static struct strbuf removal = STRBUF_INIT; | |
276 | ||
277 | static void do_remove_scheduled_dirs(int new_len) | |
278 | { | |
279 | while (removal.len > new_len) { | |
280 | removal.buf[removal.len] = '\0'; | |
281 | if (rmdir(removal.buf)) | |
282 | break; | |
283 | do { | |
284 | removal.len--; | |
285 | } while (removal.len > new_len && | |
286 | removal.buf[removal.len] != '/'); | |
287 | } | |
288 | removal.len = new_len; | |
289 | } | |
290 | ||
291 | void schedule_dir_for_removal(const char *name, int len) | |
292 | { | |
293 | int match_len, last_slash, i, previous_slash; | |
294 | ||
295 | match_len = last_slash = i = | |
296 | longest_path_match(name, len, removal.buf, removal.len, | |
297 | &previous_slash); | |
298 | /* Find last slash inside 'name' */ | |
299 | while (i < len) { | |
300 | if (name[i] == '/') | |
301 | last_slash = i; | |
302 | i++; | |
303 | } | |
304 | ||
305 | /* | |
306 | * If we are about to go down the directory tree, we check if | |
307 | * we must first go upwards the tree, such that we then can | |
308 | * remove possible empty directories as we go upwards. | |
309 | */ | |
310 | if (match_len < last_slash && match_len < removal.len) | |
311 | do_remove_scheduled_dirs(match_len); | |
312 | /* | |
313 | * If we go deeper down the directory tree, we only need to | |
314 | * save the new path components as we go down. | |
315 | */ | |
316 | if (match_len < last_slash) | |
317 | strbuf_add(&removal, &name[match_len], last_slash - match_len); | |
318 | } | |
319 | ||
320 | void remove_scheduled_dirs(void) | |
321 | { | |
322 | do_remove_scheduled_dirs(0); | |
323 | } |