X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=update-cache.c;h=3d1fd2be7593ac832e40c3f64b207d2bf5318e39;hb=fa6a1427c608e4e4a22aa6d176dd7b001b5f3021;hp=735d19920d998a3d53dbfd9a68336cc13780ef23;hpb=ee267527aa80807f37caf1d00bcf1b5263945adb;p=git.git diff --git a/update-cache.c b/update-cache.c index 735d1992..3d1fd2be 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, info_only = 0; +static int force_remove; /* Three functions to allow overloaded pointer return; see linux/err.h */ static inline void *ERR_PTR(long error) @@ -31,40 +31,33 @@ 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; char *target; - if (lstat(path, &st) < 0) { - if (errno == ENOENT || errno == ENOTDIR) { + 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; + if (0 == status) + return error("%s: is a directory", path); + else + return error("lstat(\"%s\"): %s", path, + strerror(errno)); } namelen = strlen(path); size = cache_entry_size(namelen); @@ -79,7 +72,7 @@ static int add_file_to_cache(char *path) fd = open(path, O_RDONLY); if (fd < 0) return -1; - if (index_fd(ce->sha1, fd, &st) < 0) + if (index_fd(ce->sha1, fd, &st, !info_only, NULL) < 0) return -1; break; case S_IFLNK: @@ -88,46 +81,32 @@ static int add_file_to_cache(char *path) free(target); return -1; } - if (write_sha1_file(target, st.st_size, "blob", ce->sha1)) + if (info_only) { + unsigned char hdr[50]; + int hdrlen; + write_sha1_file_prepare(target, st.st_size, "blob", + ce->sha1, hdr, &hdrlen); + } else 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); -} - -static int match_data(int fd, void *buffer, unsigned long size) -{ - while (size) { - char compare[1024]; - int ret = read(fd, compare, sizeof(compare)); - - if (ret <= 0 || ret > size || memcmp(buffer, compare, ret)) - return -1; - size -= ret; - buffer += ret; - } - return 0; + 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 compare_data(struct cache_entry *ce, unsigned long expected_size) +static int compare_data(struct cache_entry *ce, struct stat *st) { int match = -1; int fd = open(ce->name, O_RDONLY); if (fd >= 0) { - void *buffer; - unsigned long size; - char type[10]; - - buffer = read_sha1_file(ce->sha1, type, &size); - if (buffer) { - if (size == expected_size && !strcmp(type, "blob")) - match = match_data(fd, buffer, size); - free(buffer); - } + unsigned char sha1[20]; + if (!index_fd(sha1, fd, st, 0, NULL)) + match = memcmp(sha1, ce->sha1, 20); close(fd); } return match; @@ -168,7 +147,7 @@ static int compare_link(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) @@ -180,7 +159,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; @@ -193,7 +172,7 @@ static struct cache_entry *refresh_entry(struct cache_entry *ce) switch (st.st_mode & S_IFMT) { case S_IFREG: - if (compare_data(ce, st.st_size)) + if (compare_data(ce, &st)) return ERR_PTR(-EINVAL); break; case S_IFLNK: @@ -231,13 +210,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; @@ -245,13 +229,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; @@ -263,8 +276,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++; @@ -273,7 +293,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; @@ -294,39 +314,23 @@ 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(); + const char *prefix = setup_git_directory(); - 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"); @@ -339,10 +343,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; @@ -352,17 +364,19 @@ 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, "--info-only")) { + info_only = 1; + 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; } @@ -372,16 +386,22 @@ int main(int argc, char **argv) } die("unknown option %s", path); } + path = prefix_path(prefix, prefix ? strlen(prefix) : 0, path); if (!verify_path(path)) { 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); + die("Unable to add %s to database; maybe you want to use --add option?", 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 ? 1 : 0; }