builtin/commit.c

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