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         const char *hook_arg1 = NULL;
 572         const char *hook_arg2 = NULL;
 573         int ident_shown = 0;
 574
 575         if (!no_verify && run_hook(index_file, "pre-commit", NULL))
 576                 return 0;
 577
 578         if (squash_message) {
 579                 /*
 580                  * Insert the proper subject line before other commit
 581                  * message options add their content.
 582                  */
 583                 if (use_message && !strcmp(use_message, squash_message))
 584                         strbuf_addstr(&sb, "squash! ");
 585                 else {
 586                         struct pretty_print_context ctx = {0};
 587                         struct commit *c;
 588                         c = lookup_commit_reference_by_name(squash_message);
 589                         if (!c)
 590                                 die("could not lookup commit %s", squash_message);
 591                         ctx.output_encoding = get_commit_output_encoding();
 592                         format_commit_message(c, "squash! %s\n\n", &sb,
 593                                               &ctx);
 594                 }
 595         }
 596
 597         if (message.len) {
 598                 strbuf_addbuf(&sb, &message);
 599                 hook_arg1 = "message";
 600         } else if (logfile && !strcmp(logfile, "-")) {
 601                 if (isatty(0))
 602                         fprintf(stderr, "(reading log message from standard input)\n");
 603                 if (strbuf_read(&sb, 0, 0) < 0)
 604                         die_errno("could not read log from standard input");
 605                 hook_arg1 = "message";
 606         } else if (logfile) {
 607                 if (strbuf_read_file(&sb, logfile, 0) < 0)
 608                         die_errno("could not read log file '%s'",
 609                                   logfile);
 610                 hook_arg1 = "message";
 611         } else if (use_message) {
 612                 buffer = strstr(use_message_buffer, "\n\n");
 613                 if (!buffer || buffer[2] == '\0')
 614                         die("commit has empty message");
 615                 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
 616                 hook_arg1 = "commit";
 617                 hook_arg2 = use_message;
 618         } else if (fixup_message) {
 619                 struct pretty_print_context ctx = {0};
 620                 struct commit *commit;
 621                 commit = lookup_commit_reference_by_name(fixup_message);
 622                 if (!commit)
 623                         die("could not lookup commit %s", fixup_message);
 624                 ctx.output_encoding = get_commit_output_encoding();
 625                 format_commit_message(commit, "fixup! %s\n\n",
 626                                       &sb, &ctx);
 627                 hook_arg1 = "message";
 628         } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
 629                 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
 630                         die_errno("could not read MERGE_MSG");
 631                 hook_arg1 = "merge";
 632         } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
 633                 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
 634                         die_errno("could not read SQUASH_MSG");
 635                 hook_arg1 = "squash";
 636         } else if (template_file && !stat(template_file, &statbuf)) {
 637                 if (strbuf_read_file(&sb, template_file, 0) < 0)
 638                         die_errno("could not read '%s'", template_file);
 639                 hook_arg1 = "template";
 640         }
 641
 642         /*
 643          * This final case does not modify the template message,
 644          * it just sets the argument to the prepare-commit-msg hook.
 645          */
 646         else if (in_merge)
 647                 hook_arg1 = "merge";
 648
 649         if (squash_message) {
 650                 /*
 651                  * If squash_commit was used for the commit subject,
 652                  * then we're possibly hijacking other commit log options.
 653                  * Reset the hook args to tell the real story.
 654                  */
 655                 hook_arg1 = "message";
 656                 hook_arg2 = "";
 657         }
 658
 659         s->fp = fopen(git_path(commit_editmsg), "w");
 660         if (s->fp == NULL)
 661                 die_errno("could not open '%s'", git_path(commit_editmsg));
 662
 663         if (cleanup_mode != CLEANUP_NONE)
 664                 stripspace(&sb, 0);
 665
 666         if (signoff) {
 667                 struct strbuf sob = STRBUF_INIT;
 668                 int i;
 669
 670                 strbuf_addstr(&sob, sign_off_header);
 671                 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
 672                                              getenv("GIT_COMMITTER_EMAIL")));
 673                 strbuf_addch(&sob, '\n');
 674                 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
 675                         ; /* do nothing */
 676                 if (prefixcmp(sb.buf + i, sob.buf)) {
 677                         if (!i || !ends_rfc2822_footer(&sb))
 678                                 strbuf_addch(&sb, '\n');
 679                         strbuf_addbuf(&sb, &sob);
 680                 }
 681                 strbuf_release(&sob);
 682         }
 683
 684         if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
 685                 die_errno("could not write commit template");
 686
 687         strbuf_release(&sb);
 688
 689         /* This checks and barfs if author is badly specified */
 690         determine_author_info(author_ident);
 691
 692         /* This checks if committer ident is explicitly given */
 693         strbuf_addstr(&committer_ident, git_committer_info(0));
 694         if (use_editor && include_status) {
 695                 char *ai_tmp, *ci_tmp;
 696                 if (in_merge)
 697                         fprintf(s->fp,
 698                                 "#\n"
 699                                 "# It looks like you may be committing a MERGE.\n"
 700                                 "# If this is not correct, please remove the file\n"
 701                                 "#      %s\n"
 702                                 "# and try again.\n"
 703                                 "#\n",
 704                                 git_path("MERGE_HEAD"));
 705
 706                 fprintf(s->fp,
 707                         "\n"
 708                         "# Please enter the commit message for your changes.");
 709                 if (cleanup_mode == CLEANUP_ALL)
 710                         fprintf(s->fp,
 711                                 " Lines starting\n"
 712                                 "# with '#' will be ignored, and an empty"
 713                                 " message aborts the commit.\n");
 714                 else /* CLEANUP_SPACE, that is. */
 715                         fprintf(s->fp,
 716                                 " Lines starting\n"
 717                                 "# with '#' will be kept; you may remove them"
 718                                 " yourself if you want to.\n"
 719                                 "# An empty message aborts the commit.\n");
 720                 if (only_include_assumed)
 721                         fprintf(s->fp, "# %s\n", only_include_assumed);
 722
 723                 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
 724                 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
 725                 if (strcmp(author_ident->buf, committer_ident.buf))
 726                         fprintf(s->fp,
 727                                 "%s"
 728                                 "# Author:    %s\n",
 729                                 ident_shown++ ? "" : "#\n",
 730                                 author_ident->buf);
 731
 732                 if (!user_ident_sufficiently_given())
 733                         fprintf(s->fp,
 734                                 "%s"
 735                                 "# Committer: %s\n",
 736                                 ident_shown++ ? "" : "#\n",
 737                                 committer_ident.buf);
 738
 739                 if (ident_shown)
 740                         fprintf(s->fp, "#\n");
 741
 742                 saved_color_setting = s->use_color;
 743                 s->use_color = 0;
 744                 commitable = run_status(s->fp, index_file, prefix, 1, s);
 745                 s->use_color = saved_color_setting;
 746
 747                 *ai_tmp = ' ';
 748                 *ci_tmp = ' ';
 749         } else {
 750                 unsigned char sha1[20];
 751                 const char *parent = "HEAD";
 752
 753                 if (!active_nr && read_cache() < 0)
 754                         die("Cannot read index");
 755
 756                 if (amend)
 757                         parent = "HEAD^1";
 758
 759                 if (get_sha1(parent, sha1))
 760                         commitable = !!active_nr;
 761                 else
 762                         commitable = index_differs_from(parent, 0);
 763         }
 764         strbuf_release(&committer_ident);
 765
 766         fclose(s->fp);
 767
 768         if (!commitable && !in_merge && !allow_empty &&
 769             !(amend && is_a_merge(head_sha1))) {
 770                 run_status(stdout, index_file, prefix, 0, s);
 771                 if (amend)
 772                         fputs(empty_amend_advice, stderr);
 773                 return 0;
 774         }
 775
 776         /*
 777          * Re-read the index as pre-commit hook could have updated it,
 778          * and write it out as a tree.  We must do this before we invoke
 779          * the editor and after we invoke run_status above.
 780          */
 781         discard_cache();
 782         read_cache_from(index_file);
 783         if (!active_cache_tree)
 784                 active_cache_tree = cache_tree();
 785         if (cache_tree_update(active_cache_tree,
 786                               active_cache, active_nr, 0, 0) < 0) {
 787                 error("Error building trees");
 788                 return 0;
 789         }
 790
 791         if (run_hook(index_file, "prepare-commit-msg",
 792                      git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
 793                 return 0;
 794
 795         if (use_editor) {
 796                 char index[PATH_MAX];
 797                 const char *env[2] = { NULL };
 798                 env[0] =  index;
 799                 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
 800                 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
 801                         fprintf(stderr,
 802                         "Please supply the message using either -m or -F option.\n");
 803                         exit(1);
 804                 }
 805         }
 806
 807         if (!no_verify &&
 808             run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
 809                 return 0;
 810         }
 811
 812         return 1;
 813 }
 814
 815 /*
 816  * Find out if the message in the strbuf contains only whitespace and
 817  * Signed-off-by lines.
 818  */
 819 static int message_is_empty(struct strbuf *sb)
 820 {
 821         struct strbuf tmpl = STRBUF_INIT;
 822         const char *nl;
 823         int eol, i, start = 0;
 824
 825         if (cleanup_mode == CLEANUP_NONE && sb->len)
 826                 return 0;
 827
 828         /* See if the template is just a prefix of the message. */
 829         if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
 830                 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
 831                 if (start + tmpl.len <= sb->len &&
 832                     memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
 833                         start += tmpl.len;
 834         }
 835         strbuf_release(&tmpl);
 836
 837         /* Check if the rest is just whitespace and Signed-of-by's. */
 838         for (i = start; i < sb->len; i++) {
 839                 nl = memchr(sb->buf + i, '\n', sb->len - i);
 840                 if (nl)
 841                         eol = nl - sb->buf;
 842                 else
 843                         eol = sb->len;
 844
 845                 if (strlen(sign_off_header) <= eol - i &&
 846                     !prefixcmp(sb->buf + i, sign_off_header)) {
 847                         i = eol;
 848                         continue;
 849                 }
 850                 while (i < eol)
 851                         if (!isspace(sb->buf[i++]))
 852                                 return 0;
 853         }
 854
 855         return 1;
 856 }
 857
 858 static const char *find_author_by_nickname(const char *name)
 859 {
 860         struct rev_info revs;
 861         struct commit *commit;
 862         struct strbuf buf = STRBUF_INIT;
 863         const char *av[20];
 864         int ac = 0;
 865
 866         init_revisions(&revs, NULL);
 867         strbuf_addf(&buf, "--author=%s", name);
 868         av[++ac] = "--all";
 869         av[++ac] = "-i";
 870         av[++ac] = buf.buf;
 871         av[++ac] = NULL;
 872         setup_revisions(ac, av, &revs, NULL);
 873         prepare_revision_walk(&revs);
 874         commit = get_revision(&revs);
 875         if (commit) {
 876                 struct pretty_print_context ctx = {0};
 877                 ctx.date_mode = DATE_NORMAL;
 878                 strbuf_release(&buf);
 879                 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
 880                 return strbuf_detach(&buf, NULL);
 881         }
 882         die("No existing author found with '%s'", name);
 883 }
 884
 885
 886 static void handle_untracked_files_arg(struct wt_status *s)
 887 {
 888         if (!untracked_files_arg)
 889                 ; /* default already initialized */
 890         else if (!strcmp(untracked_files_arg, "no"))
 891                 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
 892         else if (!strcmp(untracked_files_arg, "normal"))
 893                 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
 894         else if (!strcmp(untracked_files_arg, "all"))
 895                 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
 896         else
 897                 die("Invalid untracked files mode '%s'", untracked_files_arg);
 898 }
 899
 900 static int parse_and_validate_options(int argc, const char *argv[],
 901                                       const char * const usage[],
 902                                       const char *prefix,
 903                                       struct wt_status *s)
 904 {
 905         int f = 0;
 906
 907         argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
 908                              0);
 909
 910         if (force_author && !strchr(force_author, '>'))
 911                 force_author = find_author_by_nickname(force_author);
 912
 913         if (force_author && renew_authorship)
 914                 die("Using both --reset-author and --author does not make sense");
 915
 916         if (logfile || message.len || use_message || fixup_message)
 917                 use_editor = 0;
 918         if (edit_flag)
 919                 use_editor = 1;
 920         if (!use_editor)
 921                 setenv("GIT_EDITOR", ":", 1);
 922
 923         if (get_sha1("HEAD", head_sha1))
 924                 initial_commit = 1;
 925
 926         /* Sanity check options */
 927         if (amend && initial_commit)
 928                 die("You have nothing to amend.");
 929         if (amend && in_merge)
 930                 die("You are in the middle of a merge -- cannot amend.");
 931         if (fixup_message && squash_message)
 932                 die("Options --squash and --fixup cannot be used together");
 933         if (use_message)
 934                 f++;
 935         if (edit_message)
 936                 f++;
 937         if (fixup_message)
 938                 f++;
 939         if (logfile)
 940                 f++;
 941         if (f > 1)
 942                 die("Only one of -c/-C/-F/--fixup can be used.");
 943         if (message.len && f > 0)
 944                 die("Option -m cannot be combined with -c/-C/-F/--fixup.");
 945         if (edit_message)
 946                 use_message = edit_message;
 947         if (amend && !use_message && !fixup_message)
 948                 use_message = "HEAD";
 949         if (!use_message && renew_authorship)
 950                 die("--reset-author can be used only with -C, -c or --amend.");
 951         if (use_message) {
 952                 const char *out_enc;
 953                 struct commit *commit;
 954
 955                 commit = lookup_commit_reference_by_name(use_message);
 956                 if (!commit)
 957                         die("could not lookup commit %s", use_message);
 958                 out_enc = get_commit_output_encoding();
 959                 use_message_buffer = logmsg_reencode(commit, out_enc);
 960
 961                 /*
 962                  * If we failed to reencode the buffer, just copy it
 963                  * byte for byte so the user can try to fix it up.
 964                  * This also handles the case where input and output
 965                  * encodings are identical.
 966                  */
 967                 if (use_message_buffer == NULL)
 968                         use_message_buffer = xstrdup(commit->buffer);
 969         }
 970
 971         if (!!also + !!only + !!all + !!interactive > 1)
 972                 die("Only one of --include/--only/--all/--interactive can be used.");
 973         if (argc == 0 && (also || (only && !amend)))
 974                 die("No paths with --include/--only does not make sense.");
 975         if (argc == 0 && only && amend)
 976                 only_include_assumed = "Clever... amending the last one with dirty index.";
 977         if (argc > 0 && !also && !only)
 978                 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
 979         if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
 980                 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
 981         else if (!strcmp(cleanup_arg, "verbatim"))
 982                 cleanup_mode = CLEANUP_NONE;
 983         else if (!strcmp(cleanup_arg, "whitespace"))
 984                 cleanup_mode = CLEANUP_SPACE;
 985         else if (!strcmp(cleanup_arg, "strip"))
 986                 cleanup_mode = CLEANUP_ALL;
 987         else
 988                 die("Invalid cleanup mode %s", cleanup_arg);
 989
 990         handle_untracked_files_arg(s);
 991
 992         if (all && argc > 0)
 993                 die("Paths with -a does not make sense.");
 994         else if (interactive && argc > 0)
 995                 die("Paths with --interactive does not make sense.");
 996
 997         if (null_termination && status_format == STATUS_FORMAT_LONG)
 998                 status_format = STATUS_FORMAT_PORCELAIN;
 999         if (status_format != STATUS_FORMAT_LONG)
1000                 dry_run = 1;
1001
1002         return argc;
1003 }
1004
1005 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1006                           struct wt_status *s)
1007 {
1008         int commitable;
1009         const char *index_file;
1010
1011         index_file = prepare_index(argc, argv, prefix, 1);
1012         commitable = run_status(stdout, index_file, prefix, 0, s);
1013         rollback_index_files();
1014
1015         return commitable ? 0 : 1;
1016 }
1017
1018 static int parse_status_slot(const char *var, int offset)
1019 {
1020         if (!strcasecmp(var+offset, "header"))
1021                 return WT_STATUS_HEADER;
1022         if (!strcasecmp(var+offset, "branch"))
1023                 return WT_STATUS_ONBRANCH;
1024         if (!strcasecmp(var+offset, "updated")
1025                 || !strcasecmp(var+offset, "added"))
1026                 return WT_STATUS_UPDATED;
1027         if (!strcasecmp(var+offset, "changed"))
1028                 return WT_STATUS_CHANGED;
1029         if (!strcasecmp(var+offset, "untracked"))
1030                 return WT_STATUS_UNTRACKED;
1031         if (!strcasecmp(var+offset, "nobranch"))
1032                 return WT_STATUS_NOBRANCH;
1033         if (!strcasecmp(var+offset, "unmerged"))
1034                 return WT_STATUS_UNMERGED;
1035         return -1;
1036 }
1037
1038 static int git_status_config(const char *k, const char *v, void *cb)
1039 {
1040         struct wt_status *s = cb;
1041
1042         if (!strcmp(k, "status.submodulesummary")) {
1043                 int is_bool;
1044                 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1045                 if (is_bool && s->submodule_summary)
1046                         s->submodule_summary = -1;
1047                 return 0;
1048         }
1049         if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1050                 s->use_color = git_config_colorbool(k, v, -1);
1051                 return 0;
1052         }
1053         if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1054                 int slot = parse_status_slot(k, 13);
1055                 if (slot < 0)
1056                         return 0;
1057                 if (!v)
1058                         return config_error_nonbool(k);
1059                 color_parse(v, k, s->color_palette[slot]);
1060                 return 0;
1061         }
1062         if (!strcmp(k, "status.relativepaths")) {
1063                 s->relative_paths = git_config_bool(k, v);
1064                 return 0;
1065         }
1066         if (!strcmp(k, "status.showuntrackedfiles")) {
1067                 if (!v)
1068                         return config_error_nonbool(k);
1069                 else if (!strcmp(v, "no"))
1070                         s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1071                 else if (!strcmp(v, "normal"))
1072                         s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1073                 else if (!strcmp(v, "all"))
1074                         s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1075                 else
1076                         return error("Invalid untracked files mode '%s'", v);
1077                 return 0;
1078         }
1079         return git_diff_ui_config(k, v, NULL);
1080 }
1081
1082 int cmd_status(int argc, const char **argv, const char *prefix)
1083 {
1084         struct wt_status s;
1085         int fd;
1086         unsigned char sha1[20];
1087         static struct option builtin_status_options[] = {
1088                 OPT__VERBOSE(&verbose, "be verbose"),
1089                 OPT_SET_INT('s', "short", &status_format,
1090                             "show status concisely", STATUS_FORMAT_SHORT),
1091                 OPT_BOOLEAN('b', "branch", &status_show_branch,
1092                             "show branch information"),
1093                 OPT_SET_INT(0, "porcelain", &status_format,
1094                             "machine-readable output",
1095                             STATUS_FORMAT_PORCELAIN),
1096                 OPT_BOOLEAN('z', "null", &null_termination,
1097                             "terminate entries with NUL"),
1098                 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1099                   "mode",
1100                   "show untracked files, optional modes: all, normal, no. (Default: all)",
1101                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1102                 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1103                             "show ignored files"),
1104                 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1105                   "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1106                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1107                 OPT_END(),
1108         };
1109
1110         if (argc == 2 && !strcmp(argv[1], "-h"))
1111                 usage_with_options(builtin_status_usage, builtin_status_options);
1112
1113         if (null_termination && status_format == STATUS_FORMAT_LONG)
1114                 status_format = STATUS_FORMAT_PORCELAIN;
1115
1116         wt_status_prepare(&s);
1117         gitmodules_config();
1118         git_config(git_status_config, &s);
1119         in_merge = file_exists(git_path("MERGE_HEAD"));
1120         argc = parse_options(argc, argv, prefix,
1121                              builtin_status_options,
1122                              builtin_status_usage, 0);
1123         handle_untracked_files_arg(&s);
1124         if (show_ignored_in_status)
1125                 s.show_ignored_files = 1;
1126         if (*argv)
1127                 s.pathspec = get_pathspec(prefix, argv);
1128
1129         read_cache_preload(s.pathspec);
1130         refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1131
1132         fd = hold_locked_index(&index_lock, 0);
1133         if (0 <= fd) {
1134                 if (active_cache_changed &&
1135                     !write_cache(fd, active_cache, active_nr))
1136                         commit_locked_index(&index_lock);
1137                 else
1138                         rollback_lock_file(&index_lock);
1139         }
1140
1141         s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1142         s.in_merge = in_merge;
1143         s.ignore_submodule_arg = ignore_submodule_arg;
1144         wt_status_collect(&s);
1145
1146         if (s.relative_paths)
1147                 s.prefix = prefix;
1148         if (s.use_color == -1)
1149                 s.use_color = git_use_color_default;
1150         if (diff_use_color_default == -1)
1151                 diff_use_color_default = git_use_color_default;
1152
1153         switch (status_format) {
1154         case STATUS_FORMAT_SHORT:
1155                 wt_shortstatus_print(&s, null_termination, status_show_branch);
1156                 break;
1157         case STATUS_FORMAT_PORCELAIN:
1158                 wt_porcelain_print(&s, null_termination);
1159                 break;
1160         case STATUS_FORMAT_LONG:
1161                 s.verbose = verbose;
1162                 s.ignore_submodule_arg = ignore_submodule_arg;
1163                 wt_status_print(&s);
1164                 break;
1165         }
1166         return 0;
1167 }
1168
1169 static void print_summary(const char *prefix, const unsigned char *sha1)
1170 {
1171         struct rev_info rev;
1172         struct commit *commit;
1173         struct strbuf format = STRBUF_INIT;
1174         unsigned char junk_sha1[20];
1175         const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1176         struct pretty_print_context pctx = {0};
1177         struct strbuf author_ident = STRBUF_INIT;
1178         struct strbuf committer_ident = STRBUF_INIT;
1179
1180         commit = lookup_commit(sha1);
1181         if (!commit)
1182                 die("couldn't look up newly created commit");
1183         if (!commit || parse_commit(commit))
1184                 die("could not parse newly created commit");
1185
1186         strbuf_addstr(&format, "format:%h] %s");
1187
1188         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1189         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1190         if (strbuf_cmp(&author_ident, &committer_ident)) {
1191                 strbuf_addstr(&format, "\n Author: ");
1192                 strbuf_addbuf_percentquote(&format, &author_ident);
1193         }
1194         if (!user_ident_sufficiently_given()) {
1195                 strbuf_addstr(&format, "\n Committer: ");
1196                 strbuf_addbuf_percentquote(&format, &committer_ident);
1197                 if (advice_implicit_identity) {
1198                         strbuf_addch(&format, '\n');
1199                         strbuf_addstr(&format, implicit_ident_advice);
1200                 }
1201         }
1202         strbuf_release(&author_ident);
1203         strbuf_release(&committer_ident);
1204
1205         init_revisions(&rev, prefix);
1206         setup_revisions(0, NULL, &rev, NULL);
1207
1208         rev.diff = 1;
1209         rev.diffopt.output_format =
1210                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1211
1212         rev.verbose_header = 1;
1213         rev.show_root_diff = 1;
1214         get_commit_format(format.buf, &rev);
1215         rev.always_show_header = 0;
1216         rev.diffopt.detect_rename = 1;
1217         rev.diffopt.rename_limit = 100;
1218         rev.diffopt.break_opt = 0;
1219         diff_setup_done(&rev.diffopt);
1220
1221         printf("[%s%s ",
1222                 !prefixcmp(head, "refs/heads/") ?
1223                         head + 11 :
1224                         !strcmp(head, "HEAD") ?
1225                                 "detached HEAD" :
1226                                 head,
1227                 initial_commit ? " (root-commit)" : "");
1228
1229         if (!log_tree_commit(&rev, commit)) {
1230                 rev.always_show_header = 1;
1231                 rev.use_terminator = 1;
1232                 log_tree_commit(&rev, commit);
1233         }
1234
1235         strbuf_release(&format);
1236 }
1237
1238 static int git_commit_config(const char *k, const char *v, void *cb)
1239 {
1240         struct wt_status *s = cb;
1241
1242         if (!strcmp(k, "commit.template"))
1243                 return git_config_pathname(&template_file, k, v);
1244         if (!strcmp(k, "commit.status")) {
1245                 include_status = git_config_bool(k, v);
1246                 return 0;
1247         }
1248
1249         return git_status_config(k, v, s);
1250 }
1251
1252 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1253
1254 static int run_rewrite_hook(const unsigned char *oldsha1,
1255                             const unsigned char *newsha1)
1256 {
1257         /* oldsha1 SP newsha1 LF NUL */
1258         static char buf[2*40 + 3];
1259         struct child_process proc;
1260         const char *argv[3];
1261         int code;
1262         size_t n;
1263
1264         if (access(git_path(post_rewrite_hook), X_OK) < 0)
1265                 return 0;
1266
1267         argv[0] = git_path(post_rewrite_hook);
1268         argv[1] = "amend";
1269         argv[2] = NULL;
1270
1271         memset(&proc, 0, sizeof(proc));
1272         proc.argv = argv;
1273         proc.in = -1;
1274         proc.stdout_to_stderr = 1;
1275
1276         code = start_command(&proc);
1277         if (code)
1278                 return code;
1279         n = snprintf(buf, sizeof(buf), "%s %s\n",
1280                      sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1281         write_in_full(proc.in, buf, n);
1282         close(proc.in);
1283         return finish_command(&proc);
1284 }
1285
1286 int cmd_commit(int argc, const char **argv, const char *prefix)
1287 {
1288         struct strbuf sb = STRBUF_INIT;
1289         struct strbuf author_ident = STRBUF_INIT;
1290         const char *index_file, *reflog_msg;
1291         char *nl, *p;
1292         unsigned char commit_sha1[20];
1293         struct ref_lock *ref_lock;
1294         struct commit_list *parents = NULL, **pptr = &parents;
1295         struct stat statbuf;
1296         int allow_fast_forward = 1;
1297         struct wt_status s;
1298
1299         if (argc == 2 && !strcmp(argv[1], "-h"))
1300                 usage_with_options(builtin_commit_usage, builtin_commit_options);
1301
1302         wt_status_prepare(&s);
1303         git_config(git_commit_config, &s);
1304         in_merge = file_exists(git_path("MERGE_HEAD"));
1305         s.in_merge = in_merge;
1306
1307         if (s.use_color == -1)
1308                 s.use_color = git_use_color_default;
1309         argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1310                                           prefix, &s);
1311         if (dry_run) {
1312                 if (diff_use_color_default == -1)
1313                         diff_use_color_default = git_use_color_default;
1314                 return dry_run_commit(argc, argv, prefix, &s);
1315         }
1316         index_file = prepare_index(argc, argv, prefix, 0);
1317
1318         /* Set up everything for writing the commit object.  This includes
1319            running hooks, writing the trees, and interacting with the user.  */
1320         if (!prepare_to_commit(index_file, prefix, &s, &author_ident)) {
1321                 rollback_index_files();
1322                 return 1;
1323         }
1324
1325         /* Determine parents */
1326         reflog_msg = getenv("GIT_REFLOG_ACTION");
1327         if (initial_commit) {
1328                 if (!reflog_msg)
1329                         reflog_msg = "commit (initial)";
1330         } else if (amend) {
1331                 struct commit_list *c;
1332                 struct commit *commit;
1333
1334                 if (!reflog_msg)
1335                         reflog_msg = "commit (amend)";
1336                 commit = lookup_commit(head_sha1);
1337                 if (!commit || parse_commit(commit))
1338                         die("could not parse HEAD commit");
1339
1340                 for (c = commit->parents; c; c = c->next)
1341                         pptr = &commit_list_insert(c->item, pptr)->next;
1342         } else if (in_merge) {
1343                 struct strbuf m = STRBUF_INIT;
1344                 FILE *fp;
1345
1346                 if (!reflog_msg)
1347                         reflog_msg = "commit (merge)";
1348                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1349                 fp = fopen(git_path("MERGE_HEAD"), "r");
1350                 if (fp == NULL)
1351                         die_errno("could not open '%s' for reading",
1352                                   git_path("MERGE_HEAD"));
1353                 while (strbuf_getline(&m, fp, '\n') != EOF) {
1354                         unsigned char sha1[20];
1355                         if (get_sha1_hex(m.buf, sha1) < 0)
1356                                 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1357                         pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1358                 }
1359                 fclose(fp);
1360                 strbuf_release(&m);
1361                 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1362                         if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1363                                 die_errno("could not read MERGE_MODE");
1364                         if (!strcmp(sb.buf, "no-ff"))
1365                                 allow_fast_forward = 0;
1366                 }
1367                 if (allow_fast_forward)
1368                         parents = reduce_heads(parents);
1369         } else {
1370                 if (!reflog_msg)
1371                         reflog_msg = "commit";
1372                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1373         }
1374
1375         /* Finally, get the commit message */
1376         strbuf_reset(&sb);
1377         if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1378                 int saved_errno = errno;
1379                 rollback_index_files();
1380                 die("could not read commit message: %s", strerror(saved_errno));
1381         }
1382
1383         /* Truncate the message just before the diff, if any. */
1384         if (verbose) {
1385                 p = strstr(sb.buf, "\ndiff --git ");
1386                 if (p != NULL)
1387                         strbuf_setlen(&sb, p - sb.buf + 1);
1388         }
1389
1390         if (cleanup_mode != CLEANUP_NONE)
1391                 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1392         if (message_is_empty(&sb) && !allow_empty_message) {
1393                 rollback_index_files();
1394                 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1395                 exit(1);
1396         }
1397
1398         if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1399                         author_ident.buf)) {
1400                 rollback_index_files();
1401                 die("failed to write commit object");
1402         }
1403         strbuf_release(&author_ident);
1404
1405         ref_lock = lock_any_ref_for_update("HEAD",
1406                                            initial_commit ? NULL : head_sha1,
1407                                            0);
1408
1409         nl = strchr(sb.buf, '\n');
1410         if (nl)
1411                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1412         else
1413                 strbuf_addch(&sb, '\n');
1414         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1415         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1416
1417         if (!ref_lock) {
1418                 rollback_index_files();
1419                 die("cannot lock HEAD ref");
1420         }
1421         if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1422                 rollback_index_files();
1423                 die("cannot update HEAD ref");
1424         }
1425
1426         unlink(git_path("MERGE_HEAD"));
1427         unlink(git_path("MERGE_MSG"));
1428         unlink(git_path("MERGE_MODE"));
1429         unlink(git_path("SQUASH_MSG"));
1430
1431         if (commit_index_files())
1432                 die ("Repository has been updated, but unable to write\n"
1433                      "new_index file. Check that disk is not full or quota is\n"
1434                      "not exceeded, and then \"git reset HEAD\" to recover.");
1435
1436         rerere(0);
1437         run_hook(get_index_file(), "post-commit", NULL);
1438         if (amend && !no_post_rewrite) {
1439                 struct notes_rewrite_cfg *cfg;
1440                 cfg = init_copy_notes_for_rewrite("amend");
1441                 if (cfg) {
1442                         copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1443                         finish_copy_notes_for_rewrite(cfg);
1444                 }
1445                 run_rewrite_hook(head_sha1, commit_sha1);
1446         }
1447         if (!quiet)
1448                 print_summary(prefix, commit_sha1);
1449
1450         return 0;
1451 }