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