X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=update-cache.c;h=d2f79fa4535d3ec718b60a13a9a8c67d74323d8e;hb=ec73962d8e17e89ac0c4b21f07cefe16594e07a2;hp=19d8f826a5d266c3ca0271c5b29c7fc504632d30;hpb=62d046a07b4cd4328d3d40aab097a1d97c4d7b20;p=git.git diff --git a/update-cache.c b/update-cache.c index 19d8f826..d2f79fa4 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 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; @@ -179,7 +159,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 +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; @@ -259,13 +239,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; @@ -277,8 +286,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++; @@ -313,36 +329,17 @@ 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); - 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"); @@ -373,18 +370,14 @@ 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, "--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; } @@ -398,12 +391,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 ? 1 : 0; }