From e7c730530065fb2f366ecbcb1e71d7f7346b6a25 Mon Sep 17 00:00:00 2001 From: Karsten Blees Date: Sat, 5 Jul 2014 00:41:46 +0200 Subject: symlinks: remove PATH_MAX limitation 'git checkout' fails if a directory is longer than PATH_MAX, because the lstat_cache in symlinks.c checks if the leading directory exists using PATH_MAX-bounded string operations. Remove the limitation by using strbuf instead. Signed-off-by: Karsten Blees Signed-off-by: Junio C Hamano --- symlinks.c | 63 ++++++++++++++++++++++++++++---------------------------------- 1 file changed, 28 insertions(+), 35 deletions(-) (limited to 'symlinks.c') diff --git a/symlinks.c b/symlinks.c index c2b41a8501..5261e8cf49 100644 --- a/symlinks.c +++ b/symlinks.c @@ -35,12 +35,11 @@ static int longest_path_match(const char *name_a, int len_a, return match_len; } -static struct cache_def default_cache; +static struct cache_def default_cache = CACHE_DEF_INIT; static inline void reset_lstat_cache(struct cache_def *cache) { - cache->path[0] = '\0'; - cache->len = 0; + strbuf_reset(&cache->path); cache->flags = 0; /* * The track_flags and prefix_len_stat_func members is only @@ -73,7 +72,7 @@ static int lstat_cache_matchlen(struct cache_def *cache, int prefix_len_stat_func) { int match_len, last_slash, last_slash_dir, previous_slash; - int save_flags, max_len, ret; + int save_flags, ret; struct stat st; if (cache->track_flags != track_flags || @@ -93,14 +92,14 @@ static int lstat_cache_matchlen(struct cache_def *cache, * the 2 "excluding" path types. */ match_len = last_slash = - longest_path_match(name, len, cache->path, cache->len, - &previous_slash); + longest_path_match(name, len, cache->path.buf, + cache->path.len, &previous_slash); *ret_flags = cache->flags & track_flags & (FL_NOENT|FL_SYMLINK); if (!(track_flags & FL_FULLPATH) && match_len == len) match_len = last_slash = previous_slash; - if (*ret_flags && match_len == cache->len) + if (*ret_flags && match_len == cache->path.len) return match_len; /* * If we now have match_len > 0, we would know that @@ -121,21 +120,22 @@ static int lstat_cache_matchlen(struct cache_def *cache, */ *ret_flags = FL_DIR; last_slash_dir = last_slash; - max_len = len < PATH_MAX ? len : PATH_MAX; - while (match_len < max_len) { + if (len > cache->path.len) + strbuf_grow(&cache->path, len - cache->path.len); + while (match_len < len) { do { - cache->path[match_len] = name[match_len]; + cache->path.buf[match_len] = name[match_len]; match_len++; - } while (match_len < max_len && name[match_len] != '/'); - if (match_len >= max_len && !(track_flags & FL_FULLPATH)) + } while (match_len < len && name[match_len] != '/'); + if (match_len >= len && !(track_flags & FL_FULLPATH)) break; last_slash = match_len; - cache->path[last_slash] = '\0'; + cache->path.buf[last_slash] = '\0'; if (last_slash <= prefix_len_stat_func) - ret = stat(cache->path, &st); + ret = stat(cache->path.buf, &st); else - ret = lstat(cache->path, &st); + ret = lstat(cache->path.buf, &st); if (ret) { *ret_flags = FL_LSTATERR; @@ -158,12 +158,11 @@ static int lstat_cache_matchlen(struct cache_def *cache, * for the moment! */ save_flags = *ret_flags & track_flags & (FL_NOENT|FL_SYMLINK); - if (save_flags && last_slash > 0 && last_slash <= PATH_MAX) { - cache->path[last_slash] = '\0'; - cache->len = last_slash; + if (save_flags && last_slash > 0) { + cache->path.buf[last_slash] = '\0'; + cache->path.len = last_slash; cache->flags = save_flags; - } else if ((track_flags & FL_DIR) && - last_slash_dir > 0 && last_slash_dir <= PATH_MAX) { + } else if ((track_flags & FL_DIR) && last_slash_dir > 0) { /* * We have a separate test for the directory case, * since it could be that we have found a symlink or a @@ -175,8 +174,8 @@ static int lstat_cache_matchlen(struct cache_def *cache, * can still cache the path components before the last * one (the found symlink or non-existing component). */ - cache->path[last_slash_dir] = '\0'; - cache->len = last_slash_dir; + cache->path.buf[last_slash_dir] = '\0'; + cache->path.len = last_slash_dir; cache->flags = FL_DIR; } else { reset_lstat_cache(cache); @@ -273,21 +272,18 @@ static int threaded_has_dirs_only_path(struct cache_def *cache, const char *name FL_DIR; } -static struct removal_def { - char path[PATH_MAX]; - int len; -} removal; +static struct strbuf removal = STRBUF_INIT; static void do_remove_scheduled_dirs(int new_len) { while (removal.len > new_len) { - removal.path[removal.len] = '\0'; - if (rmdir(removal.path)) + removal.buf[removal.len] = '\0'; + if (rmdir(removal.buf)) break; do { removal.len--; } while (removal.len > new_len && - removal.path[removal.len] != '/'); + removal.buf[removal.len] != '/'); } removal.len = new_len; } @@ -297,7 +293,7 @@ void schedule_dir_for_removal(const char *name, int len) int match_len, last_slash, i, previous_slash; match_len = last_slash = i = - longest_path_match(name, len, removal.path, removal.len, + longest_path_match(name, len, removal.buf, removal.len, &previous_slash); /* Find last slash inside 'name' */ while (i < len) { @@ -317,11 +313,8 @@ void schedule_dir_for_removal(const char *name, int len) * If we go deeper down the directory tree, we only need to * save the new path components as we go down. */ - if (match_len < last_slash) { - memcpy(&removal.path[match_len], &name[match_len], - last_slash - match_len); - removal.len = last_slash; - } + if (match_len < last_slash) + strbuf_add(&removal, &name[match_len], last_slash - match_len); } void remove_scheduled_dirs(void) -- cgit v1.2.3