Merge branch 'js/maint-send-pack-stateless-rpc-deadlock-fix' into maint-1.7.4
[git] / builtin / commit.c
1 /*
2  * Builtin "git commit"
3  *
4  * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5  * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6  */
7
8 #include "cache.h"
9 #include "cache-tree.h"
10 #include "color.h"
11 #include "dir.h"
12 #include "builtin.h"
13 #include "diff.h"
14 #include "diffcore.h"
15 #include "commit.h"
16 #include "revision.h"
17 #include "wt-status.h"
18 #include "run-command.h"
19 #include "refs.h"
20 #include "log-tree.h"
21 #include "strbuf.h"
22 #include "utf8.h"
23 #include "parse-options.h"
24 #include "string-list.h"
25 #include "rerere.h"
26 #include "unpack-trees.h"
27 #include "quote.h"
28 #include "submodule.h"
29
30 static const char * const builtin_commit_usage[] = {
31         "git commit [options] [--] <filepattern>...",
32         NULL
33 };
34
35 static const char * const builtin_status_usage[] = {
36         "git status [options] [--] <filepattern>...",
37         NULL
38 };
39
40 static const char implicit_ident_advice[] =
41 "Your name and email address were configured automatically based\n"
42 "on your username and hostname. Please check that they are accurate.\n"
43 "You can suppress this message by setting them explicitly:\n"
44 "\n"
45 "    git config --global user.name \"Your Name\"\n"
46 "    git config --global user.email you@example.com\n"
47 "\n"
48 "After doing this, you may fix the identity used for this commit with:\n"
49 "\n"
50 "    git commit --amend --reset-author\n";
51
52 static const char empty_amend_advice[] =
53 "You asked to amend the most recent commit, but doing so would make\n"
54 "it empty. You can repeat your command with --allow-empty, or you can\n"
55 "remove the commit entirely with \"git reset HEAD^\".\n";
56
57 static unsigned char head_sha1[20];
58
59 static char *use_message_buffer;
60 static const char commit_editmsg[] = "COMMIT_EDITMSG";
61 static struct lock_file index_lock; /* real index */
62 static struct lock_file false_lock; /* used only for partial commits */
63 static enum {
64         COMMIT_AS_IS = 1,
65         COMMIT_NORMAL,
66         COMMIT_PARTIAL
67 } commit_style;
68
69 static const char *logfile, *force_author;
70 static const char *template_file;
71 static char *edit_message, *use_message;
72 static char *fixup_message, *squash_message;
73 static int all, edit_flag, also, interactive, only, amend, signoff;
74 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
75 static int no_post_rewrite, allow_empty_message;
76 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
77 /*
78  * The default commit message cleanup mode will remove the lines
79  * beginning with # (shell comments) and leading and trailing
80  * whitespaces (empty lines or containing only whitespaces)
81  * if editor is used, and only the whitespaces if the message
82  * is specified explicitly.
83  */
84 static enum {
85         CLEANUP_SPACE,
86         CLEANUP_NONE,
87         CLEANUP_ALL
88 } cleanup_mode;
89 static char *cleanup_arg;
90
91 static int use_editor = 1, initial_commit, in_merge, include_status = 1;
92 static int show_ignored_in_status;
93 static const char *only_include_assumed;
94 static struct strbuf message;
95
96 static int null_termination;
97 static enum {
98         STATUS_FORMAT_LONG,
99         STATUS_FORMAT_SHORT,
100         STATUS_FORMAT_PORCELAIN
101 } status_format = STATUS_FORMAT_LONG;
102 static int status_show_branch;
103
104 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
105 {
106         struct strbuf *buf = opt->value;
107         if (unset)
108                 strbuf_setlen(buf, 0);
109         else {
110                 strbuf_addstr(buf, arg);
111                 strbuf_addstr(buf, "\n\n");
112         }
113         return 0;
114 }
115
116 static struct option builtin_commit_options[] = {
117         OPT__QUIET(&quiet, "suppress summary after successful commit"),
118         OPT__VERBOSE(&verbose, "show diff in commit message template"),
119
120         OPT_GROUP("Commit message options"),
121         OPT_FILENAME('F', "file", &logfile, "read message from file"),
122         OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
123         OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
124         OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
125         OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
126         OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
127         OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
128         OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
129         OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
130         OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
131         OPT_FILENAME('t', "template", &template_file, "use specified template file"),
132         OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
133         OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
134         OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
135         /* end commit message options */
136
137         OPT_GROUP("Commit contents options"),
138         OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
139         OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
140         OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
141         OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
142         OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
143         OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
144         OPT_SET_INT(0, "short", &status_format, "show status concisely",
145                     STATUS_FORMAT_SHORT),
146         OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
147         OPT_SET_INT(0, "porcelain", &status_format,
148                     "machine-readable output", STATUS_FORMAT_PORCELAIN),
149         OPT_BOOLEAN('z', "null", &null_termination,
150                     "terminate entries with NUL"),
151         OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
152         OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
153         { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
154         /* end commit contents options */
155
156         { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
157           "ok to record an empty change",
158           PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
159         { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
160           "ok to record a change with an empty message",
161           PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
162
163         OPT_END()
164 };
165
166 static void rollback_index_files(void)
167 {
168         switch (commit_style) {
169         case COMMIT_AS_IS:
170                 break; /* nothing to do */
171         case COMMIT_NORMAL:
172                 rollback_lock_file(&index_lock);
173                 break;
174         case COMMIT_PARTIAL:
175                 rollback_lock_file(&index_lock);
176                 rollback_lock_file(&false_lock);
177                 break;
178         }
179 }
180
181 static int commit_index_files(void)
182 {
183         int err = 0;
184
185         switch (commit_style) {
186         case COMMIT_AS_IS:
187                 break; /* nothing to do */
188         case COMMIT_NORMAL:
189                 err = commit_lock_file(&index_lock);
190                 break;
191         case COMMIT_PARTIAL:
192                 err = commit_lock_file(&index_lock);
193                 rollback_lock_file(&false_lock);
194                 break;
195         }
196
197         return err;
198 }
199
200 /*
201  * Take a union of paths in the index and the named tree (typically, "HEAD"),
202  * and return the paths that match the given pattern in list.
203  */
204 static int list_paths(struct string_list *list, const char *with_tree,
205                       const char *prefix, const char **pattern)
206 {
207         int i;
208         char *m;
209
210         for (i = 0; pattern[i]; i++)
211                 ;
212         m = xcalloc(1, i);
213
214         if (with_tree)
215                 overlay_tree_on_cache(with_tree, prefix);
216
217         for (i = 0; i < active_nr; i++) {
218                 struct cache_entry *ce = active_cache[i];
219                 struct string_list_item *item;
220
221                 if (ce->ce_flags & CE_UPDATE)
222                         continue;
223                 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
224                         continue;
225                 item = string_list_insert(list, ce->name);
226                 if (ce_skip_worktree(ce))
227                         item->util = item; /* better a valid pointer than a fake one */
228         }
229
230         return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
231 }
232
233 static void add_remove_files(struct string_list *list)
234 {
235         int i;
236         for (i = 0; i < list->nr; i++) {
237                 struct stat st;
238                 struct string_list_item *p = &(list->items[i]);
239
240                 /* p->util is skip-worktree */
241                 if (p->util)
242                         continue;
243
244                 if (!lstat(p->string, &st)) {
245                         if (add_to_cache(p->string, &st, 0))
246                                 die("updating files failed");
247                 } else
248                         remove_file_from_cache(p->string);
249         }
250 }
251
252 static void create_base_index(void)
253 {
254         struct tree *tree;
255         struct unpack_trees_options opts;
256         struct tree_desc t;
257
258         if (initial_commit) {
259                 discard_cache();
260                 return;
261         }
262
263         memset(&opts, 0, sizeof(opts));
264         opts.head_idx = 1;
265         opts.index_only = 1;
266         opts.merge = 1;
267         opts.src_index = &the_index;
268         opts.dst_index = &the_index;
269
270         opts.fn = oneway_merge;
271         tree = parse_tree_indirect(head_sha1);
272         if (!tree)
273                 die("failed to unpack HEAD tree object");
274         parse_tree(tree);
275         init_tree_desc(&t, tree->buffer, tree->size);
276         if (unpack_trees(1, &t, &opts))
277                 exit(128); /* We've already reported the error, finish dying */
278 }
279
280 static void refresh_cache_or_die(int refresh_flags)
281 {
282         /*
283          * refresh_flags contains REFRESH_QUIET, so the only errors
284          * are for unmerged entries.
285          */
286         if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
287                 die_resolve_conflict("commit");
288 }
289
290 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
291 {
292         int fd;
293         struct string_list partial;
294         const char **pathspec = NULL;
295         int refresh_flags = REFRESH_QUIET;
296
297         if (is_status)
298                 refresh_flags |= REFRESH_UNMERGED;
299         if (interactive) {
300                 if (interactive_add(argc, argv, prefix) != 0)
301                         die("interactive add failed");
302                 if (read_cache_preload(NULL) < 0)
303                         die("index file corrupt");
304                 commit_style = COMMIT_AS_IS;
305                 return get_index_file();
306         }
307
308         if (*argv)
309                 pathspec = get_pathspec(prefix, argv);
310
311         if (read_cache_preload(pathspec) < 0)
312                 die("index file corrupt");
313
314         /*
315          * Non partial, non as-is commit.
316          *
317          * (1) get the real index;
318          * (2) update the_index as necessary;
319          * (3) write the_index out to the real index (still locked);
320          * (4) return the name of the locked index file.
321          *
322          * The caller should run hooks on the locked real index, and
323          * (A) if all goes well, commit the real index;
324          * (B) on failure, rollback the real index.
325          */
326         if (all || (also && pathspec && *pathspec)) {
327                 fd = hold_locked_index(&index_lock, 1);
328                 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
329                 refresh_cache_or_die(refresh_flags);
330                 if (write_cache(fd, active_cache, active_nr) ||
331                     close_lock_file(&index_lock))
332                         die("unable to write new_index file");
333                 commit_style = COMMIT_NORMAL;
334                 return index_lock.filename;
335         }
336
337         /*
338          * As-is commit.
339          *
340          * (1) return the name of the real index file.
341          *
342          * The caller should run hooks on the real index,
343          * and create commit from the_index.
344          * We still need to refresh the index here.
345          */
346         if (!pathspec || !*pathspec) {
347                 fd = hold_locked_index(&index_lock, 1);
348                 refresh_cache_or_die(refresh_flags);
349                 if (active_cache_changed) {
350                         if (write_cache(fd, active_cache, active_nr) ||
351                             commit_locked_index(&index_lock))
352                                 die("unable to write new_index file");
353                 } else {
354                         rollback_lock_file(&index_lock);
355                 }
356                 commit_style = COMMIT_AS_IS;
357                 return get_index_file();
358         }
359
360         /*
361          * A partial commit.
362          *
363          * (0) find the set of affected paths;
364          * (1) get lock on the real index file;
365          * (2) update the_index with the given paths;
366          * (3) write the_index out to the real index (still locked);
367          * (4) get lock on the false index file;
368          * (5) reset the_index from HEAD;
369          * (6) update the_index the same way as (2);
370          * (7) write the_index out to the false index file;
371          * (8) return the name of the false index file (still locked);
372          *
373          * The caller should run hooks on the locked false index, and
374          * create commit from it.  Then
375          * (A) if all goes well, commit the real index;
376          * (B) on failure, rollback the real index;
377          * In either case, rollback the false index.
378          */
379         commit_style = COMMIT_PARTIAL;
380
381         if (in_merge)
382                 die("cannot do a partial commit during a merge.");
383
384         memset(&partial, 0, sizeof(partial));
385         partial.strdup_strings = 1;
386         if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
387                 exit(1);
388
389         discard_cache();
390         if (read_cache() < 0)
391                 die("cannot read the index");
392
393         fd = hold_locked_index(&index_lock, 1);
394         add_remove_files(&partial);
395         refresh_cache(REFRESH_QUIET);
396         if (write_cache(fd, active_cache, active_nr) ||
397             close_lock_file(&index_lock))
398                 die("unable to write new_index file");
399
400         fd = hold_lock_file_for_update(&false_lock,
401                                        git_path("next-index-%"PRIuMAX,
402                                                 (uintmax_t) getpid()),
403                                        LOCK_DIE_ON_ERROR);
404
405         create_base_index();
406         add_remove_files(&partial);
407         refresh_cache(REFRESH_QUIET);
408
409         if (write_cache(fd, active_cache, active_nr) ||
410             close_lock_file(&false_lock))
411                 die("unable to write temporary index file");
412
413         discard_cache();
414         read_cache_from(false_lock.filename);
415
416         return false_lock.filename;
417 }
418
419 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
420                       struct wt_status *s)
421 {
422         unsigned char sha1[20];
423
424         if (s->relative_paths)
425                 s->prefix = prefix;
426
427         if (amend) {
428                 s->amend = 1;
429                 s->reference = "HEAD^1";
430         }
431         s->verbose = verbose;
432         s->index_file = index_file;
433         s->fp = fp;
434         s->nowarn = nowarn;
435         s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
436
437         wt_status_collect(s);
438
439         switch (status_format) {
440         case STATUS_FORMAT_SHORT:
441                 wt_shortstatus_print(s, null_termination, status_show_branch);
442                 break;
443         case STATUS_FORMAT_PORCELAIN:
444                 wt_porcelain_print(s, null_termination);
445                 break;
446         case STATUS_FORMAT_LONG:
447                 wt_status_print(s);
448                 break;
449         }
450
451         return s->commitable;
452 }
453
454 static int is_a_merge(const unsigned char *sha1)
455 {
456         struct commit *commit = lookup_commit(sha1);
457         if (!commit || parse_commit(commit))
458                 die("could not parse HEAD commit");
459         return !!(commit->parents && commit->parents->next);
460 }
461
462 static const char sign_off_header[] = "Signed-off-by: ";
463
464 static void determine_author_info(struct strbuf *author_ident)
465 {
466         char *name, *email, *date;
467
468         name = getenv("GIT_AUTHOR_NAME");
469         email = getenv("GIT_AUTHOR_EMAIL");
470         date = getenv("GIT_AUTHOR_DATE");
471
472         if (use_message && !renew_authorship) {
473                 const char *a, *lb, *rb, *eol;
474
475                 a = strstr(use_message_buffer, "\nauthor ");
476                 if (!a)
477                         die("invalid commit: %s", use_message);
478
479                 lb = strchrnul(a + strlen("\nauthor "), '<');
480                 rb = strchrnul(lb, '>');
481                 eol = strchrnul(rb, '\n');
482                 if (!*lb || !*rb || !*eol)
483                         die("invalid commit: %s", use_message);
484
485                 if (lb == a + strlen("\nauthor "))
486                         /* \nauthor <foo@example.com> */
487                         name = xcalloc(1, 1);
488                 else
489                         name = xmemdupz(a + strlen("\nauthor "),
490                                         (lb - strlen(" ") -
491                                          (a + strlen("\nauthor "))));
492                 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
493                 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
494         }
495
496         if (force_author) {
497                 const char *lb = strstr(force_author, " <");
498                 const char *rb = strchr(force_author, '>');
499
500                 if (!lb || !rb)
501                         die("malformed --author parameter");
502                 name = xstrndup(force_author, lb - force_author);
503                 email = xstrndup(lb + 2, rb - (lb + 2));
504         }
505
506         if (force_date)
507                 date = force_date;
508         strbuf_addstr(author_ident, fmt_ident(name, email, date,
509                                               IDENT_ERROR_ON_NO_NAME));
510 }
511
512 static int ends_rfc2822_footer(struct strbuf *sb)
513 {
514         int ch;
515         int hit = 0;
516         int i, j, k;
517         int len = sb->len;
518         int first = 1;
519         const char *buf = sb->buf;
520
521         for (i = len - 1; i > 0; i--) {
522                 if (hit && buf[i] == '\n')
523                         break;
524                 hit = (buf[i] == '\n');
525         }
526
527         while (i < len - 1 && buf[i] == '\n')
528                 i++;
529
530         for (; i < len; i = k) {
531                 for (k = i; k < len && buf[k] != '\n'; k++)
532                         ; /* do nothing */
533                 k++;
534
535                 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
536                         continue;
537
538                 first = 0;
539
540                 for (j = 0; i + j < len; j++) {
541                         ch = buf[i + j];
542                         if (ch == ':')
543                                 break;
544                         if (isalnum(ch) ||
545                             (ch == '-'))
546                                 continue;
547                         return 0;
548                 }
549         }
550         return 1;
551 }
552
553 static char *cut_ident_timestamp_part(char *string)
554 {
555         char *ket = strrchr(string, '>');
556         if (!ket || ket[1] != ' ')
557                 die("Malformed ident string: '%s'", string);
558         *++ket = '\0';
559         return ket;
560 }
561
562 static int prepare_to_commit(const char *index_file, const char *prefix,
563                              struct wt_status *s,
564                              struct strbuf *author_ident)
565 {
566         struct stat statbuf;
567         struct strbuf committer_ident = STRBUF_INIT;
568         int commitable, saved_color_setting;
569         struct strbuf sb = STRBUF_INIT;
570         char *buffer;
571         FILE *fp;
572         const char *hook_arg1 = NULL;
573         const char *hook_arg2 = NULL;
574         int ident_shown = 0;
575
576         if (!no_verify && run_hook(index_file, "pre-commit", NULL))
577                 return 0;
578
579         if (squash_message) {
580                 /*
581                  * Insert the proper subject line before other commit
582                  * message options add their content.
583                  */
584                 if (use_message && !strcmp(use_message, squash_message))
585                         strbuf_addstr(&sb, "squash! ");
586                 else {
587                         struct pretty_print_context ctx = {0};
588                         struct commit *c;
589                         c = lookup_commit_reference_by_name(squash_message);
590                         if (!c)
591                                 die("could not lookup commit %s", squash_message);
592                         ctx.output_encoding = get_commit_output_encoding();
593                         format_commit_message(c, "squash! %s\n\n", &sb,
594                                               &ctx);
595                 }
596         }
597
598         if (message.len) {
599                 strbuf_addbuf(&sb, &message);
600                 hook_arg1 = "message";
601         } else if (logfile && !strcmp(logfile, "-")) {
602                 if (isatty(0))
603                         fprintf(stderr, "(reading log message from standard input)\n");
604                 if (strbuf_read(&sb, 0, 0) < 0)
605                         die_errno("could not read log from standard input");
606                 hook_arg1 = "message";
607         } else if (logfile) {
608                 if (strbuf_read_file(&sb, logfile, 0) < 0)
609                         die_errno("could not read log file '%s'",
610                                   logfile);
611                 hook_arg1 = "message";
612         } else if (use_message) {
613                 buffer = strstr(use_message_buffer, "\n\n");
614                 if (!buffer || buffer[2] == '\0')
615                         die("commit has empty message");
616                 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
617                 hook_arg1 = "commit";
618                 hook_arg2 = use_message;
619         } else if (fixup_message) {
620                 struct pretty_print_context ctx = {0};
621                 struct commit *commit;
622                 commit = lookup_commit_reference_by_name(fixup_message);
623                 if (!commit)
624                         die("could not lookup commit %s", fixup_message);
625                 ctx.output_encoding = get_commit_output_encoding();
626                 format_commit_message(commit, "fixup! %s\n\n",
627                                       &sb, &ctx);
628                 hook_arg1 = "message";
629         } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
630                 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
631                         die_errno("could not read MERGE_MSG");
632                 hook_arg1 = "merge";
633         } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
634                 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
635                         die_errno("could not read SQUASH_MSG");
636                 hook_arg1 = "squash";
637         } else if (template_file) {
638                 if (strbuf_read_file(&sb, template_file, 0) < 0)
639                         die_errno("could not read '%s'", template_file);
640                 hook_arg1 = "template";
641         }
642
643         /*
644          * This final case does not modify the template message,
645          * it just sets the argument to the prepare-commit-msg hook.
646          */
647         else if (in_merge)
648                 hook_arg1 = "merge";
649
650         if (squash_message) {
651                 /*
652                  * If squash_commit was used for the commit subject,
653                  * then we're possibly hijacking other commit log options.
654                  * Reset the hook args to tell the real story.
655                  */
656                 hook_arg1 = "message";
657                 hook_arg2 = "";
658         }
659
660         fp = fopen(git_path(commit_editmsg), "w");
661         if (fp == NULL)
662                 die_errno("could not open '%s'", git_path(commit_editmsg));
663
664         if (cleanup_mode != CLEANUP_NONE)
665                 stripspace(&sb, 0);
666
667         if (signoff) {
668                 struct strbuf sob = STRBUF_INIT;
669                 int i;
670
671                 strbuf_addstr(&sob, sign_off_header);
672                 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
673                                              getenv("GIT_COMMITTER_EMAIL")));
674                 strbuf_addch(&sob, '\n');
675                 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
676                         ; /* do nothing */
677                 if (prefixcmp(sb.buf + i, sob.buf)) {
678                         if (!i || !ends_rfc2822_footer(&sb))
679                                 strbuf_addch(&sb, '\n');
680                         strbuf_addbuf(&sb, &sob);
681                 }
682                 strbuf_release(&sob);
683         }
684
685         if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
686                 die_errno("could not write commit template");
687
688         strbuf_release(&sb);
689
690         /* This checks and barfs if author is badly specified */
691         determine_author_info(author_ident);
692
693         /* This checks if committer ident is explicitly given */
694         strbuf_addstr(&committer_ident, git_committer_info(0));
695         if (use_editor && include_status) {
696                 char *ai_tmp, *ci_tmp;
697                 if (in_merge)
698                         fprintf(fp,
699                                 "#\n"
700                                 "# It looks like you may be committing a MERGE.\n"
701                                 "# If this is not correct, please remove the file\n"
702                                 "#      %s\n"
703                                 "# and try again.\n"
704                                 "#\n",
705                                 git_path("MERGE_HEAD"));
706
707                 fprintf(fp,
708                         "\n"
709                         "# Please enter the commit message for your changes.");
710                 if (cleanup_mode == CLEANUP_ALL)
711                         fprintf(fp,
712                                 " Lines starting\n"
713                                 "# with '#' will be ignored, and an empty"
714                                 " message aborts the commit.\n");
715                 else /* CLEANUP_SPACE, that is. */
716                         fprintf(fp,
717                                 " Lines starting\n"
718                                 "# with '#' will be kept; you may remove them"
719                                 " yourself if you want to.\n"
720                                 "# An empty message aborts the commit.\n");
721                 if (only_include_assumed)
722                         fprintf(fp, "# %s\n", only_include_assumed);
723
724                 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
725                 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
726                 if (strcmp(author_ident->buf, committer_ident.buf))
727                         fprintf(fp,
728                                 "%s"
729                                 "# Author:    %s\n",
730                                 ident_shown++ ? "" : "#\n",
731                                 author_ident->buf);
732
733                 if (!user_ident_sufficiently_given())
734                         fprintf(fp,
735                                 "%s"
736                                 "# Committer: %s\n",
737                                 ident_shown++ ? "" : "#\n",
738                                 committer_ident.buf);
739
740                 if (ident_shown)
741                         fprintf(fp, "#\n");
742
743                 saved_color_setting = s->use_color;
744                 s->use_color = 0;
745                 commitable = run_status(fp, index_file, prefix, 1, s);
746                 s->use_color = saved_color_setting;
747
748                 *ai_tmp = ' ';
749                 *ci_tmp = ' ';
750         } else {
751                 unsigned char sha1[20];
752                 const char *parent = "HEAD";
753
754                 if (!active_nr && read_cache() < 0)
755                         die("Cannot read index");
756
757                 if (amend)
758                         parent = "HEAD^1";
759
760                 if (get_sha1(parent, sha1))
761                         commitable = !!active_nr;
762                 else
763                         commitable = index_differs_from(parent, 0);
764         }
765         strbuf_release(&committer_ident);
766
767         fclose(fp);
768
769         if (!commitable && !in_merge && !allow_empty &&
770             !(amend && is_a_merge(head_sha1))) {
771                 run_status(stdout, index_file, prefix, 0, s);
772                 if (amend)
773                         fputs(empty_amend_advice, stderr);
774                 return 0;
775         }
776
777         /*
778          * Re-read the index as pre-commit hook could have updated it,
779          * and write it out as a tree.  We must do this before we invoke
780          * the editor and after we invoke run_status above.
781          */
782         discard_cache();
783         read_cache_from(index_file);
784         if (!active_cache_tree)
785                 active_cache_tree = cache_tree();
786         if (cache_tree_update(active_cache_tree,
787                               active_cache, active_nr, 0, 0) < 0) {
788                 error("Error building trees");
789                 return 0;
790         }
791
792         if (run_hook(index_file, "prepare-commit-msg",
793                      git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
794                 return 0;
795
796         if (use_editor) {
797                 char index[PATH_MAX];
798                 const char *env[2] = { NULL };
799                 env[0] =  index;
800                 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
801                 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
802                         fprintf(stderr,
803                         "Please supply the message using either -m or -F option.\n");
804                         exit(1);
805                 }
806         }
807
808         if (!no_verify &&
809             run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
810                 return 0;
811         }
812
813         return 1;
814 }
815
816 /*
817  * Find out if the message in the strbuf contains only whitespace and
818  * Signed-off-by lines.
819  */
820 static int message_is_empty(struct strbuf *sb)
821 {
822         struct strbuf tmpl = STRBUF_INIT;
823         const char *nl;
824         int eol, i, start = 0;
825
826         if (cleanup_mode == CLEANUP_NONE && sb->len)
827                 return 0;
828
829         /* See if the template is just a prefix of the message. */
830         if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
831                 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
832                 if (start + tmpl.len <= sb->len &&
833                     memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
834                         start += tmpl.len;
835         }
836         strbuf_release(&tmpl);
837
838         /* Check if the rest is just whitespace and Signed-of-by's. */
839         for (i = start; i < sb->len; i++) {
840                 nl = memchr(sb->buf + i, '\n', sb->len - i);
841                 if (nl)
842                         eol = nl - sb->buf;
843                 else
844                         eol = sb->len;
845
846                 if (strlen(sign_off_header) <= eol - i &&
847                     !prefixcmp(sb->buf + i, sign_off_header)) {
848                         i = eol;
849                         continue;
850                 }
851                 while (i < eol)
852                         if (!isspace(sb->buf[i++]))
853                                 return 0;
854         }
855
856         return 1;
857 }
858
859 static const char *find_author_by_nickname(const char *name)
860 {
861         struct rev_info revs;
862         struct commit *commit;
863         struct strbuf buf = STRBUF_INIT;
864         const char *av[20];
865         int ac = 0;
866
867         init_revisions(&revs, NULL);
868         strbuf_addf(&buf, "--author=%s", name);
869         av[++ac] = "--all";
870         av[++ac] = "-i";
871         av[++ac] = buf.buf;
872         av[++ac] = NULL;
873         setup_revisions(ac, av, &revs, NULL);
874         prepare_revision_walk(&revs);
875         commit = get_revision(&revs);
876         if (commit) {
877                 struct pretty_print_context ctx = {0};
878                 ctx.date_mode = DATE_NORMAL;
879                 strbuf_release(&buf);
880                 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
881                 return strbuf_detach(&buf, NULL);
882         }
883         die("No existing author found with '%s'", name);
884 }
885
886
887 static void handle_untracked_files_arg(struct wt_status *s)
888 {
889         if (!untracked_files_arg)
890                 ; /* default already initialized */
891         else if (!strcmp(untracked_files_arg, "no"))
892                 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
893         else if (!strcmp(untracked_files_arg, "normal"))
894                 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
895         else if (!strcmp(untracked_files_arg, "all"))
896                 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
897         else
898                 die("Invalid untracked files mode '%s'", untracked_files_arg);
899 }
900
901 static int parse_and_validate_options(int argc, const char *argv[],
902                                       const char * const usage[],
903                                       const char *prefix,
904                                       struct wt_status *s)
905 {
906         int f = 0;
907
908         argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
909                              0);
910
911         if (force_author && !strchr(force_author, '>'))
912                 force_author = find_author_by_nickname(force_author);
913
914         if (force_author && renew_authorship)
915                 die("Using both --reset-author and --author does not make sense");
916
917         if (logfile || message.len || use_message || fixup_message)
918                 use_editor = 0;
919         if (edit_flag)
920                 use_editor = 1;
921         if (!use_editor)
922                 setenv("GIT_EDITOR", ":", 1);
923
924         if (get_sha1("HEAD", head_sha1))
925                 initial_commit = 1;
926
927         /* Sanity check options */
928         if (amend && initial_commit)
929                 die("You have nothing to amend.");
930         if (amend && in_merge)
931                 die("You are in the middle of a merge -- cannot amend.");
932         if (fixup_message && squash_message)
933                 die("Options --squash and --fixup cannot be used together");
934         if (use_message)
935                 f++;
936         if (edit_message)
937                 f++;
938         if (fixup_message)
939                 f++;
940         if (logfile)
941                 f++;
942         if (f > 1)
943                 die("Only one of -c/-C/-F/--fixup can be used.");
944         if (message.len && f > 0)
945                 die("Option -m cannot be combined with -c/-C/-F/--fixup.");
946         if (edit_message)
947                 use_message = edit_message;
948         if (amend && !use_message && !fixup_message)
949                 use_message = "HEAD";
950         if (!use_message && renew_authorship)
951                 die("--reset-author can be used only with -C, -c or --amend.");
952         if (use_message) {
953                 const char *out_enc;
954                 struct commit *commit;
955
956                 commit = lookup_commit_reference_by_name(use_message);
957                 if (!commit)
958                         die("could not lookup commit %s", use_message);
959                 out_enc = get_commit_output_encoding();
960                 use_message_buffer = logmsg_reencode(commit, out_enc);
961
962                 /*
963                  * If we failed to reencode the buffer, just copy it
964                  * byte for byte so the user can try to fix it up.
965                  * This also handles the case where input and output
966                  * encodings are identical.
967                  */
968                 if (use_message_buffer == NULL)
969                         use_message_buffer = xstrdup(commit->buffer);
970         }
971
972         if (!!also + !!only + !!all + !!interactive > 1)
973                 die("Only one of --include/--only/--all/--interactive can be used.");
974         if (argc == 0 && (also || (only && !amend)))
975                 die("No paths with --include/--only does not make sense.");
976         if (argc == 0 && only && amend)
977                 only_include_assumed = "Clever... amending the last one with dirty index.";
978         if (argc > 0 && !also && !only)
979                 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
980         if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
981                 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
982         else if (!strcmp(cleanup_arg, "verbatim"))
983                 cleanup_mode = CLEANUP_NONE;
984         else if (!strcmp(cleanup_arg, "whitespace"))
985                 cleanup_mode = CLEANUP_SPACE;
986         else if (!strcmp(cleanup_arg, "strip"))
987                 cleanup_mode = CLEANUP_ALL;
988         else
989                 die("Invalid cleanup mode %s", cleanup_arg);
990
991         handle_untracked_files_arg(s);
992
993         if (all && argc > 0)
994                 die("Paths with -a does not make sense.");
995         else if (interactive && argc > 0)
996                 die("Paths with --interactive does not make sense.");
997
998         if (null_termination && status_format == STATUS_FORMAT_LONG)
999                 status_format = STATUS_FORMAT_PORCELAIN;
1000         if (status_format != STATUS_FORMAT_LONG)
1001                 dry_run = 1;
1002
1003         return argc;
1004 }
1005
1006 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1007                           struct wt_status *s)
1008 {
1009         int commitable;
1010         const char *index_file;
1011
1012         index_file = prepare_index(argc, argv, prefix, 1);
1013         commitable = run_status(stdout, index_file, prefix, 0, s);
1014         rollback_index_files();
1015
1016         return commitable ? 0 : 1;
1017 }
1018
1019 static int parse_status_slot(const char *var, int offset)
1020 {
1021         if (!strcasecmp(var+offset, "header"))
1022                 return WT_STATUS_HEADER;
1023         if (!strcasecmp(var+offset, "branch"))
1024                 return WT_STATUS_ONBRANCH;
1025         if (!strcasecmp(var+offset, "updated")
1026                 || !strcasecmp(var+offset, "added"))
1027                 return WT_STATUS_UPDATED;
1028         if (!strcasecmp(var+offset, "changed"))
1029                 return WT_STATUS_CHANGED;
1030         if (!strcasecmp(var+offset, "untracked"))
1031                 return WT_STATUS_UNTRACKED;
1032         if (!strcasecmp(var+offset, "nobranch"))
1033                 return WT_STATUS_NOBRANCH;
1034         if (!strcasecmp(var+offset, "unmerged"))
1035                 return WT_STATUS_UNMERGED;
1036         return -1;
1037 }
1038
1039 static int git_status_config(const char *k, const char *v, void *cb)
1040 {
1041         struct wt_status *s = cb;
1042
1043         if (!strcmp(k, "status.submodulesummary")) {
1044                 int is_bool;
1045                 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1046                 if (is_bool && s->submodule_summary)
1047                         s->submodule_summary = -1;
1048                 return 0;
1049         }
1050         if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1051                 s->use_color = git_config_colorbool(k, v, -1);
1052                 return 0;
1053         }
1054         if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1055                 int slot = parse_status_slot(k, 13);
1056                 if (slot < 0)
1057                         return 0;
1058                 if (!v)
1059                         return config_error_nonbool(k);
1060                 color_parse(v, k, s->color_palette[slot]);
1061                 return 0;
1062         }
1063         if (!strcmp(k, "status.relativepaths")) {
1064                 s->relative_paths = git_config_bool(k, v);
1065                 return 0;
1066         }
1067         if (!strcmp(k, "status.showuntrackedfiles")) {
1068                 if (!v)
1069                         return config_error_nonbool(k);
1070                 else if (!strcmp(v, "no"))
1071                         s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1072                 else if (!strcmp(v, "normal"))
1073                         s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1074                 else if (!strcmp(v, "all"))
1075                         s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1076                 else
1077                         return error("Invalid untracked files mode '%s'", v);
1078                 return 0;
1079         }
1080         return git_diff_ui_config(k, v, NULL);
1081 }
1082
1083 int cmd_status(int argc, const char **argv, const char *prefix)
1084 {
1085         struct wt_status s;
1086         int fd;
1087         unsigned char sha1[20];
1088         static struct option builtin_status_options[] = {
1089                 OPT__VERBOSE(&verbose, "be verbose"),
1090                 OPT_SET_INT('s', "short", &status_format,
1091                             "show status concisely", STATUS_FORMAT_SHORT),
1092                 OPT_BOOLEAN('b', "branch", &status_show_branch,
1093                             "show branch information"),
1094                 OPT_SET_INT(0, "porcelain", &status_format,
1095                             "machine-readable output",
1096                             STATUS_FORMAT_PORCELAIN),
1097                 OPT_BOOLEAN('z', "null", &null_termination,
1098                             "terminate entries with NUL"),
1099                 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1100                   "mode",
1101                   "show untracked files, optional modes: all, normal, no. (Default: all)",
1102                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1103                 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1104                             "show ignored files"),
1105                 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1106                   "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1107                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1108                 OPT_END(),
1109         };
1110
1111         if (argc == 2 && !strcmp(argv[1], "-h"))
1112                 usage_with_options(builtin_status_usage, builtin_status_options);
1113
1114         if (null_termination && status_format == STATUS_FORMAT_LONG)
1115                 status_format = STATUS_FORMAT_PORCELAIN;
1116
1117         wt_status_prepare(&s);
1118         gitmodules_config();
1119         git_config(git_status_config, &s);
1120         in_merge = file_exists(git_path("MERGE_HEAD"));
1121         argc = parse_options(argc, argv, prefix,
1122                              builtin_status_options,
1123                              builtin_status_usage, 0);
1124         handle_untracked_files_arg(&s);
1125         if (show_ignored_in_status)
1126                 s.show_ignored_files = 1;
1127         if (*argv)
1128                 s.pathspec = get_pathspec(prefix, argv);
1129
1130         read_cache_preload(s.pathspec);
1131         refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1132
1133         fd = hold_locked_index(&index_lock, 0);
1134         if (0 <= fd)
1135                 update_index_if_able(&the_index, &index_lock);
1136
1137         s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1138         s.in_merge = in_merge;
1139         s.ignore_submodule_arg = ignore_submodule_arg;
1140         wt_status_collect(&s);
1141
1142         if (s.relative_paths)
1143                 s.prefix = prefix;
1144         if (s.use_color == -1)
1145                 s.use_color = git_use_color_default;
1146         if (diff_use_color_default == -1)
1147                 diff_use_color_default = git_use_color_default;
1148
1149         switch (status_format) {
1150         case STATUS_FORMAT_SHORT:
1151                 wt_shortstatus_print(&s, null_termination, status_show_branch);
1152                 break;
1153         case STATUS_FORMAT_PORCELAIN:
1154                 wt_porcelain_print(&s, null_termination);
1155                 break;
1156         case STATUS_FORMAT_LONG:
1157                 s.verbose = verbose;
1158                 s.ignore_submodule_arg = ignore_submodule_arg;
1159                 wt_status_print(&s);
1160                 break;
1161         }
1162         return 0;
1163 }
1164
1165 static void print_summary(const char *prefix, const unsigned char *sha1)
1166 {
1167         struct rev_info rev;
1168         struct commit *commit;
1169         struct strbuf format = STRBUF_INIT;
1170         unsigned char junk_sha1[20];
1171         const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1172         struct pretty_print_context pctx = {0};
1173         struct strbuf author_ident = STRBUF_INIT;
1174         struct strbuf committer_ident = STRBUF_INIT;
1175
1176         commit = lookup_commit(sha1);
1177         if (!commit)
1178                 die("couldn't look up newly created commit");
1179         if (!commit || parse_commit(commit))
1180                 die("could not parse newly created commit");
1181
1182         strbuf_addstr(&format, "format:%h] %s");
1183
1184         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1185         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1186         if (strbuf_cmp(&author_ident, &committer_ident)) {
1187                 strbuf_addstr(&format, "\n Author: ");
1188                 strbuf_addbuf_percentquote(&format, &author_ident);
1189         }
1190         if (!user_ident_sufficiently_given()) {
1191                 strbuf_addstr(&format, "\n Committer: ");
1192                 strbuf_addbuf_percentquote(&format, &committer_ident);
1193                 if (advice_implicit_identity) {
1194                         strbuf_addch(&format, '\n');
1195                         strbuf_addstr(&format, implicit_ident_advice);
1196                 }
1197         }
1198         strbuf_release(&author_ident);
1199         strbuf_release(&committer_ident);
1200
1201         init_revisions(&rev, prefix);
1202         setup_revisions(0, NULL, &rev, NULL);
1203
1204         rev.diff = 1;
1205         rev.diffopt.output_format =
1206                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1207
1208         rev.verbose_header = 1;
1209         rev.show_root_diff = 1;
1210         get_commit_format(format.buf, &rev);
1211         rev.always_show_header = 0;
1212         rev.diffopt.detect_rename = 1;
1213         rev.diffopt.rename_limit = 100;
1214         rev.diffopt.break_opt = 0;
1215         diff_setup_done(&rev.diffopt);
1216
1217         printf("[%s%s ",
1218                 !prefixcmp(head, "refs/heads/") ?
1219                         head + 11 :
1220                         !strcmp(head, "HEAD") ?
1221                                 "detached HEAD" :
1222                                 head,
1223                 initial_commit ? " (root-commit)" : "");
1224
1225         if (!log_tree_commit(&rev, commit)) {
1226                 rev.always_show_header = 1;
1227                 rev.use_terminator = 1;
1228                 log_tree_commit(&rev, commit);
1229         }
1230
1231         strbuf_release(&format);
1232 }
1233
1234 static int git_commit_config(const char *k, const char *v, void *cb)
1235 {
1236         struct wt_status *s = cb;
1237
1238         if (!strcmp(k, "commit.template"))
1239                 return git_config_pathname(&template_file, k, v);
1240         if (!strcmp(k, "commit.status")) {
1241                 include_status = git_config_bool(k, v);
1242                 return 0;
1243         }
1244
1245         return git_status_config(k, v, s);
1246 }
1247
1248 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1249
1250 static int run_rewrite_hook(const unsigned char *oldsha1,
1251                             const unsigned char *newsha1)
1252 {
1253         /* oldsha1 SP newsha1 LF NUL */
1254         static char buf[2*40 + 3];
1255         struct child_process proc;
1256         const char *argv[3];
1257         int code;
1258         size_t n;
1259
1260         if (access(git_path(post_rewrite_hook), X_OK) < 0)
1261                 return 0;
1262
1263         argv[0] = git_path(post_rewrite_hook);
1264         argv[1] = "amend";
1265         argv[2] = NULL;
1266
1267         memset(&proc, 0, sizeof(proc));
1268         proc.argv = argv;
1269         proc.in = -1;
1270         proc.stdout_to_stderr = 1;
1271
1272         code = start_command(&proc);
1273         if (code)
1274                 return code;
1275         n = snprintf(buf, sizeof(buf), "%s %s\n",
1276                      sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1277         write_in_full(proc.in, buf, n);
1278         close(proc.in);
1279         return finish_command(&proc);
1280 }
1281
1282 int cmd_commit(int argc, const char **argv, const char *prefix)
1283 {
1284         struct strbuf sb = STRBUF_INIT;
1285         struct strbuf author_ident = STRBUF_INIT;
1286         const char *index_file, *reflog_msg;
1287         char *nl, *p;
1288         unsigned char commit_sha1[20];
1289         struct ref_lock *ref_lock;
1290         struct commit_list *parents = NULL, **pptr = &parents;
1291         struct stat statbuf;
1292         int allow_fast_forward = 1;
1293         struct wt_status s;
1294
1295         if (argc == 2 && !strcmp(argv[1], "-h"))
1296                 usage_with_options(builtin_commit_usage, builtin_commit_options);
1297
1298         wt_status_prepare(&s);
1299         git_config(git_commit_config, &s);
1300         in_merge = file_exists(git_path("MERGE_HEAD"));
1301         s.in_merge = in_merge;
1302
1303         if (s.use_color == -1)
1304                 s.use_color = git_use_color_default;
1305         argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1306                                           prefix, &s);
1307         if (dry_run) {
1308                 if (diff_use_color_default == -1)
1309                         diff_use_color_default = git_use_color_default;
1310                 return dry_run_commit(argc, argv, prefix, &s);
1311         }
1312         index_file = prepare_index(argc, argv, prefix, 0);
1313
1314         /* Set up everything for writing the commit object.  This includes
1315            running hooks, writing the trees, and interacting with the user.  */
1316         if (!prepare_to_commit(index_file, prefix, &s, &author_ident)) {
1317                 rollback_index_files();
1318                 return 1;
1319         }
1320
1321         /* Determine parents */
1322         reflog_msg = getenv("GIT_REFLOG_ACTION");
1323         if (initial_commit) {
1324                 if (!reflog_msg)
1325                         reflog_msg = "commit (initial)";
1326         } else if (amend) {
1327                 struct commit_list *c;
1328                 struct commit *commit;
1329
1330                 if (!reflog_msg)
1331                         reflog_msg = "commit (amend)";
1332                 commit = lookup_commit(head_sha1);
1333                 if (!commit || parse_commit(commit))
1334                         die("could not parse HEAD commit");
1335
1336                 for (c = commit->parents; c; c = c->next)
1337                         pptr = &commit_list_insert(c->item, pptr)->next;
1338         } else if (in_merge) {
1339                 struct strbuf m = STRBUF_INIT;
1340                 FILE *fp;
1341
1342                 if (!reflog_msg)
1343                         reflog_msg = "commit (merge)";
1344                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1345                 fp = fopen(git_path("MERGE_HEAD"), "r");
1346                 if (fp == NULL)
1347                         die_errno("could not open '%s' for reading",
1348                                   git_path("MERGE_HEAD"));
1349                 while (strbuf_getline(&m, fp, '\n') != EOF) {
1350                         unsigned char sha1[20];
1351                         if (get_sha1_hex(m.buf, sha1) < 0)
1352                                 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1353                         pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1354                 }
1355                 fclose(fp);
1356                 strbuf_release(&m);
1357                 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1358                         if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1359                                 die_errno("could not read MERGE_MODE");
1360                         if (!strcmp(sb.buf, "no-ff"))
1361                                 allow_fast_forward = 0;
1362                 }
1363                 if (allow_fast_forward)
1364                         parents = reduce_heads(parents);
1365         } else {
1366                 if (!reflog_msg)
1367                         reflog_msg = "commit";
1368                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1369         }
1370
1371         /* Finally, get the commit message */
1372         strbuf_reset(&sb);
1373         if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1374                 int saved_errno = errno;
1375                 rollback_index_files();
1376                 die("could not read commit message: %s", strerror(saved_errno));
1377         }
1378
1379         /* Truncate the message just before the diff, if any. */
1380         if (verbose) {
1381                 p = strstr(sb.buf, "\ndiff --git ");
1382                 if (p != NULL)
1383                         strbuf_setlen(&sb, p - sb.buf + 1);
1384         }
1385
1386         if (cleanup_mode != CLEANUP_NONE)
1387                 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1388         if (message_is_empty(&sb) && !allow_empty_message) {
1389                 rollback_index_files();
1390                 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1391                 exit(1);
1392         }
1393
1394         if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1395                         author_ident.buf)) {
1396                 rollback_index_files();
1397                 die("failed to write commit object");
1398         }
1399         strbuf_release(&author_ident);
1400
1401         ref_lock = lock_any_ref_for_update("HEAD",
1402                                            initial_commit ? NULL : head_sha1,
1403                                            0);
1404
1405         nl = strchr(sb.buf, '\n');
1406         if (nl)
1407                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1408         else
1409                 strbuf_addch(&sb, '\n');
1410         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1411         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1412
1413         if (!ref_lock) {
1414                 rollback_index_files();
1415                 die("cannot lock HEAD ref");
1416         }
1417         if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1418                 rollback_index_files();
1419                 die("cannot update HEAD ref");
1420         }
1421
1422         unlink(git_path("MERGE_HEAD"));
1423         unlink(git_path("MERGE_MSG"));
1424         unlink(git_path("MERGE_MODE"));
1425         unlink(git_path("SQUASH_MSG"));
1426
1427         if (commit_index_files())
1428                 die ("Repository has been updated, but unable to write\n"
1429                      "new_index file. Check that disk is not full or quota is\n"
1430                      "not exceeded, and then \"git reset HEAD\" to recover.");
1431
1432         rerere(0);
1433         run_hook(get_index_file(), "post-commit", NULL);
1434         if (amend && !no_post_rewrite) {
1435                 struct notes_rewrite_cfg *cfg;
1436                 cfg = init_copy_notes_for_rewrite("amend");
1437                 if (cfg) {
1438                         copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1439                         finish_copy_notes_for_rewrite(cfg);
1440                 }
1441                 run_rewrite_hook(head_sha1, commit_sha1);
1442         }
1443         if (!quiet)
1444                 print_summary(prefix, commit_sha1);
1445
1446         return 0;
1447 }