Merge branch 'ea/rebase-compat-doc-fix'
[git] / symlinks.c
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 }