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