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