X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=update-cache.c;h=7c2698df6e7b08315e7d20bd40c1e7e313f52bf3;hb=f9714a4a0cd4ed0ccca3833743d98ea874a2232d;hp=05d584ed48e8c7fbb200c4b9528481c1802c5bae;hpb=8ae0a8c514dc492de8aadf3ca6bb4ad55e33960e;p=git.git diff --git a/update-cache.c b/update-cache.c index 05d584ed..7c2698df 100644 --- a/update-cache.c +++ b/update-cache.c @@ -3,17 +3,17 @@ * * Copyright (C) Linus Torvalds, 2005 */ -#include #include "cache.h" /* * Default to not allowing changes to the list of files. The * tool doesn't actually care, but this makes it harder to add * files to the revision control by mistake by doing something - * like "update-cache *" and suddenly having all the object + * like "git-update-cache *" and suddenly having all the object * files be revision controlled. */ -static int allow_add = 0, allow_remove = 0, not_new = 0; +static int allow_add = 0, allow_remove = 0, allow_replace = 0, not_new = 0, quiet = 0; +static int force_remove; /* Three functions to allow overloaded pointer return; see linux/err.h */ static inline void *ERR_PTR(long error) @@ -31,41 +31,29 @@ static inline long IS_ERR(const void *ptr) return (unsigned long)ptr > (unsigned long)-1000L; } -/* - * This only updates the "non-critical" parts of the directory - * cache, ie the parts that aren't tracked by GIT, and only used - * to validate the cache. - */ -static void fill_stat_cache_info(struct cache_entry *ce, struct stat *st) -{ - ce->ce_ctime.sec = htonl(st->st_ctime); - ce->ce_mtime.sec = htonl(st->st_mtime); -#ifdef NSEC - ce->ce_ctime.nsec = htonl(st->st_ctim.tv_nsec); - ce->ce_mtime.nsec = htonl(st->st_mtim.tv_nsec); -#endif - ce->ce_dev = htonl(st->st_dev); - ce->ce_ino = htonl(st->st_ino); - ce->ce_uid = htonl(st->st_uid); - ce->ce_gid = htonl(st->st_gid); - ce->ce_size = htonl(st->st_size); -} - static int add_file_to_cache(char *path) { - int size, namelen; + int size, namelen, option, status; struct cache_entry *ce; struct stat st; int fd; - unsigned int len; - char target[1024]; - - if (lstat(path, &st) < 0) { - if (errno == ENOENT || errno == ENOTDIR) { + char *target; + + status = lstat(path, &st); + if (status < 0 || S_ISDIR(st.st_mode)) { + /* When we used to have "path" and now we want to add + * "path/file", we need a way to remove "path" before + * being able to add "path/file". However, + * "git-update-cache --remove path" would not work. + * --force-remove can be used but this is more user + * friendly, especially since we can do the opposite + * case just fine without --force-remove. + */ + if (status == 0 || (errno == ENOENT || errno == ENOTDIR)) { if (allow_remove) return remove_file_from_cache(path); } - return -1; + return error("open(\"%s\"): %s", path, strerror(errno)); } namelen = strlen(path); size = cache_entry_size(namelen); @@ -84,16 +72,21 @@ static int add_file_to_cache(char *path) return -1; break; case S_IFLNK: - len = readlink(path, target, sizeof(target)); - if (len == -1 || len+1 > sizeof(target)) + target = xmalloc(st.st_size+1); + if (readlink(path, target, st.st_size+1) != st.st_size) { + free(target); return -1; - if (write_sha1_file(target, len, "blob", ce->sha1)) + } + if (write_sha1_file(target, st.st_size, "blob", ce->sha1)) return -1; + free(target); break; default: return -1; } - return add_cache_entry(ce, allow_add); + option = allow_add ? ADD_CACHE_OK_TO_ADD : 0; + option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0; + return add_cache_entry(ce, option); } static int match_data(int fd, void *buffer, unsigned long size) @@ -118,7 +111,7 @@ static int compare_data(struct cache_entry *ce, unsigned long expected_size) if (fd >= 0) { void *buffer; unsigned long size; - char type[10]; + char type[20]; buffer = read_sha1_file(ce->sha1, type, &size); if (buffer) { @@ -131,6 +124,33 @@ static int compare_data(struct cache_entry *ce, unsigned long expected_size) return match; } +static int compare_link(struct cache_entry *ce, unsigned long expected_size) +{ + int match = -1; + char *target; + void *buffer; + unsigned long size; + char type[10]; + int len; + + target = xmalloc(expected_size); + len = readlink(ce->name, target, expected_size); + if (len != expected_size) { + free(target); + return -1; + } + buffer = read_sha1_file(ce->sha1, type, &size); + if (!buffer) { + free(target); + return -1; + } + if (size == expected_size) + match = memcmp(buffer, target, size); + free(buffer); + free(target); + return match; +} + /* * "refresh" does not calculate a new sha1 file or bring the * cache up-to-date for mode/content changes. But what it @@ -139,7 +159,7 @@ static int compare_data(struct cache_entry *ce, unsigned long expected_size) * file that hasn't been changed but where the stat entry is * out of date. * - * For example, you'd want to do this after doing a "read-tree", + * For example, you'd want to do this after doing a "git-read-tree", * to link up the stat cache details with the proper files. */ static struct cache_entry *refresh_entry(struct cache_entry *ce) @@ -151,7 +171,7 @@ static struct cache_entry *refresh_entry(struct cache_entry *ce) if (lstat(ce->name, &st) < 0) return ERR_PTR(-errno); - changed = cache_match_stat(ce, &st); + changed = ce_match_stat(ce, &st); if (!changed) return ce; @@ -162,8 +182,18 @@ static struct cache_entry *refresh_entry(struct cache_entry *ce) if (changed & (MODE_CHANGED | TYPE_CHANGED)) return ERR_PTR(-EINVAL); - if (compare_data(ce, st.st_size)) + switch (st.st_mode & S_IFMT) { + case S_IFREG: + if (compare_data(ce, st.st_size)) + return ERR_PTR(-EINVAL); + break; + case S_IFLNK: + if (compare_link(ce, st.st_size)) + return ERR_PTR(-EINVAL); + break; + default: return ERR_PTR(-EINVAL); + } size = ce_size(ce); updated = xmalloc(size); @@ -192,12 +222,18 @@ static int refresh_cache(void) new = refresh_entry(ce); if (IS_ERR(new)) { - if (!(not_new && PTR_ERR(new) == -ENOENT)) { - printf("%s: needs update\n", ce->name); - has_errors = 1; - } + if (not_new && PTR_ERR(new) == -ENOENT) + continue; + if (quiet) + continue; + printf("%s: needs update\n", ce->name); + has_errors = 1; continue; } + active_cache_changed = 1; + /* You can NOT just free active_cache[i] here, since it + * might not be necessarily malloc()ed but can also come + * from mmap(). */ active_cache[i] = new; } return has_errors; @@ -205,13 +241,42 @@ static int refresh_cache(void) /* * We fundamentally don't like some paths: we don't want - * dot or dot-dot anywhere, and in fact, we don't even want - * any other dot-files (.git or anything else). They - * are hidden, for chist sake. + * dot or dot-dot anywhere, and for obvious reasons don't + * want to recurse into ".git" either. * * Also, we don't want double slashes or slashes at the * end that can make pathnames ambiguous. */ +static int verify_dotfile(const char *rest) +{ + /* + * The first character was '.', but that + * has already been discarded, we now test + * the rest. + */ + switch (*rest) { + /* "." is not allowed */ + case '\0': case '/': + return 0; + + /* + * ".git" followed by NUL or slash is bad. This + * shares the path end test with the ".." case. + */ + case 'g': + if (rest[1] != 'i') + break; + if (rest[2] != 't') + break; + rest += 2; + /* fallthrough */ + case '.': + if (rest[1] == '\0' || rest[1] == '/') + return 0; + } + return 1; +} + static int verify_path(char *path) { char c; @@ -223,8 +288,15 @@ static int verify_path(char *path) if (c == '/') { inside: c = *path++; - if (c != '/' && c != '.' && c != '\0') + switch (c) { + default: continue; + case '/': case '\0': + break; + case '.': + if (verify_dotfile(path)) + continue; + } return 0; } c = *path++; @@ -233,7 +305,7 @@ inside: static int add_cacheinfo(char *arg1, char *arg2, char *arg3) { - int size, len; + int size, len, option; unsigned int mode; unsigned char sha1[20]; struct cache_entry *ce; @@ -254,39 +326,22 @@ static int add_cacheinfo(char *arg1, char *arg2, char *arg3) memcpy(ce->name, arg3, len); ce->ce_flags = htons(len); ce->ce_mode = create_ce_mode(mode); - return add_cache_entry(ce, allow_add); + option = allow_add ? ADD_CACHE_OK_TO_ADD : 0; + option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0; + return add_cache_entry(ce, option); } -static const char *lockfile_name = NULL; - -static void remove_lock_file(void) -{ - if (lockfile_name) - unlink(lockfile_name); -} - -static void remove_lock_file_on_signal(int signo) -{ - remove_lock_file(); -} +static struct cache_file cache_file; int main(int argc, char **argv) { int i, newfd, entries, has_errors = 0; int allow_options = 1; - static char lockfile[MAXPATHLEN+1]; - const char *indexfile = get_index_file(); - - snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile); - newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600); + newfd = hold_index_file_for_update(&cache_file, get_index_file()); if (newfd < 0) die("unable to create new cachefile"); - signal(SIGINT, remove_lock_file_on_signal); - atexit(remove_lock_file); - lockfile_name = lockfile; - entries = read_cache(); if (entries < 0) die("cache corrupted"); @@ -299,10 +354,18 @@ int main(int argc, char **argv) allow_options = 0; continue; } + if (!strcmp(path, "-q")) { + quiet = 1; + continue; + } if (!strcmp(path, "--add")) { allow_add = 1; continue; } + if (!strcmp(path, "--replace")) { + allow_replace = 1; + continue; + } if (!strcmp(path, "--remove")) { allow_remove = 1; continue; @@ -312,17 +375,15 @@ int main(int argc, char **argv) continue; } if (!strcmp(path, "--cacheinfo")) { - if (i+3 >= argc || add_cacheinfo(argv[i+1], argv[i+2], argv[i+3])) - die("update-cache: --cacheinfo "); + if (i+3 >= argc) + die("git-update-cache: --cacheinfo "); + if (add_cacheinfo(argv[i+1], argv[i+2], argv[i+3])) + die("git-update-cache: --cacheinfo cannot add %s", argv[i+3]); i += 3; continue; } if (!strcmp(path, "--force-remove")) { - if (argc <= i + 1) - die("update-cache: --force-remove "); - if (remove_file_from_cache(argv[i+1])) - die("update-cache: --force-remove cannot remove %s", argv[i+1]); - i++; + force_remove = 1; continue; } @@ -336,12 +397,17 @@ int main(int argc, char **argv) fprintf(stderr, "Ignoring path %s\n", argv[i]); continue; } + if (force_remove) { + if (remove_file_from_cache(path)) + die("git-update-cache: --force-remove cannot remove %s", path); + continue; + } if (add_file_to_cache(path)) die("Unable to add %s to database", path); } - if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile)) + if (write_cache(newfd, active_cache, active_nr) || + commit_index_file(&cache_file)) die("Unable to write new cachefile"); - lockfile_name = NULL; - return has_errors; + return has_errors ? 1 : 0; }