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, "updated")
1015                 || !strcasecmp(var+offset, "added"))
1016                 return WT_STATUS_UPDATED;
1017         if (!strcasecmp(var+offset, "changed"))
1018                 return WT_STATUS_CHANGED;
1019         if (!strcasecmp(var+offset, "untracked"))
1020                 return WT_STATUS_UNTRACKED;
1021         if (!strcasecmp(var+offset, "nobranch"))
1022                 return WT_STATUS_NOBRANCH;
1023         if (!strcasecmp(var+offset, "unmerged"))
1024                 return WT_STATUS_UNMERGED;
1025         return -1;
1026 }
1027
1028 static int git_status_config(const char *k, const char *v, void *cb)
1029 {
1030         struct wt_status *s = cb;
1031
1032         if (!strcmp(k, "status.submodulesummary")) {
1033                 int is_bool;
1034                 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1035                 if (is_bool && s->submodule_summary)
1036                         s->submodule_summary = -1;
1037                 return 0;
1038         }
1039         if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1040                 s->use_color = git_config_colorbool(k, v, -1);
1041                 return 0;
1042         }
1043         if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1044                 int slot = parse_status_slot(k, 13);
1045                 if (slot < 0)
1046                         return 0;
1047                 if (!v)
1048                         return config_error_nonbool(k);
1049                 color_parse(v, k, s->color_palette[slot]);
1050                 return 0;
1051         }
1052         if (!strcmp(k, "status.relativepaths")) {
1053                 s->relative_paths = git_config_bool(k, v);
1054                 return 0;
1055         }
1056         if (!strcmp(k, "status.showuntrackedfiles")) {
1057                 if (!v)
1058                         return config_error_nonbool(k);
1059                 else if (!strcmp(v, "no"))
1060                         s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1061                 else if (!strcmp(v, "normal"))
1062                         s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1063                 else if (!strcmp(v, "all"))
1064                         s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1065                 else
1066                         return error("Invalid untracked files mode '%s'", v);
1067                 return 0;
1068         }
1069         return git_diff_ui_config(k, v, NULL);
1070 }
1071
1072 int cmd_status(int argc, const char **argv, const char *prefix)
1073 {
1074         struct wt_status s;
1075         int fd;
1076         unsigned char sha1[20];
1077         static struct option builtin_status_options[] = {
1078                 OPT__VERBOSE(&verbose, "be verbose"),
1079                 OPT_SET_INT('s', "short", &status_format,
1080                             "show status concisely", STATUS_FORMAT_SHORT),
1081                 OPT_BOOLEAN('b', "branch", &status_show_branch,
1082                             "show branch information"),
1083                 OPT_SET_INT(0, "porcelain", &status_format,
1084                             "show porcelain output format",
1085                             STATUS_FORMAT_PORCELAIN),
1086                 OPT_BOOLEAN('z', "null", &null_termination,
1087                             "terminate entries with NUL"),
1088                 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1089                   "mode",
1090                   "show untracked files, optional modes: all, normal, no. (Default: all)",
1091                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1092                 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1093                             "show ignored files"),
1094                 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1095                   "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1096                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1097                 OPT_END(),
1098         };
1099
1100         if (null_termination && status_format == STATUS_FORMAT_LONG)
1101                 status_format = STATUS_FORMAT_PORCELAIN;
1102
1103         wt_status_prepare(&s);
1104         gitmodules_config();
1105         git_config(git_status_config, &s);
1106         in_merge = file_exists(git_path("MERGE_HEAD"));
1107         argc = parse_options(argc, argv, prefix,
1108                              builtin_status_options,
1109                              builtin_status_usage, 0);
1110         handle_untracked_files_arg(&s);
1111         if (show_ignored_in_status)
1112                 s.show_ignored_files = 1;
1113         if (*argv)
1114                 s.pathspec = get_pathspec(prefix, argv);
1115
1116         read_cache_preload(s.pathspec);
1117         refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1118
1119         fd = hold_locked_index(&index_lock, 0);
1120         if (0 <= fd) {
1121                 if (active_cache_changed &&
1122                     !write_cache(fd, active_cache, active_nr))
1123                         commit_locked_index(&index_lock);
1124                 else
1125                         rollback_lock_file(&index_lock);
1126         }
1127
1128         s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1129         s.in_merge = in_merge;
1130         s.ignore_submodule_arg = ignore_submodule_arg;
1131         wt_status_collect(&s);
1132
1133         if (s.relative_paths)
1134                 s.prefix = prefix;
1135         if (s.use_color == -1)
1136                 s.use_color = git_use_color_default;
1137         if (diff_use_color_default == -1)
1138                 diff_use_color_default = git_use_color_default;
1139
1140         switch (status_format) {
1141         case STATUS_FORMAT_SHORT:
1142                 wt_shortstatus_print(&s, null_termination, status_show_branch);
1143                 break;
1144         case STATUS_FORMAT_PORCELAIN:
1145                 wt_porcelain_print(&s, null_termination);
1146                 break;
1147         case STATUS_FORMAT_LONG:
1148                 s.verbose = verbose;
1149                 s.ignore_submodule_arg = ignore_submodule_arg;
1150                 wt_status_print(&s);
1151                 break;
1152         }
1153         return 0;
1154 }
1155
1156 static void print_summary(const char *prefix, const unsigned char *sha1)
1157 {
1158         struct rev_info rev;
1159         struct commit *commit;
1160         struct strbuf format = STRBUF_INIT;
1161         unsigned char junk_sha1[20];
1162         const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1163         struct pretty_print_context pctx = {0};
1164         struct strbuf author_ident = STRBUF_INIT;
1165         struct strbuf committer_ident = STRBUF_INIT;
1166
1167         commit = lookup_commit(sha1);
1168         if (!commit)
1169                 die("couldn't look up newly created commit");
1170         if (!commit || parse_commit(commit))
1171                 die("could not parse newly created commit");
1172
1173         strbuf_addstr(&format, "format:%h] %s");
1174
1175         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1176         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1177         if (strbuf_cmp(&author_ident, &committer_ident)) {
1178                 strbuf_addstr(&format, "\n Author: ");
1179                 strbuf_addbuf_percentquote(&format, &author_ident);
1180         }
1181         if (!user_ident_sufficiently_given()) {
1182                 strbuf_addstr(&format, "\n Committer: ");
1183                 strbuf_addbuf_percentquote(&format, &committer_ident);
1184                 if (advice_implicit_identity) {
1185                         strbuf_addch(&format, '\n');
1186                         strbuf_addstr(&format, implicit_ident_advice);
1187                 }
1188         }
1189         strbuf_release(&author_ident);
1190         strbuf_release(&committer_ident);
1191
1192         init_revisions(&rev, prefix);
1193         setup_revisions(0, NULL, &rev, NULL);
1194
1195         rev.diff = 1;
1196         rev.diffopt.output_format =
1197                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1198
1199         rev.verbose_header = 1;
1200         rev.show_root_diff = 1;
1201         get_commit_format(format.buf, &rev);
1202         rev.always_show_header = 0;
1203         rev.diffopt.detect_rename = 1;
1204         rev.diffopt.rename_limit = 100;
1205         rev.diffopt.break_opt = 0;
1206         diff_setup_done(&rev.diffopt);
1207
1208         printf("[%s%s ",
1209                 !prefixcmp(head, "refs/heads/") ?
1210                         head + 11 :
1211                         !strcmp(head, "HEAD") ?
1212                                 "detached HEAD" :
1213                                 head,
1214                 initial_commit ? " (root-commit)" : "");
1215
1216         if (!log_tree_commit(&rev, commit)) {
1217                 rev.always_show_header = 1;
1218                 rev.use_terminator = 1;
1219                 log_tree_commit(&rev, commit);
1220         }
1221
1222         strbuf_release(&format);
1223 }
1224
1225 static int git_commit_config(const char *k, const char *v, void *cb)
1226 {
1227         struct wt_status *s = cb;
1228
1229         if (!strcmp(k, "commit.template"))
1230                 return git_config_pathname(&template_file, k, v);
1231         if (!strcmp(k, "commit.status")) {
1232                 include_status = git_config_bool(k, v);
1233                 return 0;
1234         }
1235
1236         return git_status_config(k, v, s);
1237 }
1238
1239 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1240
1241 static int run_rewrite_hook(const unsigned char *oldsha1,
1242                             const unsigned char *newsha1)
1243 {
1244         /* oldsha1 SP newsha1 LF NUL */
1245         static char buf[2*40 + 3];
1246         struct child_process proc;
1247         const char *argv[3];
1248         int code;
1249         size_t n;
1250
1251         if (access(git_path(post_rewrite_hook), X_OK) < 0)
1252                 return 0;
1253
1254         argv[0] = git_path(post_rewrite_hook);
1255         argv[1] = "amend";
1256         argv[2] = NULL;
1257
1258         memset(&proc, 0, sizeof(proc));
1259         proc.argv = argv;
1260         proc.in = -1;
1261         proc.stdout_to_stderr = 1;
1262
1263         code = start_command(&proc);
1264         if (code)
1265                 return code;
1266         n = snprintf(buf, sizeof(buf), "%s %s\n",
1267                      sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1268         write_in_full(proc.in, buf, n);
1269         close(proc.in);
1270         return finish_command(&proc);
1271 }
1272
1273 int cmd_commit(int argc, const char **argv, const char *prefix)
1274 {
1275         struct strbuf sb = STRBUF_INIT;
1276         const char *index_file, *reflog_msg;
1277         char *nl, *p;
1278         unsigned char commit_sha1[20];
1279         struct ref_lock *ref_lock;
1280         struct commit_list *parents = NULL, **pptr = &parents;
1281         struct stat statbuf;
1282         int allow_fast_forward = 1;
1283         struct wt_status s;
1284
1285         wt_status_prepare(&s);
1286         git_config(git_commit_config, &s);
1287         in_merge = file_exists(git_path("MERGE_HEAD"));
1288         s.in_merge = in_merge;
1289
1290         if (s.use_color == -1)
1291                 s.use_color = git_use_color_default;
1292         argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1293                                           prefix, &s);
1294         if (dry_run) {
1295                 if (diff_use_color_default == -1)
1296                         diff_use_color_default = git_use_color_default;
1297                 return dry_run_commit(argc, argv, prefix, &s);
1298         }
1299         index_file = prepare_index(argc, argv, prefix, 0);
1300
1301         /* Set up everything for writing the commit object.  This includes
1302            running hooks, writing the trees, and interacting with the user.  */
1303         if (!prepare_to_commit(index_file, prefix, &s)) {
1304                 rollback_index_files();
1305                 return 1;
1306         }
1307
1308         /* Determine parents */
1309         reflog_msg = getenv("GIT_REFLOG_ACTION");
1310         if (initial_commit) {
1311                 if (!reflog_msg)
1312                         reflog_msg = "commit (initial)";
1313         } else if (amend) {
1314                 struct commit_list *c;
1315                 struct commit *commit;
1316
1317                 if (!reflog_msg)
1318                         reflog_msg = "commit (amend)";
1319                 commit = lookup_commit(head_sha1);
1320                 if (!commit || parse_commit(commit))
1321                         die("could not parse HEAD commit");
1322
1323                 for (c = commit->parents; c; c = c->next)
1324                         pptr = &commit_list_insert(c->item, pptr)->next;
1325         } else if (in_merge) {
1326                 struct strbuf m = STRBUF_INIT;
1327                 FILE *fp;
1328
1329                 if (!reflog_msg)
1330                         reflog_msg = "commit (merge)";
1331                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1332                 fp = fopen(git_path("MERGE_HEAD"), "r");
1333                 if (fp == NULL)
1334                         die_errno("could not open '%s' for reading",
1335                                   git_path("MERGE_HEAD"));
1336                 while (strbuf_getline(&m, fp, '\n') != EOF) {
1337                         unsigned char sha1[20];
1338                         if (get_sha1_hex(m.buf, sha1) < 0)
1339                                 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1340                         pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1341                 }
1342                 fclose(fp);
1343                 strbuf_release(&m);
1344                 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1345                         if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1346                                 die_errno("could not read MERGE_MODE");
1347                         if (!strcmp(sb.buf, "no-ff"))
1348                                 allow_fast_forward = 0;
1349                 }
1350                 if (allow_fast_forward)
1351                         parents = reduce_heads(parents);
1352         } else {
1353                 if (!reflog_msg)
1354                         reflog_msg = "commit";
1355                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1356         }
1357
1358         /* Finally, get the commit message */
1359         strbuf_reset(&sb);
1360         if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1361                 int saved_errno = errno;
1362                 rollback_index_files();
1363                 die("could not read commit message: %s", strerror(saved_errno));
1364         }
1365
1366         /* Truncate the message just before the diff, if any. */
1367         if (verbose) {
1368                 p = strstr(sb.buf, "\ndiff --git ");
1369                 if (p != NULL)
1370                         strbuf_setlen(&sb, p - sb.buf + 1);
1371         }
1372
1373         if (cleanup_mode != CLEANUP_NONE)
1374                 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1375         if (message_is_empty(&sb) && !allow_empty_message) {
1376                 rollback_index_files();
1377                 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1378                 exit(1);
1379         }
1380
1381         if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1382                         fmt_ident(author_name, author_email, author_date,
1383                                 IDENT_ERROR_ON_NO_NAME))) {
1384                 rollback_index_files();
1385                 die("failed to write commit object");
1386         }
1387
1388         ref_lock = lock_any_ref_for_update("HEAD",
1389                                            initial_commit ? NULL : head_sha1,
1390                                            0);
1391
1392         nl = strchr(sb.buf, '\n');
1393         if (nl)
1394                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1395         else
1396                 strbuf_addch(&sb, '\n');
1397         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1398         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1399
1400         if (!ref_lock) {
1401                 rollback_index_files();
1402                 die("cannot lock HEAD ref");
1403         }
1404         if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1405                 rollback_index_files();
1406                 die("cannot update HEAD ref");
1407         }
1408
1409         unlink(git_path("MERGE_HEAD"));
1410         unlink(git_path("MERGE_MSG"));
1411         unlink(git_path("MERGE_MODE"));
1412         unlink(git_path("SQUASH_MSG"));
1413
1414         if (commit_index_files())
1415                 die ("Repository has been updated, but unable to write\n"
1416                      "new_index file. Check that disk is not full or quota is\n"
1417                      "not exceeded, and then \"git reset HEAD\" to recover.");
1418
1419         rerere(0);
1420         run_hook(get_index_file(), "post-commit", NULL);
1421         if (amend && !no_post_rewrite) {
1422                 struct notes_rewrite_cfg *cfg;
1423                 cfg = init_copy_notes_for_rewrite("amend");
1424                 if (cfg) {
1425                         copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1426                         finish_copy_notes_for_rewrite(cfg);
1427                 }
1428                 run_rewrite_hook(head_sha1, commit_sha1);
1429         }
1430         if (!quiet)
1431                 print_summary(prefix, commit_sha1);
1432
1433         return 0;
1434 }