Merge branch 'sg/travis-skip-identical-test'
[git] / builtin / update-index.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6 #include "cache.h"
7 #include "config.h"
8 #include "lockfile.h"
9 #include "quote.h"
10 #include "cache-tree.h"
11 #include "tree-walk.h"
12 #include "builtin.h"
13 #include "refs.h"
14 #include "resolve-undo.h"
15 #include "parse-options.h"
16 #include "pathspec.h"
17 #include "dir.h"
18 #include "split-index.h"
19 #include "fsmonitor.h"
20
21 /*
22  * Default to not allowing changes to the list of files. The
23  * tool doesn't actually care, but this makes it harder to add
24  * files to the revision control by mistake by doing something
25  * like "git update-index *" and suddenly having all the object
26  * files be revision controlled.
27  */
28 static int allow_add;
29 static int allow_remove;
30 static int allow_replace;
31 static int info_only;
32 static int force_remove;
33 static int verbose;
34 static int mark_valid_only;
35 static int mark_skip_worktree_only;
36 static int mark_fsmonitor_only;
37 #define MARK_FLAG 1
38 #define UNMARK_FLAG 2
39 static struct strbuf mtime_dir = STRBUF_INIT;
40
41 /* Untracked cache mode */
42 enum uc_mode {
43         UC_UNSPECIFIED = -1,
44         UC_DISABLE = 0,
45         UC_ENABLE,
46         UC_TEST,
47         UC_FORCE
48 };
49
50 __attribute__((format (printf, 1, 2)))
51 static void report(const char *fmt, ...)
52 {
53         va_list vp;
54
55         if (!verbose)
56                 return;
57
58         va_start(vp, fmt);
59         vprintf(fmt, vp);
60         putchar('\n');
61         va_end(vp);
62 }
63
64 static void remove_test_directory(void)
65 {
66         if (mtime_dir.len)
67                 remove_dir_recursively(&mtime_dir, 0);
68 }
69
70 static const char *get_mtime_path(const char *path)
71 {
72         static struct strbuf sb = STRBUF_INIT;
73         strbuf_reset(&sb);
74         strbuf_addf(&sb, "%s/%s", mtime_dir.buf, path);
75         return sb.buf;
76 }
77
78 static void xmkdir(const char *path)
79 {
80         path = get_mtime_path(path);
81         if (mkdir(path, 0700))
82                 die_errno(_("failed to create directory %s"), path);
83 }
84
85 static int xstat_mtime_dir(struct stat *st)
86 {
87         if (stat(mtime_dir.buf, st))
88                 die_errno(_("failed to stat %s"), mtime_dir.buf);
89         return 0;
90 }
91
92 static int create_file(const char *path)
93 {
94         int fd;
95         path = get_mtime_path(path);
96         fd = open(path, O_CREAT | O_RDWR, 0644);
97         if (fd < 0)
98                 die_errno(_("failed to create file %s"), path);
99         return fd;
100 }
101
102 static void xunlink(const char *path)
103 {
104         path = get_mtime_path(path);
105         if (unlink(path))
106                 die_errno(_("failed to delete file %s"), path);
107 }
108
109 static void xrmdir(const char *path)
110 {
111         path = get_mtime_path(path);
112         if (rmdir(path))
113                 die_errno(_("failed to delete directory %s"), path);
114 }
115
116 static void avoid_racy(void)
117 {
118         /*
119          * not use if we could usleep(10) if USE_NSEC is defined. The
120          * field nsec could be there, but the OS could choose to
121          * ignore it?
122          */
123         sleep(1);
124 }
125
126 static int test_if_untracked_cache_is_supported(void)
127 {
128         struct stat st;
129         struct stat_data base;
130         int fd, ret = 0;
131         char *cwd;
132
133         strbuf_addstr(&mtime_dir, "mtime-test-XXXXXX");
134         if (!mkdtemp(mtime_dir.buf))
135                 die_errno("Could not make temporary directory");
136
137         cwd = xgetcwd();
138         fprintf(stderr, _("Testing mtime in '%s' "), cwd);
139         free(cwd);
140
141         atexit(remove_test_directory);
142         xstat_mtime_dir(&st);
143         fill_stat_data(&base, &st);
144         fputc('.', stderr);
145
146         avoid_racy();
147         fd = create_file("newfile");
148         xstat_mtime_dir(&st);
149         if (!match_stat_data(&base, &st)) {
150                 close(fd);
151                 fputc('\n', stderr);
152                 fprintf_ln(stderr,_("directory stat info does not "
153                                     "change after adding a new file"));
154                 goto done;
155         }
156         fill_stat_data(&base, &st);
157         fputc('.', stderr);
158
159         avoid_racy();
160         xmkdir("new-dir");
161         xstat_mtime_dir(&st);
162         if (!match_stat_data(&base, &st)) {
163                 close(fd);
164                 fputc('\n', stderr);
165                 fprintf_ln(stderr, _("directory stat info does not change "
166                                      "after adding a new directory"));
167                 goto done;
168         }
169         fill_stat_data(&base, &st);
170         fputc('.', stderr);
171
172         avoid_racy();
173         write_or_die(fd, "data", 4);
174         close(fd);
175         xstat_mtime_dir(&st);
176         if (match_stat_data(&base, &st)) {
177                 fputc('\n', stderr);
178                 fprintf_ln(stderr, _("directory stat info changes "
179                                      "after updating a file"));
180                 goto done;
181         }
182         fputc('.', stderr);
183
184         avoid_racy();
185         close(create_file("new-dir/new"));
186         xstat_mtime_dir(&st);
187         if (match_stat_data(&base, &st)) {
188                 fputc('\n', stderr);
189                 fprintf_ln(stderr, _("directory stat info changes after "
190                                      "adding a file inside subdirectory"));
191                 goto done;
192         }
193         fputc('.', stderr);
194
195         avoid_racy();
196         xunlink("newfile");
197         xstat_mtime_dir(&st);
198         if (!match_stat_data(&base, &st)) {
199                 fputc('\n', stderr);
200                 fprintf_ln(stderr, _("directory stat info does not "
201                                      "change after deleting a file"));
202                 goto done;
203         }
204         fill_stat_data(&base, &st);
205         fputc('.', stderr);
206
207         avoid_racy();
208         xunlink("new-dir/new");
209         xrmdir("new-dir");
210         xstat_mtime_dir(&st);
211         if (!match_stat_data(&base, &st)) {
212                 fputc('\n', stderr);
213                 fprintf_ln(stderr, _("directory stat info does not "
214                                      "change after deleting a directory"));
215                 goto done;
216         }
217
218         if (rmdir(mtime_dir.buf))
219                 die_errno(_("failed to delete directory %s"), mtime_dir.buf);
220         fprintf_ln(stderr, _(" OK"));
221         ret = 1;
222
223 done:
224         strbuf_release(&mtime_dir);
225         return ret;
226 }
227
228 static int mark_ce_flags(const char *path, int flag, int mark)
229 {
230         int namelen = strlen(path);
231         int pos = cache_name_pos(path, namelen);
232         if (0 <= pos) {
233                 mark_fsmonitor_invalid(&the_index, active_cache[pos]);
234                 if (mark)
235                         active_cache[pos]->ce_flags |= flag;
236                 else
237                         active_cache[pos]->ce_flags &= ~flag;
238                 active_cache[pos]->ce_flags |= CE_UPDATE_IN_BASE;
239                 cache_tree_invalidate_path(&the_index, path);
240                 active_cache_changed |= CE_ENTRY_CHANGED;
241                 return 0;
242         }
243         return -1;
244 }
245
246 static int remove_one_path(const char *path)
247 {
248         if (!allow_remove)
249                 return error("%s: does not exist and --remove not passed", path);
250         if (remove_file_from_cache(path))
251                 return error("%s: cannot remove from the index", path);
252         return 0;
253 }
254
255 /*
256  * Handle a path that couldn't be lstat'ed. It's either:
257  *  - missing file (ENOENT or ENOTDIR). That's ok if we're
258  *    supposed to be removing it and the removal actually
259  *    succeeds.
260  *  - permission error. That's never ok.
261  */
262 static int process_lstat_error(const char *path, int err)
263 {
264         if (is_missing_file_error(err))
265                 return remove_one_path(path);
266         return error("lstat(\"%s\"): %s", path, strerror(err));
267 }
268
269 static int add_one_path(const struct cache_entry *old, const char *path, int len, struct stat *st)
270 {
271         int option, size;
272         struct cache_entry *ce;
273
274         /* Was the old index entry already up-to-date? */
275         if (old && !ce_stage(old) && !ce_match_stat(old, st, 0))
276                 return 0;
277
278         size = cache_entry_size(len);
279         ce = xcalloc(1, size);
280         memcpy(ce->name, path, len);
281         ce->ce_flags = create_ce_flags(0);
282         ce->ce_namelen = len;
283         fill_stat_cache_info(ce, st);
284         ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
285
286         if (index_path(&ce->oid, path, st,
287                        info_only ? 0 : HASH_WRITE_OBJECT)) {
288                 free(ce);
289                 return -1;
290         }
291         option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
292         option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
293         if (add_cache_entry(ce, option)) {
294                 free(ce);
295                 return error("%s: cannot add to the index - missing --add option?", path);
296         }
297         return 0;
298 }
299
300 /*
301  * Handle a path that was a directory. Four cases:
302  *
303  *  - it's already a gitlink in the index, and we keep it that
304  *    way, and update it if we can (if we cannot find the HEAD,
305  *    we're going to keep it unchanged in the index!)
306  *
307  *  - it's a *file* in the index, in which case it should be
308  *    removed as a file if removal is allowed, since it doesn't
309  *    exist as such any more. If removal isn't allowed, it's
310  *    an error.
311  *
312  *    (NOTE! This is old and arguably fairly strange behaviour.
313  *    We might want to make this an error unconditionally, and
314  *    use "--force-remove" if you actually want to force removal).
315  *
316  *  - it used to exist as a subdirectory (ie multiple files with
317  *    this particular prefix) in the index, in which case it's wrong
318  *    to try to update it as a directory.
319  *
320  *  - it doesn't exist at all in the index, but it is a valid
321  *    git directory, and it should be *added* as a gitlink.
322  */
323 static int process_directory(const char *path, int len, struct stat *st)
324 {
325         struct object_id oid;
326         int pos = cache_name_pos(path, len);
327
328         /* Exact match: file or existing gitlink */
329         if (pos >= 0) {
330                 const struct cache_entry *ce = active_cache[pos];
331                 if (S_ISGITLINK(ce->ce_mode)) {
332
333                         /* Do nothing to the index if there is no HEAD! */
334                         if (resolve_gitlink_ref(path, "HEAD", &oid) < 0)
335                                 return 0;
336
337                         return add_one_path(ce, path, len, st);
338                 }
339                 /* Should this be an unconditional error? */
340                 return remove_one_path(path);
341         }
342
343         /* Inexact match: is there perhaps a subdirectory match? */
344         pos = -pos-1;
345         while (pos < active_nr) {
346                 const struct cache_entry *ce = active_cache[pos++];
347
348                 if (strncmp(ce->name, path, len))
349                         break;
350                 if (ce->name[len] > '/')
351                         break;
352                 if (ce->name[len] < '/')
353                         continue;
354
355                 /* Subdirectory match - error out */
356                 return error("%s: is a directory - add individual files instead", path);
357         }
358
359         /* No match - should we add it as a gitlink? */
360         if (!resolve_gitlink_ref(path, "HEAD", &oid))
361                 return add_one_path(NULL, path, len, st);
362
363         /* Error out. */
364         return error("%s: is a directory - add files inside instead", path);
365 }
366
367 static int process_path(const char *path)
368 {
369         int pos, len;
370         struct stat st;
371         const struct cache_entry *ce;
372
373         len = strlen(path);
374         if (has_symlink_leading_path(path, len))
375                 return error("'%s' is beyond a symbolic link", path);
376
377         pos = cache_name_pos(path, len);
378         ce = pos < 0 ? NULL : active_cache[pos];
379         if (ce && ce_skip_worktree(ce)) {
380                 /*
381                  * working directory version is assumed "good"
382                  * so updating it does not make sense.
383                  * On the other hand, removing it from index should work
384                  */
385                 if (allow_remove && remove_file_from_cache(path))
386                         return error("%s: cannot remove from the index", path);
387                 return 0;
388         }
389
390         /*
391          * First things first: get the stat information, to decide
392          * what to do about the pathname!
393          */
394         if (lstat(path, &st) < 0)
395                 return process_lstat_error(path, errno);
396
397         if (S_ISDIR(st.st_mode))
398                 return process_directory(path, len, &st);
399
400         return add_one_path(ce, path, len, &st);
401 }
402
403 static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
404                          const char *path, int stage)
405 {
406         int size, len, option;
407         struct cache_entry *ce;
408
409         if (!verify_path(path))
410                 return error("Invalid path '%s'", path);
411
412         len = strlen(path);
413         size = cache_entry_size(len);
414         ce = xcalloc(1, size);
415
416         oidcpy(&ce->oid, oid);
417         memcpy(ce->name, path, len);
418         ce->ce_flags = create_ce_flags(stage);
419         ce->ce_namelen = len;
420         ce->ce_mode = create_ce_mode(mode);
421         if (assume_unchanged)
422                 ce->ce_flags |= CE_VALID;
423         option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
424         option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
425         if (add_cache_entry(ce, option))
426                 return error("%s: cannot add to the index - missing --add option?",
427                              path);
428         report("add '%s'", path);
429         return 0;
430 }
431
432 static void chmod_path(char flip, const char *path)
433 {
434         int pos;
435         struct cache_entry *ce;
436
437         pos = cache_name_pos(path, strlen(path));
438         if (pos < 0)
439                 goto fail;
440         ce = active_cache[pos];
441         if (chmod_cache_entry(ce, flip) < 0)
442                 goto fail;
443
444         report("chmod %cx '%s'", flip, path);
445         return;
446  fail:
447         die("git update-index: cannot chmod %cx '%s'", flip, path);
448 }
449
450 static void update_one(const char *path)
451 {
452         if (!verify_path(path)) {
453                 fprintf(stderr, "Ignoring path %s\n", path);
454                 return;
455         }
456         if (mark_valid_only) {
457                 if (mark_ce_flags(path, CE_VALID, mark_valid_only == MARK_FLAG))
458                         die("Unable to mark file %s", path);
459                 return;
460         }
461         if (mark_skip_worktree_only) {
462                 if (mark_ce_flags(path, CE_SKIP_WORKTREE, mark_skip_worktree_only == MARK_FLAG))
463                         die("Unable to mark file %s", path);
464                 return;
465         }
466         if (mark_fsmonitor_only) {
467                 if (mark_ce_flags(path, CE_FSMONITOR_VALID, mark_fsmonitor_only == MARK_FLAG))
468                         die("Unable to mark file %s", path);
469                 return;
470         }
471
472         if (force_remove) {
473                 if (remove_file_from_cache(path))
474                         die("git update-index: unable to remove %s", path);
475                 report("remove '%s'", path);
476                 return;
477         }
478         if (process_path(path))
479                 die("Unable to process path %s", path);
480         report("add '%s'", path);
481 }
482
483 static void read_index_info(int nul_term_line)
484 {
485         struct strbuf buf = STRBUF_INIT;
486         struct strbuf uq = STRBUF_INIT;
487         strbuf_getline_fn getline_fn;
488
489         getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
490         while (getline_fn(&buf, stdin) != EOF) {
491                 char *ptr, *tab;
492                 char *path_name;
493                 struct object_id oid;
494                 unsigned int mode;
495                 unsigned long ul;
496                 int stage;
497
498                 /* This reads lines formatted in one of three formats:
499                  *
500                  * (1) mode         SP sha1          TAB path
501                  * The first format is what "git apply --index-info"
502                  * reports, and used to reconstruct a partial tree
503                  * that is used for phony merge base tree when falling
504                  * back on 3-way merge.
505                  *
506                  * (2) mode SP type SP sha1          TAB path
507                  * The second format is to stuff "git ls-tree" output
508                  * into the index file.
509                  *
510                  * (3) mode         SP sha1 SP stage TAB path
511                  * This format is to put higher order stages into the
512                  * index file and matches "git ls-files --stage" output.
513                  */
514                 errno = 0;
515                 ul = strtoul(buf.buf, &ptr, 8);
516                 if (ptr == buf.buf || *ptr != ' '
517                     || errno || (unsigned int) ul != ul)
518                         goto bad_line;
519                 mode = ul;
520
521                 tab = strchr(ptr, '\t');
522                 if (!tab || tab - ptr < GIT_SHA1_HEXSZ + 1)
523                         goto bad_line;
524
525                 if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
526                         stage = tab[-1] - '0';
527                         ptr = tab + 1; /* point at the head of path */
528                         tab = tab - 2; /* point at tail of sha1 */
529                 }
530                 else {
531                         stage = 0;
532                         ptr = tab + 1; /* point at the head of path */
533                 }
534
535                 if (get_oid_hex(tab - GIT_SHA1_HEXSZ, &oid) ||
536                         tab[-(GIT_SHA1_HEXSZ + 1)] != ' ')
537                         goto bad_line;
538
539                 path_name = ptr;
540                 if (!nul_term_line && path_name[0] == '"') {
541                         strbuf_reset(&uq);
542                         if (unquote_c_style(&uq, path_name, NULL)) {
543                                 die("git update-index: bad quoting of path name");
544                         }
545                         path_name = uq.buf;
546                 }
547
548                 if (!verify_path(path_name)) {
549                         fprintf(stderr, "Ignoring path %s\n", path_name);
550                         continue;
551                 }
552
553                 if (!mode) {
554                         /* mode == 0 means there is no such path -- remove */
555                         if (remove_file_from_cache(path_name))
556                                 die("git update-index: unable to remove %s",
557                                     ptr);
558                 }
559                 else {
560                         /* mode ' ' sha1 '\t' name
561                          * ptr[-1] points at tab,
562                          * ptr[-41] is at the beginning of sha1
563                          */
564                         ptr[-(GIT_SHA1_HEXSZ + 2)] = ptr[-1] = 0;
565                         if (add_cacheinfo(mode, &oid, path_name, stage))
566                                 die("git update-index: unable to update %s",
567                                     path_name);
568                 }
569                 continue;
570
571         bad_line:
572                 die("malformed index info %s", buf.buf);
573         }
574         strbuf_release(&buf);
575         strbuf_release(&uq);
576 }
577
578 static const char * const update_index_usage[] = {
579         N_("git update-index [<options>] [--] [<file>...]"),
580         NULL
581 };
582
583 static struct object_id head_oid;
584 static struct object_id merge_head_oid;
585
586 static struct cache_entry *read_one_ent(const char *which,
587                                         struct object_id *ent, const char *path,
588                                         int namelen, int stage)
589 {
590         unsigned mode;
591         struct object_id oid;
592         int size;
593         struct cache_entry *ce;
594
595         if (get_tree_entry(ent->hash, path, oid.hash, &mode)) {
596                 if (which)
597                         error("%s: not in %s branch.", path, which);
598                 return NULL;
599         }
600         if (mode == S_IFDIR) {
601                 if (which)
602                         error("%s: not a blob in %s branch.", path, which);
603                 return NULL;
604         }
605         size = cache_entry_size(namelen);
606         ce = xcalloc(1, size);
607
608         oidcpy(&ce->oid, &oid);
609         memcpy(ce->name, path, namelen);
610         ce->ce_flags = create_ce_flags(stage);
611         ce->ce_namelen = namelen;
612         ce->ce_mode = create_ce_mode(mode);
613         return ce;
614 }
615
616 static int unresolve_one(const char *path)
617 {
618         int namelen = strlen(path);
619         int pos;
620         int ret = 0;
621         struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
622
623         /* See if there is such entry in the index. */
624         pos = cache_name_pos(path, namelen);
625         if (0 <= pos) {
626                 /* already merged */
627                 pos = unmerge_cache_entry_at(pos);
628                 if (pos < active_nr) {
629                         const struct cache_entry *ce = active_cache[pos];
630                         if (ce_stage(ce) &&
631                             ce_namelen(ce) == namelen &&
632                             !memcmp(ce->name, path, namelen))
633                                 return 0;
634                 }
635                 /* no resolve-undo information; fall back */
636         } else {
637                 /* If there isn't, either it is unmerged, or
638                  * resolved as "removed" by mistake.  We do not
639                  * want to do anything in the former case.
640                  */
641                 pos = -pos-1;
642                 if (pos < active_nr) {
643                         const struct cache_entry *ce = active_cache[pos];
644                         if (ce_namelen(ce) == namelen &&
645                             !memcmp(ce->name, path, namelen)) {
646                                 fprintf(stderr,
647                                         "%s: skipping still unmerged path.\n",
648                                         path);
649                                 goto free_return;
650                         }
651                 }
652         }
653
654         /* Grab blobs from given path from HEAD and MERGE_HEAD,
655          * stuff HEAD version in stage #2,
656          * stuff MERGE_HEAD version in stage #3.
657          */
658         ce_2 = read_one_ent("our", &head_oid, path, namelen, 2);
659         ce_3 = read_one_ent("their", &merge_head_oid, path, namelen, 3);
660
661         if (!ce_2 || !ce_3) {
662                 ret = -1;
663                 goto free_return;
664         }
665         if (!oidcmp(&ce_2->oid, &ce_3->oid) &&
666             ce_2->ce_mode == ce_3->ce_mode) {
667                 fprintf(stderr, "%s: identical in both, skipping.\n",
668                         path);
669                 goto free_return;
670         }
671
672         remove_file_from_cache(path);
673         if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
674                 error("%s: cannot add our version to the index.", path);
675                 ret = -1;
676                 goto free_return;
677         }
678         if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
679                 return 0;
680         error("%s: cannot add their version to the index.", path);
681         ret = -1;
682  free_return:
683         free(ce_2);
684         free(ce_3);
685         return ret;
686 }
687
688 static void read_head_pointers(void)
689 {
690         if (read_ref("HEAD", &head_oid))
691                 die("No HEAD -- no initial commit yet?");
692         if (read_ref("MERGE_HEAD", &merge_head_oid)) {
693                 fprintf(stderr, "Not in the middle of a merge.\n");
694                 exit(0);
695         }
696 }
697
698 static int do_unresolve(int ac, const char **av,
699                         const char *prefix, int prefix_length)
700 {
701         int i;
702         int err = 0;
703
704         /* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
705          * are not doing a merge, so exit with success status.
706          */
707         read_head_pointers();
708
709         for (i = 1; i < ac; i++) {
710                 const char *arg = av[i];
711                 char *p = prefix_path(prefix, prefix_length, arg);
712                 err |= unresolve_one(p);
713                 free(p);
714         }
715         return err;
716 }
717
718 static int do_reupdate(int ac, const char **av,
719                        const char *prefix, int prefix_length)
720 {
721         /* Read HEAD and run update-index on paths that are
722          * merged and already different between index and HEAD.
723          */
724         int pos;
725         int has_head = 1;
726         struct pathspec pathspec;
727
728         parse_pathspec(&pathspec, 0,
729                        PATHSPEC_PREFER_CWD,
730                        prefix, av + 1);
731
732         if (read_ref("HEAD", &head_oid))
733                 /* If there is no HEAD, that means it is an initial
734                  * commit.  Update everything in the index.
735                  */
736                 has_head = 0;
737  redo:
738         for (pos = 0; pos < active_nr; pos++) {
739                 const struct cache_entry *ce = active_cache[pos];
740                 struct cache_entry *old = NULL;
741                 int save_nr;
742                 char *path;
743
744                 if (ce_stage(ce) || !ce_path_match(ce, &pathspec, NULL))
745                         continue;
746                 if (has_head)
747                         old = read_one_ent(NULL, &head_oid,
748                                            ce->name, ce_namelen(ce), 0);
749                 if (old && ce->ce_mode == old->ce_mode &&
750                     !oidcmp(&ce->oid, &old->oid)) {
751                         free(old);
752                         continue; /* unchanged */
753                 }
754                 /* Be careful.  The working tree may not have the
755                  * path anymore, in which case, under 'allow_remove',
756                  * or worse yet 'allow_replace', active_nr may decrease.
757                  */
758                 save_nr = active_nr;
759                 path = xstrdup(ce->name);
760                 update_one(path);
761                 free(path);
762                 free(old);
763                 if (save_nr != active_nr)
764                         goto redo;
765         }
766         clear_pathspec(&pathspec);
767         return 0;
768 }
769
770 struct refresh_params {
771         unsigned int flags;
772         int *has_errors;
773 };
774
775 static int refresh(struct refresh_params *o, unsigned int flag)
776 {
777         setup_work_tree();
778         read_cache_preload(NULL);
779         *o->has_errors |= refresh_cache(o->flags | flag);
780         return 0;
781 }
782
783 static int refresh_callback(const struct option *opt,
784                                 const char *arg, int unset)
785 {
786         return refresh(opt->value, 0);
787 }
788
789 static int really_refresh_callback(const struct option *opt,
790                                 const char *arg, int unset)
791 {
792         return refresh(opt->value, REFRESH_REALLY);
793 }
794
795 static int chmod_callback(const struct option *opt,
796                                 const char *arg, int unset)
797 {
798         char *flip = opt->value;
799         if ((arg[0] != '-' && arg[0] != '+') || arg[1] != 'x' || arg[2])
800                 return error("option 'chmod' expects \"+x\" or \"-x\"");
801         *flip = arg[0];
802         return 0;
803 }
804
805 static int resolve_undo_clear_callback(const struct option *opt,
806                                 const char *arg, int unset)
807 {
808         resolve_undo_clear();
809         return 0;
810 }
811
812 static int parse_new_style_cacheinfo(const char *arg,
813                                      unsigned int *mode,
814                                      struct object_id *oid,
815                                      const char **path)
816 {
817         unsigned long ul;
818         char *endp;
819
820         if (!arg)
821                 return -1;
822
823         errno = 0;
824         ul = strtoul(arg, &endp, 8);
825         if (errno || endp == arg || *endp != ',' || (unsigned int) ul != ul)
826                 return -1; /* not a new-style cacheinfo */
827         *mode = ul;
828         endp++;
829         if (get_oid_hex(endp, oid) || endp[GIT_SHA1_HEXSZ] != ',')
830                 return -1;
831         *path = endp + GIT_SHA1_HEXSZ + 1;
832         return 0;
833 }
834
835 static int cacheinfo_callback(struct parse_opt_ctx_t *ctx,
836                                 const struct option *opt, int unset)
837 {
838         struct object_id oid;
839         unsigned int mode;
840         const char *path;
841
842         if (!parse_new_style_cacheinfo(ctx->argv[1], &mode, &oid, &path)) {
843                 if (add_cacheinfo(mode, &oid, path, 0))
844                         die("git update-index: --cacheinfo cannot add %s", path);
845                 ctx->argv++;
846                 ctx->argc--;
847                 return 0;
848         }
849         if (ctx->argc <= 3)
850                 return error("option 'cacheinfo' expects <mode>,<sha1>,<path>");
851         if (strtoul_ui(*++ctx->argv, 8, &mode) ||
852             get_oid_hex(*++ctx->argv, &oid) ||
853             add_cacheinfo(mode, &oid, *++ctx->argv, 0))
854                 die("git update-index: --cacheinfo cannot add %s", *ctx->argv);
855         ctx->argc -= 3;
856         return 0;
857 }
858
859 static int stdin_cacheinfo_callback(struct parse_opt_ctx_t *ctx,
860                               const struct option *opt, int unset)
861 {
862         int *nul_term_line = opt->value;
863
864         if (ctx->argc != 1)
865                 return error("option '%s' must be the last argument", opt->long_name);
866         allow_add = allow_replace = allow_remove = 1;
867         read_index_info(*nul_term_line);
868         return 0;
869 }
870
871 static int stdin_callback(struct parse_opt_ctx_t *ctx,
872                                 const struct option *opt, int unset)
873 {
874         int *read_from_stdin = opt->value;
875
876         if (ctx->argc != 1)
877                 return error("option '%s' must be the last argument", opt->long_name);
878         *read_from_stdin = 1;
879         return 0;
880 }
881
882 static int unresolve_callback(struct parse_opt_ctx_t *ctx,
883                                 const struct option *opt, int flags)
884 {
885         int *has_errors = opt->value;
886         const char *prefix = startup_info->prefix;
887
888         /* consume remaining arguments. */
889         *has_errors = do_unresolve(ctx->argc, ctx->argv,
890                                 prefix, prefix ? strlen(prefix) : 0);
891         if (*has_errors)
892                 active_cache_changed = 0;
893
894         ctx->argv += ctx->argc - 1;
895         ctx->argc = 1;
896         return 0;
897 }
898
899 static int reupdate_callback(struct parse_opt_ctx_t *ctx,
900                                 const struct option *opt, int flags)
901 {
902         int *has_errors = opt->value;
903         const char *prefix = startup_info->prefix;
904
905         /* consume remaining arguments. */
906         setup_work_tree();
907         *has_errors = do_reupdate(ctx->argc, ctx->argv,
908                                 prefix, prefix ? strlen(prefix) : 0);
909         if (*has_errors)
910                 active_cache_changed = 0;
911
912         ctx->argv += ctx->argc - 1;
913         ctx->argc = 1;
914         return 0;
915 }
916
917 int cmd_update_index(int argc, const char **argv, const char *prefix)
918 {
919         int newfd, entries, has_errors = 0, nul_term_line = 0;
920         enum uc_mode untracked_cache = UC_UNSPECIFIED;
921         int read_from_stdin = 0;
922         int prefix_length = prefix ? strlen(prefix) : 0;
923         int preferred_index_format = 0;
924         char set_executable_bit = 0;
925         struct refresh_params refresh_args = {0, &has_errors};
926         int lock_error = 0;
927         int split_index = -1;
928         int force_write = 0;
929         int fsmonitor = -1;
930         struct lock_file lock_file = LOCK_INIT;
931         struct parse_opt_ctx_t ctx;
932         strbuf_getline_fn getline_fn;
933         int parseopt_state = PARSE_OPT_UNKNOWN;
934         struct option options[] = {
935                 OPT_BIT('q', NULL, &refresh_args.flags,
936                         N_("continue refresh even when index needs update"),
937                         REFRESH_QUIET),
938                 OPT_BIT(0, "ignore-submodules", &refresh_args.flags,
939                         N_("refresh: ignore submodules"),
940                         REFRESH_IGNORE_SUBMODULES),
941                 OPT_SET_INT(0, "add", &allow_add,
942                         N_("do not ignore new files"), 1),
943                 OPT_SET_INT(0, "replace", &allow_replace,
944                         N_("let files replace directories and vice-versa"), 1),
945                 OPT_SET_INT(0, "remove", &allow_remove,
946                         N_("notice files missing from worktree"), 1),
947                 OPT_BIT(0, "unmerged", &refresh_args.flags,
948                         N_("refresh even if index contains unmerged entries"),
949                         REFRESH_UNMERGED),
950                 {OPTION_CALLBACK, 0, "refresh", &refresh_args, NULL,
951                         N_("refresh stat information"),
952                         PARSE_OPT_NOARG | PARSE_OPT_NONEG,
953                         refresh_callback},
954                 {OPTION_CALLBACK, 0, "really-refresh", &refresh_args, NULL,
955                         N_("like --refresh, but ignore assume-unchanged setting"),
956                         PARSE_OPT_NOARG | PARSE_OPT_NONEG,
957                         really_refresh_callback},
958                 {OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL,
959                         N_("<mode>,<object>,<path>"),
960                         N_("add the specified entry to the index"),
961                         PARSE_OPT_NOARG | /* disallow --cacheinfo=<mode> form */
962                         PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
963                         (parse_opt_cb *) cacheinfo_callback},
964                 {OPTION_CALLBACK, 0, "chmod", &set_executable_bit, N_("(+/-)x"),
965                         N_("override the executable bit of the listed files"),
966                         PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
967                         chmod_callback},
968                 {OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL,
969                         N_("mark files as \"not changing\""),
970                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
971                 {OPTION_SET_INT, 0, "no-assume-unchanged", &mark_valid_only, NULL,
972                         N_("clear assumed-unchanged bit"),
973                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
974                 {OPTION_SET_INT, 0, "skip-worktree", &mark_skip_worktree_only, NULL,
975                         N_("mark files as \"index-only\""),
976                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
977                 {OPTION_SET_INT, 0, "no-skip-worktree", &mark_skip_worktree_only, NULL,
978                         N_("clear skip-worktree bit"),
979                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
980                 OPT_SET_INT(0, "info-only", &info_only,
981                         N_("add to index only; do not add content to object database"), 1),
982                 OPT_SET_INT(0, "force-remove", &force_remove,
983                         N_("remove named paths even if present in worktree"), 1),
984                 OPT_BOOL('z', NULL, &nul_term_line,
985                          N_("with --stdin: input lines are terminated by null bytes")),
986                 {OPTION_LOWLEVEL_CALLBACK, 0, "stdin", &read_from_stdin, NULL,
987                         N_("read list of paths to be updated from standard input"),
988                         PARSE_OPT_NONEG | PARSE_OPT_NOARG,
989                         (parse_opt_cb *) stdin_callback},
990                 {OPTION_LOWLEVEL_CALLBACK, 0, "index-info", &nul_term_line, NULL,
991                         N_("add entries from standard input to the index"),
992                         PARSE_OPT_NONEG | PARSE_OPT_NOARG,
993                         (parse_opt_cb *) stdin_cacheinfo_callback},
994                 {OPTION_LOWLEVEL_CALLBACK, 0, "unresolve", &has_errors, NULL,
995                         N_("repopulate stages #2 and #3 for the listed paths"),
996                         PARSE_OPT_NONEG | PARSE_OPT_NOARG,
997                         (parse_opt_cb *) unresolve_callback},
998                 {OPTION_LOWLEVEL_CALLBACK, 'g', "again", &has_errors, NULL,
999                         N_("only update entries that differ from HEAD"),
1000                         PARSE_OPT_NONEG | PARSE_OPT_NOARG,
1001                         (parse_opt_cb *) reupdate_callback},
1002                 OPT_BIT(0, "ignore-missing", &refresh_args.flags,
1003                         N_("ignore files missing from worktree"),
1004                         REFRESH_IGNORE_MISSING),
1005                 OPT_SET_INT(0, "verbose", &verbose,
1006                         N_("report actions to standard output"), 1),
1007                 {OPTION_CALLBACK, 0, "clear-resolve-undo", NULL, NULL,
1008                         N_("(for porcelains) forget saved unresolved conflicts"),
1009                         PARSE_OPT_NOARG | PARSE_OPT_NONEG,
1010                         resolve_undo_clear_callback},
1011                 OPT_INTEGER(0, "index-version", &preferred_index_format,
1012                         N_("write index in this format")),
1013                 OPT_BOOL(0, "split-index", &split_index,
1014                         N_("enable or disable split index")),
1015                 OPT_BOOL(0, "untracked-cache", &untracked_cache,
1016                         N_("enable/disable untracked cache")),
1017                 OPT_SET_INT(0, "test-untracked-cache", &untracked_cache,
1018                             N_("test if the filesystem supports untracked cache"), UC_TEST),
1019                 OPT_SET_INT(0, "force-untracked-cache", &untracked_cache,
1020                             N_("enable untracked cache without testing the filesystem"), UC_FORCE),
1021                 OPT_SET_INT(0, "force-write-index", &force_write,
1022                         N_("write out the index even if is not flagged as changed"), 1),
1023                 OPT_BOOL(0, "fsmonitor", &fsmonitor,
1024                         N_("enable or disable file system monitor")),
1025                 {OPTION_SET_INT, 0, "fsmonitor-valid", &mark_fsmonitor_only, NULL,
1026                         N_("mark files as fsmonitor valid"),
1027                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
1028                 {OPTION_SET_INT, 0, "no-fsmonitor-valid", &mark_fsmonitor_only, NULL,
1029                         N_("clear fsmonitor valid bit"),
1030                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
1031                 OPT_END()
1032         };
1033
1034         if (argc == 2 && !strcmp(argv[1], "-h"))
1035                 usage_with_options(update_index_usage, options);
1036
1037         git_config(git_default_config, NULL);
1038
1039         /* we will diagnose later if it turns out that we need to update it */
1040         newfd = hold_locked_index(&lock_file, 0);
1041         if (newfd < 0)
1042                 lock_error = errno;
1043
1044         entries = read_cache();
1045         if (entries < 0)
1046                 die("cache corrupted");
1047
1048         /*
1049          * Custom copy of parse_options() because we want to handle
1050          * filename arguments as they come.
1051          */
1052         parse_options_start(&ctx, argc, argv, prefix,
1053                             options, PARSE_OPT_STOP_AT_NON_OPTION);
1054         while (ctx.argc) {
1055                 if (parseopt_state != PARSE_OPT_DONE)
1056                         parseopt_state = parse_options_step(&ctx, options,
1057                                                             update_index_usage);
1058                 if (!ctx.argc)
1059                         break;
1060                 switch (parseopt_state) {
1061                 case PARSE_OPT_HELP:
1062                         exit(129);
1063                 case PARSE_OPT_NON_OPTION:
1064                 case PARSE_OPT_DONE:
1065                 {
1066                         const char *path = ctx.argv[0];
1067                         char *p;
1068
1069                         setup_work_tree();
1070                         p = prefix_path(prefix, prefix_length, path);
1071                         update_one(p);
1072                         if (set_executable_bit)
1073                                 chmod_path(set_executable_bit, p);
1074                         free(p);
1075                         ctx.argc--;
1076                         ctx.argv++;
1077                         break;
1078                 }
1079                 case PARSE_OPT_UNKNOWN:
1080                         if (ctx.argv[0][1] == '-')
1081                                 error("unknown option '%s'", ctx.argv[0] + 2);
1082                         else
1083                                 error("unknown switch '%c'", *ctx.opt);
1084                         usage_with_options(update_index_usage, options);
1085                 }
1086         }
1087         argc = parse_options_end(&ctx);
1088
1089         getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
1090         if (preferred_index_format) {
1091                 if (preferred_index_format < INDEX_FORMAT_LB ||
1092                     INDEX_FORMAT_UB < preferred_index_format)
1093                         die("index-version %d not in range: %d..%d",
1094                             preferred_index_format,
1095                             INDEX_FORMAT_LB, INDEX_FORMAT_UB);
1096
1097                 if (the_index.version != preferred_index_format)
1098                         active_cache_changed |= SOMETHING_CHANGED;
1099                 the_index.version = preferred_index_format;
1100         }
1101
1102         if (read_from_stdin) {
1103                 struct strbuf buf = STRBUF_INIT;
1104                 struct strbuf unquoted = STRBUF_INIT;
1105
1106                 setup_work_tree();
1107                 while (getline_fn(&buf, stdin) != EOF) {
1108                         char *p;
1109                         if (!nul_term_line && buf.buf[0] == '"') {
1110                                 strbuf_reset(&unquoted);
1111                                 if (unquote_c_style(&unquoted, buf.buf, NULL))
1112                                         die("line is badly quoted");
1113                                 strbuf_swap(&buf, &unquoted);
1114                         }
1115                         p = prefix_path(prefix, prefix_length, buf.buf);
1116                         update_one(p);
1117                         if (set_executable_bit)
1118                                 chmod_path(set_executable_bit, p);
1119                         free(p);
1120                 }
1121                 strbuf_release(&unquoted);
1122                 strbuf_release(&buf);
1123         }
1124
1125         if (split_index > 0) {
1126                 if (git_config_get_split_index() == 0)
1127                         warning(_("core.splitIndex is set to false; "
1128                                   "remove or change it, if you really want to "
1129                                   "enable split index"));
1130                 if (the_index.split_index)
1131                         the_index.cache_changed |= SPLIT_INDEX_ORDERED;
1132                 else
1133                         add_split_index(&the_index);
1134         } else if (!split_index) {
1135                 if (git_config_get_split_index() == 1)
1136                         warning(_("core.splitIndex is set to true; "
1137                                   "remove or change it, if you really want to "
1138                                   "disable split index"));
1139                 remove_split_index(&the_index);
1140         }
1141
1142         switch (untracked_cache) {
1143         case UC_UNSPECIFIED:
1144                 break;
1145         case UC_DISABLE:
1146                 if (git_config_get_untracked_cache() == 1)
1147                         warning(_("core.untrackedCache is set to true; "
1148                                   "remove or change it, if you really want to "
1149                                   "disable the untracked cache"));
1150                 remove_untracked_cache(&the_index);
1151                 report(_("Untracked cache disabled"));
1152                 break;
1153         case UC_TEST:
1154                 setup_work_tree();
1155                 return !test_if_untracked_cache_is_supported();
1156         case UC_ENABLE:
1157         case UC_FORCE:
1158                 if (git_config_get_untracked_cache() == 0)
1159                         warning(_("core.untrackedCache is set to false; "
1160                                   "remove or change it, if you really want to "
1161                                   "enable the untracked cache"));
1162                 add_untracked_cache(&the_index);
1163                 report(_("Untracked cache enabled for '%s'"), get_git_work_tree());
1164                 break;
1165         default:
1166                 die("BUG: bad untracked_cache value: %d", untracked_cache);
1167         }
1168
1169         if (fsmonitor > 0) {
1170                 if (git_config_get_fsmonitor() == 0)
1171                         warning(_("core.fsmonitor is unset; "
1172                                 "set it if you really want to "
1173                                 "enable fsmonitor"));
1174                 add_fsmonitor(&the_index);
1175                 report(_("fsmonitor enabled"));
1176         } else if (!fsmonitor) {
1177                 if (git_config_get_fsmonitor() == 1)
1178                         warning(_("core.fsmonitor is set; "
1179                                 "remove it if you really want to "
1180                                 "disable fsmonitor"));
1181                 remove_fsmonitor(&the_index);
1182                 report(_("fsmonitor disabled"));
1183         }
1184
1185         if (active_cache_changed || force_write) {
1186                 if (newfd < 0) {
1187                         if (refresh_args.flags & REFRESH_QUIET)
1188                                 exit(128);
1189                         unable_to_lock_die(get_index_file(), lock_error);
1190                 }
1191                 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
1192                         die("Unable to write new index file");
1193         }
1194
1195         rollback_lock_file(&lock_file);
1196
1197         return has_errors ? 1 : 0;
1198 }