X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=update-cache.c;h=63815ed658e9c2007938309458444b218c330d68;hb=e70a165d3db26dbab62e3430553a21d5e97b74ec;hp=2f5d620fd8b849d761a2bf337ecdd86f251271ac;hpb=b3f94c4b554cd6c3db3e99dc33bdac7d8155d606;p=git.git diff --git a/update-cache.c b/update-cache.c index 2f5d620f..63815ed6 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, allow_replace = 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,26 +31,6 @@ 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, option, status; @@ -73,7 +53,7 @@ static int add_file_to_cache(char *path) 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); @@ -88,7 +68,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: @@ -97,7 +77,12 @@ 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; @@ -109,36 +94,15 @@ static int add_file_to_cache(char *path) return add_cache_entry(ce, option); } -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; -} - -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; @@ -179,7 +143,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) @@ -191,7 +155,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; @@ -204,7 +168,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: @@ -242,13 +206,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; @@ -256,13 +225,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; @@ -274,8 +272,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++; @@ -310,36 +315,18 @@ static int add_cacheinfo(char *arg1, char *arg2, char *arg3) 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); + const char *prefix = setup_git_directory(); - 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"); @@ -352,6 +339,10 @@ 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; @@ -370,18 +361,18 @@ int main(int argc, char **argv) } if (!strcmp(path, "--cacheinfo")) { if (i+3 >= argc) - die("update-cache: --cacheinfo "); + die("git-update-cache: --cacheinfo "); if (add_cacheinfo(argv[i+1], argv[i+2], argv[i+3])) - die("update-cache: --cacheinfo cannot add %s", 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; } @@ -391,16 +382,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); } - 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; }