1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
6#include "cache.h"
7#include "strbuf.h"
8#include "quote.h"
9#include "cache-tree.h"
10#include "tree-walk.h"
11/*
13 * Default to not allowing changes to the list of files. The
14 * tool doesn't actually care, but this makes it harder to add
15 * files to the revision control by mistake by doing something
16 * like "git-update-index *" and suddenly having all the object
17 * files be revision controlled.
18 */
19static int allow_add;
20static int allow_remove;
21static int allow_replace;
22static int allow_unmerged; /* --refresh needing merge is not error */
23static int not_new; /* --refresh not having working tree files is not error */
24static int quiet; /* --refresh needing update is not error */
25static int info_only;
26static int force_remove;
27static int verbose;
28static int mark_valid_only = 0;
29#define MARK_VALID 1
30#define UNMARK_VALID 2
31/* Three functions to allow overloaded pointer return; see linux/err.h */
34static inline void *ERR_PTR(long error)
35{
36 return (void *) error;
37}
38static inline long PTR_ERR(const void *ptr)
40{
41 return (long) ptr;
42}
43static inline long IS_ERR(const void *ptr)
45{
46 return (unsigned long)ptr > (unsigned long)-1000L;
47}
48static void report(const char *fmt, ...)
50{
51 va_list vp;
52 if (!verbose)
54 return;
55 va_start(vp, fmt);
57 vprintf(fmt, vp);
58 putchar('\n');
59 va_end(vp);
60}
61static int mark_valid(const char *path)
63{
64 int namelen = strlen(path);
65 int pos = cache_name_pos(path, namelen);
66 if (0 <= pos) {
67 switch (mark_valid_only) {
68 case MARK_VALID:
69 active_cache[pos]->ce_flags |= htons(CE_VALID);
70 break;
71 case UNMARK_VALID:
72 active_cache[pos]->ce_flags &= ~htons(CE_VALID);
73 break;
74 }
75 cache_tree_invalidate_path(active_cache_tree, path);
76 active_cache_changed = 1;
77 return 0;
78 }
79 return -1;
80}
81static int add_file_to_cache(const char *path)
83{
84 int size, namelen, option, status;
85 struct cache_entry *ce;
86 struct stat st;
87 status = lstat(path, &st);
89 /* We probably want to do this in remove_file_from_cache() and
91 * add_cache_entry() instead...
92 */
93 cache_tree_invalidate_path(active_cache_tree, path);
94 if (status < 0 || S_ISDIR(st.st_mode)) {
96 /* When we used to have "path" and now we want to add
97 * "path/file", we need a way to remove "path" before
98 * being able to add "path/file". However,
99 * "git-update-index --remove path" would not work.
100 * --force-remove can be used but this is more user
101 * friendly, especially since we can do the opposite
102 * case just fine without --force-remove.
103 */
104 if (status == 0 || (errno == ENOENT || errno == ENOTDIR)) {
105 if (allow_remove) {
106 if (remove_file_from_cache(path))
107 return error("%s: cannot remove from the index",
108 path);
109 else
110 return 0;
111 } else if (status < 0) {
112 return error("%s: does not exist and --remove not passed",
113 path);
114 }
115 }
116 if (0 == status)
117 return error("%s: is a directory - add files inside instead",
118 path);
119 else
120 return error("lstat(\"%s\"): %s", path,
121 strerror(errno));
122 }
123 namelen = strlen(path);
125 size = cache_entry_size(namelen);
126 ce = xcalloc(1, size);
127 memcpy(ce->name, path, namelen);
128 ce->ce_flags = htons(namelen);
129 fill_stat_cache_info(ce, &st);
130 ce->ce_mode = create_ce_mode(st.st_mode);
132 if (!trust_executable_bit) {
133 /* If there is an existing entry, pick the mode bits
134 * from it.
135 */
136 int pos = cache_name_pos(path, namelen);
137 if (0 <= pos)
138 ce->ce_mode = active_cache[pos]->ce_mode;
139 }
140 if (index_path(ce->sha1, path, &st, !info_only))
142 return -1;
143 option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
144 option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
145 if (add_cache_entry(ce, option))
146 return error("%s: cannot add to the index - missing --add option?",
147 path);
148 return 0;
149}
150/*
152 * "refresh" does not calculate a new sha1 file or bring the
153 * cache up-to-date for mode/content changes. But what it
154 * _does_ do is to "re-match" the stat information of a file
155 * with the cache, so that you can refresh the cache for a
156 * file that hasn't been changed but where the stat entry is
157 * out of date.
158 *
159 * For example, you'd want to do this after doing a "git-read-tree",
160 * to link up the stat cache details with the proper files.
161 */
162static struct cache_entry *refresh_entry(struct cache_entry *ce, int really)
163{
164 struct stat st;
165 struct cache_entry *updated;
166 int changed, size;
167 if (lstat(ce->name, &st) < 0)
169 return ERR_PTR(-errno);
170 changed = ce_match_stat(ce, &st, really);
172 if (!changed) {
173 if (really && assume_unchanged &&
174 !(ce->ce_flags & htons(CE_VALID)))
175 ; /* mark this one VALID again */
176 else
177 return NULL;
178 }
179 if (ce_modified(ce, &st, really))
181 return ERR_PTR(-EINVAL);
182 size = ce_size(ce);
184 updated = xmalloc(size);
185 memcpy(updated, ce, size);
186 fill_stat_cache_info(updated, &st);
187 /* In this case, if really is not set, we should leave
189 * CE_VALID bit alone. Otherwise, paths marked with
190 * --no-assume-unchanged (i.e. things to be edited) will
191 * reacquire CE_VALID bit automatically, which is not
192 * really what we want.
193 */
194 if (!really && assume_unchanged && !(ce->ce_flags & htons(CE_VALID)))
195 updated->ce_flags &= ~htons(CE_VALID);
196 return updated;
198}
199static int refresh_cache(int really)
201{
202 int i;
203 int has_errors = 0;
204 for (i = 0; i < active_nr; i++) {
206 struct cache_entry *ce, *new;
207 ce = active_cache[i];
208 if (ce_stage(ce)) {
209 while ((i < active_nr) &&
210 ! strcmp(active_cache[i]->name, ce->name))
211 i++;
212 i--;
213 if (allow_unmerged)
214 continue;
215 printf("%s: needs merge\n", ce->name);
216 has_errors = 1;
217 continue;
218 }
219 new = refresh_entry(ce, really);
221 if (!new)
222 continue;
223 if (IS_ERR(new)) {
224 if (not_new && PTR_ERR(new) == -ENOENT)
225 continue;
226 if (really && PTR_ERR(new) == -EINVAL) {
227 /* If we are doing --really-refresh that
228 * means the index is not valid anymore.
229 */
230 ce->ce_flags &= ~htons(CE_VALID);
231 active_cache_changed = 1;
232 }
233 if (quiet)
234 continue;
235 printf("%s: needs update\n", ce->name);
236 has_errors = 1;
237 continue;
238 }
239 active_cache_changed = 1;
240 /* You can NOT just free active_cache[i] here, since it
241 * might not be necessarily malloc()ed but can also come
242 * from mmap(). */
243 active_cache[i] = new;
244 }
245 return has_errors;
246}
247/*
249 * We fundamentally don't like some paths: we don't want
250 * dot or dot-dot anywhere, and for obvious reasons don't
251 * want to recurse into ".git" either.
252 *
253 * Also, we don't want double slashes or slashes at the
254 * end that can make pathnames ambiguous.
255 */
256static int verify_dotfile(const char *rest)
257{
258 /*
259 * The first character was '.', but that
260 * has already been discarded, we now test
261 * the rest.
262 */
263 switch (*rest) {
264 /* "." is not allowed */
265 case '\0': case '/':
266 return 0;
267 /*
269 * ".git" followed by NUL or slash is bad. This
270 * shares the path end test with the ".." case.
271 */
272 case 'g':
273 if (rest[1] != 'i')
274 break;
275 if (rest[2] != 't')
276 break;
277 rest += 2;
278 /* fallthrough */
279 case '.':
280 if (rest[1] == '\0' || rest[1] == '/')
281 return 0;
282 }
283 return 1;
284}
285static int verify_path(const char *path)
287{
288 char c;
289 goto inside;
291 for (;;) {
292 if (!c)
293 return 1;
294 if (c == '/') {
295inside:
296 c = *path++;
297 switch (c) {
298 default:
299 continue;
300 case '/': case '\0':
301 break;
302 case '.':
303 if (verify_dotfile(path))
304 continue;
305 }
306 return 0;
307 }
308 c = *path++;
309 }
310}
311static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
313 const char *path, int stage)
314{
315 int size, len, option;
316 struct cache_entry *ce;
317 if (!verify_path(path))
319 return -1;
320 len = strlen(path);
322 size = cache_entry_size(len);
323 ce = xcalloc(1, size);
324 memcpy(ce->sha1, sha1, 20);
326 memcpy(ce->name, path, len);
327 ce->ce_flags = create_ce_flags(len, stage);
328 ce->ce_mode = create_ce_mode(mode);
329 if (assume_unchanged)
330 ce->ce_flags |= htons(CE_VALID);
331 option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
332 option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
333 if (add_cache_entry(ce, option))
334 return error("%s: cannot add to the index - missing --add option?",
335 path);
336 report("add '%s'", path);
337 cache_tree_invalidate_path(active_cache_tree, path);
338 return 0;
339}
340static void chmod_path(int flip, const char *path)
342{
343 int pos;
344 struct cache_entry *ce;
345 unsigned int mode;
346 pos = cache_name_pos(path, strlen(path));
348 if (pos < 0)
349 goto fail;
350 ce = active_cache[pos];
351 mode = ntohl(ce->ce_mode);
352 if (!S_ISREG(mode))
353 goto fail;
354 switch (flip) {
355 case '+':
356 ce->ce_mode |= htonl(0111); break;
357 case '-':
358 ce->ce_mode &= htonl(~0111); break;
359 default:
360 goto fail;
361 }
362 cache_tree_invalidate_path(active_cache_tree, path);
363 active_cache_changed = 1;
364 report("chmod %cx '%s'", flip, path);
365 return;
366 fail:
367 die("git-update-index: cannot chmod %cx '%s'", flip, path);
368}
369static struct cache_file cache_file;
371static void update_one(const char *path, const char *prefix, int prefix_length)
373{
374 const char *p = prefix_path(prefix, prefix_length, path);
375 if (!verify_path(p)) {
376 fprintf(stderr, "Ignoring path %s\n", path);
377 return;
378 }
379 if (mark_valid_only) {
380 if (mark_valid(p))
381 die("Unable to mark file %s", path);
382 return;
383 }
384 cache_tree_invalidate_path(active_cache_tree, path);
385 if (force_remove) {
387 if (remove_file_from_cache(p))
388 die("git-update-index: unable to remove %s", path);
389 report("remove '%s'", path);
390 return;
391 }
392 if (add_file_to_cache(p))
393 die("Unable to process file %s", path);
394 report("add '%s'", path);
395}
396static void read_index_info(int line_termination)
398{
399 struct strbuf buf;
400 strbuf_init(&buf);
401 while (1) {
402 char *ptr, *tab;
403 char *path_name;
404 unsigned char sha1[20];
405 unsigned int mode;
406 int stage;
407 /* This reads lines formatted in one of three formats:
409 *
410 * (1) mode SP sha1 TAB path
411 * The first format is what "git-apply --index-info"
412 * reports, and used to reconstruct a partial tree
413 * that is used for phony merge base tree when falling
414 * back on 3-way merge.
415 *
416 * (2) mode SP type SP sha1 TAB path
417 * The second format is to stuff git-ls-tree output
418 * into the index file.
419 *
420 * (3) mode SP sha1 SP stage TAB path
421 * This format is to put higher order stages into the
422 * index file and matches git-ls-files --stage output.
423 */
424 read_line(&buf, stdin, line_termination);
425 if (buf.eof)
426 break;
427 mode = strtoul(buf.buf, &ptr, 8);
429 if (ptr == buf.buf || *ptr != ' ')
430 goto bad_line;
431 tab = strchr(ptr, '\t');
433 if (!tab || tab - ptr < 41)
434 goto bad_line;
435 if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
437 stage = tab[-1] - '0';
438 ptr = tab + 1; /* point at the head of path */
439 tab = tab - 2; /* point at tail of sha1 */
440 }
441 else {
442 stage = 0;
443 ptr = tab + 1; /* point at the head of path */
444 }
445 if (get_sha1_hex(tab - 40, sha1) || tab[-41] != ' ')
447 goto bad_line;
448 if (line_termination && ptr[0] == '"')
450 path_name = unquote_c_style(ptr, NULL);
451 else
452 path_name = ptr;
453 if (!verify_path(path_name)) {
455 fprintf(stderr, "Ignoring path %s\n", path_name);
456 if (path_name != ptr)
457 free(path_name);
458 continue;
459 }
460 cache_tree_invalidate_path(active_cache_tree, path_name);
461 if (!mode) {
463 /* mode == 0 means there is no such path -- remove */
464 if (remove_file_from_cache(path_name))
465 die("git-update-index: unable to remove %s",
466 ptr);
467 }
468 else {
469 /* mode ' ' sha1 '\t' name
470 * ptr[-1] points at tab,
471 * ptr[-41] is at the beginning of sha1
472 */
473 ptr[-42] = ptr[-1] = 0;
474 if (add_cacheinfo(mode, sha1, path_name, stage))
475 die("git-update-index: unable to update %s",
476 path_name);
477 }
478 if (path_name != ptr)
479 free(path_name);
480 continue;
481 bad_line:
483 die("malformed index info %s", buf.buf);
484 }
485}
486static const char update_index_usage[] =
488"git-update-index [-q] [--add] [--replace] [--remove] [--unmerged] [--refresh] [--cacheinfo] [--chmod=(+|-)x] [--info-only] [--force-remove] [--stdin] [--index-info] [--ignore-missing] [-z] [--verbose] [--] <file>...";
489static unsigned char head_sha1[20];
491static unsigned char merge_head_sha1[20];
492static struct cache_entry *read_one_ent(const char *which,
494 unsigned char *ent, const char *path,
495 int namelen, int stage)
496{
497 unsigned mode;
498 unsigned char sha1[20];
499 int size;
500 struct cache_entry *ce;
501 if (get_tree_entry(ent, path, sha1, &mode)) {
503 error("%s: not in %s branch.", path, which);
504 return NULL;
505 }
506 if (mode == S_IFDIR) {
507 error("%s: not a blob in %s branch.", path, which);
508 return NULL;
509 }
510 size = cache_entry_size(namelen);
511 ce = xcalloc(1, size);
512 memcpy(ce->sha1, sha1, 20);
514 memcpy(ce->name, path, namelen);
515 ce->ce_flags = create_ce_flags(namelen, stage);
516 ce->ce_mode = create_ce_mode(mode);
517 return ce;
518}
519static int unresolve_one(const char *path)
521{
522 int namelen = strlen(path);
523 int pos;
524 int ret = 0;
525 struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
526 /* See if there is such entry in the index. */
528 pos = cache_name_pos(path, namelen);
529 if (pos < 0) {
530 /* If there isn't, either it is unmerged, or
531 * resolved as "removed" by mistake. We do not
532 * want to do anything in the former case.
533 */
534 pos = -pos-1;
535 if (pos < active_nr) {
536 struct cache_entry *ce = active_cache[pos];
537 if (ce_namelen(ce) == namelen &&
538 !memcmp(ce->name, path, namelen)) {
539 fprintf(stderr,
540 "%s: skipping still unmerged path.\n",
541 path);
542 goto free_return;
543 }
544 }
545 }
546 /* Grab blobs from given path from HEAD and MERGE_HEAD,
548 * stuff HEAD version in stage #2,
549 * stuff MERGE_HEAD version in stage #3.
550 */
551 ce_2 = read_one_ent("our", head_sha1, path, namelen, 2);
552 ce_3 = read_one_ent("their", merge_head_sha1, path, namelen, 3);
553 if (!ce_2 || !ce_3) {
555 ret = -1;
556 goto free_return;
557 }
558 if (!memcmp(ce_2->sha1, ce_3->sha1, 20) &&
559 ce_2->ce_mode == ce_3->ce_mode) {
560 fprintf(stderr, "%s: identical in both, skipping.\n",
561 path);
562 goto free_return;
563 }
564 cache_tree_invalidate_path(active_cache_tree, path);
566 remove_file_from_cache(path);
567 if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
568 error("%s: cannot add our version to the index.", path);
569 ret = -1;
570 goto free_return;
571 }
572 if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
573 return 0;
574 error("%s: cannot add their version to the index.", path);
575 ret = -1;
576 free_return:
577 free(ce_2);
578 free(ce_3);
579 return ret;
580}
581static void read_head_pointers(void)
583{
584 if (read_ref(git_path("HEAD"), head_sha1))
585 die("No HEAD -- no initial commit yet?\n");
586 if (read_ref(git_path("MERGE_HEAD"), merge_head_sha1)) {
587 fprintf(stderr, "Not in the middle of a merge.\n");
588 exit(0);
589 }
590}
591static int do_unresolve(int ac, const char **av)
593{
594 int i;
595 int err = 0;
596 /* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
598 * are not doing a merge, so exit with success status.
599 */
600 read_head_pointers();
601 for (i = 1; i < ac; i++) {
603 const char *arg = av[i];
604 err |= unresolve_one(arg);
605 }
606 return err;
607}
608int main(int argc, const char **argv)
610{
611 int i, newfd, entries, has_errors = 0, line_termination = '\n';
612 int allow_options = 1;
613 int read_from_stdin = 0;
614 const char *prefix = setup_git_directory();
615 int prefix_length = prefix ? strlen(prefix) : 0;
616 char set_executable_bit = 0;
617 git_config(git_default_config);
619 newfd = hold_index_file_for_update(&cache_file, get_index_file());
621 if (newfd < 0)
622 die("unable to create new cachefile");
623 entries = read_cache();
625 if (entries < 0)
626 die("cache corrupted");
627 for (i = 1 ; i < argc; i++) {
629 const char *path = argv[i];
630 if (allow_options && *path == '-') {
632 if (!strcmp(path, "--")) {
633 allow_options = 0;
634 continue;
635 }
636 if (!strcmp(path, "-q")) {
637 quiet = 1;
638 continue;
639 }
640 if (!strcmp(path, "--add")) {
641 allow_add = 1;
642 continue;
643 }
644 if (!strcmp(path, "--replace")) {
645 allow_replace = 1;
646 continue;
647 }
648 if (!strcmp(path, "--remove")) {
649 allow_remove = 1;
650 continue;
651 }
652 if (!strcmp(path, "--unmerged")) {
653 allow_unmerged = 1;
654 continue;
655 }
656 if (!strcmp(path, "--refresh")) {
657 has_errors |= refresh_cache(0);
658 continue;
659 }
660 if (!strcmp(path, "--really-refresh")) {
661 has_errors |= refresh_cache(1);
662 continue;
663 }
664 if (!strcmp(path, "--cacheinfo")) {
665 unsigned char sha1[20];
666 unsigned int mode;
667 if (i+3 >= argc)
669 die("git-update-index: --cacheinfo <mode> <sha1> <path>");
670 if ((sscanf(argv[i+1], "%o", &mode) != 1) ||
672 get_sha1_hex(argv[i+2], sha1) ||
673 add_cacheinfo(mode, sha1, argv[i+3], 0))
674 die("git-update-index: --cacheinfo"
675 " cannot add %s", argv[i+3]);
676 i += 3;
677 continue;
678 }
679 if (!strcmp(path, "--chmod=-x") ||
680 !strcmp(path, "--chmod=+x")) {
681 if (argc <= i+1)
682 die("git-update-index: %s <path>", path);
683 set_executable_bit = path[8];
684 continue;
685 }
686 if (!strcmp(path, "--assume-unchanged")) {
687 mark_valid_only = MARK_VALID;
688 continue;
689 }
690 if (!strcmp(path, "--no-assume-unchanged")) {
691 mark_valid_only = UNMARK_VALID;
692 continue;
693 }
694 if (!strcmp(path, "--info-only")) {
695 info_only = 1;
696 continue;
697 }
698 if (!strcmp(path, "--force-remove")) {
699 force_remove = 1;
700 continue;
701 }
702 if (!strcmp(path, "-z")) {
703 line_termination = 0;
704 continue;
705 }
706 if (!strcmp(path, "--stdin")) {
707 if (i != argc - 1)
708 die("--stdin must be at the end");
709 read_from_stdin = 1;
710 break;
711 }
712 if (!strcmp(path, "--index-info")) {
713 if (i != argc - 1)
714 die("--index-info must be at the end");
715 allow_add = allow_replace = allow_remove = 1;
716 read_index_info(line_termination);
717 break;
718 }
719 if (!strcmp(path, "--unresolve")) {
720 has_errors = do_unresolve(argc - i, argv + i);
721 if (has_errors)
722 active_cache_changed = 0;
723 goto finish;
724 }
725 if (!strcmp(path, "--ignore-missing")) {
726 not_new = 1;
727 continue;
728 }
729 if (!strcmp(path, "--verbose")) {
730 verbose = 1;
731 continue;
732 }
733 if (!strcmp(path, "-h") || !strcmp(path, "--help"))
734 usage(update_index_usage);
735 die("unknown option %s", path);
736 }
737 update_one(path, prefix, prefix_length);
738 if (set_executable_bit)
739 chmod_path(set_executable_bit, path);
740 }
741 if (read_from_stdin) {
742 struct strbuf buf;
743 strbuf_init(&buf);
744 while (1) {
745 char *path_name;
746 read_line(&buf, stdin, line_termination);
747 if (buf.eof)
748 break;
749 if (line_termination && buf.buf[0] == '"')
750 path_name = unquote_c_style(buf.buf, NULL);
751 else
752 path_name = buf.buf;
753 update_one(path_name, prefix, prefix_length);
754 if (set_executable_bit) {
755 const char *p = prefix_path(prefix, prefix_length, path_name);
756 chmod_path(set_executable_bit, p);
757 }
758 if (path_name != buf.buf)
759 free(path_name);
760 }
761 }
762 finish:
764 if (active_cache_changed) {
765 if (write_cache(newfd, active_cache, active_nr) ||
766 commit_index_file(&cache_file))
767 die("Unable to write new cachefile");
768 }
769 return has_errors ? 1 : 0;
771}