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