git.oblomov.eu Git - git/blob - symlinks.c

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