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, allow_empty_message;
  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 int show_ignored_in_status;
  87 static const char *only_include_assumed;
  88 static struct strbuf message;
  89
  90 static int null_termination;
  91 static enum {
  92         STATUS_FORMAT_LONG,
  93         STATUS_FORMAT_SHORT,
  94         STATUS_FORMAT_PORCELAIN,
  95 } status_format = STATUS_FORMAT_LONG;
  96 static int status_show_branch;
  97
  98 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
  99 {
 100         struct strbuf *buf = opt->value;
 101         if (unset)
 102                 strbuf_setlen(buf, 0);
 103         else {
 104                 strbuf_addstr(buf, arg);
 105                 strbuf_addstr(buf, "\n\n");
 106         }
 107         return 0;
 108 }
 109
 110 static struct option builtin_commit_options[] = {
 111         OPT__QUIET(&quiet),
 112         OPT__VERBOSE(&verbose),
 113
 114         OPT_GROUP("Commit message options"),
 115         OPT_FILENAME('F', "file", &logfile, "read log from file"),
 116         OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
 117         OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
 118         OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
 119         OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
 120         OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
 121         OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
 122         OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
 123         OPT_FILENAME('t', "template", &template_file, "use specified template file"),
 124         OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
 125         OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
 126         OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
 127         /* end commit message options */
 128
 129         OPT_GROUP("Commit contents options"),
 130         OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
 131         OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
 132         OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
 133         OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
 134         OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
 135         OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
 136         OPT_SET_INT(0, "short", &status_format, "show status concisely",
 137                     STATUS_FORMAT_SHORT),
 138         OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
 139         OPT_SET_INT(0, "porcelain", &status_format,
 140                     "show porcelain output format", STATUS_FORMAT_PORCELAIN),
 141         OPT_BOOLEAN('z', "null", &null_termination,
 142                     "terminate entries with NUL"),
 143         OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
 144         OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
 145         { 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" },
 146         /* end commit contents options */
 147
 148         { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
 149           "ok to record an empty change",
 150           PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 151         { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
 152           "ok to record a change with an empty message",
 153           PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 154
 155         OPT_END()
 156 };
 157
 158 static void rollback_index_files(void)
 159 {
 160         switch (commit_style) {
 161         case COMMIT_AS_IS:
 162                 break; /* nothing to do */
 163         case COMMIT_NORMAL:
 164                 rollback_lock_file(&index_lock);
 165                 break;
 166         case COMMIT_PARTIAL:
 167                 rollback_lock_file(&index_lock);
 168                 rollback_lock_file(&false_lock);
 169                 break;
 170         }
 171 }
 172
 173 static int commit_index_files(void)
 174 {
 175         int err = 0;
 176
 177         switch (commit_style) {
 178         case COMMIT_AS_IS:
 179                 break; /* nothing to do */
 180         case COMMIT_NORMAL:
 181                 err = commit_lock_file(&index_lock);
 182                 break;
 183         case COMMIT_PARTIAL:
 184                 err = commit_lock_file(&index_lock);
 185                 rollback_lock_file(&false_lock);
 186                 break;
 187         }
 188
 189         return err;
 190 }
 191
 192 /*
 193  * Take a union of paths in the index and the named tree (typically, "HEAD"),
 194  * and return the paths that match the given pattern in list.
 195  */
 196 static int list_paths(struct string_list *list, const char *with_tree,
 197                       const char *prefix, const char **pattern)
 198 {
 199         int i;
 200         char *m;
 201
 202         for (i = 0; pattern[i]; i++)
 203                 ;
 204         m = xcalloc(1, i);
 205
 206         if (with_tree)
 207                 overlay_tree_on_cache(with_tree, prefix);
 208
 209         for (i = 0; i < active_nr; i++) {
 210                 struct cache_entry *ce = active_cache[i];
 211                 struct string_list_item *item;
 212
 213                 if (ce->ce_flags & CE_UPDATE)
 214                         continue;
 215                 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
 216                         continue;
 217                 item = string_list_insert(ce->name, list);
 218                 if (ce_skip_worktree(ce))
 219                         item->util = item; /* better a valid pointer than a fake one */
 220         }
 221
 222         return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
 223 }
 224
 225 static void add_remove_files(struct string_list *list)
 226 {
 227         int i;
 228         for (i = 0; i < list->nr; i++) {
 229                 struct stat st;
 230                 struct string_list_item *p = &(list->items[i]);
 231
 232                 /* p->util is skip-worktree */
 233                 if (p->util)
 234                         continue;
 235
 236                 if (!lstat(p->string, &st)) {
 237                         if (add_to_cache(p->string, &st, 0))
 238                                 die("updating files failed");
 239                 } else
 240                         remove_file_from_cache(p->string);
 241         }
 242 }
 243
 244 static void create_base_index(void)
 245 {
 246         struct tree *tree;
 247         struct unpack_trees_options opts;
 248         struct tree_desc t;
 249
 250         if (initial_commit) {
 251                 discard_cache();
 252                 return;
 253         }
 254
 255         memset(&opts, 0, sizeof(opts));
 256         opts.head_idx = 1;
 257         opts.index_only = 1;
 258         opts.merge = 1;
 259         opts.src_index = &the_index;
 260         opts.dst_index = &the_index;
 261
 262         opts.fn = oneway_merge;
 263         tree = parse_tree_indirect(head_sha1);
 264         if (!tree)
 265                 die("failed to unpack HEAD tree object");
 266         parse_tree(tree);
 267         init_tree_desc(&t, tree->buffer, tree->size);
 268         if (unpack_trees(1, &t, &opts))
 269                 exit(128); /* We've already reported the error, finish dying */
 270 }
 271
 272 static void refresh_cache_or_die(int refresh_flags)
 273 {
 274         /*
 275          * refresh_flags contains REFRESH_QUIET, so the only errors
 276          * are for unmerged entries.
 277          */
 278         if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
 279                 die_resolve_conflict("commit");
 280 }
 281
 282 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
 283 {
 284         int fd;
 285         struct string_list partial;
 286         const char **pathspec = NULL;
 287         int refresh_flags = REFRESH_QUIET;
 288
 289         if (is_status)
 290                 refresh_flags |= REFRESH_UNMERGED;
 291         if (interactive) {
 292                 if (interactive_add(argc, argv, prefix) != 0)
 293                         die("interactive add failed");
 294                 if (read_cache_preload(NULL) < 0)
 295                         die("index file corrupt");
 296                 commit_style = COMMIT_AS_IS;
 297                 return get_index_file();
 298         }
 299
 300         if (*argv)
 301                 pathspec = get_pathspec(prefix, argv);
 302
 303         if (read_cache_preload(pathspec) < 0)
 304                 die("index file corrupt");
 305
 306         /*
 307          * Non partial, non as-is commit.
 308          *
 309          * (1) get the real index;
 310          * (2) update the_index as necessary;
 311          * (3) write the_index out to the real index (still locked);
 312          * (4) return the name of the locked index file.
 313          *
 314          * The caller should run hooks on the locked real index, and
 315          * (A) if all goes well, commit the real index;
 316          * (B) on failure, rollback the real index.
 317          */
 318         if (all || (also && pathspec && *pathspec)) {
 319                 fd = hold_locked_index(&index_lock, 1);
 320                 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
 321                 refresh_cache_or_die(refresh_flags);
 322                 if (write_cache(fd, active_cache, active_nr) ||
 323                     close_lock_file(&index_lock))
 324                         die("unable to write new_index file");
 325                 commit_style = COMMIT_NORMAL;
 326                 return index_lock.filename;
 327         }
 328
 329         /*
 330          * As-is commit.
 331          *
 332          * (1) return the name of the real index file.
 333          *
 334          * The caller should run hooks on the real index,
 335          * and create commit from the_index.
 336          * We still need to refresh the index here.
 337          */
 338         if (!pathspec || !*pathspec) {
 339                 fd = hold_locked_index(&index_lock, 1);
 340                 refresh_cache_or_die(refresh_flags);
 341                 if (write_cache(fd, active_cache, active_nr) ||
 342                     commit_locked_index(&index_lock))
 343                         die("unable to write new_index file");
 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, status_show_branch);
 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                 return 0;
 712         }
 713
 714         /*
 715          * Re-read the index as pre-commit hook could have updated it,
 716          * and write it out as a tree.  We must do this before we invoke
 717          * the editor and after we invoke run_status above.
 718          */
 719         discard_cache();
 720         read_cache_from(index_file);
 721         if (!active_cache_tree)
 722                 active_cache_tree = cache_tree();
 723         if (cache_tree_update(active_cache_tree,
 724                               active_cache, active_nr, 0, 0) < 0) {
 725                 error("Error building trees");
 726                 return 0;
 727         }
 728
 729         if (run_hook(index_file, "prepare-commit-msg",
 730                      git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
 731                 return 0;
 732
 733         if (use_editor) {
 734                 char index[PATH_MAX];
 735                 const char *env[2] = { index, NULL };
 736                 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
 737                 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
 738                         fprintf(stderr,
 739                         "Please supply the message using either -m or -F option.\n");
 740                         exit(1);
 741                 }
 742         }
 743
 744         if (!no_verify &&
 745             run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
 746                 return 0;
 747         }
 748
 749         return 1;
 750 }
 751
 752 /*
 753  * Find out if the message in the strbuf contains only whitespace and
 754  * Signed-off-by lines.
 755  */
 756 static int message_is_empty(struct strbuf *sb)
 757 {
 758         struct strbuf tmpl = STRBUF_INIT;
 759         const char *nl;
 760         int eol, i, start = 0;
 761
 762         if (cleanup_mode == CLEANUP_NONE && sb->len)
 763                 return 0;
 764
 765         /* See if the template is just a prefix of the message. */
 766         if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
 767                 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
 768                 if (start + tmpl.len <= sb->len &&
 769                     memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
 770                         start += tmpl.len;
 771         }
 772         strbuf_release(&tmpl);
 773
 774         /* Check if the rest is just whitespace and Signed-of-by's. */
 775         for (i = start; i < sb->len; i++) {
 776                 nl = memchr(sb->buf + i, '\n', sb->len - i);
 777                 if (nl)
 778                         eol = nl - sb->buf;
 779                 else
 780                         eol = sb->len;
 781
 782                 if (strlen(sign_off_header) <= eol - i &&
 783                     !prefixcmp(sb->buf + i, sign_off_header)) {
 784                         i = eol;
 785                         continue;
 786                 }
 787                 while (i < eol)
 788                         if (!isspace(sb->buf[i++]))
 789                                 return 0;
 790         }
 791
 792         return 1;
 793 }
 794
 795 static const char *find_author_by_nickname(const char *name)
 796 {
 797         struct rev_info revs;
 798         struct commit *commit;
 799         struct strbuf buf = STRBUF_INIT;
 800         const char *av[20];
 801         int ac = 0;
 802
 803         init_revisions(&revs, NULL);
 804         strbuf_addf(&buf, "--author=%s", name);
 805         av[++ac] = "--all";
 806         av[++ac] = "-i";
 807         av[++ac] = buf.buf;
 808         av[++ac] = NULL;
 809         setup_revisions(ac, av, &revs, NULL);
 810         prepare_revision_walk(&revs);
 811         commit = get_revision(&revs);
 812         if (commit) {
 813                 struct pretty_print_context ctx = {0};
 814                 ctx.date_mode = DATE_NORMAL;
 815                 strbuf_release(&buf);
 816                 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
 817                 return strbuf_detach(&buf, NULL);
 818         }
 819         die("No existing author found with '%s'", name);
 820 }
 821
 822
 823 static void handle_untracked_files_arg(struct wt_status *s)
 824 {
 825         if (!untracked_files_arg)
 826                 ; /* default already initialized */
 827         else if (!strcmp(untracked_files_arg, "no"))
 828                 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
 829         else if (!strcmp(untracked_files_arg, "normal"))
 830                 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
 831         else if (!strcmp(untracked_files_arg, "all"))
 832                 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
 833         else
 834                 die("Invalid untracked files mode '%s'", untracked_files_arg);
 835 }
 836
 837 static int parse_and_validate_options(int argc, const char *argv[],
 838                                       const char * const usage[],
 839                                       const char *prefix,
 840                                       struct wt_status *s)
 841 {
 842         int f = 0;
 843
 844         argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
 845                              0);
 846
 847         if (force_author && !strchr(force_author, '>'))
 848                 force_author = find_author_by_nickname(force_author);
 849
 850         if (force_author && renew_authorship)
 851                 die("Using both --reset-author and --author does not make sense");
 852
 853         if (logfile || message.len || use_message)
 854                 use_editor = 0;
 855         if (edit_flag)
 856                 use_editor = 1;
 857         if (!use_editor)
 858                 setenv("GIT_EDITOR", ":", 1);
 859
 860         if (get_sha1("HEAD", head_sha1))
 861                 initial_commit = 1;
 862
 863         /* Sanity check options */
 864         if (amend && initial_commit)
 865                 die("You have nothing to amend.");
 866         if (amend && in_merge)
 867                 die("You are in the middle of a merge -- cannot amend.");
 868
 869         if (use_message)
 870                 f++;
 871         if (edit_message)
 872                 f++;
 873         if (logfile)
 874                 f++;
 875         if (f > 1)
 876                 die("Only one of -c/-C/-F can be used.");
 877         if (message.len && f > 0)
 878                 die("Option -m cannot be combined with -c/-C/-F.");
 879         if (edit_message)
 880                 use_message = edit_message;
 881         if (amend && !use_message)
 882                 use_message = "HEAD";
 883         if (!use_message && renew_authorship)
 884                 die("--reset-author can be used only with -C, -c or --amend.");
 885         if (use_message) {
 886                 unsigned char sha1[20];
 887                 static char utf8[] = "UTF-8";
 888                 const char *out_enc;
 889                 char *enc, *end;
 890                 struct commit *commit;
 891
 892                 if (get_sha1(use_message, sha1))
 893                         die("could not lookup commit %s", use_message);
 894                 commit = lookup_commit_reference(sha1);
 895                 if (!commit || parse_commit(commit))
 896                         die("could not parse commit %s", use_message);
 897
 898                 enc = strstr(commit->buffer, "\nencoding");
 899                 if (enc) {
 900                         end = strchr(enc + 10, '\n');
 901                         enc = xstrndup(enc + 10, end - (enc + 10));
 902                 } else {
 903                         enc = utf8;
 904                 }
 905                 out_enc = git_commit_encoding ? git_commit_encoding : utf8;
 906
 907                 if (strcmp(out_enc, enc))
 908                         use_message_buffer =
 909                                 reencode_string(commit->buffer, out_enc, enc);
 910
 911                 /*
 912                  * If we failed to reencode the buffer, just copy it
 913                  * byte for byte so the user can try to fix it up.
 914                  * This also handles the case where input and output
 915                  * encodings are identical.
 916                  */
 917                 if (use_message_buffer == NULL)
 918                         use_message_buffer = xstrdup(commit->buffer);
 919                 if (enc != utf8)
 920                         free(enc);
 921         }
 922
 923         if (!!also + !!only + !!all + !!interactive > 1)
 924                 die("Only one of --include/--only/--all/--interactive can be used.");
 925         if (argc == 0 && (also || (only && !amend)))
 926                 die("No paths with --include/--only does not make sense.");
 927         if (argc == 0 && only && amend)
 928                 only_include_assumed = "Clever... amending the last one with dirty index.";
 929         if (argc > 0 && !also && !only)
 930                 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
 931         if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
 932                 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
 933         else if (!strcmp(cleanup_arg, "verbatim"))
 934                 cleanup_mode = CLEANUP_NONE;
 935         else if (!strcmp(cleanup_arg, "whitespace"))
 936                 cleanup_mode = CLEANUP_SPACE;
 937         else if (!strcmp(cleanup_arg, "strip"))
 938                 cleanup_mode = CLEANUP_ALL;
 939         else
 940                 die("Invalid cleanup mode %s", cleanup_arg);
 941
 942         handle_untracked_files_arg(s);
 943
 944         if (all && argc > 0)
 945                 die("Paths with -a does not make sense.");
 946         else if (interactive && argc > 0)
 947                 die("Paths with --interactive does not make sense.");
 948
 949         if (null_termination && status_format == STATUS_FORMAT_LONG)
 950                 status_format = STATUS_FORMAT_PORCELAIN;
 951         if (status_format != STATUS_FORMAT_LONG)
 952                 dry_run = 1;
 953
 954         return argc;
 955 }
 956
 957 static int dry_run_commit(int argc, const char **argv, const char *prefix,
 958                           struct wt_status *s)
 959 {
 960         int commitable;
 961         const char *index_file;
 962
 963         index_file = prepare_index(argc, argv, prefix, 1);
 964         commitable = run_status(stdout, index_file, prefix, 0, s);
 965         rollback_index_files();
 966
 967         return commitable ? 0 : 1;
 968 }
 969
 970 static int parse_status_slot(const char *var, int offset)
 971 {
 972         if (!strcasecmp(var+offset, "header"))
 973                 return WT_STATUS_HEADER;
 974         if (!strcasecmp(var+offset, "updated")
 975                 || !strcasecmp(var+offset, "added"))
 976                 return WT_STATUS_UPDATED;
 977         if (!strcasecmp(var+offset, "changed"))
 978                 return WT_STATUS_CHANGED;
 979         if (!strcasecmp(var+offset, "untracked"))
 980                 return WT_STATUS_UNTRACKED;
 981         if (!strcasecmp(var+offset, "nobranch"))
 982                 return WT_STATUS_NOBRANCH;
 983         if (!strcasecmp(var+offset, "unmerged"))
 984                 return WT_STATUS_UNMERGED;
 985         return -1;
 986 }
 987
 988 static int git_status_config(const char *k, const char *v, void *cb)
 989 {
 990         struct wt_status *s = cb;
 991
 992         if (!strcmp(k, "status.submodulesummary")) {
 993                 int is_bool;
 994                 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
 995                 if (is_bool && s->submodule_summary)
 996                         s->submodule_summary = -1;
 997                 return 0;
 998         }
 999         if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1000                 s->use_color = git_config_colorbool(k, v, -1);
1001                 return 0;
1002         }
1003         if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1004                 int slot = parse_status_slot(k, 13);
1005                 if (slot < 0)
1006                         return 0;
1007                 if (!v)
1008                         return config_error_nonbool(k);
1009                 color_parse(v, k, s->color_palette[slot]);
1010                 return 0;
1011         }
1012         if (!strcmp(k, "status.relativepaths")) {
1013                 s->relative_paths = git_config_bool(k, v);
1014                 return 0;
1015         }
1016         if (!strcmp(k, "status.showuntrackedfiles")) {
1017                 if (!v)
1018                         return config_error_nonbool(k);
1019                 else if (!strcmp(v, "no"))
1020                         s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1021                 else if (!strcmp(v, "normal"))
1022                         s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1023                 else if (!strcmp(v, "all"))
1024                         s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1025                 else
1026                         return error("Invalid untracked files mode '%s'", v);
1027                 return 0;
1028         }
1029         return git_diff_ui_config(k, v, NULL);
1030 }
1031
1032 int cmd_status(int argc, const char **argv, const char *prefix)
1033 {
1034         struct wt_status s;
1035         int fd;
1036         unsigned char sha1[20];
1037         static struct option builtin_status_options[] = {
1038                 OPT__VERBOSE(&verbose),
1039                 OPT_SET_INT('s', "short", &status_format,
1040                             "show status concisely", STATUS_FORMAT_SHORT),
1041                 OPT_BOOLEAN('b', "branch", &status_show_branch,
1042                             "show branch information"),
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_BOOLEAN(0, "ignored", &show_ignored_in_status,
1053                             "show ignored files"),
1054                 OPT_END(),
1055         };
1056
1057         if (null_termination && status_format == STATUS_FORMAT_LONG)
1058                 status_format = STATUS_FORMAT_PORCELAIN;
1059
1060         wt_status_prepare(&s);
1061         git_config(git_status_config, &s);
1062         in_merge = file_exists(git_path("MERGE_HEAD"));
1063         argc = parse_options(argc, argv, prefix,
1064                              builtin_status_options,
1065                              builtin_status_usage, 0);
1066         handle_untracked_files_arg(&s);
1067         if (show_ignored_in_status)
1068                 s.show_ignored_files = 1;
1069         if (*argv)
1070                 s.pathspec = get_pathspec(prefix, argv);
1071
1072         read_cache_preload(s.pathspec);
1073         refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1074
1075         fd = hold_locked_index(&index_lock, 0);
1076         if (0 <= fd) {
1077                 if (!write_cache(fd, active_cache, active_nr))
1078                         commit_locked_index(&index_lock);
1079                 rollback_lock_file(&index_lock);
1080         }
1081
1082         s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1083         s.in_merge = in_merge;
1084         wt_status_collect(&s);
1085
1086         if (s.relative_paths)
1087                 s.prefix = prefix;
1088         if (s.use_color == -1)
1089                 s.use_color = git_use_color_default;
1090         if (diff_use_color_default == -1)
1091                 diff_use_color_default = git_use_color_default;
1092
1093         switch (status_format) {
1094         case STATUS_FORMAT_SHORT:
1095                 wt_shortstatus_print(&s, null_termination, status_show_branch);
1096                 break;
1097         case STATUS_FORMAT_PORCELAIN:
1098                 wt_porcelain_print(&s, null_termination);
1099                 break;
1100         case STATUS_FORMAT_LONG:
1101                 s.verbose = verbose;
1102                 wt_status_print(&s);
1103                 break;
1104         }
1105         return 0;
1106 }
1107
1108 static void print_summary(const char *prefix, const unsigned char *sha1)
1109 {
1110         struct rev_info rev;
1111         struct commit *commit;
1112         struct strbuf format = STRBUF_INIT;
1113         unsigned char junk_sha1[20];
1114         const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1115         struct pretty_print_context pctx = {0};
1116         struct strbuf author_ident = STRBUF_INIT;
1117         struct strbuf committer_ident = STRBUF_INIT;
1118
1119         commit = lookup_commit(sha1);
1120         if (!commit)
1121                 die("couldn't look up newly created commit");
1122         if (!commit || parse_commit(commit))
1123                 die("could not parse newly created commit");
1124
1125         strbuf_addstr(&format, "format:%h] %s");
1126
1127         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1128         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1129         if (strbuf_cmp(&author_ident, &committer_ident)) {
1130                 strbuf_addstr(&format, "\n Author: ");
1131                 strbuf_addbuf_percentquote(&format, &author_ident);
1132         }
1133         if (!user_ident_sufficiently_given()) {
1134                 strbuf_addstr(&format, "\n Committer: ");
1135                 strbuf_addbuf_percentquote(&format, &committer_ident);
1136                 if (advice_implicit_identity) {
1137                         strbuf_addch(&format, '\n');
1138                         strbuf_addstr(&format, implicit_ident_advice);
1139                 }
1140         }
1141         strbuf_release(&author_ident);
1142         strbuf_release(&committer_ident);
1143
1144         init_revisions(&rev, prefix);
1145         setup_revisions(0, NULL, &rev, NULL);
1146
1147         rev.abbrev = 0;
1148         rev.diff = 1;
1149         rev.diffopt.output_format =
1150                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1151
1152         rev.verbose_header = 1;
1153         rev.show_root_diff = 1;
1154         get_commit_format(format.buf, &rev);
1155         rev.always_show_header = 0;
1156         rev.diffopt.detect_rename = 1;
1157         rev.diffopt.rename_limit = 100;
1158         rev.diffopt.break_opt = 0;
1159         diff_setup_done(&rev.diffopt);
1160
1161         printf("[%s%s ",
1162                 !prefixcmp(head, "refs/heads/") ?
1163                         head + 11 :
1164                         !strcmp(head, "HEAD") ?
1165                                 "detached HEAD" :
1166                                 head,
1167                 initial_commit ? " (root-commit)" : "");
1168
1169         if (!log_tree_commit(&rev, commit)) {
1170                 struct pretty_print_context ctx = {0};
1171                 struct strbuf buf = STRBUF_INIT;
1172                 ctx.date_mode = DATE_NORMAL;
1173                 format_commit_message(commit, format.buf + 7, &buf, &ctx);
1174                 printf("%s\n", buf.buf);
1175                 strbuf_release(&buf);
1176         }
1177         strbuf_release(&format);
1178 }
1179
1180 static int git_commit_config(const char *k, const char *v, void *cb)
1181 {
1182         struct wt_status *s = cb;
1183
1184         if (!strcmp(k, "commit.template"))
1185                 return git_config_pathname(&template_file, k, v);
1186         if (!strcmp(k, "commit.status")) {
1187                 include_status = git_config_bool(k, v);
1188                 return 0;
1189         }
1190
1191         return git_status_config(k, v, s);
1192 }
1193
1194 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1195
1196 static int run_rewrite_hook(const unsigned char *oldsha1,
1197                             const unsigned char *newsha1)
1198 {
1199         /* oldsha1 SP newsha1 LF NUL */
1200         static char buf[2*40 + 3];
1201         struct child_process proc;
1202         const char *argv[3];
1203         int code;
1204         size_t n;
1205
1206         if (access(git_path(post_rewrite_hook), X_OK) < 0)
1207                 return 0;
1208
1209         argv[0] = git_path(post_rewrite_hook);
1210         argv[1] = "amend";
1211         argv[2] = NULL;
1212
1213         memset(&proc, 0, sizeof(proc));
1214         proc.argv = argv;
1215         proc.in = -1;
1216         proc.stdout_to_stderr = 1;
1217
1218         code = start_command(&proc);
1219         if (code)
1220                 return code;
1221         n = snprintf(buf, sizeof(buf), "%s %s\n",
1222                      sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1223         write_in_full(proc.in, buf, n);
1224         close(proc.in);
1225         return finish_command(&proc);
1226 }
1227
1228 int cmd_commit(int argc, const char **argv, const char *prefix)
1229 {
1230         struct strbuf sb = STRBUF_INIT;
1231         const char *index_file, *reflog_msg;
1232         char *nl, *p;
1233         unsigned char commit_sha1[20];
1234         struct ref_lock *ref_lock;
1235         struct commit_list *parents = NULL, **pptr = &parents;
1236         struct stat statbuf;
1237         int allow_fast_forward = 1;
1238         struct wt_status s;
1239
1240         wt_status_prepare(&s);
1241         git_config(git_commit_config, &s);
1242         in_merge = file_exists(git_path("MERGE_HEAD"));
1243         s.in_merge = in_merge;
1244
1245         if (s.use_color == -1)
1246                 s.use_color = git_use_color_default;
1247         argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1248                                           prefix, &s);
1249         if (dry_run) {
1250                 if (diff_use_color_default == -1)
1251                         diff_use_color_default = git_use_color_default;
1252                 return dry_run_commit(argc, argv, prefix, &s);
1253         }
1254         index_file = prepare_index(argc, argv, prefix, 0);
1255
1256         /* Set up everything for writing the commit object.  This includes
1257            running hooks, writing the trees, and interacting with the user.  */
1258         if (!prepare_to_commit(index_file, prefix, &s)) {
1259                 rollback_index_files();
1260                 return 1;
1261         }
1262
1263         /* Determine parents */
1264         if (initial_commit) {
1265                 reflog_msg = "commit (initial)";
1266         } else if (amend) {
1267                 struct commit_list *c;
1268                 struct commit *commit;
1269
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                 reflog_msg = "commit (merge)";
1282                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1283                 fp = fopen(git_path("MERGE_HEAD"), "r");
1284                 if (fp == NULL)
1285                         die_errno("could not open '%s' for reading",
1286                                   git_path("MERGE_HEAD"));
1287                 while (strbuf_getline(&m, fp, '\n') != EOF) {
1288                         unsigned char sha1[20];
1289                         if (get_sha1_hex(m.buf, sha1) < 0)
1290                                 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1291                         pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1292                 }
1293                 fclose(fp);
1294                 strbuf_release(&m);
1295                 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1296                         if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1297                                 die_errno("could not read MERGE_MODE");
1298                         if (!strcmp(sb.buf, "no-ff"))
1299                                 allow_fast_forward = 0;
1300                 }
1301                 if (allow_fast_forward)
1302                         parents = reduce_heads(parents);
1303         } else {
1304                 reflog_msg = "commit";
1305                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1306         }
1307
1308         /* Finally, get the commit message */
1309         strbuf_reset(&sb);
1310         if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1311                 int saved_errno = errno;
1312                 rollback_index_files();
1313                 die("could not read commit message: %s", strerror(saved_errno));
1314         }
1315
1316         /* Truncate the message just before the diff, if any. */
1317         if (verbose) {
1318                 p = strstr(sb.buf, "\ndiff --git ");
1319                 if (p != NULL)
1320                         strbuf_setlen(&sb, p - sb.buf + 1);
1321         }
1322
1323         if (cleanup_mode != CLEANUP_NONE)
1324                 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1325         if (message_is_empty(&sb) && !allow_empty_message) {
1326                 rollback_index_files();
1327                 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1328                 exit(1);
1329         }
1330
1331         if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1332                         fmt_ident(author_name, author_email, author_date,
1333                                 IDENT_ERROR_ON_NO_NAME))) {
1334                 rollback_index_files();
1335                 die("failed to write commit object");
1336         }
1337
1338         ref_lock = lock_any_ref_for_update("HEAD",
1339                                            initial_commit ? NULL : head_sha1,
1340                                            0);
1341
1342         nl = strchr(sb.buf, '\n');
1343         if (nl)
1344                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1345         else
1346                 strbuf_addch(&sb, '\n');
1347         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1348         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1349
1350         if (!ref_lock) {
1351                 rollback_index_files();
1352                 die("cannot lock HEAD ref");
1353         }
1354         if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1355                 rollback_index_files();
1356                 die("cannot update HEAD ref");
1357         }
1358
1359         unlink(git_path("MERGE_HEAD"));
1360         unlink(git_path("MERGE_MSG"));
1361         unlink(git_path("MERGE_MODE"));
1362         unlink(git_path("SQUASH_MSG"));
1363
1364         if (commit_index_files())
1365                 die ("Repository has been updated, but unable to write\n"
1366                      "new_index file. Check that disk is not full or quota is\n"
1367                      "not exceeded, and then \"git reset HEAD\" to recover.");
1368
1369         rerere(0);
1370         run_hook(get_index_file(), "post-commit", NULL);
1371         if (amend && !no_post_rewrite) {
1372                 struct notes_rewrite_cfg *cfg;
1373                 cfg = init_copy_notes_for_rewrite("amend");
1374                 if (cfg) {
1375                         copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1376                         finish_copy_notes_for_rewrite(cfg);
1377                 }
1378                 run_rewrite_hook(head_sha1, commit_sha1);
1379         }
1380         if (!quiet)
1381                 print_summary(prefix, commit_sha1);
1382
1383         return 0;
1384 }