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