t/t8*: avoid redundant use of cat
[git.git] / symlinks.c
blobb29e340c2da43e9ac35adcda05322b1e068017ca
1 #include "git-compat-util.h"
2 #include "gettext.h"
3 #include "setup.h"
4 #include "symlinks.h"
6 static int threaded_check_leading_path(struct cache_def *cache, const char *name,
7 int len, int warn_on_lstat_err);
8 static int threaded_has_dirs_only_path(struct cache_def *cache, const char *name, int len, int prefix_len);
11 * Returns the length (on a path component basis) of the longest
12 * common prefix match of 'name_a' and 'name_b'.
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)
18 int max_len, match_len = 0, match_len_prev = 0, i = 0;
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] == '/') {
23 match_len_prev = match_len;
24 match_len = i;
26 i++;
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?
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))) {
35 match_len_prev = match_len;
36 match_len = i;
38 *previous_slash = match_len_prev;
39 return match_len;
42 static struct cache_def default_cache = CACHE_DEF_INIT;
44 static inline void reset_lstat_cache(struct cache_def *cache)
46 strbuf_reset(&cache->path);
47 cache->flags = 0;
49 * The track_flags and prefix_len_stat_func members is only
50 * set by the safeguard rule inside lstat_cache()
54 #define FL_DIR (1 << 0)
55 #define FL_NOENT (1 << 1)
56 #define FL_SYMLINK (1 << 2)
57 #define FL_LSTATERR (1 << 3)
58 #define FL_ERR (1 << 4)
59 #define FL_FULLPATH (1 << 5)
62 * Check if name 'name' of length 'len' has a symlink leading
63 * component, or if the directory exists and is real, or not.
65 * To speed up the check, some information is allowed to be cached.
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.
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.
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)
78 int match_len, last_slash, last_slash_dir, previous_slash;
79 int save_flags, ret, saved_errno = 0;
80 struct stat st;
82 if (cache->track_flags != track_flags ||
83 cache->prefix_len_stat_func != prefix_len_stat_func) {
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.
89 reset_lstat_cache(cache);
90 cache->track_flags = track_flags;
91 cache->prefix_len_stat_func = prefix_len_stat_func;
92 match_len = last_slash = 0;
93 } else {
95 * Check to see if we have a match from the cache for
96 * the 2 "excluding" path types.
98 match_len = last_slash =
99 longest_path_match(name, len, cache->path.buf,
100 cache->path.len, &previous_slash);
101 *ret_flags = cache->flags & track_flags & (FL_NOENT|FL_SYMLINK);
103 if (!(track_flags & FL_FULLPATH) && match_len == len)
104 match_len = last_slash = previous_slash;
106 if (*ret_flags && match_len == cache->path.len)
107 return match_len;
109 * If we now have match_len > 0, we would know that
110 * the matched part will always be a directory.
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.
116 *ret_flags = track_flags & FL_DIR;
117 if (*ret_flags && len == match_len)
118 return match_len;
122 * Okay, no match from the cache so far, so now we have to
123 * check the rest of the path components.
125 *ret_flags = FL_DIR;
126 last_slash_dir = last_slash;
127 if (len > cache->path.len)
128 strbuf_grow(&cache->path, len - cache->path.len);
129 while (match_len < len) {
130 do {
131 cache->path.buf[match_len] = name[match_len];
132 match_len++;
133 } while (match_len < len && name[match_len] != '/');
134 if (match_len >= len && !(track_flags & FL_FULLPATH))
135 break;
136 last_slash = match_len;
137 cache->path.buf[last_slash] = '\0';
139 if (last_slash <= prefix_len_stat_func)
140 ret = stat(cache->path.buf, &st);
141 else
142 ret = lstat(cache->path.buf, &st);
144 if (ret) {
145 *ret_flags = FL_LSTATERR;
146 saved_errno = errno;
147 if (errno == ENOENT)
148 *ret_flags |= FL_NOENT;
149 } else if (S_ISDIR(st.st_mode)) {
150 last_slash_dir = last_slash;
151 continue;
152 } else if (S_ISLNK(st.st_mode)) {
153 *ret_flags = FL_SYMLINK;
154 } else {
155 *ret_flags = FL_ERR;
157 break;
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!
165 save_flags = *ret_flags & track_flags & (FL_NOENT|FL_SYMLINK);
166 if (save_flags && last_slash > 0) {
167 cache->path.buf[last_slash] = '\0';
168 cache->path.len = last_slash;
169 cache->flags = save_flags;
170 } else if ((track_flags & FL_DIR) && last_slash_dir > 0) {
172 * We have a separate test for the directory case,
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.
178 * But if we are allowed to track real directories, we
179 * can still cache the path components before the last
180 * one (the found symlink or non-existing component).
182 cache->path.buf[last_slash_dir] = '\0';
183 cache->path.len = last_slash_dir;
184 cache->flags = FL_DIR;
185 } else {
186 reset_lstat_cache(cache);
188 if (saved_errno)
189 errno = saved_errno;
190 return match_len;
193 static int lstat_cache(struct cache_def *cache, const char *name, int len,
194 int track_flags, int prefix_len_stat_func)
196 int flags;
197 (void)lstat_cache_matchlen(cache, name, len, &flags, track_flags,
198 prefix_len_stat_func);
199 return flags;
202 #define USE_ONLY_LSTAT 0
205 * Return non-zero if path 'name' has a leading symlink component
207 int threaded_has_symlink_leading_path(struct cache_def *cache, const char *name, int len)
209 return lstat_cache(cache, name, len, FL_SYMLINK|FL_DIR, USE_ONLY_LSTAT) & FL_SYMLINK;
212 int has_symlink_leading_path(const char *name, int len)
214 return threaded_has_symlink_leading_path(&default_cache, name, len);
217 int check_leading_path(const char *name, int len, int warn_on_lstat_err)
219 return threaded_check_leading_path(&default_cache, name, len,
220 warn_on_lstat_err);
224 * Return zero if some leading path component of 'name' does not exist.
226 * Return -1 if leading path exists and is a directory.
228 * Return the length of a leading component if it either exists but it's not a
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.
232 static int threaded_check_leading_path(struct cache_def *cache, const char *name,
233 int len, int warn_on_lstat_err)
235 int flags;
236 int match_len = lstat_cache_matchlen(cache, name, len, &flags,
237 FL_SYMLINK|FL_NOENT|FL_DIR, USE_ONLY_LSTAT);
238 int saved_errno = errno;
240 if (flags & FL_NOENT)
241 return 0;
242 else if (flags & FL_DIR)
243 return -1;
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);
250 return match_len;
253 int has_dirs_only_path(const char *name, int len, int prefix_len)
255 return threaded_has_dirs_only_path(&default_cache, name, len, prefix_len);
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.
265 static int threaded_has_dirs_only_path(struct cache_def *cache, const char *name, int len, int prefix_len)
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.
274 return lstat_cache(cache, name, len,
275 FL_DIR|FL_FULLPATH, prefix_len) &
276 FL_DIR;
279 static struct strbuf removal = STRBUF_INIT;
281 static void do_remove_scheduled_dirs(int new_len)
283 while (removal.len > new_len) {
284 removal.buf[removal.len] = '\0';
285 if ((startup_info->original_cwd &&
286 !strcmp(removal.buf, startup_info->original_cwd)) ||
287 rmdir(removal.buf))
288 break;
289 do {
290 removal.len--;
291 } while (removal.len > new_len &&
292 removal.buf[removal.len] != '/');
294 removal.len = new_len;
297 void schedule_dir_for_removal(const char *name, int len)
299 int match_len, last_slash, i, previous_slash;
301 if (startup_info->original_cwd &&
302 !strcmp(name, startup_info->original_cwd))
303 return; /* Do not remove the current working directory */
305 match_len = last_slash = i =
306 longest_path_match(name, len, removal.buf, removal.len,
307 &previous_slash);
308 /* Find last slash inside 'name' */
309 while (i < len) {
310 if (name[i] == '/')
311 last_slash = i;
312 i++;
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.
320 if (match_len < last_slash && match_len < removal.len)
321 do_remove_scheduled_dirs(match_len);
323 * If we go deeper down the directory tree, we only need to
324 * save the new path components as we go down.
326 if (match_len < last_slash)
327 strbuf_add(&removal, &name[match_len], last_slash - match_len);
330 void remove_scheduled_dirs(void)
332 do_remove_scheduled_dirs(0);
335 void invalidate_lstat_cache(void)
337 reset_lstat_cache(&default_cache);
340 #undef rmdir
341 int lstat_cache_aware_rmdir(const char *path)
343 /* Any change in this function must be made also in `mingw_rmdir()` */
344 int ret = rmdir(path);
346 if (!ret)
347 invalidate_lstat_cache();
349 return ret;